@openlife/cli 1.7.3

package/dist/orchestrator/QueueScheduler.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * QueueScheduler — background mission queue poller for the autonomous
+ * daemon profile.
+ *
+ * Story 6.3 — OpenLife v1.2 Royal Stack.
+ *
+ * Reads `.openlife/agent-queue.json`, picks the next `pending` mission,
+ * acquires a per-mission DistributedLock, marks it `running`, runs an
+ * injected MissionExecutor, marks the terminal state, and persists the
+ * queue via AtomicWriter. Concurrency capped by maxConcurrent (default 3).
+ *
+ * Opt-in via OPENLIFE_QUEUE_POLL_INTERVAL_MS env var or explicit
+ * `start({pollIntervalMs})`. Off by default — `start --daemon` gateway
+ * passes `--enable-queue` to flip it on. Keeps the existing Gateway
+ * event-driven path unchanged.
+ *
+ * Crash semantics: a process restart finds `running` items orphaned (no
+ * lock holder, no executing process). `reconcileOrphans()` on start
+ * resets those back to `pending` so the next worker picks them up.
+ */
+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.QueueScheduler = exports.NoopMissionExecutor = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./util/AtomicWriter");
+const DistributedLock_1 = require("./util/DistributedLock");
+class NoopMissionExecutor {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async execute() {
+        return { status: 'completed' };
+    }
+}
+exports.NoopMissionExecutor = NoopMissionExecutor;
+class QueueScheduler {
+    queueFile;
+    pollIntervalMs;
+    maxConcurrent;
+    executor;
+    lock;
+    maxAttempts;
+    timer = null;
+    running = new Set();
+    pollPromise = null;
+    shuttingDown = false;
+    constructor(opts = {}) {
+        const stateDir = process.env.OPENLIFE_STATE_DIR || path.join(process.cwd(), '.openlife');
+        this.queueFile = opts.queueFile || path.join(stateDir, 'agent-queue.json');
+        this.pollIntervalMs = opts.pollIntervalMs ?? Number(process.env.OPENLIFE_QUEUE_POLL_INTERVAL_MS || 10_000);
+        this.maxConcurrent = opts.maxConcurrent ?? 3;
+        this.executor = opts.executor || new NoopMissionExecutor();
+        this.lock = opts.lock || new DistributedLock_1.DistributedLock();
+        this.maxAttempts = opts.maxAttempts ?? 5;
+    }
+    /** Add a mission to the queue. Atomic. */
+    enqueue(spec) {
+        const q = this.read();
+        const mission = {
+            ...spec,
+            enqueuedAt: new Date().toISOString(),
+            status: 'pending',
+            attempts: 0,
+        };
+        q.items.push(mission);
+        this.write(q);
+        return mission;
+    }
+    /** Inspect the queue without modification. */
+    list() {
+        return this.read().items;
+    }
+    /**
+     * Reset any 'running' missions back to 'pending'. Call on boot to
+     * recover from a previous crash that left missions mid-flight.
+     */
+    reconcileOrphans() {
+        const q = this.read();
+        let reset = 0;
+        for (const item of q.items) {
+            if (item.status === 'running') {
+                item.status = 'pending';
+                item.startedAt = undefined;
+                reset += 1;
+            }
+        }
+        if (reset > 0)
+            this.write(q);
+        return reset;
+    }
+    /**
+     * Start the poll loop. Performs an immediate reconcileOrphans() then
+     * schedules periodic ticks. Idempotent.
+     */
+    start() {
+        if (this.timer)
+            return;
+        this.reconcileOrphans();
+        // Immediate tick + interval
+        void this.tick();
+        this.timer = setInterval(() => { void this.tick(); }, this.pollIntervalMs);
+        if (typeof this.timer.unref === 'function')
+            this.timer.unref();
+    }
+    /**
+     * Gracefully stop. Awaits the current tick to settle (no new picks)
+     * but does not wait for in-flight missions to finish — those continue
+     * on their own promises. Idempotent.
+     */
+    async stop() {
+        this.shuttingDown = true;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (this.pollPromise) {
+            try {
+                await this.pollPromise;
+            }
+            catch { /* swallow */ }
+        }
+    }
+    /** Force one poll iteration (used by tests). */
+    async tick() {
+        if (this.shuttingDown)
+            return;
+        if (this.pollPromise)
+            return; // already polling
+        this.pollPromise = (async () => {
+            try {
+                await this.poll();
+            }
+            finally {
+                this.pollPromise = null;
+            }
+        })();
+        return this.pollPromise;
+    }
+    // ─────────────────────────────────────────────────────────
+    // Internals
+    // ─────────────────────────────────────────────────────────
+    async poll() {
+        const q = this.read();
+        const slots = this.maxConcurrent - this.running.size;
+        if (slots <= 0)
+            return;
+        let picked = 0;
+        for (const item of q.items) {
+            if (picked >= slots)
+                break;
+            if (item.status !== 'pending')
+                continue;
+            if (this.running.has(item.id))
+                continue;
+            // Attempt to acquire the per-mission lock
+            const acq = this.lock.acquire(`mission:${item.id}`, this.pollIntervalMs * 4, { startHeartbeat: true });
+            if (!acq.ok)
+                continue;
+            item.status = 'running';
+            item.startedAt = new Date().toISOString();
+            item.attempts += 1;
+            this.running.add(item.id);
+            picked += 1;
+            // Persist the running transition before dispatching
+            this.writeItems(q.items);
+            // Fire-and-track the execution without blocking the poll loop
+            void this.runMission(item, acq.lockId);
+        }
+    }
+    async runMission(item, lockId) {
+        let result;
+        try {
+            result = await this.executor.execute(item);
+        }
+        catch (err) {
+            result = { status: 'failed', error: err instanceof Error ? err.message : String(err) };
+        }
+        const q = this.read();
+        const ref = q.items.find((m) => m.id === item.id);
+        if (ref) {
+            if (result.status === 'completed') {
+                ref.status = 'completed';
+                ref.completedAt = new Date().toISOString();
+                ref.lastError = undefined;
+            }
+            else {
+                ref.lastError = result.error;
+                if (ref.attempts >= this.maxAttempts) {
+                    ref.status = 'failed';
+                    ref.completedAt = new Date().toISOString();
+                }
+                else {
+                    // Re-queue for another attempt
+                    ref.status = 'pending';
+                    ref.startedAt = undefined;
+                }
+            }
+            this.writeItems(q.items);
+        }
+        this.lock.release(lockId);
+        this.running.delete(item.id);
+    }
+    read() {
+        if (!fs.existsSync(this.queueFile))
+            return { items: [] };
+        try {
+            const raw = JSON.parse(fs.readFileSync(this.queueFile, 'utf-8'));
+            if (Array.isArray(raw.items))
+                return raw;
+            return { items: [] };
+        }
+        catch {
+            return { items: [] };
+        }
+    }
+    write(payload) {
+        payload.lastFlushedAt = new Date().toISOString();
+        (0, AtomicWriter_1.writeJsonAtomic)(this.queueFile, payload);
+    }
+    writeItems(items) {
+        this.write({ items, lastFlushedAt: new Date().toISOString() });
+    }
+    /** Exposed for tests. */
+    _queueFile() {
+        return this.queueFile;
+    }
+}
+exports.QueueScheduler = QueueScheduler;

