@openlife/cli 1.7.3

package/dist/orchestrator/TaskExecutor.js

@@ -0,0 +1,422 @@
+"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.TaskExecutor = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process = __importStar(require("child_process"));
+const ToolsetGuard_1 = require("./toolset/ToolsetGuard");
+const ProcessSandbox_1 = require("./ProcessSandbox");
+class TaskExecutor {
+    artifactsDir;
+    commandTimeoutMs = 10 * 60 * 1000;
+    constructor() {
+        this.artifactsDir = path.join(process.cwd(), '.artifacts');
+        if (!fs.existsSync(this.artifactsDir)) {
+            fs.mkdirSync(this.artifactsDir, { recursive: true });
+        }
+    }
+    async execute(kind, prompt, projectName) {
+        switch (kind) {
+            case 'gemini':
+                return this.executeWithGemini(prompt, projectName);
+            case 'claude':
+                return this.executeWithClaude(prompt, projectName, 'claude');
+            case 'openclaude':
+                return this.executeWithClaude(prompt, projectName, 'openclaude');
+            default:
+                return this.executeWithCodex(prompt, projectName);
+        }
+    }
+    async executeWithCodex(prompt, projectName) {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('delegation', 'TaskExecutor.executeWithCodex');
+        const artifactDir = this.ensureArtifactDir(projectName);
+        const cwd = process.cwd();
+        const outputFile = path.join(artifactDir, 'codex-last-message.txt');
+        const stdoutFile = path.join(artifactDir, 'codex-stdout.jsonl');
+        const stderrFile = path.join(artifactDir, 'codex-stderr.txt');
+        const shellCommand = `cd ${JSON.stringify(cwd)} && codex exec --skip-git-repo-check --model gpt-5.4 --json --output-last-message ${JSON.stringify(outputFile)} ${JSON.stringify(prompt)} > ${JSON.stringify(stdoutFile)} 2> ${JSON.stringify(stderrFile)}`;
+        const startedAt = new Date().toISOString();
+        const startedMs = Date.now();
+        const result = await this.runShellCommand(shellCommand, cwd);
+        const finishedAt = new Date().toISOString();
+        const durationMs = Date.now() - startedMs;
+        const stdout = this.safeRead(stdoutFile);
+        const stderr = this.safeRead(stderrFile);
+        const finalMessage = fs.existsSync(outputFile) ? this.safeRead(outputFile).trim() : this.extractCodexFinalMessage(stdout);
+        if (result.code === 0 && finalMessage) {
+            const artifactPath = path.join(artifactDir, 'codex-result.txt');
+            fs.writeFileSync(artifactPath, finalMessage, 'utf-8');
+            const maskedStdout = this.maskSensitiveText(finalMessage);
+            const maskedStderr = this.maskSensitiveText(stderr);
+            const metadataPath = this.writeExecutionMetadata(artifactDir, {
+                executor: 'codex', ok: true, status: 'success', fallbackUsed: false, providerUnavailable: false, initRan: false,
+                projectName, artifactPath, stdout: maskedStdout, stderr: maskedStderr, command: ['/bin/bash', '-lc', shellCommand],
+                commandProvenance: shellCommand,
+                exitCode: result.code, signal: result.signal, startedAt, finishedAt, durationMs
+            });
+            return {
+                executor: 'codex',
+                ok: true,
+                projectName,
+                artifactPath,
+                stdout: maskedStdout,
+                stderr: maskedStderr,
+                command: ['/bin/bash', '-lc', shellCommand],
+                commandProvenance: shellCommand,
+                exitCode: result.code,
+                signal: result.signal,
+                startedAt,
+                finishedAt,
+                durationMs,
+                metadataPath,
+                status: 'success',
+                fallbackUsed: false,
+                providerUnavailable: false,
+                initRan: false
+            };
+        }
+        const artifactPath = path.join(artifactDir, 'codex-error.txt');
+        fs.writeFileSync(artifactPath, `${finalMessage || stdout}\n\n${stderr}`, 'utf-8');
+        const maskedStdout = this.maskSensitiveText(finalMessage || stdout);
+        const maskedStderr = this.maskSensitiveText(stderr);
+        const metadataPath = this.writeExecutionMetadata(artifactDir, {
+            executor: 'codex', ok: false, status: 'failed', fallbackUsed: false, providerUnavailable: false, initRan: false,
+            projectName, artifactPath, stdout: maskedStdout, stderr: maskedStderr, command: ['/bin/bash', '-lc', shellCommand],
+            commandProvenance: shellCommand,
+            exitCode: result.code, signal: result.signal, startedAt, finishedAt, durationMs
+        });
+        return {
+            executor: 'codex',
+            ok: false,
+            projectName,
+            artifactPath,
+            stdout: maskedStdout,
+            stderr: maskedStderr,
+            command: ['/bin/bash', '-lc', shellCommand],
+            commandProvenance: shellCommand,
+            exitCode: result.code,
+            signal: result.signal,
+            startedAt,
+            finishedAt,
+            durationMs,
+            metadataPath,
+            status: 'failed',
+            fallbackUsed: false,
+            providerUnavailable: false,
+            initRan: false
+        };
+    }
+    async executeWithGemini(prompt, projectName) {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('delegation', 'TaskExecutor.executeWithGemini');
+        const artifactDir = this.ensureArtifactDir(projectName);
+        const cwd = process.cwd();
+        const stdoutFile = path.join(artifactDir, 'gemini-stdout.txt');
+        const stderrFile = path.join(artifactDir, 'gemini-stderr.txt');
+        const resultFile = path.join(artifactDir, 'gemini-result.txt');
+        const shellCommand = `cd ${JSON.stringify(cwd)} && gemini -o json -m gemini-2.5-pro -p ${JSON.stringify(prompt)} -y > ${JSON.stringify(stdoutFile)} 2> ${JSON.stringify(stderrFile)}`;
+        const startedAt = new Date().toISOString();
+        const startedMs = Date.now();
+        const result = await this.runShellCommand(shellCommand, cwd);
+        const finishedAt = new Date().toISOString();
+        const durationMs = Date.now() - startedMs;
+        const stdout = this.safeRead(stdoutFile);
+        const stderr = this.safeRead(stderrFile);
+        const finalMessage = this.extractGeminiFinalMessage(stdout);
+        if (result.code === 0 && finalMessage) {
+            fs.writeFileSync(resultFile, finalMessage, 'utf-8');
+            const maskedStdout = this.maskSensitiveText(finalMessage);
+            const maskedStderr = this.maskSensitiveText(stderr);
+            const metadataPath = this.writeExecutionMetadata(artifactDir, {
+                executor: 'gemini', ok: true, status: 'success', fallbackUsed: false, providerUnavailable: false, initRan: false,
+                projectName, artifactPath: resultFile, stdout: maskedStdout, stderr: maskedStderr, command: ['/bin/bash', '-lc', shellCommand],
+                commandProvenance: shellCommand,
+                exitCode: result.code, signal: result.signal, startedAt, finishedAt, durationMs
+            });
+            return {
+                executor: 'gemini',
+                ok: true,
+                projectName,
+                artifactPath: resultFile,
+                stdout: maskedStdout,
+                stderr: maskedStderr,
+                command: ['/bin/bash', '-lc', shellCommand],
+                commandProvenance: shellCommand,
+                exitCode: result.code,
+                signal: result.signal,
+                startedAt,
+                finishedAt,
+                durationMs,
+                metadataPath,
+                status: 'success',
+                fallbackUsed: false,
+                providerUnavailable: false,
+                initRan: false
+            };
+        }
+        const artifactPath = path.join(artifactDir, 'gemini-error.txt');
+        fs.writeFileSync(artifactPath, `${stdout}\n\n${stderr}`, 'utf-8');
+        const providerUnavailable = /quota_exhausted|status 429|exhausted your capacity|retry with backoff/i.test(stderr);
+        const maskedStdout = this.maskSensitiveText(stdout);
+        const maskedStderr = this.maskSensitiveText(stderr);
+        const metadataPath = this.writeExecutionMetadata(artifactDir, {
+            executor: 'gemini', ok: false, status: providerUnavailable ? 'partial' : 'failed', fallbackUsed: false, providerUnavailable, initRan: false,
+            projectName, artifactPath, stdout: maskedStdout, stderr: maskedStderr, command: ['/bin/bash', '-lc', shellCommand],
+            commandProvenance: shellCommand,
+            exitCode: result.code, signal: result.signal, startedAt, finishedAt, durationMs
+        });
+        return {
+            executor: 'gemini',
+            ok: false,
+            projectName,
+            artifactPath,
+            stdout: maskedStdout,
+            stderr: maskedStderr,
+            command: ['/bin/bash', '-lc', shellCommand],
+            commandProvenance: shellCommand,
+            exitCode: result.code,
+            signal: result.signal,
+            startedAt,
+            finishedAt,
+            durationMs,
+            metadataPath,
+            status: providerUnavailable ? 'partial' : 'failed',
+            fallbackUsed: false,
+            providerUnavailable,
+            initRan: false
+        };
+    }
+    async executeWithClaude(prompt, projectName, cliName) {
+        const artifactDir = this.ensureArtifactDir(projectName);
+        const cwd = process.cwd();
+        const stdoutFile = path.join(artifactDir, `${cliName}-stdout.txt`);
+        const stderrFile = path.join(artifactDir, `${cliName}-stderr.txt`);
+        const resultFile = path.join(artifactDir, `${cliName}-result.txt`);
+        const initMetaFile = path.join(artifactDir, `${cliName}-init-meta.json`);
+        const initInstruction = this.buildClaudeInitInstruction(projectName);
+        const initCommand = this.buildClaudeInitCommand(cwd, cliName, initInstruction, stdoutFile, stderrFile);
+        const shouldInit = !this.hasClaudeInit(cwd);
+        if (shouldInit) {
+            const initResult = await this.runShellCommand(initCommand, cwd);
+            fs.writeFileSync(initMetaFile, JSON.stringify({ initialized: initResult.code === 0, cliName, cwd }, null, 2), 'utf-8');
+        }
+        const shellCommand = this.buildClaudeExecCommand(cwd, cliName, prompt, stdoutFile, stderrFile);
+        const startedAt = new Date().toISOString();
+        const startedMs = Date.now();
+        const result = await this.runShellCommand(shellCommand, cwd);
+        const finishedAt = new Date().toISOString();
+        const durationMs = Date.now() - startedMs;
+        const stdout = this.safeRead(stdoutFile);
+        const stderr = this.safeRead(stderrFile);
+        const finalMessage = stdout.trim();
+        if (result.code === 0 && finalMessage) {
+            fs.writeFileSync(resultFile, finalMessage, 'utf-8');
+            const maskedStdout = this.maskSensitiveText(finalMessage);
+            const maskedStderr = this.maskSensitiveText(stderr);
+            const metadataPath = this.writeExecutionMetadata(artifactDir, {
+                executor: cliName, ok: true, status: 'success', fallbackUsed: false, providerUnavailable: false, initRan: shouldInit,
+                projectName, artifactPath: resultFile, stdout: maskedStdout, stderr: maskedStderr, command: ['/bin/bash', '-lc', shellCommand],
+                commandProvenance: shellCommand,
+                exitCode: result.code, signal: result.signal, startedAt, finishedAt, durationMs
+            });
+            return {
+                executor: cliName,
+                ok: true,
+                projectName,
+                artifactPath: resultFile,
+                stdout: maskedStdout,
+                stderr: maskedStderr,
+                command: ['/bin/bash', '-lc', shellCommand],
+                commandProvenance: shellCommand,
+                exitCode: result.code,
+                signal: result.signal,
+                startedAt,
+                finishedAt,
+                durationMs,
+                metadataPath,
+                status: 'success',
+                fallbackUsed: false,
+                providerUnavailable: false,
+                initRan: shouldInit
+            };
+        }
+        const artifactPath = path.join(artifactDir, `${cliName}-error.txt`);
+        fs.writeFileSync(artifactPath, `${stdout}\n\n${stderr}`, 'utf-8');
+        const maskedStdout = this.maskSensitiveText(stdout);
+        const maskedStderr = this.maskSensitiveText(stderr);
+        const metadataPath = this.writeExecutionMetadata(artifactDir, {
+            executor: cliName, ok: false, status: 'failed', fallbackUsed: false, providerUnavailable: false, initRan: shouldInit,
+            projectName, artifactPath, stdout: maskedStdout, stderr: maskedStderr, command: ['/bin/bash', '-lc', shellCommand],
+            commandProvenance: shellCommand,
+            exitCode: result.code, signal: result.signal, startedAt, finishedAt, durationMs
+        });
+        return {
+            executor: cliName,
+            ok: false,
+            projectName,
+            artifactPath,
+            stdout: maskedStdout,
+            stderr: maskedStderr,
+            command: ['/bin/bash', '-lc', shellCommand],
+            commandProvenance: shellCommand,
+            exitCode: result.code,
+            signal: result.signal,
+            startedAt,
+            finishedAt,
+            durationMs,
+            metadataPath,
+            status: 'failed',
+            fallbackUsed: false,
+            providerUnavailable: false,
+            initRan: shouldInit
+        };
+    }
+    ensureArtifactDir(projectName) {
+        const artifactDir = path.join(this.artifactsDir, projectName);
+        if (!fs.existsSync(artifactDir)) {
+            fs.mkdirSync(artifactDir, { recursive: true });
+        }
+        return artifactDir;
+    }
+    safeRead(filePath) {
+        return fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : '';
+    }
+    async runShellCommand(shellCommand, cwd) {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('terminal', 'TaskExecutor.runShellCommand');
+        // Story 18.2 (v1.6) — opt-in route through ProcessSandbox so the spawn
+        // path is consistent across the codebase and produces a structured
+        // telemetry envelope (enforced state, applied flags, captured stdout).
+        // For /bin/bash this is currently a pass-through — Node's --permission
+        // only applies when spawning Node itself — but the wiring is in place
+        // for the v1.7 work that will route node-script steps through the
+        // wrapper with real enforcement.
+        if ((process.env.OPENLIFE_PROCESS_SANDBOX || '').toLowerCase() === 'on') {
+            const sandbox = new ProcessSandbox_1.ProcessSandbox({ allowFsRead: [cwd], allowFsWrite: [path.join(cwd, '.artifacts')] });
+            const result = await sandbox.spawn('/bin/bash', ['-lc', shellCommand], { cwd, timeout: this.commandTimeoutMs });
+            return { code: result.code, signal: result.signal };
+        }
+        return new Promise((resolve) => {
+            const child = child_process.spawn('/bin/bash', ['-lc', shellCommand], {
+                cwd,
+                stdio: 'ignore'
+            });
+            const timer = setTimeout(() => {
+                child.kill('SIGTERM');
+            }, this.commandTimeoutMs);
+            child.on('close', (code, signal) => {
+                clearTimeout(timer);
+                resolve({ code, signal });
+            });
+            child.on('error', () => {
+                clearTimeout(timer);
+                resolve({ code: 1, signal: null });
+            });
+        });
+    }
+    hasClaudeInit(cwd) {
+        return fs.existsSync(path.join(cwd, 'CLAUDE.md')) || fs.existsSync(path.join(cwd, 'Claude.md'));
+    }
+    buildClaudeInitInstruction(projectName) {
+        return [
+            '/init',
+            '',
+            `Projeto: ${projectName}`,
+            'Gere o contexto inicial do projeto neste repositório.',
+            'Inclua também regras úteis de execução, arquitetura e comportamento do projeto.',
+            'Se este projeto já tiver Claude.md/CLAUDE.md, não regenere do zero desnecessariamente.'
+        ].join('\n');
+    }
+    buildClaudeInitCommand(cwd, cliName, prompt, stdoutFile, stderrFile) {
+        if (cliName === 'claude') {
+            return `cd ${JSON.stringify(cwd)} && claude --dangerously-skip-permissions --print ${JSON.stringify(prompt)} > ${JSON.stringify(stdoutFile)} 2> ${JSON.stringify(stderrFile)}`;
+        }
+        return `cd ${JSON.stringify(cwd)} && openclaude ${JSON.stringify(prompt)} > ${JSON.stringify(stdoutFile)} 2> ${JSON.stringify(stderrFile)}`;
+    }
+    buildClaudeExecCommand(cwd, cliName, prompt, stdoutFile, stderrFile) {
+        if (cliName === 'claude') {
+            return `cd ${JSON.stringify(cwd)} && claude --dangerously-skip-permissions --print ${JSON.stringify(prompt)} > ${JSON.stringify(stdoutFile)} 2> ${JSON.stringify(stderrFile)}`;
+        }
+        return `cd ${JSON.stringify(cwd)} && openclaude ${JSON.stringify(prompt)} > ${JSON.stringify(stdoutFile)} 2> ${JSON.stringify(stderrFile)}`;
+    }
+    writeExecutionMetadata(artifactDir, payload) {
+        const metadataPath = path.join(artifactDir, 'execution-meta.json');
+        fs.writeFileSync(metadataPath, JSON.stringify(payload, null, 2), 'utf-8');
+        return metadataPath;
+    }
+    extractCodexFinalMessage(stdoutJsonl) {
+        const lines = stdoutJsonl.split('\n').map(l => l.trim()).filter(Boolean);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const parsed = JSON.parse(lines[i]);
+                if (typeof parsed?.item?.text === 'string' && parsed.item.text.trim())
+                    return parsed.item.text.trim();
+                if (typeof parsed?.message === 'string' && parsed.message.trim())
+                    return parsed.message.trim();
+                if (typeof parsed?.content === 'string' && parsed.content.trim())
+                    return parsed.content.trim();
+            }
+            catch {
+                continue;
+            }
+        }
+        return '';
+    }
+    extractGeminiFinalMessage(stdout) {
+        const trimmed = stdout.trim();
+        if (!trimmed)
+            return '';
+        const jsonStart = trimmed.indexOf('{');
+        if (jsonStart !== -1) {
+            try {
+                const parsed = JSON.parse(trimmed.slice(jsonStart));
+                if (typeof parsed?.response === 'string' && parsed.response.trim())
+                    return parsed.response.trim();
+                if (typeof parsed?.text === 'string' && parsed.text.trim())
+                    return parsed.text.trim();
+            }
+            catch {
+                // fallback abaixo
+            }
+        }
+        return trimmed;
+    }
+    maskSensitiveText(text) {
+        return text
+            .replace(/\b(sk|ghp|sbp|hf|fc|rnd|vcp|gsk|sm)_[A-Za-z0-9\-_]+\b/g, '[REDACTED_TOKEN]')
+            .replace(/\bAIza[0-9A-Za-z\-_]{20,}\b/g, '[REDACTED_GOOGLE_KEY]')
+            .replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, '[REDACTED_EMAIL]');
+    }
+}
+exports.TaskExecutor = TaskExecutor;

