@openlife/cli 1.7.10 → 1.7.11

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 });

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,48 @@ 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);
+}
+/**
+ * Typed Codex CLI timeout. Callers (Gateway, Gatekeeper) can distinguish a
+ * real timeout from a generic provider failure and present a clearer message.
+ * The `depth` attribute marks whether the fast or deep budget fired.
+ */
+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;
@@ -90,6 +120,15 @@ class Brain {
     async think(systemPrompt, userMessage) {
         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');
+    }
+    /** Fast conversational path. Keeps the configured model chain order intact. */
+    async thinkFast(systemPrompt, userMessage) {
+        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');
+    }
+    async runModelChain(systemPrompt, userMessage, modelsToTry, depth = 'deep') {
         const failures = [];
         for (let i = 0; i < modelsToTry.length; i++) {
             const modelIdent = modelsToTry[i];
@@ -101,7 +140,7 @@ class Brain {
                         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);
@@ -139,10 +178,24 @@ class Brain {
             }
         }
         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 +246,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)

package/dist/orchestrator/Gatekeeper.js

@@ -229,78 +229,73 @@ class Gatekeeper {
             return direct;
         }
         let finalResponse = "";
-        const recoveredContext = await this.conversationMemory.recoverContext(userId, userInput);
         switch (task.intent) {
-            case IntentClassifier_1.TaskIntent.KNOWLEDGE_RETRIEVAL:
-                finalResponse = await this.handleFastPath(userInput, recoveredContext.recentHistory, recoveredContext.memorySnippet);
+            case IntentClassifier_1.TaskIntent.KNOWLEDGE_RETRIEVAL: {
+                const useMemoryContext = this.shouldUseMemoryContext(userInput);
+                const recoveredContext = useMemoryContext
+                    ? await this.conversationMemory.recoverContext(userId, userInput)
+                    : { recentHistory: this.getRecentSessionHistory(userId), memorySnippet: '', autoRecovered: false };
+                finalResponse = await this.handleFastPath(userInput, recoveredContext.recentHistory, recoveredContext.memorySnippet, useMemoryContext);
                 break;
+            }
             case IntentClassifier_1.TaskIntent.ENGINEERING_BUILD:
-            case IntentClassifier_1.TaskIntent.RESEARCH_ANALYSIS:
+            case IntentClassifier_1.TaskIntent.RESEARCH_ANALYSIS: {
+                const recoveredContext = await this.conversationMemory.recoverContext(userId, userInput);
                 finalResponse = await this.handleComplexPath(userInput, task, recoveredContext.recentHistory, userId, options?.mode);
                 break;
+            }
             default:
-                finalResponse = "Intenção desconhecida. Proteção Mythos ativada.";
+                finalResponse = await this.handleFastPath(userInput, this.getRecentSessionHistory(userId), '', false);
         }
         this.sessionManager.addMessage(userId, 'agent', finalResponse);
         return finalResponse;
     }
