@openlife/cli 1.7.3

package/dist/orchestrator/MediaManager.js

@@ -0,0 +1,92 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaManager = void 0;
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+class MediaManager {
+    outputDir;
+    constructor() {
+        this.outputDir = path.join(process.cwd(), '.media_output');
+        if (!fs.existsSync(this.outputDir)) {
+            fs.mkdirSync(this.outputDir, { recursive: true });
+        }
+    }
+    async extractAudio(inputPath, outputFilename = `audio_${Date.now()}.mp3`) {
+        const outputPath = path.join(this.outputDir, outputFilename);
+        return new Promise((resolve, reject) => {
+            console.log(`[MEDIA] Extraindo áudio de ${inputPath}...`);
+            (0, fluent_ffmpeg_1.default)(inputPath)
+                .output(outputPath)
+                .noVideo()
+                .audioCodec('libmp3lame')
+                .on('end', () => {
+                console.log(`[MEDIA] Sucesso! Salvo em: ${outputPath}`);
+                resolve(outputPath);
+            })
+                .on('error', (err) => {
+                console.error('[MEDIA] Falha ao extrair áudio:', err);
+                reject(err);
+            })
+                .run();
+        });
+    }
+    async cutVideo(inputPath, startTime, duration, outputFilename = `cut_${Date.now()}.mp4`) {
+        const outputPath = path.join(this.outputDir, outputFilename);
+        return new Promise((resolve, reject) => {
+            console.log(`[MEDIA] Cortando vídeo ${inputPath} (Start: ${startTime}, Dur: ${duration})...`);
+            (0, fluent_ffmpeg_1.default)(inputPath)
+                .setStartTime(startTime)
+                .setDuration(duration)
+                .output(outputPath)
+                .videoCodec('copy')
+                .audioCodec('copy')
+                .on('end', () => {
+                console.log(`[MEDIA] Corte finalizado! Salvo em: ${outputPath}`);
+                resolve(outputPath);
+            })
+                .on('error', (err) => {
+                console.error('[MEDIA] Erro ao cortar vídeo:', err);
+                reject(err);
+            })
+                .run();
+        });
+    }
+}
+exports.MediaManager = MediaManager;