package/dist/orchestrator/ReleaseGate.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseGate = void 0;
+const SystemDoctor_1 = require("./SystemDoctor");
+const TestHarness_1 = require("./TestHarness");
+const ReleaseWorkflow_1 = require("./ReleaseWorkflow");
+const OperatingSystem_1 = require("./OperatingSystem");
+class ReleaseGate {
+    doctor;
+    harness;
+    workflow;
+    operatingSystem;
+    constructor() {
+        this.doctor = new SystemDoctor_1.SystemDoctor();
+        this.harness = new TestHarness_1.TestHarness();
+        this.workflow = new ReleaseWorkflow_1.ReleaseWorkflow();
+        this.operatingSystem = new OperatingSystem_1.OperatingSystem();
+    }
+    async run(releaseId, missionId) {
+        const staticChecks = this.doctor.run();
+        const runtimeChecks = await this.doctor.runRuntimeChecks();
+        const harnessChecks = await this.harness.runPhase1Checks();
+        const checks = [
+            ...staticChecks.map((check) => ({ name: `doctor:${check.name}`, ok: check.ok })),
+            ...runtimeChecks.map((check) => ({ name: `runtime:${check.name}`, ok: check.ok })),
+            ...harnessChecks.map((check) => ({ name: `harness:${check.name}`, ok: check.ok }))
+        ];
+        if (missionId) {
+            const decision = this.operatingSystem.decide(missionId);
+            checks.push({ name: `ops:shouldRelease`, ok: decision.shouldRelease });
+            checks.push({ name: `ops:noBlockers`, ok: decision.blockers.length === 0 });
+        }
+        return this.workflow.create(releaseId, checks);
+    }
+}
+exports.ReleaseGate = ReleaseGate;