-    async handleFastPath(input, recentHistory, recoveredMemory) {
-        console.log("[FAST PATH] Acionando Omni-Memory e recuperação automática de contexto...");
-        const searchResult = recoveredMemory || await this.memory.search(input);
+    getRecentSessionHistory(userId) {
+        const session = this.sessionManager.getSession(userId);
+        return session.history
+            .slice(-4)
+            .map((h) => `${h.role}: ${h.content}`)
+            .join('\n');
+    }
+    shouldUseMemoryContext(input) {
+        const normalized = input.toLowerCase();
+        if (String(process.env.OPENLIFE_FASTPATH_MEMORY || 'auto').toLowerCase() === 'always')
+            return true;
+        if (String(process.env.OPENLIFE_FASTPATH_MEMORY || 'auto').toLowerCase() === 'off')
+            return false;
+        if (input.length > 240)
+            return true;
+        return /(lembra|memória|memoria|projeto|openlife|lara|aiobuilder|catalog|catálogo|railway|github|deploy|repo|arquivo|documento|histórico|historico)/i.test(normalized);
+    }
+    async handleFastPath(input, recentHistory, recoveredMemory, useMemoryContext) {
+        console.log(useMemoryContext
+            ? "[FAST PATH] GPT-5.5 com contexto de memória seletivo..."
+            : "[FAST PATH] GPT-5.5 modo compacto sem OmniMemory...");
+        const searchResult = useMemoryContext ? (recoveredMemory || await this.memory.search(input)) : '';
         const systemPrompt = `
-Sua Alma (SOUL):
-${this.systemSoul}
-
-Sua Identidade (IDENTITY):
-${this.systemIdentity}
+Identidade:
+${this.systemIdentity.substring(0, 900)}
 
-Contexto da OmniMemory (Arquivos):
-${searchResult.substring(0, 1500)}
+${searchResult ? `Contexto relevante:\n${searchResult.substring(0, 900)}\n` : ''}
+Histórico recente:
+${recentHistory.slice(-1200)}
 
-[Histórico Recente da Sessão (Save State)]:
-${recentHistory.slice(-3000)}
-
-Instruções Adicionais:
-- IMPORTANTE: NÃO comece sua resposta com saudações ("Olá", "Oi") se o usuário já estiver conversando com você no Histórico Recente. Continue a conversa naturalmente.
-- Você tem memória fluida. Baseie-se fortemente no [Histórico Recente da Sessão] para manter o contexto vivo. Responda DIRETAMENTE à última mensagem.
-- Use a OmniMemory para informações profundas de projetos (como LARA, AIOBUILDER).
-- Se for apenas um 'oi' inicial, saúde amigavelmente e pergunte como pode ajudar.
-- NUNCA mencione tool calls, comandos internos, ou frases como "vou executar comando". Apenas responda naturalmente com o resultado final.
+Instruções:
+- Responda diretamente à última mensagem, em português natural.
+- Seja rápido e conciso por padrão.
+- Não mencione comandos internos, tool calls ou detalhes de execução.
+- Se precisar de contexto profundo, diga objetivamente o que falta.
 `;
-        const fastTimeoutMs = Number(process.env.OPENLIFE_FASTPATH_TIMEOUT_MS || 90000);
-        const degradedPrompt = `${this.systemIdentity}\n\nResponda de forma direta e curta, sem contexto extra.`;
         try {
-            return await Promise.race([
-                this.brain.think(systemPrompt, input),
-                new Promise((_, reject) => setTimeout(() => reject(new Error(`FAST_PATH_TIMEOUT_${fastTimeoutMs}`)), fastTimeoutMs))
-            ]);
+            return await this.brain.thinkFast(systemPrompt, input);
         }
         catch (err) {
             const code = (err instanceof Error ? err.message : String(err)) || 'FAST_PATH_FAILURE';
             console.error(`[FAST PATH ERROR] ${code}`);
-            if (String(code).startsWith('FAST_PATH_TIMEOUT_')) {
-                try {
-                    const retryTimeoutMs = Number(process.env.OPENLIFE_FASTPATH_RETRY_TIMEOUT_MS || 30000);
-                    return await Promise.race([
-                        this.brain.think(degradedPrompt, input),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error(`FAST_PATH_RETRY_TIMEOUT_${retryTimeoutMs}`)), retryTimeoutMs))
-                    ]);
-                }
-                catch (retryErr) {
-                    const retryCode = (retryErr instanceof Error ? retryErr.message : String(retryErr)) || 'FAST_PATH_RETRY_FAILURE';
-                    return [
-                        'OPENLIFE ONLINE ✅',
-                        'Modo resiliente: primeira rota estourou tempo, tentei fallback enxuto.',
-                        `Motivo técnico: ${retryCode}`,
-                        'Ação: valide cadeia de modelos com `openlife models status` e aumente timeout com OPENLIFE_FASTPATH_TIMEOUT_MS.'
-                    ].join('\n');
-                }
-            }
             return [
-                'OPENLIFE ONLINE ✅',
-                'Modo seguro ativado: não vou inventar resposta quando o executor falhar.',
+                'Executor GPT-5.5 indisponível ou lento demais neste momento.',
                 `Motivo técnico: ${code}`,
-                'Ação: tente novamente em alguns segundos. Se persistir, rode `openlife governance audit` e `openlife models status`.'
+                'Ação: verifique OAuth do Codex e tente novamente.'
             ].join('\n');
         }
     }

