@openlife/cli 1.7.3

package/dist/orchestrator/ConsequenceForecaster.js

@@ -0,0 +1,286 @@
+"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.ConsequenceForecaster = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const AtomicWriter_1 = require("./util/AtomicWriter");
+class ConsequenceForecaster {
+    forecast(goal, governanceRisk, basePolicy, executors) {
+        const normalizedGoal = goal.toLowerCase();
+        const paths = [
+            this.buildConservativePath(basePolicy, executors, governanceRisk, normalizedGoal),
+            this.buildBalancedPath(basePolicy, executors, governanceRisk, normalizedGoal),
+            this.buildAggressivePath(basePolicy, executors, governanceRisk, normalizedGoal)
+        ];
+        const selectedPath = this.pickBest(paths);
+        const executiveSummary = this.buildExecutiveSummary(selectedPath, governanceRisk, normalizedGoal);
+        return { selectedPath, consideredPaths: paths, executiveSummary };
+    }
+    /**
+     * Story 14.3 (v1.5) — Brain-enriched forecast with persistent cache.
+     *
+     * Calls `forecast()` first, then layers a Brain-derived
+     * `BrainForecastEnrichment` on top (riskAmplifiers / opportunityFactors /
+     * overallVerdict / rationale). The enrichment is cached at
+     * `.openlife/forecasts/<sha256(goal)>.json` keyed by goalHash + governanceRisk
+     * so repeated forecasts for the same goal don't burn tokens.
+     *
+     * Falls back gracefully:
+     *   • Cache hit fresher than TTL (default 24h) → cached enrichment, source='cache'
+     *   • Brain key absent → no enrichment attached; pure heuristic forecast
+     *   • Brain available + parseable → fresh enrichment cached, source='brain'
+     *   • Brain available + garbage → no enrichment attached
+     *
+     * Disable cache via OPENLIFE_FORECAST_CACHE=off. Custom TTL via
+     * OPENLIFE_FORECAST_CACHE_TTL_HOURS.
+     */
+    async forecastWithBrain(goal, governanceRisk, basePolicy, executors) {
+        const base = this.forecast(goal, governanceRisk, basePolicy, executors);
+        const goalHash = crypto.createHash('sha256').update(goal).digest('hex');
+        const cacheKey = `${goalHash}_${governanceRisk}`;
+        const cached = this.readForecastCache(cacheKey);
+        if (cached)
+            return { ...base, brain: { ...cached, source: 'cache' } };
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { Brain } = require('./Brain');
+            const brain = new Brain();
+            if (!brain.isAnyProviderAvailable())
+                return base;
+            const systemPrompt = [
+                'You are a risk forecaster for an autonomous orchestrator.',
+                'Given a mission goal, governance risk level, and selected execution path,',
+                'output ONE LINE of JSON: { "riskAmplifiers": [string,...], "opportunityFactors": [string,...], "overallVerdict": "safe"|"caution"|"block", "rationale": string }',
+                'Max 5 entries per array. No markdown, no preamble.',
+            ].join(' ');
+            const userMessage = [
+                `Goal: ${goal}`,
+                `Governance risk: ${governanceRisk}`,
+                `Selected path: ${base.selectedPath.id} (${base.selectedPath.description})`,
+                `Considered consequences: ${base.selectedPath.consequences.join(' | ')}`,
+            ].join('\n');
+            const raw = await brain.think(systemPrompt, userMessage);
+            const parsed = this.parseBrainEnrichment(raw);
+            if (!parsed)
+                return base;
+            const enrichment = { ...parsed, source: 'brain', cachedAt: new Date().toISOString() };
+            this.writeForecastCache(cacheKey, enrichment);
+            return { ...base, brain: enrichment };
+        }
+        catch {
+            return base;
+        }
+    }
+    parseBrainEnrichment(raw) {
+        try {
+            const start = raw.indexOf('{');
+            const end = raw.lastIndexOf('}');
+            if (start < 0 || end <= start)
+                return null;
+            const obj = JSON.parse(raw.slice(start, end + 1));
+            const amp = Array.isArray(obj.riskAmplifiers)
+                ? obj.riskAmplifiers.filter((s) => typeof s === 'string').slice(0, 5)
+                : null;
+            const opp = Array.isArray(obj.opportunityFactors)
+                ? obj.opportunityFactors.filter((s) => typeof s === 'string').slice(0, 5)
+                : null;
+            const verdict = obj.overallVerdict === 'safe' || obj.overallVerdict === 'caution' || obj.overallVerdict === 'block'
+                ? obj.overallVerdict
+                : null;
+            const rationale = typeof obj.rationale === 'string' ? obj.rationale.slice(0, 400) : '';
+            if (!amp || !opp || !verdict)
+                return null;
+            return { riskAmplifiers: amp, opportunityFactors: opp, overallVerdict: verdict, rationale };
+        }
+        catch {
+            return null;
+        }
+    }
+    readForecastCache(cacheKey) {
+        if (process.env.OPENLIFE_FORECAST_CACHE === 'off')
+            return null;
+        const file = this.cacheFile(cacheKey);
+        if (!fs.existsSync(file))
+            return null;
+        try {
+            const entry = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            const ttlHours = Number(process.env.OPENLIFE_FORECAST_CACHE_TTL_HOURS || 24);
+            if (!entry.cachedAt)
+                return null;
+            const ageMs = Date.now() - new Date(entry.cachedAt).getTime();
+            if (ageMs > ttlHours * 60 * 60 * 1000)
+                return null;
+            return entry;
+        }
+        catch {
+            return null;
+        }
+    }
+    writeForecastCache(cacheKey, entry) {
+        if (process.env.OPENLIFE_FORECAST_CACHE === 'off')
+            return;
+        try {
+            const file = this.cacheFile(cacheKey);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            (0, AtomicWriter_1.writeJsonAtomic)(file, entry);
+        }
+        catch { /* non-fatal */ }
+    }
+    cacheFile(cacheKey) {
+        const stateDir = process.env.OPENLIFE_STATE_DIR || path.join(process.cwd(), '.openlife');
+        return path.join(stateDir, 'forecasts', `${cacheKey}.json`);
+    }
+    buildConservativePath(basePolicy, executors, risk, normalizedGoal) {
+        const policy = {
+            executionMode: 'balanced',
+            swarmMode: 'none',
+            maxBranches: 1,
+            rationale: 'Conservador: minimizar risco de efeitos colaterais.'
+        };
+        const score = this.scorePath(risk, policy, executors, normalizedGoal, true);
+        return {
+            id: 'conservative',
+            description: 'Executa com baixa superfície e validação estrita.',
+            policy,
+            executors,
+            consequences: [
+                'Reduz chance de bloqueio por governança',
+                'Pode aumentar tempo total de execução',
+                'Preserva previsibilidade do serviço'
+            ],
+            score
+        };
+    }
+    buildBalancedPath(basePolicy, executors, risk, normalizedGoal) {
+        const policy = {
+            ...basePolicy,
+            executionMode: 'balanced',
+            swarmMode: basePolicy.swarmMode === 'consensus' ? 'parallel' : basePolicy.swarmMode,
+            maxBranches: Math.max(1, Math.min(basePolicy.maxBranches, 3)),
+            rationale: 'Balanceado: manter qualidade com risco controlado.'
+        };
+        const score = this.scorePath(risk, policy, executors, normalizedGoal, false) + 1;
+        return {
+            id: 'balanced',
+            description: 'Combina execução robusta com fallback e revisão.',
+            policy,
+            executors,
+            consequences: [
+                'Boa relação entre velocidade e segurança',
+                'Mantém chance alta de serviço completo',
+                'Risco moderado de retrabalho'
+            ],
+            score
+        };
+    }
+    buildAggressivePath(basePolicy, executors, risk, normalizedGoal) {
+        const policy = {
+            executionMode: 'performance',
+            swarmMode: 'consensus',
+            maxBranches: 4,
+            rationale: 'Agressivo: maximizar throughput e paralelismo.'
+        };
+        const score = this.scorePath(risk, policy, executors, normalizedGoal, false) - 2;
+        return {
+            id: 'aggressive',
+            description: 'Força paralelismo para velocidade máxima.',
+            policy,
+            executors,
+            consequences: [
+                'Aumenta velocidade em cenários favoráveis',
+                'Eleva superfície de risco e custo',
+                'Maior probabilidade de bloqueio em risco alto'
+            ],
+            score
+        };
+    }
+    pickBest(paths) {
+        return paths.reduce((best, current) => {
+            if (current.score > best.score)
+                return current;
+            if (current.score < best.score)
+                return best;
+            const stabilityRank = {
+                conservative: 3,
+                balanced: 2,
+                aggressive: 1
+            };
+            return stabilityRank[current.id] > stabilityRank[best.id] ? current : best;
+        });
+    }
+    buildExecutiveSummary(selectedPath, risk, normalizedGoal) {
+        const goalHint = this.goalBias(normalizedGoal);
+        return `Rota escolhida: ${selectedPath.id}. Risk=${risk}. Viés do objetivo=${goalHint}. Consequências previstas: ${selectedPath.consequences.join(' | ')}`;
+    }
+    goalBias(normalizedGoal) {
+        const speedTokens = ['deploy', 'urgente', 'hotfix', 'incident', 'performance', 'rápido', 'rapido'];
+        const safetyTokens = ['prod', 'produção', 'producao', 'governança', 'governanca', 'compliance', 'security', 'segurança', 'seguranca'];
+        const speed = speedTokens.some((token) => normalizedGoal.includes(token));
+        const safety = safetyTokens.some((token) => normalizedGoal.includes(token));
+        if (speed && !safety)
+            return 'speed';
+        if (safety)
+            return 'safety';
+        return 'neutral';
+    }
+    scorePath(risk, policy, executors, normalizedGoal, conservative) {
+        let score = 0;
+        if (executors.length > 1)
+            score += 2;
+        if (policy.swarmMode === 'none')
+            score += 1;
+        if (policy.swarmMode === 'light')
+            score += 1;
+        if (policy.swarmMode === 'parallel')
+            score += 1;
+        if (policy.swarmMode === 'consensus')
+            score -= 1;
+        if (risk === 'high')
+            score += conservative ? 4 : -3;
+        if (risk === 'medium')
+            score += conservative ? 1 : 0;
+        if (risk === 'low')
+            score += conservative ? 0 : 2;
+        const bias = this.goalBias(normalizedGoal);
+        if (bias === 'speed' && !conservative)
+            score += 2;
+        if (bias === 'safety' && conservative)
+            score += 2;
+        return score;
+    }
+}
+exports.ConsequenceForecaster = ConsequenceForecaster;