package/dist/orchestrator/ReleaseWorkflow.js

@@ -0,0 +1,68 @@
+"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.ReleaseWorkflow = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ReleaseWorkflow {
+    filePath;
+    constructor() {
+        this.filePath = path.join(process.cwd(), '.artifacts', 'release-checklists.json');
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    }
+    create(releaseId, checks) {
+        const checklist = {
+            releaseId,
+            checks,
+            approved: checks.every((check) => check.ok),
+            createdAt: new Date().toISOString()
+        };
+        const all = this.getAll();
+        all.push(checklist);
+        fs.writeFileSync(this.filePath, JSON.stringify(all, null, 2), 'utf-8');
+        return checklist;
+    }
+    getAll() {
+        if (!fs.existsSync(this.filePath))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.ReleaseWorkflow = ReleaseWorkflow;

package/dist/orchestrator/RemotePublisher.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * RemotePublisher — Story 14.1 (v1.5)
+ *
+ * Pushes a sealed asset (Squad or Skill) to a remote registry over HTTPS.
+ * OpenLife does not yet bundle a registry of its own — this module ships
+ * the client-side surface so any HTTPS endpoint that accepts an
+ * authenticated PUT can serve as the registry.
+ *
+ * Wire-up:
+ *   • Activate by setting OPENLIFE_REMOTE_PUBLISH_URL (base URL).
+ *   • Optional OPENLIFE_REMOTE_PUBLISH_TOKEN — sent as `Authorization: Bearer ...`.
+ *   • Each publish request is: PUT <base>/<kind>/<id>/<sha256>.md
+ *     with the asset markdown as the request body and the SHA-256 in
+ *     the `X-Asset-Sha256` header so the server can verify integrity.
+ *
+ * Failure shape: never throws. Returns
+ *   { ok: false, error: '<stable-code>', detail?: '<short>' }
+ * with stable codes:
+ *   • 'remote_publish_not_configured'  — no URL env var set
+ *   • 'invalid_url'                    — base URL is malformed
+ *   • 'fetch_error'                    — network / abort
+ *   • 'http_<status>'                  — non-2xx response
+ *   • 'asset_not_found'                — local file disappeared mid-flight
+ *   • 'sha_mismatch_local'             — local re-hash != provided sha256
+ */
+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.RemotePublisher = void 0;
+const fs = __importStar(require("fs"));
+class RemotePublisher {
+    baseUrl;
+    token;
+    fetchImpl;
+    timeoutMs;
+    constructor(opts = {}) {
+        this.baseUrl = opts.baseUrl ?? (process.env.OPENLIFE_REMOTE_PUBLISH_URL || '');
+        this.token = opts.token ?? (process.env.OPENLIFE_REMOTE_PUBLISH_TOKEN || '');
+        this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+        this.timeoutMs = opts.timeoutMs ?? 15_000;
+    }
+    isConfigured() {
+        return this.baseUrl.trim().length > 0;
+    }
+    async publishAsset(kind, id, sha256, file) {
+        if (!this.isConfigured()) {
+            return { ok: false, error: 'remote_publish_not_configured', detail: 'set OPENLIFE_REMOTE_PUBLISH_URL' };
+        }
+        const url = this.buildUrl(kind, id, sha256);
+        if (!url)
+            return { ok: false, error: 'invalid_url' };
+        if (!fs.existsSync(file))
+            return { ok: false, error: 'asset_not_found', detail: file };
+        let body;
+        try {
+            body = fs.readFileSync(file, 'utf-8');
+        }
+        catch (err) {
+            return { ok: false, error: 'asset_not_found', detail: err instanceof Error ? err.message : String(err) };
+        }
+        // Defensive: re-hash locally to make sure the caller didn't drift.
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const crypto = require('crypto');
+        const computed = crypto.createHash('sha256').update(body).digest('hex');
+        if (computed !== sha256) {
+            return { ok: false, error: 'sha_mismatch_local', detail: `expected=${sha256.slice(0, 12)}… computed=${computed.slice(0, 12)}…` };
+        }
+        const headers = {
+            'Content-Type': 'text/markdown',
+            'X-Asset-Sha256': sha256,
+            'X-Asset-Kind': kind,
+            'X-Asset-Id': id,
+        };
+        if (this.token)
+            headers.Authorization = `Bearer ${this.token}`;
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), this.timeoutMs);
+        try {
+            const response = await this.fetchImpl(url, { method: 'PUT', headers, body, signal: ac.signal });
+            const status = response.status;
+            const etag = response.headers.get?.('etag') || undefined;
+            if (status < 200 || status >= 300) {
+                return { ok: false, url, status, error: `http_${status}` };
+            }
+            return { ok: true, url, status, etag };
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: 'fetch_error', detail };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    buildUrl(kind, id, sha256) {
+        try {
+            const base = new URL(this.baseUrl);
+            // Always append a clean path; ignore any base path hidden in baseUrl
+            const trimmed = base.toString().replace(/\/+$/, '');
+            return `${trimmed}/${encodeURIComponent(kind)}/${encodeURIComponent(id)}/${encodeURIComponent(sha256)}.md`;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.RemotePublisher = RemotePublisher;

package/dist/orchestrator/ReuseEngine.js

@@ -0,0 +1,89 @@
+"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.ReuseEngine = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ReuseEngine {
+    memoryFile;
+    promotedDir;
+    constructor() {
+        this.memoryFile = path.join(process.cwd(), '.artifacts', 'operational-memory.json');
+        this.promotedDir = path.join(process.cwd(), '.openlife', 'promoted-assets');
+    }
+    findHints(goal) {
+        const normalized = goal.toLowerCase();
+        const hints = [];
+        if (fs.existsSync(this.memoryFile)) {
+            try {
+                const entries = JSON.parse(fs.readFileSync(this.memoryFile, 'utf-8'));
+                for (const entry of entries) {
+                    const blob = `${entry.goal || ''} ${entry.summary || ''} ${(entry.lessons || []).join(' ')}`.toLowerCase();
+                    if (blob.includes(normalized.slice(0, 20)) || normalized.includes((entry.goal || '').toLowerCase().slice(0, 20))) {
+                        hints.push({
+                            source: 'operational-memory',
+                            summary: entry.summary || entry.goal || 'memory hit',
+                            filePath: this.memoryFile
+                        });
+                    }
+                }
+            }
+            catch { }
+        }
+        if (fs.existsSync(this.promotedDir)) {
+            const files = fs.readdirSync(this.promotedDir).map(f => path.join(this.promotedDir, f));
+            for (const file of files) {
+                try {
+                    const content = fs.readFileSync(file, 'utf-8');
+                    if (content.toLowerCase().includes(normalized.slice(0, 20))) {
+                        hints.push({
+                            source: 'promoted-asset',
+                            summary: content.slice(0, 200),
+                            filePath: file
+                        });
+                    }
+                }
+                catch { }
+            }
+        }
+        return hints.slice(0, 5);
+    }
+    enrichAgents(agents, hints) {
+        if (!hints.length)
+            return agents;
+        return agents.map(agent => ({ ...agent, priority: agent.priority + 1 }));
+    }
+}
+exports.ReuseEngine = ReuseEngine;

package/dist/orchestrator/ReviewerAgent.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewerAgent = void 0;
+class ReviewerAgent {
+    brain;
+    constructor(brain) {
+        this.brain = brain;
+    }
+    async review(goal, executorOutput, successCriteria) {
+        const prompt = `
+Você é o Reviewer do OpenLife.
+
+Objetivo:
+${goal}
+
+Critérios de sucesso:
+${successCriteria.join('\n- ')}
+
+Output do executor:
+${executorOutput}
+
+Responda em JSON com:
+- approved (boolean)
+- critique (string curta)
+- nextAction ('refine' ou 'finish')
+- score (0 a 10)
+`;
+        const raw = await this.brain.think('Faça uma revisão crítica, objetiva e curta.', prompt);
+        try {
+            const jsonStart = raw.indexOf('{');
+            const parsed = JSON.parse(jsonStart >= 0 ? raw.slice(jsonStart) : raw);
+            return {
+                approved: !!parsed.approved,
+                critique: parsed.critique || 'Sem crítica específica.',
+                nextAction: parsed.nextAction === 'finish' ? 'finish' : 'refine',
+                score: typeof parsed.score === 'number' ? parsed.score : 7
+            };
+        }
+        catch {
+            return {
+                approved: true,
+                critique: 'Revisão fallback: output aceitável.',
+                nextAction: 'finish',
+                score: 7
+            };
+        }
+    }
+}
+exports.ReviewerAgent = ReviewerAgent;