@openlife/cli 1.7.10 → 1.7.12

package/dist/cli/ProviderSelector.js

@@ -0,0 +1,178 @@
+"use strict";
+// src/cli/ProviderSelector.ts
+// Reusable arrow-key radio menu — used by ConfigTui and any TUI that
+// needs a "pick one of N options" interaction.
+//
+// Matches the Hermes Agent provider-selector UX:
+//   - ↑↓ navigate
+//   - ENTER / SPACE select
+//   - ESC cancel
+//   - currently-active option marked with `(•)` and `← currently active`
+//   - other options marked with `(o)`
+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.selectOne = selectOne;
+exports.numberedChoice = numberedChoice;
+const readline = __importStar(require("readline"));
+const MatrixTheme_1 = require("./MatrixTheme");
+/**
+ * Show the menu, await user input, return the selected value (or null on ESC).
+ *
+ * In non-TTY contexts (CI, piped), prints the menu once and returns
+ * `options[initialIndex].value` without blocking — keeps scripts working.
+ */
+async function selectOne(opts) {
+    const activeIdx = opts.options.findIndex(o => o.value === opts.active);
+    let cursor = opts.initialIndex ?? (activeIdx >= 0 ? activeIdx : 0);
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stdout.write(renderMenu(opts.title, opts.options, cursor, opts.active));
+        return opts.options[cursor]?.value ?? null;
+    }
+    return new Promise((resolve) => {
+        const previousRaw = process.stdin.isRaw === true;
+        try {
+            readline.emitKeypressEvents(process.stdin);
+            process.stdin.setRawMode(true);
+        }
+        catch {
+            // Non-TTY edge case — fall back to first option.
+            resolve(opts.options[cursor]?.value ?? null);
+            return;
+        }
+        process.stdout.write(MatrixTheme_1.ANSI.hideCursor);
+        let firstDraw = true;
+        const draw = () => {
+            const block = renderMenu(opts.title, opts.options, cursor, opts.active);
+            if (!firstDraw) {
+                // Move cursor up by the number of lines previously printed so we
+                // overwrite the menu in place rather than scroll.
+                const lineCount = block.split('\n').length;
+                process.stdout.write(`\x1b[${lineCount}A`);
+            }
+            firstDraw = false;
+            process.stdout.write(block);
+        };
+        const cleanup = () => {
+            process.stdin.removeListener('keypress', onKey);
+            try {
+                process.stdin.setRawMode(previousRaw);
+            }
+            catch { /* ignore */ }
+            process.stdout.write(MatrixTheme_1.ANSI.showCursor);
+            process.stdout.write(MatrixTheme_1.ANSI.reset);
+        };
+        const onKey = (_str, key) => {
+            if (!key)
+                return;
+            if (key.ctrl && key.name === 'c') {
+                cleanup();
+                process.stdout.write('\n');
+                resolve(null);
+                return;
+            }
+            if (key.name === 'escape') {
+                cleanup();
+                process.stdout.write('\n');
+                resolve(null);
+                return;
+            }
+            if (key.name === 'up' || key.name === 'k') {
+                cursor = (cursor - 1 + opts.options.length) % opts.options.length;
+                draw();
+                return;
+            }
+            if (key.name === 'down' || key.name === 'j') {
+                cursor = (cursor + 1) % opts.options.length;
+                draw();
+                return;
+            }
+            if (key.name === 'return' || key.name === 'space') {
+                cleanup();
+                process.stdout.write('\n');
+                resolve(opts.options[cursor]?.value ?? null);
+                return;
+            }
+        };
+        process.stdin.on('keypress', onKey);
+        draw();
+    });
+}
+function renderMenu(title, options, cursor, active) {
+    const useColor = (0, MatrixTheme_1.supportsColor)();
+    const head = useColor ? MatrixTheme_1.MATRIX.head : '';
+    const body = useColor ? MatrixTheme_1.MATRIX.body : '';
+    const tail = useColor ? MatrixTheme_1.MATRIX.tail : '';
+    const reset = useColor ? MatrixTheme_1.ANSI.reset : '';
+    const lines = [];
+    lines.push(`${head}${title}${reset}`);
+    lines.push(`${tail}↑↓ navigate · ENTER select · ESC cancel${reset}`);
+    lines.push('');
+    for (let i = 0; i < options.length; i++) {
+        const opt = options[i];
+        const isCursor = i === cursor;
+        const isActive = opt.value === active;
+        const marker = isActive ? '(•)' : '(o)';
+        const arrow = isCursor ? '▶' : ' ';
+        const hint = opt.hint ? `${tail} — ${opt.hint}${reset}` : '';
+        const activeTag = isActive ? `  ${tail}← currently active${reset}` : '';
+        const color = isCursor ? head : body;
+        lines.push(`  ${color}${arrow} ${marker} ${opt.label}${reset}${hint}${activeTag}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Convenience: numbered 1/2/3 choice prompt — used after provider
+ * selection for the `1) Use existing  2) Reauth  3) Cancel` flow.
+ */
+async function numberedChoice(question, choices) {
+    const useColor = (0, MatrixTheme_1.supportsColor)();
+    const head = useColor ? MatrixTheme_1.MATRIX.head : '';
+    const body = useColor ? MatrixTheme_1.MATRIX.body : '';
+    const reset = useColor ? MatrixTheme_1.ANSI.reset : '';
+    process.stdout.write(`\n${head}${question}${reset}\n`);
+    for (const c of choices) {
+        process.stdout.write(`  ${body}${c.key}) ${c.label}${reset}\n`);
+    }
+    const keys = choices.map(c => c.key).join('/');
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`\n  ${body}choice [${keys}]:${reset} `, (answer) => {
+            rl.close();
+            const k = answer.trim();
+            resolve(choices.find(c => c.key === k)?.key ?? null);
+        });
+    });
+}

package/dist/index.js

@@ -537,11 +537,10 @@ program
     .action(async (mensagemArgs, options) => {
     const mensagem = mensagemArgs.join(' ');
     console.log(`\n> Você: "${mensagem}"\n`);
-    const designHandled = tryHandleDesignConversation(mensagem);
-    if (designHandled) {
-        console.log(`\n> OPEN-LIFE: ${designHandled}\n`);
-        process.exit(0);
-    }
+    // Hermes parity: `ask` must send the user's message to the agent runtime.
+    // Conversational shortcuts such as design import/generate belong to explicit
+    // subcommands, not to the main chat path, otherwise OpenLife appears to
+    // "answer" without invoking the configured GPT-5.5 executor.
     const timeoutMs = Number(process.env.OPENLIFE_ASK_TIMEOUT_MS || 90000);
     const classifier = new IntentClassifier_1.IntentClassifier();
     const { Gatekeeper } = require('./orchestrator/Gatekeeper');
@@ -1397,7 +1396,28 @@ program
 program
     .command('update')
     .description('Atualiza dependências, recompila o core e valida status do sistema (modo dev)')
-    .action(async () => {
+    .option('--global', 'Self-update via npm global install (npm i -g @openlife/cli@latest)')
+    .action(async (opts) => {
+    if (opts.global) {
+        const { execFileSync } = require('child_process');
+        try {
+            const current = require('../package.json').version;
+            const latest = String(execFileSync('npm', ['view', '@openlife/cli', 'version'], { encoding: 'utf-8' })).trim();
+            if (latest === current) {
+                console.log(JSON.stringify({ ok: true, status: 'up-to-date', version: current }));
+                return;
+            }
+            console.log(`🔄 Self-update ${current} → ${latest}`);
+            execFileSync('npm', ['install', '-g', '@openlife/cli@latest'], { stdio: 'inherit' });
+            const after = String(execFileSync('openlife', ['--version'], { encoding: 'utf-8' })).trim();
+            console.log(JSON.stringify({ ok: true, from: current, to: after }));
+        }
+        catch (e) {
+            console.error(JSON.stringify({ ok: false, error: 'self_update_failed', detail: errMsg(e) }));
+            process.exitCode = 1;
+        }
+        return;
+    }
     console.log('🔄 OPEN-LIFE update: npm install + build + system status');
     try {
         const { stdout, stderr } = await exec('npm install && npm run build && node bin/openlife.js system status', { cwd: process.cwd(), maxBuffer: 1024 * 1024 * 10 });
@@ -2805,4 +2825,43 @@ profileCmd.command('import <file>').description('Import a profile from a JSON fi
         process.exitCode = 1;
     }
 });
-program.parse(process.argv);
+// `openlife config` — interactive configuration TUI (provider, keys, telegram, voice, daemon)
+program
+    .command('config')
+    .description('Configurações interativas (provider, API keys, Telegram, voz, daemon)')
+    .option('--focus <section>', 'Open directly into a section: provider | api-keys | telegram | voice | daemon')
+    .action(async (opts) => {
+    const { runConfig } = require('./cli/ConfigTui');
+    await runConfig({ focus: opts.focus });
+});
+// `openlife chat` — explicit alias for the interactive chat TUI (matches docs)
+program
+    .command('chat')
+    .description('Inicia o chat interativo no terminal (Matrix-themed REPL)')
+    .action(async () => {
+    const { runChat } = require('./cli/ChatTui');
+    await runChat();
+});
+// Bare invocation (no subcommand + interactive TTY) → launch chat TUI.
+// Piped, CI, or `--help` flows fall through to the standard Commander parse.
+const isBareInteractive = process.argv.length === 2 &&
+    process.stdout.isTTY === true &&
+    process.stdin.isTTY === true &&
+    !process.env.OPENLIFE_DISABLE_CHAT_TUI;
+if (isBareInteractive) {
+    // Defer to ChatTui — never returns under normal use.
+    (async () => {
+        try {
+            const { runChat } = require('./cli/ChatTui');
+            await runChat();
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[chat] failed to start: ${msg}`);
+            process.exitCode = 1;
+        }
+    })();
+}
+else {
+    program.parse(process.argv);
+}