package/dist/orchestrator/CronManager.js

@@ -0,0 +1,286 @@
+"use strict";
+/**
+ * CronManager — minimal 5-field cron scheduler.
+ *
+ * Story 5.1 — OpenLife v1.3 Agent OS Integration.
+ *
+ * 5-field cron syntax: `minute hour day-of-month month day-of-week`
+ *   - * (any)
+ *   - n (literal)
+ *   - n-m (range)
+ *   - n,m (list)
+ *   - * /n (step)
+ *
+ * Storage: `.openlife/crons.json` (atomic via AtomicWriter).
+ *
+ * Lifecycle: jobs are persisted; start() polls every 30s (or
+ * tickIntervalMs) and fires any job whose due-time falls inside the
+ * last interval. Idempotent start/stop.
+ *
+ * The trigger payload is dispatched via an optional `executor` callback
+ * supplied at construction time. By default, the cron only logs the fire
+ * event to `.openlife/cron-events.jsonl` — operators can wire QueueScheduler
+ * or any other dispatcher.
+ */
+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.CronManager = void 0;
+exports.parseCronExpression = parseCronExpression;
+exports.matchesCron = matchesCron;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./util/AtomicWriter");
+const ToolsetGuard_1 = require("./toolset/ToolsetGuard");
+class CronManager {
+    file;
+    eventsFile;
+    tickIntervalMs;
+    executor;
+    timer = null;
+    lastTickAt = 0;
+    constructor(opts = {}) {
+        const stateDir = opts.stateDir
+            || process.env.OPENLIFE_STATE_DIR
+            || path.join(process.cwd(), '.openlife');
+        fs.mkdirSync(stateDir, { recursive: true });
+        this.file = path.join(stateDir, 'crons.json');
+        this.eventsFile = path.join(stateDir, 'cron-events.jsonl');
+        this.tickIntervalMs = opts.tickIntervalMs ?? 30000;
+        this.executor = opts.executor;
+    }
+    read() {
+        if (!fs.existsSync(this.file))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(this.file, 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+    }
+    write(jobs) {
+        (0, AtomicWriter_1.writeJsonAtomic)(this.file, jobs);
+    }
+    list() {
+        return this.read();
+    }
+    create(id, expression, payload = {}) {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('cron', 'CronManager.create');
+        if (!/^[a-z0-9][a-z0-9._-]+$/i.test(id)) {
+            throw Object.assign(new Error('invalid_cron_id'), { code: 'invalid_cron_id' });
+        }
+        const validation = parseCronExpression(expression);
+        if (!validation.ok) {
+            throw Object.assign(new Error(`invalid_cron_expression:${validation.error}`), { code: 'invalid_cron_expression', detail: validation.error });
+        }
+        const jobs = this.read();
+        if (jobs.some((j) => j.id === id)) {
+            throw Object.assign(new Error('cron_already_exists'), { code: 'cron_already_exists' });
+        }
+        const job = {
+            id, expression, payload,
+            status: 'active',
+            createdAt: new Date().toISOString(),
+        };
+        jobs.push(job);
+        this.write(jobs);
+        return job;
+    }
+    remove(id) {
+        const jobs = this.read();
+        const filtered = jobs.filter((j) => j.id !== id);
+        if (filtered.length === jobs.length)
+            return false;
+        this.write(filtered);
+        return true;
+    }
+    pause(id) {
+        return this.setStatus(id, 'paused');
+    }
+    resume(id) {
+        return this.setStatus(id, 'active');
+    }
+    setStatus(id, status) {
+        const jobs = this.read();
+        const idx = jobs.findIndex((j) => j.id === id);
+        if (idx === -1)
+            return false;
+        jobs[idx].status = status;
+        this.write(jobs);
+        return true;
+    }
+    /** Manually fire a job (regardless of schedule). */
+    async runNow(id) {
+        const jobs = this.read();
+        const job = jobs.find((j) => j.id === id);
+        if (!job)
+            return { ok: false, error: 'not_found' };
+        await this.fire(job);
+        return { ok: true };
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.lastTickAt = Date.now();
+        // Run an immediate tick to catch up, then schedule.
+        void this.tick();
+        this.timer = setInterval(() => { void this.tick(); }, this.tickIntervalMs);
+        if (this.timer.unref)
+            this.timer.unref();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    /** Run one tick — fire any active jobs whose due-time falls in the last interval. */
+    async tick(now = new Date()) {
+        const fired = [];
+        const jobs = this.read();
+        let mutated = false;
+        for (const job of jobs) {
+            if (job.status !== 'active')
+                continue;
+            const expr = parseCronExpression(job.expression);
+            if (!expr.ok || !expr.fields)
+                continue;
+            // Fire if the current minute matches the schedule AND we haven't
+            // already fired in this minute (idempotency vs short tick intervals).
+            if (!matchesCron(expr.fields, now))
+                continue;
+            const minuteKey = `${now.getFullYear()}-${now.getMonth()}-${now.getDate()}-${now.getHours()}-${now.getMinutes()}`;
+            const lastKey = job.lastFiredAt ? (() => {
+                const d = new Date(job.lastFiredAt);
+                return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}-${d.getHours()}-${d.getMinutes()}`;
+            })() : null;
+            if (minuteKey === lastKey)
+                continue;
+            job.lastFiredAt = now.toISOString();
+            mutated = true;
+            await this.fire(job);
+            fired.push(job.id);
+        }
+        if (mutated)
+            this.write(jobs);
+        return fired;
+    }
+    async fire(job) {
+        (0, AtomicWriter_1.appendJsonlAtomic)(this.eventsFile, {
+            at: new Date().toISOString(),
+            type: 'cron_fired',
+            id: job.id,
+            expression: job.expression,
+        });
+        if (this.executor) {
+            try {
+                await this.executor.execute(job);
+            }
+            catch (err) {
+                (0, AtomicWriter_1.appendJsonlAtomic)(this.eventsFile, {
+                    at: new Date().toISOString(),
+                    type: 'cron_executor_error',
+                    id: job.id,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+}
+exports.CronManager = CronManager;
+function parseCronExpression(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        return { ok: false, error: 'expected_5_fields' };
+    }
+    try {
+        const fields = {
+            minutes: expandField(parts[0], 0, 59),
+            hours: expandField(parts[1], 0, 23),
+            daysOfMonth: expandField(parts[2], 1, 31),
+            months: expandField(parts[3], 1, 12),
+            daysOfWeek: expandField(parts[4], 0, 6),
+        };
+        return { ok: true, fields };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : 'parse_error' };
+    }
+}
+function expandField(field, min, max) {
+    const out = new Set();
+    for (const token of field.split(',')) {
+        let stride = 1;
+        let body = token;
+        const slashIdx = body.indexOf('/');
+        if (slashIdx >= 0) {
+            stride = parseInt(body.slice(slashIdx + 1), 10);
+            if (!Number.isFinite(stride) || stride <= 0)
+                throw new Error(`invalid_step:${field}`);
+            body = body.slice(0, slashIdx);
+        }
+        let lo;
+        let hi;
+        if (body === '*' || body === '') {
+            lo = min;
+            hi = max;
+        }
+        else if (body.includes('-')) {
+            const [a, b] = body.split('-').map((n) => parseInt(n, 10));
+            if (!Number.isFinite(a) || !Number.isFinite(b))
+                throw new Error(`invalid_range:${field}`);
+            lo = a;
+            hi = b;
+        }
+        else {
+            const n = parseInt(body, 10);
+            if (!Number.isFinite(n))
+                throw new Error(`invalid_number:${field}`);
+            lo = n;
+            hi = n;
+        }
+        if (lo < min || hi > max || lo > hi)
+            throw new Error(`out_of_range:${field}`);
+        for (let v = lo; v <= hi; v += stride)
+            out.add(v);
+    }
+    return out;
+}
+function matchesCron(fields, d) {
+    return (fields.minutes.has(d.getMinutes())
+        && fields.hours.has(d.getHours())
+        && fields.daysOfMonth.has(d.getDate())
+        && fields.months.has(d.getMonth() + 1)
+        && fields.daysOfWeek.has(d.getDay()));
+}

package/dist/orchestrator/DynamicAgentBuilder.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicAgentBuilder = void 0;
+class DynamicAgentBuilder {
+    brain;
+    constructor(brain) {
+        this.brain = brain;
+    }
+    async propose(goal, existingAgents) {
+        const prompt = `
+Você é o DynamicAgentBuilder do OpenLife.
+
+Objetivo:
+${goal}
+
+Agentes já disponíveis:
+${existingAgents.map(a => `${a.id} -> ${a.role}`).join('\n')}
+
+Decida se falta um agente temporário especializado.
+Se sim, responda em JSON com:
+- id
+- name
+- role
+- capabilities (array)
+- temporary: true
+
+Se não precisar, responda {"temporary": false}.
+`;
+        const raw = await this.brain.think('Decida se vale criar um agente temporário especializado.', prompt);
+        try {
+            const jsonStart = raw.indexOf('{');
+            const parsed = JSON.parse(jsonStart >= 0 ? raw.slice(jsonStart) : raw);
+            if (!parsed.temporary)
+                return null;
+            return {
+                id: parsed.id || `dynamic-agent-${Date.now()}`,
+                name: parsed.name || 'Dynamic Specialist',
+                role: parsed.role || 'specialist',
+                capabilities: Array.isArray(parsed.capabilities) ? parsed.capabilities : ['specialized-task'],
+                temporary: true
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.DynamicAgentBuilder = DynamicAgentBuilder;

package/dist/orchestrator/DynamicAgentExecutor.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicAgentExecutor = void 0;
+class DynamicAgentExecutor {
+    taskExecutor;
+    constructor(taskExecutor) {
+        this.taskExecutor = taskExecutor;
+    }
+    async execute(agent, goal, taskId) {
+        const prompt = `[Agente Dinâmico]\n${agent.name} (${agent.role})\n\n[Capabilities]\n${agent.capabilities.join(', ')}\n\n[Objetivo]\n${goal}`;
+        const result = await this.taskExecutor.execute('codex', prompt, `${taskId}_dynamic_${agent.id}`);
+        return result.stdout || result.stderr || '';
+    }
+}
+exports.DynamicAgentExecutor = DynamicAgentExecutor;