package/dist/orchestrator/TeammateBoard.js

@@ -0,0 +1,61 @@
+"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.TeammateBoardStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("./util/AtomicWriter");
+class TeammateBoardStore {
+    workspaceId;
+    filePath;
+    constructor(workspaceId = 'default') {
+        this.workspaceId = workspaceId;
+        this.filePath = path.join(process.cwd(), '.artifacts', 'workspaces', workspaceId, 'teammate-board.json');
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    }
+    list() { if (!fs.existsSync(this.filePath))
+        return []; return JSON.parse(fs.readFileSync(this.filePath, 'utf-8')); }
+    save(cards) { (0, AtomicWriter_1.writeJsonAtomic)(this.filePath, cards); }
+    upsert(card) {
+        const cards = this.list();
+        const idx = cards.findIndex((c) => c.id === card.id);
+        if (idx >= 0)
+            cards[idx] = card;
+        else
+            cards.push(card);
+        this.save(cards);
+    }
+}
+exports.TeammateBoardStore = TeammateBoardStore;

package/dist/orchestrator/TestHarness.js

@@ -0,0 +1,184 @@
+"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.TestHarness = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const Brain_1 = require("./Brain");
+const Gatekeeper_1 = require("./Gatekeeper");
+const IntentClassifier_1 = require("./IntentClassifier");
+const VoiceManager_1 = require("./VoiceManager");
+const ModelManager_1 = require("./ModelManager");
+const Gateway_1 = require("./Gateway");
+const RuntimeProbe_1 = require("./RuntimeProbe");
+const RuntimePolicy_1 = require("./RuntimePolicy");
+class TestHarness {
+    brain = new Brain_1.Brain();
+    gatekeeper = new Gatekeeper_1.Gatekeeper();
+    voiceManager = new VoiceManager_1.VoiceManager();
+    modelManager = new ModelManager_1.ModelManager();
+    gateway = new Gateway_1.Gateway();
+    runtimeProbe = new RuntimeProbe_1.RuntimeProbe();
+    runtimePolicy = new RuntimePolicy_1.RuntimePolicy();
+    async runPhase1Checks() {
+        const results = [];
+        results.push(await this.checkModelConfig());
+        results.push(await this.checkRuntimeExecutors());
+        results.push(await this.checkRuntimePolicyChain());
+        results.push(await this.checkBrainPrimary());
+        results.push(await this.checkFastPathMemory());
+        results.push(await this.checkVoiceTts());
+        results.push(await this.checkGatewayText());
+        results.push(await this.checkGatewayImage());
+        return results;
+    }
+    async checkModelConfig() {
+        const config = this.modelManager.getModelConfig();
+        const deduped = [config.primary, ...config.fallbacks].map(m => m.raw);
+        const unique = new Set(deduped);
+        if (deduped.length !== unique.size) {
+            return { name: 'model-config', ok: false, detail: 'Há modelos duplicados na cadeia de fallback.' };
+        }
+        return {
+            name: 'model-config',
+            ok: true,
+            detail: `Primário: ${config.primary.raw} | Fallbacks: ${config.fallbacks.map(f => f.raw).join(', ') || 'nenhum'}`
+        };
+    }
+    async checkRuntimeExecutors() {
+        try {
+            const probes = await this.runtimeProbe.probeAll();
+            const okCount = probes.filter((probe) => probe.available).length;
+            return {
+                name: 'runtime-executors',
+                ok: okCount >= 1,
+                detail: probes.map((probe) => `${probe.executor}:${probe.available ? 'ok' : 'fail'}:${probe.category}`).join(' | ')
+            };
+        }
+        catch (error) {
+            return { name: 'runtime-executors', ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async checkRuntimePolicyChain() {
+        try {
+            const research = this.runtimePolicy.decide('RESEARCH_ANALYSIS');
+            const engineering = this.runtimePolicy.decide('ENGINEERING_BUILD');
+            const ok = research.preferred.length > 0 && engineering.preferred.length > 0;
+            return {
+                name: 'runtime-policy-chain',
+                ok,
+                detail: `research=${research.preferred.join('>')} | engineering=${engineering.preferred.join('>')}`
+            };
+        }
+        catch (error) {
+            return { name: 'runtime-policy-chain', ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async checkBrainPrimary() {
+        try {
+            const response = await this.brain.think('Responda apenas com OK_BRAIN', 'OK_BRAIN');
+            const ok = response.includes('OK_BRAIN');
+            return {
+                name: 'brain-primary',
+                ok,
+                detail: ok ? 'Brain respondeu via runtime principal.' : `Resposta inesperada: ${response}`
+            };
+        }
+        catch (error) {
+            return { name: 'brain-primary', ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async checkFastPathMemory() {
+        try {
+            const response = await this.gatekeeper.routeTask({ intent: IntentClassifier_1.TaskIntent.KNOWLEDGE_RETRIEVAL, budgetLimit: 0.1, requiresHarness: false }, 'Responda apenas OK_MEMORY', 'phase1-test-user');
+            const ok = typeof response === 'string' && response.length > 0;
+            return {
+                name: 'fastpath-memory',
+                ok,
+                detail: ok ? `Gatekeeper respondeu (${response.slice(0, 120)})` : 'Gatekeeper não respondeu.'
+            };
+        }
+        catch (error) {
+            return { name: 'fastpath-memory', ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async checkVoiceTts() {
+        try {
+            const outputPath = await this.voiceManager.generateSpeech('Teste de voz do OpenLife.');
+            const exists = fs.existsSync(outputPath);
+            return {
+                name: 'voice-tts',
+                ok: exists,
+                detail: exists ? `Áudio gerado em ${path.basename(outputPath)}` : 'Arquivo de áudio não foi criado.'
+            };
+        }
+        catch (error) {
+            return { name: 'voice-tts', ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async checkGatewayText() {
+        try {
+            const response = await this.gateway.processTextForTest('phase1-gateway-user', 'Responda apenas OK_GATEWAY');
+            const ok = typeof response === 'string' && response.length > 0;
+            return {
+                name: 'gateway-text',
+                ok,
+                detail: ok ? `Gateway respondeu (${response.slice(0, 120)})` : 'Gateway não retornou resposta.'
+            };
+        }
+        catch (error) {
+            return { name: 'gateway-text', ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async checkGatewayImage() {
+        try {
+            const imagePath = path.join(process.cwd(), '.temp_images', 'AgACAgEAAxkBAAMcadbcsuXT9sQEbNGuKEEPX1fiMLEAAkgMaxtdRbhGvMTAvX1tmS8BAAMCAAN5AAM7BA.jpg');
+            if (!fs.existsSync(imagePath)) {
+                return { name: 'gateway-image', ok: true, detail: 'Imagem de teste ausente; check multimodal pulado explicitamente. Adicione fixture em .temp_images para validar visão completa.' };
+            }
+            const response = await this.gateway.processImageForTest('phase1-image-user', imagePath, 'Descreva esta imagem em uma frase.');
+            const ok = typeof response === 'string' && response.length > 0 && !response.includes('CRITICAL ERROR');
+            return {
+                name: 'gateway-image',
+                ok,
+                detail: ok ? `Gateway imagem respondeu (${response.slice(0, 120)})` : `Resposta inválida: ${response}`
+            };
+        }
+        catch (error) {
+            return { name: 'gateway-image', ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+    }
+}
+exports.TestHarness = TestHarness;