package/dist/memory/MemoryProviderRegistry.js

@@ -11,11 +11,15 @@ class MemoryProviderRegistry {
     constructor() {
         this.providers = {
             local: new LocalMemoryProvider_1.LocalMemoryProvider(),
-            mempalace: new MempalaceProvider_1.MempalaceProvider(),
             mem0: new Mem0Provider_1.Mem0Provider(),
             'zep-graphiti': new ZepGraphitiProvider_1.ZepGraphitiProvider(),
             'redis-ams': new RedisAgentMemoryProvider_1.RedisAgentMemoryProvider()
         };
+        // MemPalace é opcional: registra apenas se o binário Python existir.
+        // Evita shell-out por turno em runtimes (Railway) que não têm mempalace instalado.
+        if (MempalaceProvider_1.MempalaceProvider.isAvailable()) {
+            this.providers.mempalace = new MempalaceProvider_1.MempalaceProvider();
+        }
     }
     get(name) {
         return this.providers[name] || null;

package/dist/memory/MempalaceProvider.js

@@ -35,21 +35,69 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MempalaceProvider = void 0;
 const child_process = __importStar(require("child_process"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
 const util_1 = require("util");
-const exec = (0, util_1.promisify)(child_process.exec);
+const execFile = (0, util_1.promisify)(child_process.execFile);
+const DEFAULT_BIN = '~/.venvs/mempalace/bin/mempalace';
+function expandHome(p) {
+    if (!p)
+        return p;
+    if (p === '~')
+        return os.homedir();
+    if (p.startsWith('~/'))
+        return path.join(os.homedir(), p.slice(2));
+    return p;
+}
+/**
+ * MemPalace é uma integração OPCIONAL. Em produção (Railway) o binário Python
+ * normalmente não existe; tentar shell-out adiciona latência e ruído de log a
+ * cada turno de conversa. `isAvailable()` resolve o path uma única vez e
+ * retorna false silenciosamente quando o binário não está instalado, para que
+ * o MemoryProviderRegistry possa pular o registro sem custo.
+ */
 class MempalaceProvider {
     mempalacePath;
-    constructor(mempalacePath = process.env.MEMPALACE_BIN_PATH || '~/.venvs/mempalace/bin/mempalace') {
+    static cachedAvailability = null;
+    static cachedPath = null;
+    constructor(mempalacePath = process.env.MEMPALACE_BIN_PATH || DEFAULT_BIN) {
         this.mempalacePath = mempalacePath;
     }
     name() {
         return 'mempalace';
     }
+    static isAvailable(rawPath) {
+        const configured = (rawPath ?? process.env.MEMPALACE_BIN_PATH ?? DEFAULT_BIN).trim();
+        if (configured === '' || configured.toLowerCase() === 'off' || configured.toLowerCase() === 'disabled') {
+            MempalaceProvider.cachedAvailability = false;
+            MempalaceProvider.cachedPath = null;
+            return false;
+        }
+        if (MempalaceProvider.cachedAvailability !== null && MempalaceProvider.cachedPath === configured) {
+            return MempalaceProvider.cachedAvailability;
+        }
+        const resolved = expandHome(configured);
+        let ok = false;
+        try {
+            ok = fs.existsSync(resolved) && fs.statSync(resolved).isFile();
+        }
+        catch {
+            ok = false;
+        }
+        MempalaceProvider.cachedAvailability = ok;
+        MempalaceProvider.cachedPath = configured;
+        return ok;
+    }
+    static resetAvailabilityCache() {
+        MempalaceProvider.cachedAvailability = null;
+        MempalaceProvider.cachedPath = null;
+    }
     async search(input) {
-        const safeQuery = input.query.replace(/"/g, '\\"');
-        const command = `bash -c "${this.mempalacePath} search \\\"${safeQuery}\\\""`;
+        if (!MempalaceProvider.isAvailable(this.mempalacePath))
+            return [];
         try {
-            const { stdout } = await exec(command);
+            const { stdout } = await execFile(expandHome(this.mempalacePath), ['search', input.query], { timeout: 5000 });
             if (!stdout.trim())
                 return [];
             return [{

package/dist/memory/OmniMemory.js

@@ -39,6 +39,7 @@ const util_1 = require("util");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const LocalMemoryProvider_1 = require("./LocalMemoryProvider");
+const MempalaceProvider_1 = require("./MempalaceProvider");
 const MemoryOrchestrator_1 = require("./MemoryOrchestrator");
 const ToolsetGuard_1 = require("../orchestrator/toolset/ToolsetGuard");
 const exec = (0, util_1.promisify)(child_process.exec);
@@ -57,20 +58,23 @@ class OmniMemory {
         if (hits.length) {
             return hits.map(hit => `- [${hit.provider}] ${hit.record.summary || hit.record.content}`).join('\n');
         }
+        if (!MempalaceProvider_1.MempalaceProvider.isAvailable(this.mempalacePath)) {
+            return '';
+        }
         console.log(`[OMNI-MEMORY] Buscando no MemPalace: "${query}"...`);
         try {
             const safeQuery = query.replace(/"/g, '\\"');
             const command = `bash -c "${this.mempalacePath} search \\\"${safeQuery}\\\""`;
-            const { stdout } = await exec(command);
+            const timeoutMs = Number(process.env.OPENLIFE_MEMORY_SEARCH_TIMEOUT_MS || 1500);
+            const { stdout } = await exec(command, { timeout: timeoutMs });
             if (!stdout.trim() || stdout.includes("No results found")) {
-                return "Nenhuma memória encontrada no Palácio para este termo.";
+                return "";
             }
             const citation = `\n\n[RAG de Evidências: Buscado em ${new Date().toISOString()}]`;
             return stdout + citation;
         }
-        catch (error) {
-            console.warn(`[OMNI-MEMORY] Aviso ao buscar no MemPalace (pode ser ausência de resultados):`, error);
-            return "Busca na Omni-Memory concluída com alertas ou sem resultados diretos.";
+        catch (_error) {
+            return "";
         }
     }
     async saveFact(fact, metadata, namespace) {

package/dist/orchestrator/Brain.js

@@ -36,18 +36,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Brain = void 0;
+exports.Brain = exports.CodexTimeoutError = void 0;
 const child_process = __importStar(require("child_process"));
 const util_1 = require("util");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const openai_1 = __importDefault(require("openai"));
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const generative_ai_1 = require("@google/generative-ai");
 const ModelManager_1 = require("./ModelManager");
 const ToolsetGuard_1 = require("./toolset/ToolsetGuard");
 const execFile = (0, util_1.promisify)(child_process.execFile);
-const DEFAULT_MODEL_TIMEOUT_MS = Number(process.env.OPENLIFE_MODEL_TIMEOUT_MS || 120000);
+const DEFAULT_MODEL_TIMEOUT_MS = Number(process.env.OPENLIFE_MODEL_TIMEOUT_MS || 60000);
 const REASONING_MODE = String(process.env.OPENLIFE_REASONING_MODE || 'errors').toLowerCase(); // off | errors | always
+// Conversational fast path must fail fast so the Gateway can surface a
+// timeout-aware reply to the user. Deep engineering missions keep the full
+// 60s budget. Both are env-overridable.
+function getCodexFastTimeoutMs() {
+    return Number(process.env.OPENLIFE_CODEX_FAST_TIMEOUT_MS || 30000);
+}
+function getCodexDeepTimeoutMs() {
+    return Number(process.env.OPENLIFE_CODEX_DEEP_TIMEOUT_MS || DEFAULT_MODEL_TIMEOUT_MS);
+}
+class CodexTimeoutError extends Error {
+    depth;
+    timeoutMs;
+    model;
+    constructor(depth, timeoutMs, model) {
+        super(`CODEX_TIMEOUT_${depth.toUpperCase()}_${timeoutMs}MS_${model || 'default'}`);
+        this.name = 'CodexTimeoutError';
+        this.depth = depth;
+        this.timeoutMs = timeoutMs;
+        this.model = model || 'default';
+    }
+}
+exports.CodexTimeoutError = CodexTimeoutError;
 class Brain {
+    static codexQueue = Promise.resolve();
     openai = null;
     anthropic = null;
     geminiApi = null;
@@ -87,21 +112,38 @@ class Brain {
             return true;
         return false;
     }
-    async think(systemPrompt, userMessage) {
+    async think(systemPrompt, userMessage, opts) {
         const config = this.modelManager.getModelConfig();
         const modelsToTry = [config.primary, ...config.fallbacks].filter((model, index, arr) => arr.findIndex(m => m.raw === model.raw) === index);
+        return this.runModelChain(systemPrompt, userMessage, modelsToTry, 'deep', opts);
+    }
+    /** Fast conversational path. Keeps the configured model chain order intact. */
+    async thinkFast(systemPrompt, userMessage, opts) {
+        const config = this.modelManager.getModelConfig();
+        const models = [config.primary, ...config.fallbacks].filter((model, index, arr) => arr.findIndex(m => m.raw === model.raw) === index);
+        return this.runModelChain(systemPrompt, userMessage, models, 'fast', opts);
+    }
+    async runModelChain(systemPrompt, userMessage, modelsToTry, depth = 'deep', opts) {
+        const emitReasoning = (chunk) => {
+            try {
+                opts?.onReasoning?.(chunk);
+            }
+            catch { /* never let a callback break the chain */ }
+        };
+        emitReasoning(`🧭 chain: ${modelsToTry.map(m => m.raw).join(' → ')}`);
         const failures = [];
         for (let i = 0; i < modelsToTry.length; i++) {
             const modelIdent = modelsToTry[i];
             try {
                 console.log(`[BRAIN] Tentando modelo ${i === 0 ? 'PRIMÁRIO' : 'FALLBACK ' + i}: ${modelIdent.raw}...`);
+                emitReasoning(`🔎 trying ${i === 0 ? 'primary' : `fallback ${i}`}: ${modelIdent.raw}`);
                 let out = '';
                 switch (modelIdent.provider) {
                     case 'openai-api':
                         out = await this.thinkWithOpenAIAPI(systemPrompt, userMessage, modelIdent.name);
                         break;
                     case 'openai-cli':
-                        out = await this.thinkWithOpenAICLI(systemPrompt, userMessage, modelIdent.name);
+                        out = await this.thinkWithOpenAICLI(systemPrompt, userMessage, modelIdent.name, depth);
                         break;
                     case 'anthropic':
                         out = await this.thinkWithAnthropic(systemPrompt, userMessage, modelIdent.name);
@@ -134,15 +176,32 @@ class Brain {
                 const reason = error instanceof Error ? error.message : String(error);
                 failures.push({ model: modelIdent.raw, reason });
                 console.error(`[BRAIN ERROR - ${modelIdent.raw}]`, reason);
-                if (i !== modelsToTry.length - 1)
+                emitReasoning(`✗ ${modelIdent.raw} failed: ${reason.slice(0, 120)}`);
+                if (i !== modelsToTry.length - 1) {
                     console.log(`[BRAIN] Rotacionando para o próximo fallback da cadeia...`);
+                    emitReasoning('↻ rotating to next fallback');
+                }
             }
         }
         const concise = failures.slice(-3).map(f => `- ${f.model}: ${f.reason}`).join('\n');
+        const strictGpt55Only = modelsToTry.length === 1 && modelsToTry[0]?.raw === 'openai-cli/gpt-5.5';
+        if (strictGpt55Only) {
+            return [
+                'Executor GPT-5.5 indisponível no momento.',
+                '',
+                'Falhas recentes:',
+                concise,
+                '',
+                'Ação recomendada:',
+                '1) Reautentique o Codex OAuth no mesmo runtime onde o OpenLife está rodando.',
+                '2) Valide com: codex login status',
+                '3) Valide execução real com: codex exec --model gpt-5.5 "responda apenas OK"'
+            ].join('\n');
+        }
         const guidance = [
-            '1) Configure ao menos um provedor API no Railway (ex.: GEMINI_API_KEY ou OPENAI_API_KEY).',
-            '2) Não dependa de CLI providers (codex/gemini) no container sem binário/auth.',
-            '3) Rode: openlife doctor e valide a cadeia de modelos.'
+            '1) Valide as credenciais/binários dos provedores configurados.',
+            '2) Ajuste models.json apenas se a política do produto permitir fallbacks.',
+            '3) Rode: openlife doctor e openlife models status.'
         ].join('\n');
         const summary = REASONING_MODE !== 'off'
             ? `\n\nResumo operacional:\n- Objetivo: responder com robustez por fallback.\n- Estratégia: rotação sequencial de provedores.\n- Resultado: todos os provedores tentados falharam.`
@@ -193,19 +252,73 @@ class Brain {
             throw this.formatProviderError('openai-api', model, err, { keyEnvVar: 'OPENAI_API_KEY', expectedKeyPrefix: 'sk-' });
         }
     }
-    async thinkWithOpenAICLI(systemPrompt, userMessage, model) {
+    async thinkWithOpenAICLI(systemPrompt, userMessage, model, depth = 'deep') {
         (0, ToolsetGuard_1.assertToolsetAllowed)('delegation', 'Brain.thinkWithOpenAICLI');
-        const args = ['exec', '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check'];
+        const outputFile = path.join(process.cwd(), '.openlife', `codex-last-message-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.txt`);
+        fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+        const args = ['exec', '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check', '--color', 'never', '--output-last-message', outputFile];
+        if (String(process.env.OPENLIFE_CODEX_EPHEMERAL || 'true').toLowerCase() !== 'false')
+            args.push('--ephemeral');
         if (model && model !== 'default')
             args.push('--model', model);
-        args.push(`${systemPrompt}\n\nMensagem: ${userMessage}`);
+        const prompt = depth === 'fast'
+            ? [
+                'Você é Lara, agente conversacional do OpenLife.',
+                'Responda diretamente em português natural e conciso.',
+                'Não use ferramentas, não leia arquivos e não execute comandos para responder esta mensagem.',
+                'Se não souber algo específico, seja honesta e diga o que falta.',
+                '',
+                `Mensagem: ${userMessage}`
+            ].join('\n')
+            : `${systemPrompt}\n\nMensagem: ${userMessage}`;
+        args.push(prompt);
+        const timeoutMs = depth === 'fast' ? getCodexFastTimeoutMs() : getCodexDeepTimeoutMs();
+        // Deep missions remain serialized through the static queue to avoid
+        // contending Codex CLI invocations. Fast conversational calls bypass
+        // the queue so a long-running deep mission can not block a greeting.
+        let release = () => { };
+        if (depth === 'deep') {
+            const previous = Brain.codexQueue;
+            Brain.codexQueue = new Promise((resolve) => { release = resolve; });
+            await previous;
+        }
         try {
-            const { stdout } = await execFile('codex', args, { maxBuffer: 1024 * 1024 * 10, timeout: DEFAULT_MODEL_TIMEOUT_MS });
-            return stdout.trim() || 'Sem resposta do Codex CLI.';
+            const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1000));
+            const command = process.platform === 'win32' ? 'codex' : 'timeout';
+            const commandArgs = process.platform === 'win32'
+                ? args
+                : ['-k', '2s', `${timeoutSeconds}s`, 'codex', ...args];
+            const { stdout } = await execFile(command, commandArgs, { maxBuffer: 1024 * 1024 * 10, timeout: timeoutMs + 3000, killSignal: 'SIGKILL' });
+            const lastMessage = fs.existsSync(outputFile) ? fs.readFileSync(outputFile, 'utf-8').trim() : '';
+            try {
+                fs.unlinkSync(outputFile);
+            }
+            catch { /* ignore cleanup */ }
+            const finalText = lastMessage || stdout.trim();
+            if (!finalText)
+                throw new Error(`EMPTY_CODEX_RESPONSE_${model || 'default'}`);
+            return finalText;
         }
         catch (err) {
+            try {
+                if (fs.existsSync(outputFile))
+                    fs.unlinkSync(outputFile);
+            }
+            catch { /* ignore cleanup */ }
+            // execFile signals a timeout via either ETIMEDOUT or by killing the
+            // child (signal !== null). Surface a typed error so callers can
+            // present a depth-aware message.
+            const e = err;
+            const errCode = e.code;
+            const isTimeout = errCode === 'ETIMEDOUT' || errCode === 124 || errCode === '124' || (e?.killed === true && !!e?.signal);
+            if (isTimeout) {
+                throw new CodexTimeoutError(depth, timeoutMs, model);
+            }
             throw this.formatProviderError('openai-cli', model, err);
         }
+        finally {
+            release();
+        }
     }
     async thinkWithAnthropic(systemPrompt, userMessage, model) {
         if (!this.anthropic)