package/dist/orchestrator/Gateway.js

@@ -415,16 +415,59 @@ class Gateway {
         }
     }
     async processTextForTest(userId, text) {
-        let finalReply = '';
+        const detailed = await this.processTextForTestDetailed(userId, text);
+        return detailed.finalText;
+    }
+    /**
+     * Test seam that captures the full ACK + final timeline for the fast-ACK
+     * pattern. Used by the regression test to assert the placeholder reply
+     * lands within the ACK budget even when downstream model processing is
+     * slow. Returns:
+     *   - finalText: the user-visible final answer (edited ACK or last reply)
+     *   - events: ordered timeline (kind = 'reply' | 'edit' | 'voice')
+     *   - ackMs: ms until the first reply landed (null if none was sent)
+     *   - finalMs: ms until the last event landed
+     */
+    async processTextForTestDetailed(userId, text) {
+        const startTs = Date.now();
+        const events = [];
+        let ackMs = null;
+        let lastReplyText = '';
+        let lastEditText = null;
+        let messageIdCounter = 0;
+        let lastReplyMessageId = 0;
         const testCtx = {
             sendChatAction: async (_action) => { },
-            reply: async (message) => { finalReply = message; },
+            reply: async (message) => {
+                const tsMs = Date.now() - startTs;
+                events.push({ kind: 'reply', text: message, tsMs });
+                if (ackMs === null)
+                    ackMs = tsMs;
+                lastReplyText = message;
+                lastReplyMessageId = ++messageIdCounter;
+                return { message_id: lastReplyMessageId };
+            },
             sendVoice: async (_source, options) => {
-                finalReply = options?.caption || '[voice_sent]';
+                const caption = options?.caption || '[voice_sent]';
+                const tsMs = Date.now() - startTs;
+                events.push({ kind: 'voice', text: caption, tsMs });
+                lastReplyText = caption;
+                return { message_id: ++messageIdCounter };
+            },
+            chat: { id: userId },
+            telegram: {
+                editMessageText: async (_chatId, _messageId, _inlineId, edited) => {
+                    const tsMs = Date.now() - startTs;
+                    events.push({ kind: 'edit', text: edited, tsMs });
+                    lastEditText = edited;
+                    return true;
+                }
             }
         };
         await this.processInput(testCtx, userId, text);
-        return finalReply;
+        const finalText = lastEditText ?? lastReplyText;
+        const finalMs = events.length ? events[events.length - 1].tsMs : 0;
+        return { finalText, events, ackMs, finalMs };
     }
     async processImageForTest(userId, imagePath, caption = 'Descreva esta imagem.') {
         (0, ToolsetGuard_1.assertToolsetAllowed)('vision', 'Gateway.processImageForTest');
@@ -442,6 +485,42 @@ class Gateway {
             await this.safeReply(ctx, 'Acesso negado por policy de segurança deste bot.');
             return;
         }
+        // Fast ACK pattern: fire a placeholder reply in parallel with the actual
+        // classifier+gatekeeper work. When the work completes, edit the ACK with
+        // the real answer (Telegraf editMessageText). Falls back to a fresh
+        // reply when the surface does not expose `chat`/`telegram` (webhook mock
+        // and similar internal callers).
+        const ackText = '🔎 Recebido — processando…';
+        let ackMessageId = null;
+        const ackPromise = (async () => {
+            try {
+                const result = await ctx.reply(ackText);
+                if (result && typeof result === 'object' && 'message_id' in result) {
+                    const mid = result.message_id;
+                    if (typeof mid === 'number')
+                        ackMessageId = mid;
+                }
+            }
+            catch (ackErr) {
+                console.error('[GATEWAY] Falha ao enviar ACK rápido:', ackErr);
+            }
+        })();
+        const sendFinal = async (finalText) => {
+            await ackPromise;
+            if (ackMessageId !== null &&
+                ctx.chat &&
+                ctx.telegram &&
+                typeof ctx.telegram.editMessageText === 'function') {
+                try {
+                    await ctx.telegram.editMessageText(ctx.chat.id, ackMessageId, undefined, finalText);
+                    return;
+                }
+                catch (editErr) {
+                    console.error('[GATEWAY] editMessageText falhou, enviando nova mensagem:', editErr);
+                }
+            }
+            await this.safeReply(ctx, finalText);
+        };
         const stopTyping = this.startTypingIndicator(ctx);
         const trace = [];
         try {
@@ -459,11 +538,11 @@ class Gateway {
                 }
                 catch (ttsError) {
                     console.log("[GATEWAY] Fallback para texto (Erro no TTS).", ttsError);
-                    await this.safeReply(ctx, finalResponse);
+                    await sendFinal(finalResponse);
                 }
             }
             else {
-                await this.safeReply(ctx, finalResponse);
+                await sendFinal(finalResponse);
             }
         }
         catch (err) {
@@ -471,7 +550,7 @@ class Gateway {
             const errMsg = this.reasoningMode !== 'off'
                 ? `${trace.join('\n')}\n\n❌ error: "${err instanceof Error ? err.message : String(err)}"\n\nErro no córtex ao processar a solicitação.`
                 : "Erro no córtex ao processar a solicitação.";
-            await this.safeReply(ctx, errMsg);
+            await sendFinal(errMsg);
         }
         finally {
             stopTyping();

package/dist/orchestrator/RuntimePolicy.js

@@ -46,11 +46,14 @@ class RuntimePolicy {
         this.runtimeHealth = new RuntimeHealthMonitor_1.RuntimeHealthMonitor();
     }
     decide(intent, explicitExecutors = []) {
+        const strictModelExecutors = this.getStrictModelExecutors();
         const base = explicitExecutors.length
             ? explicitExecutors
-            : intent === 'RESEARCH_ANALYSIS'
-                ? ['gemini', 'claude', 'codex']
-                : ['codex', 'claude', 'gemini'];
+            : strictModelExecutors.length
+                ? strictModelExecutors
+                : intent === 'RESEARCH_ANALYSIS'
+                    ? ['gemini', 'claude', 'codex']
+                    : ['codex', 'claude', 'gemini'];
         const allowedRaw = (process.env.OPENLIFE_ALLOWED_LLM_EXECUTORS || '').trim().toLowerCase();
         const allowed = new Set();
         if (allowedRaw) {
@@ -76,6 +79,28 @@ class RuntimePolicy {
                 : 'Todos os executores da cadeia configurada estão indisponíveis no momento.'
         };
     }
+    getStrictModelExecutors() {
+        try {
+            const modelsPath = path.join(process.cwd(), 'models.json');
+            if (!fs.existsSync(modelsPath))
+                return [];
+            const cfg = JSON.parse(fs.readFileSync(modelsPath, 'utf-8'));
+            const chain = [cfg.primary, ...(cfg.fallbacks || [])].filter(Boolean);
+            if (chain.length !== 1)
+                return [];
+            const provider = chain[0].provider || '';
+            if (provider === 'openai-cli')
+                return ['codex'];
+            if (provider === 'gemini-cli' || provider === 'gemini-api')
+                return ['gemini'];
+            if (provider === 'anthropic-api')
+                return ['claude'];
+            return [];
+        }
+        catch {
+            return [];
+        }
+    }
     recordResult(executor, ok, reason) {
         this.executorHealth.set(executor, ok, reason);
         if (ok) {

package/dist/orchestrator/SquadCreator.js

@@ -171,17 +171,21 @@ class SquadCreator {
         if (frontmatter.id && frontmatter.id !== squadId) {
             errors.push(`frontmatter id '${frontmatter.id}' does not match directory '${squadId}'`);
         }
-        // Component files referenced in SQUAD.md should exist
-        const componentRefs = this.parseComponentRefs(content);
-        for (const refPath of componentRefs.agents) {
-            const full = path.join(squadDir, 'agents', refPath);
-            if (!fs.existsSync(full))
-                warnings.push(`referenced agent not found: agents/${refPath}`);
-        }
-        for (const refPath of componentRefs.tasks) {
-            const full = path.join(squadDir, 'tasks', refPath);
-            if (!fs.existsSync(full))
-                warnings.push(`referenced task not found: tasks/${refPath}`);
+        // Imported squads (lara-squads-import, obsidian-mirror, etc.) reference
+        // agents/tasks from the global .catalog/{agents,skills}/ pool, not squad-local.
+        const isImported = typeof frontmatter.source === 'string' && frontmatter.source.endsWith('-import');
+        if (!isImported) {
+            const componentRefs = this.parseComponentRefs(content);
+            for (const refPath of componentRefs.agents) {
+                const full = path.join(squadDir, 'agents', refPath);
+                if (!fs.existsSync(full))
+                    warnings.push(`referenced agent not found: agents/${refPath}`);
+            }
+            for (const refPath of componentRefs.tasks) {
+                const full = path.join(squadDir, 'tasks', refPath);
+                if (!fs.existsSync(full))
+                    warnings.push(`referenced task not found: tasks/${refPath}`);
+            }
         }
         return { ok: errors.length === 0, squadId, errors, warnings };
     }

package/dist/test_gateway_fast_ack.js

@@ -0,0 +1,66 @@
+"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 });
+const assert = __importStar(require("assert"));
+const Gateway_1 = require("./orchestrator/Gateway");
+async function main() {
+    process.env.OPENLIFE_TELEGRAM_ALLOWED_USER_ID = '';
+    process.env.OPENLIFE_ENABLE_TTS = 'false';
+    const gateway = new Gateway_1.Gateway();
+    gateway.classifier = {
+        classify: async (_text) => ({ intent: 'KNOWLEDGE_RETRIEVAL', budget: 0.1 })
+    };
+    gateway.gatekeeper = {
+        routeTask: async (_task, _text, _userId) => {
+            await new Promise(resolve => setTimeout(resolve, 1200));
+            return 'FINAL_AGENT_RESPONSE_FROM_GPT55_PATH';
+        }
+    };
+    const started = Date.now();
+    const result = await gateway.processTextForTestDetailed('1344110010', 'ola');
+    const totalMs = Date.now() - started;
+    assert.ok(result.ackMs !== null, 'ACK_NOT_SENT');
+    assert.ok(result.ackMs < 500, `ACK_TOO_SLOW_${result.ackMs}`);
+    assert.ok(result.events.length >= 2, `EXPECTED_ACK_AND_FINAL_EVENTS_${JSON.stringify(result.events)}`);
+    assert.strictEqual(result.events[0].kind, 'reply', 'FIRST_EVENT_SHOULD_BE_ACK_REPLY');
+    assert.ok(result.events[0].text.includes('processando'), `ACK_TEXT_UNEXPECTED_${result.events[0].text}`);
+    assert.strictEqual(result.finalText, 'FINAL_AGENT_RESPONSE_FROM_GPT55_PATH', `FINAL_TEXT_UNEXPECTED_${result.finalText}`);
+    assert.ok(totalMs >= 1100, 'TEST_STUB_DID_NOT_SIMULATE_SLOW_PATH');
+    console.log('TEST_GATEWAY_FAST_ACK_OK');
+}
+main().catch((err) => {
+    console.error('TEST_GATEWAY_FAST_ACK_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_no_automatic_messages.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Regression: OpenLife chat surface must not return canned/automatic replies.
+ * The main ask/Gatekeeper path should invoke the configured model executor even
+ * for greetings; deterministic status commands remain explicit operational paths.
+ */
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+function installBrainMock(mock) {
+    const brainPath = require.resolve('./orchestrator/Brain');
+    const orig = require.cache[brainPath];
+    require.cache[brainPath] = {
+        ...orig,
+        exports: {
+            Brain: class {
+                isAnyProviderAvailable() { return true; }
+                async thinkFast(_systemPrompt, userMessage) {
+                    mock.invocations += 1;
+                    mock.lastUserMessage = userMessage;
+                    return mock.reply;
+                }
+                async think(_systemPrompt, userMessage) {
+                    mock.invocations += 1;
+                    mock.lastUserMessage = userMessage;
+                    return mock.reply;
+                }
+            },
+        },
+    };
+    return () => {
+        if (orig)
+            require.cache[brainPath] = orig;
+        else
+            delete require.cache[brainPath];
+    };
+}
+async function main() {
+    process.env.OPENLIFE_OUTCOME_SIMULATION = 'off';
+    const mock = { invocations: 0, reply: 'MODEL_REPLY_FROM_GPT55_PATH' };
+    const restore = installBrainMock(mock);
+    try {
+        const { IntentClassifier } = require('./orchestrator/IntentClassifier');
+        const { Gatekeeper } = require('./orchestrator/Gatekeeper');
+        const classifier = new IntentClassifier();
+        const gatekeeper = new Gatekeeper();
+        const greeting = 'ola';
+        const task = await classifier.classify(greeting);
+        const response = await gatekeeper.routeTask(task, greeting, 'no-auto-test');
+        assertTrue(response === 'MODEL_REPLY_FROM_GPT55_PATH', 'greeting response comes from Brain/model path');
+        assertTrue(mock.invocations === 1, `Brain invoked exactly once for greeting (got ${mock.invocations})`);
+        assertTrue(mock.lastUserMessage === greeting, 'original greeting passed to model');
+        assertTrue(!/OpenLife online|Como posso ajudar|OPENLIFE ONLINE|Intenção desconhecida/.test(response), 'no canned chat text returned');
+    }
+    finally {
+        restore();
+    }
+    console.log('TEST_NO_AUTOMATIC_MESSAGES_OK');
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlife/cli",
-  "version": "1.7.10",
+  "version": "1.7.11",
   "description": "OPEN-LIFE Córtex Orquestrador Dual-Core",
   "main": "dist/index.js",
   "files": [
@@ -161,11 +161,14 @@
     "test:agent-creator": "npm run build && node dist/test_agent_creator.js",
     "pretest:all": "node scripts/clean-test-pollution.js",
     "test:all": "npm run build && node dist/test_distribution_installability.js && node dist/test_orchestration_assets_lifecycle.js && node dist/test_openlife_runtime_source_truth.js && node dist/test_openlife_evolution_surface.js && node dist/test_openlife_routing_surface.js && node dist/test_openlife_auto_creator_routing.js && node dist/test_openlife_gatekeeper_routing.js && node dist/test_enterprise_agentic_core.js && node dist/test_admin_teams_networks.js && node dist/test_agent_team_skill_network.js && node dist/test_benchmark_engine.js && node dist/test_cli_service_commands.js && node dist/test_consequence_forecaster.js && node dist/test_conversation_memory.js && node dist/test_create_entities.js && node dist/test_designmd_import_registry.js && node dist/test_designmd_mode.js && node dist/test_designmd_mode_workspace.js && node dist/test_dream_organizer.js && node dist/test_dual_mode.js && node dist/test_governance.js && node dist/test_governance_advanced.js && node dist/test_install_flow.js && node dist/test_job_lifecycle.js && node dist/test_memory_orchestrator.js && node dist/test_memory_promotion.js && node dist/test_memory_retention.js && node dist/test_operating_system.js && node dist/test_optimization_loop.js && node dist/test_outcome_simulator.js && node dist/test_performance_scorecard.js && node dist/test_phase6_board.js && node dist/test_phase6_cadence.js && node dist/test_phase6_ops.js && node dist/test_release_gate.js && node dist/test_reversa_contracts_e2e.js && node dist/test_reversa_export_and_strict.js && node dist/test_reversa_full_execution.js && node dist/test_reversa_lite.js && node dist/test_runtime_policy.js && node dist/test_runtime_probe.js && node dist/test_runtime_registry.js && node dist/test_security_download_guard.js && node dist/test_service_command_surface.js && node dist/test_service_completion_policy.js && node dist/test_service_guardrails_delete.js && node dist/test_sources_import_ref.js && node dist/test_sources_scaffold.js && node dist/test_teammate_learning.js && node dist/test_telegram_delete_guardrail.js && node dist/test_daemon_sigterm.js && node dist/test_ask_exit.js && node dist/test_brain_error_diagnostics.js && node dist/test_cli_doc_parity.js && node dist/test_trigger_basic_auth.js && node dist/test_brain_fallback_chain.js && node dist/test_cli_help_surface.js && node dist/test_cli_diagnostics.js && node dist/test_cli_crud_roundtrip.js && node dist/test_subsystems_routing_governance.js && node dist/test_subsystems_org_state.js && node dist/test_subsystems_promotion_memory_assets.js && node dist/test_phase1_check_exit.js && node dist/test_install_flow_host_validation.js && node dist/test_dist_templates_layout.js && node dist/test_host_installer.js && node dist/test_host_uninstaller.js && node dist/test_install_wizard.js && node dist/test_multi_host_docs_parity.js && node dist/test_host_install_e2e.js && node dist/test_runtime_profile_oauth_only.js && node dist/test_atomic_writer.js && node dist/test_mission_checkpoint.js && node dist/test_workflow_parser.js && node dist/test_workflow_engine.js && node dist/test_workflow_e2e.js && node dist/test_distributed_lock.js && node dist/test_watchdog_heartbeat.js && node dist/test_runtime_health_backoff.js && node dist/test_queue_scheduler.js && node dist/test_squad_skill_creator.js && node dist/test_aiobuilder_cli_parity.js && node dist/test_catalog_quality.js && node dist/test_royal_stack_golden.js && node dist/test_capability_pack_schema.js && node dist/test_capability_genesis_engine.js && node dist/test_workflow_schema_backward_compat.js && node dist/test_service_mode_explicit_only.js && node dist/test_deep_research_capability.js && node dist/test_guided_creator_cli.js && node dist/test_governance_v13_policies.js && node dist/test_gateway_telegram_guardrails.js && node dist/test_cron_manager.js && node dist/test_profile_toolset_mcp.js && node dist/test_squad_skill_design_llm.js && node dist/test_workflow_condition_parser.js && node dist/test_security_download_and_scan.js && node dist/test_host_installers_gemini_codex.js && node dist/test_toolset_enforcement.js && node dist/test_creator_placeholders_completed.js && node dist/test_performance_latency.js && node dist/test_post_mission_evaluation.js && node dist/test_governance_scope_ledger.js && node dist/test_consequence_forecast_brain.js && node dist/test_remote_publish.js && node dist/test_process_sandbox.js && node dist/test_v15_e2e_integration.js && node dist/test_doctor_sandbox_check.js && node dist/test_task_executor_sandbox_optin.js && node dist/test_forecast_brain_wiring.js && node dist/test_status_command.js && node dist/test_logs_command.js && node dist/test_agent_creator.js",
-    "prepublishOnly": "npm run test:all"
+    "prepublishOnly": "npm run test:all",
+    "test:no-automatic-messages": "npm run build && node dist/test_no_automatic_messages.js",
+    "test:gateway-fast-ack": "npm run build && node dist/test_gateway_fast_ack.js"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.86.1",
     "@google/generative-ai": "^0.24.1",
+    "@openai/codex": "^0.130.0",
     "axios": "^1.15.0",
     "commander": "^11.1.0",
     "dotenv": "^16.3.1",