package/dist/orchestrator/MemoryCuratorAgent.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCuratorAgent = void 0;
+class MemoryCuratorAgent {
+    brain;
+    constructor(brain) {
+        this.brain = brain;
+    }
+    async curate(state) {
+        const prompt = `
+Você é o Memory Curator do OpenLife.
+
+Missão:
+${state.goal}
+
+Plano:
+${state.plan.join('\n- ')}
+
+Agentes usados:
+${state.chosenAgents.map(a => `${a.id} (${a.role})`).join('\n')}
+
+Review findings:
+${state.reviewFindings.map(r => `${r.score} - ${r.critique}`).join('\n')}
+
+Resposta final:
+${state.finalAnswer || ''}
+
+Responda em JSON com um array "memoryCandidates" contendo até 5 aprendizados operacionais curtos e reutilizáveis.
+`;
+        const raw = await this.brain.think('Extraia aprendizados operacionais reutilizáveis.', prompt);
+        try {
+            const jsonStart = raw.indexOf('{');
+            const parsed = JSON.parse(jsonStart >= 0 ? raw.slice(jsonStart) : raw);
+            return Array.isArray(parsed.memoryCandidates) ? parsed.memoryCandidates.slice(0, 5) : [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.MemoryCuratorAgent = MemoryCuratorAgent;

package/dist/orchestrator/MissionState.js

@@ -0,0 +1,155 @@
+"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.MissionCheckpointStore = exports.MissionStateStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./util/AtomicWriter");
+class MissionStateStore {
+    baseDir;
+    constructor() {
+        this.baseDir = path.join(process.cwd(), '.artifacts', 'missions');
+        if (!fs.existsSync(this.baseDir))
+            fs.mkdirSync(this.baseDir, { recursive: true });
+    }
+    persist(state) {
+        const filePath = path.join(this.baseDir, `${state.taskId}.json`);
+        (0, AtomicWriter_1.writeJsonAtomic)(filePath, state);
+        if (state.consequenceThoughtTrace) {
+            const thoughtTracePath = path.join(this.baseDir, `${state.taskId}.thought-trace.json`);
+            (0, AtomicWriter_1.writeJsonAtomic)(thoughtTracePath, state.consequenceThoughtTrace);
+        }
+        return filePath;
+    }
+}
+exports.MissionStateStore = MissionStateStore;
+/**
+ * Checkpoint persistence backed by atomic writes. Each missionId has at most
+ * one active checkpoint file; saveCheckpoint replaces the previous one.
+ *
+ * Storage: `<stateDir>/checkpoints/<sanitizedMissionId>.json` where
+ * `<stateDir>` = `OPENLIFE_STATE_DIR` env var if set, else `.openlife/`
+ * relative to the constructor root (or process.cwd()).
+ *
+ * Why a separate store and not extending MissionStateStore? Checkpoints are
+ * autonomy-layer artifacts (lives in `.openlife/`, survives across project
+ * workspaces) while MissionStateStore is workspace-scoped under
+ * `.artifacts/missions/`. The split matches the v1.2 layering: `.openlife/`
+ * is the autonomous runtime layer, `.artifacts/` is the execution-results
+ * layer.
+ */
+class MissionCheckpointStore {
+    baseDir;
+    constructor(root = process.cwd()) {
+        const stateDir = process.env.OPENLIFE_STATE_DIR || path.join(root, '.openlife');
+        this.baseDir = path.join(stateDir, 'checkpoints');
+    }
+    /**
+     * Save (or overwrite) the latest checkpoint for `missionId`. The write is
+     * atomic — if the process crashes mid-save the previous checkpoint stays
+     * intact.
+     */
+    saveCheckpoint(missionId, step, state) {
+        const ckpt = {
+            missionId,
+            step,
+            state,
+            savedAt: new Date().toISOString(),
+        };
+        (0, AtomicWriter_1.writeJsonAtomic)(this.checkpointPath(missionId), ckpt);
+    }
+    /**
+     * Read the latest checkpoint for `missionId`. Returns null if no checkpoint
+     * exists or the file is corrupted (in which case the caller should treat
+     * the mission as un-resumable and start fresh).
+     */
+    getLatestCheckpoint(missionId) {
+        const filePath = this.checkpointPath(missionId);
+        if (!fs.existsSync(filePath))
+            return null;
+        try {
+            const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            if (raw && typeof raw === 'object' && typeof raw.step === 'string') {
+                return raw;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Read the latest checkpoint and signal intent to resume. Currently
+     * identical to getLatestCheckpoint; the separate method exists so that
+     * future audit/event hooks (e.g. emit `mission.resume.started` to the
+     * security event log) can be attached here without changing call sites.
+     */
+    resumeFromCheckpoint(missionId) {
+        return this.getLatestCheckpoint(missionId);
+    }
+    /**
+     * List all missionIds that currently have a saved checkpoint. Useful for
+     * recovery sweeps on daemon boot (find pending resumes after a crash).
+     */
+    list() {
+        if (!fs.existsSync(this.baseDir))
+            return [];
+        return fs.readdirSync(this.baseDir)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => f.replace(/\.json$/, ''));
+    }
+    /**
+     * Remove the checkpoint for `missionId`. Call after a successful resume
+     * has consumed the checkpoint, or after the mission has reached a
+     * terminal state.
+     */
+    clear(missionId) {
+        const filePath = this.checkpointPath(missionId);
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+    /** Exposed for tests so they can assert the resolved storage location. */
+    _baseDir() {
+        return this.baseDir;
+    }
+    checkpointPath(missionId) {
+        return path.join(this.baseDir, `${this.sanitize(missionId)}.json`);
+    }
+    sanitize(missionId) {
+        return missionId.replace(/[^a-zA-Z0-9._-]/g, '_');
+    }
+}
+exports.MissionCheckpointStore = MissionCheckpointStore;

package/dist/orchestrator/ModelManager.js

@@ -0,0 +1,84 @@
+"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.ModelManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ModelManager {
+    configPath;
+    defaultModels = {
+        primary: { provider: 'gemini-api', name: 'gemini-3.1-flash-lite-preview', raw: 'gemini-api/gemini-3.1-flash-lite-preview' },
+        fallbacks: [
+            { provider: 'openai-api', name: 'gpt-5.4-mini-2026-03-17', raw: 'openai-api/gpt-5.4-mini-2026-03-17' },
+            { provider: 'ollama', name: 'qwen2.5-coder:7b', raw: 'ollama/qwen2.5-coder:7b' }
+        ]
+    };
+    constructor() {
+        this.configPath = path.join(process.cwd(), 'models.json');
+        this.ensureConfigFile();
+    }
+    ensureConfigFile() {
+        if (!fs.existsSync(this.configPath)) {
+            fs.writeFileSync(this.configPath, JSON.stringify(this.defaultModels, null, 2));
+        }
+    }
+    getModelConfig() {
+        try {
+            const content = fs.readFileSync(this.configPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (e) {
+            return this.defaultModels;
+        }
+    }
+    saveConfig(config) {
+        fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+    }
+    parseModelString(input) {
+        if (!input.includes('/')) {
+            throw new Error(`Formato inválido: '${input}'. O padrão exigido é <provider>/<model> (ex: gemini-cli/gemini-3.1-pro-preview).`);
+        }
+        const parts = input.split('/');
+        const providerStr = parts[0];
+        const name = parts.slice(1).join('/');
+        const validProviders = ['openai-api', 'openai-cli', 'anthropic', 'gemini-api', 'gemini-cli', 'ollama', 'openrouter'];
+        const provider = providerStr.toLowerCase();
+        if (!validProviders.includes(provider)) {
+            throw new Error(`Provedor não suportado: '${provider}'. Provedores válidos: ${validProviders.join(', ')}.`);
+        }
+        return { provider, name, raw: input };
+    }
+}
+exports.ModelManager = ModelManager;

package/dist/orchestrator/OperatingSystem.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatingSystem = void 0;
+const ExecutionBoard_1 = require("./ExecutionBoard");
+const RoleHandoff_1 = require("./RoleHandoff");
+const CadenceEngine_1 = require("./CadenceEngine");
+class OperatingSystem {
+    board;
+    handoffs;
+    cadence;
+    constructor() {
+        this.board = new ExecutionBoard_1.ExecutionBoard();
+        this.handoffs = new RoleHandoff_1.RoleHandoff();
+        this.cadence = new CadenceEngine_1.CadenceEngine();
+    }
+    decide(missionId) {
+        const item = this.board.getAll().find((entry) => entry.id === missionId);
+        const handoff = this.handoffs.getAll().find((entry) => entry.missionId === missionId && entry.status !== 'completed');
+        const blockers = this.collectBlockers(item);
+        const effectiveOwnerRole = handoff?.toRole || item?.ownerRole || 'coo';
+        const effectivePriority = this.computePriority(item, blockers);
+        const cadence = this.cadence.getAll().filter((event) => event.linkedMissionId === missionId);
+        const hasReview = cadence.some((event) => event.kind === 'review');
+        const shouldRelease = blockers.length === 0 && hasReview && item?.status === 'done';
+        return {
+            missionId,
+            effectiveOwnerRole,
+            effectivePriority,
+            blockers,
+            shouldRelease,
+            rationale: `owner=${effectiveOwnerRole}; priority=${effectivePriority}; blockers=${blockers.join('|') || 'none'}; handoff=${handoff ? `${handoff.fromRole}->${handoff.toRole}` : 'none'}`
+        };
+    }
+    scheduleWeeklyCadence(anchor = 'weekly-operating-cycle') {
+        const planning = this.cadence.schedule('planning', `${anchor}: planning`, 'coo');
+        const review = this.cadence.schedule('review', `${anchor}: review`, 'ceo');
+        const release = this.cadence.schedule('release', `${anchor}: release`, 'cto');
+        return [planning, review, release];
+    }
+    collectBlockers(item) {
+        const blockers = [];
+        if (!item)
+            return ['missing-board-item'];
+        if (item.blockerReason)
+            blockers.push(item.blockerReason);
+        if (item.dependencies?.length) {
+            const all = this.board.getAll();
+            for (const dep of item.dependencies) {
+                const depItem = all.find((candidate) => candidate.id === dep);
+                if (!depItem || depItem.status !== 'done')
+                    blockers.push(`dependency:${dep}`);
+            }
+        }
+        if (typeof item.slaHours === 'number' && typeof item.ageHours === 'number' && item.ageHours > item.slaHours) {
+            blockers.push('sla-breached');
+        }
+        return blockers;
+    }
+    computePriority(item, blockers) {
+        if (!item)
+            return 'critical';
+        if (blockers.includes('sla-breached'))
+            return 'critical';
+        if (item.priority === 'critical')
+            return 'critical';
+        if (blockers.length > 0)
+            return 'high';
+        return item.priority;
+    }
+}
+exports.OperatingSystem = OperatingSystem;

package/dist/orchestrator/OperationalMemoryStore.js

@@ -0,0 +1,94 @@
+"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.OperationalMemoryStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const LocalMemoryProvider_1 = require("../memory/LocalMemoryProvider");
+const MemoryOrchestrator_1 = require("../memory/MemoryOrchestrator");
+class OperationalMemoryStore {
+    filePath;
+    provider;
+    orchestrator;
+    constructor() {
+        this.filePath = path.join(process.cwd(), '.artifacts', 'operational-memory.json');
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        this.provider = new LocalMemoryProvider_1.LocalMemoryProvider();
+        this.orchestrator = new MemoryOrchestrator_1.MemoryOrchestrator();
+    }
+    add(entry, namespace) {
+        const all = this.getAll();
+        all.push(entry);
+        fs.writeFileSync(this.filePath, JSON.stringify(all, null, 2), 'utf-8');
+        const record = {
+            id: `mem-${entry.missionId}`,
+            type: 'episodic',
+            namespace: namespace || {},
+            content: `${entry.goal}\n\n${entry.summary}\n\n${entry.lessons.join('\n')}`,
+            summary: entry.summary,
+            tags: entry.lessons,
+            confidence: 0.8,
+            sourceMissionId: entry.missionId,
+            dedupeKey: entry.missionId,
+            createdAt: entry.createdAt,
+            updatedAt: entry.createdAt
+        };
+        void this.provider.save(record);
+        void this.orchestrator.save({
+            type: 'episodic',
+            namespace: namespace || {},
+            content: record.content,
+            summary: record.summary,
+            tags: record.tags,
+            confidence: record.confidence,
+            sourceMissionId: record.sourceMissionId,
+            dedupeKey: record.dedupeKey,
+            providers: ['local']
+        });
+    }
+    getAll() {
+        if (!fs.existsSync(this.filePath))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.OperationalMemoryStore = OperationalMemoryStore;

package/dist/orchestrator/OptimizationLoop.js

@@ -0,0 +1,72 @@
+"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.OptimizationLoop = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PerformanceScorecard_1 = require("./PerformanceScorecard");
+class OptimizationLoop {
+    filePath;
+    scorecard;
+    constructor() {
+        this.filePath = path.join(process.cwd(), '.artifacts', 'optimization-suggestions.json');
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        this.scorecard = new PerformanceScorecard_1.PerformanceScorecard();
+    }
+    generateSuggestions() {
+        const all = Object.values(this.scorecard.getAll());
+        const suggestions = all
+            .filter((item) => item.runs >= 2)
+            .filter((item) => item.score < 1 || item.fallbackRate > 0.4 || item.avgReviewScore < 6)
+            .map((item) => ({
+            entityId: item.entityId,
+            entityType: item.entityType,
+            reason: `score=${item.score.toFixed(2)}, fallbackRate=${item.fallbackRate.toFixed(2)}, avgReviewScore=${item.avgReviewScore.toFixed(2)}`,
+            suggestedAction: this.suggestAction(item),
+            priority: item.score < 0 || item.avgReviewScore < 5 ? 'high' : 'medium',
+            createdAt: new Date().toISOString()
+        }));
+        fs.writeFileSync(this.filePath, JSON.stringify(suggestions, null, 2), 'utf-8');
+        return suggestions;
+    }
+    suggestAction(item) {
+        if (item.fallbackRate > 0.4)
+            return 'Reduzir dependência desta rota e testar fallback alternativo ou policy de seleção.';
+        if (item.avgReviewScore < 6)
+            return 'Revisar qualidade da saída e ajustar prompt/roteamento/skill associada.';
+        return 'Reavaliar prioridade desta entidade no roteamento e comparar com alternativas melhores.';
+    }
+}
+exports.OptimizationLoop = OptimizationLoop;