@openlife/cli 1.7.10 → 1.7.12

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,123 @@ class Gateway {
         }
     }
     async processTextForTest(userId, text) {
+        const detailed = await this.processTextForTestDetailed(userId, text);
+        return detailed.finalText;
+    }
+    /**
+     * Public chat entry point for non-Telegram surfaces (CLI chat TUI, HTTP
+     * pilots, etc.). Wraps the same processInput pipeline used by the Telegram
+     * flow but routes replies through a minimal in-memory ctx so no Telegraf
+     * dependency is required at the call site.
+     *
+     * onReasoning fires for each pipeline trace event (classify → route →
+     * finalize) so a TUI can stream the agent's thinking into the Matrix-rain
+     * region instead of showing an opaque spinner.
+     */
+    async processChat(userId, text, opts) {
         let finalReply = '';
+        let lastEdit = null;
+        let mid = 0;
+        const ctx = {
+            sendChatAction: async () => { },
+            reply: async (m) => {
+                finalReply = m;
+                return { message_id: ++mid };
+            },
+            sendVoice: async (_src, options) => {
+                finalReply = options?.caption || finalReply;
+                return { message_id: ++mid };
+            },
+            chat: { id: userId },
+            telegram: {
+                editMessageText: async (_chat, _msg, _inline, edited) => {
+                    lastEdit = edited;
+                    return true;
+                }
+            }
+        };
+        // Bridge: every line containing one of the Gateway trace markers also
+        // becomes an onReasoning event. We patch the trace array indirectly by
+        // wrapping safeReply / editMessageText to detect when the final ACK
+        // edit lands. For per-step events we rely on processInput's existing
+        // trace.push() calls — to expose those we use a console.log shim only
+        // for THIS call (not global) when a callback is provided.
+        const onReasoning = opts?.onReasoning;
+        if (typeof onReasoning === 'function') {
+            const originalLog = console.log;
+            const restore = () => { console.log = originalLog; };
+            console.log = ((...args) => {
+                originalLog(...args);
+                const line = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+                if (/\[BRAIN\]|\[GATEWAY\]|\[GATEKEEPER\]|classify_intent|route_task|finalize_reply/.test(line)) {
+                    try {
+                        onReasoning(line);
+                    }
+                    catch { /* ignore */ }
+                }
+            });
+            try {
+                await this.processInput(ctx, userId, text);
+            }
+            finally {
+                restore();
+            }
+        }
+        else {
+            await this.processInput(ctx, userId, text);
+        }
+        return lastEdit ?? finalReply;
+    }
+    /**
+     * 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 +549,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 +602,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 +614,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_chat_tui.js

@@ -0,0 +1,116 @@
+"use strict";
+// src/test_chat_tui.ts
+// Tests for the ChatTui non-TTY surface area:
+// - buildInventoryStats reads .catalog counts correctly
+// - reading models.json returns the active model
+// - session log appends to .openlife/chat-sessions/<id>.jsonl
+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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const ChatTui_1 = require("./cli/ChatTui");
+let failed = 0;
+function check(label, condition, detail) {
+    if (condition) {
+        console.log(`✅ ${label}`);
+    }
+    else {
+        console.error(`❌ ${label}${detail ? ` — ${detail}` : ''}`);
+        failed++;
+    }
+}
+function makeTempRoot() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-chat-tui-'));
+    // .catalog skeleton with a couple of fake entries
+    fs.mkdirSync(path.join(root, '.catalog', 'agents', 'agent-a'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.catalog', 'agents', 'agent-b'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.catalog', 'squads', 'squad-a'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.catalog', 'skills', 'skill-a'), { recursive: true });
+    fs.mkdirSync(path.join(root, '.catalog', 'mcps'), { recursive: true });
+    // package.json with version
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'test', version: '9.9.9' }), 'utf-8');
+    // models.json with a primary
+    fs.writeFileSync(path.join(root, 'models.json'), JSON.stringify({ primary: { provider: 'p', name: 'm', raw: 'p/m' }, fallbacks: [] }), 'utf-8');
+    return root;
+}
+// 1. buildInventoryStats reads .catalog and models.json
+{
+    const root = makeTempRoot();
+    try {
+        const stats = (0, ChatTui_1.buildInventoryStats)(root, 'sess-1');
+        check('version reads from package.json', stats.version === 'v9.9.9', `got=${stats.version}`);
+        check('model reads from models.json', stats.model === 'p/m', `got=${stats.model}`);
+        check('agents counted', stats.agents === 2, `got=${stats.agents}`);
+        check('squads counted', stats.squads === 1, `got=${stats.squads}`);
+        check('skills counted', stats.skills === 1, `got=${stats.skills}`);
+        check('mcps counted (0 ok)', stats.mcps === 0, `got=${stats.mcps}`);
+        check('sessionId echoed', stats.sessionId === 'sess-1');
+        check('cwd reflects root', stats.cwd === root);
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 2. test-* directories are ignored (matches clean-test-pollution semantics)
+{
+    const root = makeTempRoot();
+    try {
+        fs.mkdirSync(path.join(root, '.catalog', 'agents', 'test-pollution-1'), { recursive: true });
+        const stats = (0, ChatTui_1.buildInventoryStats)(root, 's');
+        check('test-* agents excluded from counts', stats.agents === 2, `got=${stats.agents} (should ignore test-pollution-1)`);
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 3. Missing .catalog returns zeros, doesn't throw
+{
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-chat-tui-empty-'));
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'x', version: '1.0.0' }), 'utf-8');
+    try {
+        const stats = (0, ChatTui_1.buildInventoryStats)(root, 's');
+        check('empty .catalog yields zero counts', stats.agents === 0 && stats.squads === 0 && stats.skills === 0 && stats.mcps === 0);
+        check('missing models.json yields unknown', stats.model === 'unknown');
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+if (failed > 0) {
+    console.error(`\n${failed} check(s) failed.`);
+    process.exit(1);
+}
+console.log('\nTEST_CHAT_TUI_OK');

package/dist/test_config_tui.js

@@ -0,0 +1,116 @@
+"use strict";
+// src/test_config_tui.ts
+// Tests for ConfigTui persistence helpers — focused on file-level effects
+// (the interactive surface is exercised separately via the TUI).
+//
+// What we verify:
+// - saveApiKeysToEnv writes to .env, masks correctly via existing helper
+// - saveTelegramConfig persists token + chat id
+// - validateTelegramToken catches format errors before going to the network
+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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const InstallModules_1 = require("./cli/InstallModules");
+let failed = 0;
+function check(label, condition, detail) {
+    if (condition) {
+        console.log(`✅ ${label}`);
+    }
+    else {
+        console.error(`❌ ${label}${detail ? ` — ${detail}` : ''}`);
+        failed++;
+    }
+}
+// 1. saveApiKeysToEnv idempotent (writing same key twice does not duplicate)
+{
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-cfg-keys-'));
+    try {
+        (0, InstallModules_1.saveApiKeysToEnv)(root, { openai: 'sk-aaa' });
+        (0, InstallModules_1.saveApiKeysToEnv)(root, { openai: 'sk-bbb' });
+        const env = fs.readFileSync(path.join(root, '.env'), 'utf-8');
+        const matches = env.match(/^OPENAI_API_KEY=/gm) || [];
+        check('OPENAI_API_KEY appears exactly once after two saves', matches.length === 1, `count=${matches.length}`);
+        check('OPENAI_API_KEY reflects latest value', env.includes('OPENAI_API_KEY=sk-bbb'));
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 2. saveApiKeysToEnv preserves unrelated lines
+{
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-cfg-keys-mix-'));
+    try {
+        fs.writeFileSync(path.join(root, '.env'), 'SOME_OTHER=preserve_me\nFOO=bar\n', 'utf-8');
+        (0, InstallModules_1.saveApiKeysToEnv)(root, { gemini: 'gem-xyz' });
+        const env = fs.readFileSync(path.join(root, '.env'), 'utf-8');
+        check('preserved unrelated SOME_OTHER', env.includes('SOME_OTHER=preserve_me'));
+        check('preserved unrelated FOO', env.includes('FOO=bar'));
+        check('added new GEMINI_API_KEY', env.includes('GEMINI_API_KEY=gem-xyz'));
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 3. saveTelegramConfig sets token + chat id idempotently
+{
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-cfg-tg-'));
+    try {
+        (0, InstallModules_1.saveTelegramConfig)(root, '123456789:AAEEABCDEFGHIJKLMNOPQRSTUVWXYZ0123', '999');
+        (0, InstallModules_1.saveTelegramConfig)(root, '999999999:ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '999');
+        const env = fs.readFileSync(path.join(root, '.env'), 'utf-8');
+        const tokenCount = (env.match(/^TELEGRAM_BOT_TOKEN=/gm) || []).length;
+        check('TELEGRAM_BOT_TOKEN appears exactly once', tokenCount === 1, `count=${tokenCount}`);
+        check('TELEGRAM_BOT_TOKEN updated to second value', env.includes('TELEGRAM_BOT_TOKEN=999999999:'));
+    }
+    finally {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+}
+// 4. validateTelegramToken rejects bad format without going to network
+{
+    const r1 = (0, InstallModules_1.validateTelegramToken)(undefined);
+    check('validate rejects undefined token', r1.ok === false);
+    const r2 = (0, InstallModules_1.validateTelegramToken)('not-a-token');
+    check('validate rejects malformed token', r2.ok === false && r2.detail.includes('inválido'));
+    const r3 = (0, InstallModules_1.validateTelegramToken)('123:short');
+    check('validate rejects token with short secret', r3.ok === false);
+}
+if (failed > 0) {
+    console.error(`\n${failed} check(s) failed.`);
+    process.exit(1);
+}
+console.log('\nTEST_CONFIG_TUI_OK');