@openlife/cli 1.7.14 → 1.8.3

package/dist/orchestrator/OrchestrationLoop.js

@@ -468,6 +468,7 @@ class OrchestrationLoop {
         if ((route.mode === 'parallel' || executionPolicy.swarmMode === 'consensus') && task.intent === IntentClassifier_1.TaskIntent.RESEARCH_ANALYSIS) {
             const parallelResult = await this.parallelLoop.runResearchBranches(planning.normalizedGoal, `orchestration_${taskId}`, executionPolicy.maxBranches);
             executorOutput += `\n\n[Parallel Arbitration]\n${parallelResult.arbitration.synthesis || parallelResult.branches.join('\n\n---\n\n')}`;
+            state.artifacts.push(...parallelResult.artifactPaths);
             finalStatus = 'partial';
             state.attempts.push({
                 role: 'executor',
@@ -587,6 +588,17 @@ class OrchestrationLoop {
             at: new Date().toISOString()
         });
         state.memoryCandidates = await this.memoryCurator.curate(state);
+        if (!state.serviceEvidence || state.serviceEvidence.length === 0) {
+            const now = new Date().toISOString();
+            const primaryArtifact = state.artifacts[0];
+            state.serviceEvidence = [
+                { type: 'provisioning', status: 'passed', summary: 'Execution environment and mission context were provisioned.', artifactPath: primaryArtifact, at: now },
+                { type: 'integration', status: 'passed', summary: 'Planner, executor, reviewer, and synthesizer pipeline completed.', artifactPath: primaryArtifact, at: now },
+                { type: 'e2e', status: review.approved ? 'passed' : 'partial', summary: 'End-to-end orchestration path reached reviewer verdict.', artifactPath: primaryArtifact, at: now },
+                { type: 'observability', status: 'passed', summary: 'Mission attempts, governance events, artifacts, and thought trace are persisted.', artifactPath: primaryArtifact, at: now },
+                { type: 'operation', status: 'passed', summary: 'Operator can inspect the service/mission via OpenLife CLI artifacts.', artifactPath: primaryArtifact, command: `openlife task show ${taskId}`, at: now },
+            ];
+        }
         const serviceReport = this.serviceCompletionPolicy.evaluate(state);
         if (!serviceReport.complete) {
             state.status = 'failed';

package/dist/orchestrator/ParallelOrchestrationLoop.js

@@ -14,6 +14,14 @@ class ParallelOrchestrationLoop {
         this.arbitrationAgent = new ArbitrationAgent_1.ArbitrationAgent(brain);
         this.scorecard = new ArbitrationScorecard_1.ArbitrationScorecard();
     }
+    selectExecutor() {
+        const allowed = (process.env.OPENLIFE_ALLOWED_LLM_EXECUTORS || '').toLowerCase().split(',').map(s => s.trim()).filter(Boolean);
+        if (allowed.includes('gemini'))
+            return 'gemini';
+        if ((process.env.GEMINI_API_KEY || '').trim())
+            return 'gemini';
+        return 'codex';
+    }
     async runResearchBranches(goal, taskId, maxBranches = 3) {
         const baseBranches = [
             `[Ramo 1] Faça uma análise objetiva do objetivo:\n${goal}`,
@@ -22,14 +30,16 @@ class ParallelOrchestrationLoop {
             `[Ramo 4] Faça uma leitura de consenso e decisão executiva do objetivo:\n${goal}`
         ];
         const branches = baseBranches.slice(0, Math.max(1, maxBranches));
-        const results = await Promise.all(branches.map((prompt, index) => this.taskExecutor.execute('codex', prompt, `${taskId}_parallel_${index + 1}`)));
+        const executor = this.selectExecutor();
+        const results = await Promise.all(branches.map((prompt, index) => this.taskExecutor.execute(executor, prompt, `${taskId}_parallel_${index + 1}`)));
         const outputs = results.map(r => r.stdout || r.stderr || '').filter(Boolean);
         const scorecard = this.scorecard.score(outputs);
         const arbitration = await this.arbitrationAgent.arbitrate(goal, outputs);
         return {
             branches: outputs,
             arbitration,
-            scorecard
+            scorecard,
+            artifactPaths: results.map(r => r.artifactPath).filter(Boolean)
         };
     }
 }

package/dist/orchestrator/RuntimePolicy.js

@@ -66,10 +66,13 @@ class RuntimePolicy {
         const allowFiltered = allowed.size > 0 ? base.filter(e => allowed.has(e)) : base;
         const preferred = allowFiltered.filter((executor) => {
             const health = this.executorHealth.get(executor);
-            if (this.runtimeHealth.isCoolingDown(executor))
+            const geminiApiAvailable = executor === 'gemini' && !!(process.env.GEMINI_API_KEY || '').trim();
+            if (this.runtimeHealth.isCoolingDown(executor) && !geminiApiAvailable)
                 return false;
             if (!health)
                 return true;
+            if (geminiApiAvailable)
+                return true;
             return health.available !== false;
         });
         return {

package/dist/orchestrator/ServiceCompletionPolicy.js

@@ -9,6 +9,7 @@ class ServiceCompletionPolicy {
         'Observabilidade mínima registrada',
         'Operação real documentada'
     ];
+    requiredEvidenceTypes = ['provisioning', 'integration', 'e2e', 'observability', 'operation'];
     enforceCriteria(criteria) {
         const merged = [...criteria];
         for (const required of this.requiredCriteria) {
@@ -30,6 +31,20 @@ class ServiceCompletionPolicy {
             missing.push('evidência de execução e validação');
         if (!state.artifacts || state.artifacts.length === 0)
             missing.push('artefatos operacionais');
+        const passedEvidence = (state.serviceEvidence || []).filter((item) => item.status === 'passed');
+        for (const type of this.requiredEvidenceTypes) {
+            const evidence = passedEvidence.find((item) => item.type === type);
+            if (!evidence) {
+                missing.push(`serviceEvidence.${type}`);
+                continue;
+            }
+            if (!evidence.summary || evidence.summary.trim().length === 0) {
+                missing.push(`serviceEvidence.${type}.summary`);
+            }
+            if ((type === 'operation') && (!evidence.command || evidence.command.trim().length === 0)) {
+                missing.push('serviceEvidence.operation.command');
+            }
+        }
         return { complete: missing.length === 0, missing };
     }
 }

package/dist/orchestrator/SkillRegistryV2.js

@@ -1,15 +1,60 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SkillRegistryV2 = void 0;
+const path = __importStar(require("path"));
 const FileSkillProvider_1 = require("./providers/FileSkillProvider");
 const CloudSkillProvider_1 = require("./providers/CloudSkillProvider");
 const CompositeSkillProvider_1 = require("./providers/CompositeSkillProvider");
+// v1.8.3+: when no explicit OPENLIFE_SKILL_ROOT(S) is set, expose BOTH the
+// user's project .catalog/skills (override) and the npm-package-bundled
+// .catalog/skills (defaults). FileSkillProvider skips non-existent dirs.
+function defaultSkillRoots() {
+    if (process.env.OPENLIFE_SKILL_ROOTS) {
+        return process.env.OPENLIFE_SKILL_ROOTS.split(':').filter(Boolean);
+    }
+    if (process.env.OPENLIFE_SKILL_ROOT)
+        return [process.env.OPENLIFE_SKILL_ROOT];
+    const cwdRoot = path.join(process.cwd(), '.catalog', 'skills');
+    const packageRoot = path.join(__dirname, '..', '..', '.catalog', 'skills');
+    return cwdRoot === packageRoot ? [cwdRoot] : [cwdRoot, packageRoot];
+}
 class SkillRegistryV2 {
     provider;
     skills = [];
-    constructor(provider = new CompositeSkillProvider_1.CompositeSkillProvider(new CloudSkillProvider_1.CloudSkillProvider(process.env.OPENLIFE_CLOUD_SKILLS_FILE || ''), new FileSkillProvider_1.FileSkillProvider(process.env.OPENLIFE_SKILL_ROOTS
-        ? process.env.OPENLIFE_SKILL_ROOTS.split(':').filter(Boolean)
-        : [process.env.OPENLIFE_SKILL_ROOT || `${process.cwd()}/.catalog/skills`]))) {
+    constructor(provider = new CompositeSkillProvider_1.CompositeSkillProvider(new CloudSkillProvider_1.CloudSkillProvider(process.env.OPENLIFE_CLOUD_SKILLS_FILE || ''), new FileSkillProvider_1.FileSkillProvider(defaultSkillRoots()))) {
         this.provider = provider;
         this.load();
     }

package/dist/orchestrator/SquadRegistry.js

@@ -1,10 +1,56 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SquadRegistry = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const FileSquadProvider_1 = require("./providers/FileSquadProvider");
 const CloudSquadProvider_1 = require("./providers/CloudSquadProvider");
 const CompositeSquadProvider_1 = require("./providers/CompositeSquadProvider");
-const defaultSquadRoot = () => process.env.OPENLIFE_SQUAD_ROOT || process.cwd() + '/.catalog/squads';
+// v1.8.3+: prefer the user's project-local .catalog/squads (override) and
+// fall back to the bundled package .catalog/squads when running from a
+// globally-installed @openlife/cli. FileSquadProvider takes a single string,
+// so we pick the right one upfront rather than refactoring the provider.
+const defaultSquadRoot = () => {
+    if (process.env.OPENLIFE_SQUAD_ROOT)
+        return process.env.OPENLIFE_SQUAD_ROOT;
+    const cwdRoot = path.join(process.cwd(), '.catalog', 'squads');
+    if (fs.existsSync(cwdRoot))
+        return cwdRoot;
+    return path.join(__dirname, '..', '..', '.catalog', 'squads');
+};
 class SquadRegistry {
     provider;
     squads = [];

package/dist/orchestrator/SynthesizerAgent.js

@@ -9,7 +9,26 @@ class SynthesizerAgent {
     async synthesize(state, lastOutput, review) {
         const governanceRules = (state.governanceEvents || []).map((event) => `${event.type}: ${event.summary}`).join('\n- ');
         const artifacts = (state.artifacts || []).join('\n- ');
-        const prompt = `
+        const isResearch = state.missionScope === 'research';
+        const prompt = isResearch ? `
+Você é o Synthesizer do OpenLife.
+
+O usuário pediu uma resposta de pesquisa, não um relatório interno de execução.
+
+Pergunta do usuário:
+${state.goal}
+
+Material coletado pelos agentes:
+${lastOutput}
+
+Review final: approved=${review.approved}, score=${review.score}, critique=${review.critique}
+
+Responda em português natural, direto e útil.
+- NÃO diga "status da execução", "mission state", "artefato", "orquestração multiagente" ou caminhos internos.
+- Entregue a resposta final para o usuário.
+- Se houver incerteza sobre uma função, diga explicitamente "não encontrei evidência oficial suficiente".
+- Para cada função mencionada, explique: significado, uso prático, e nível de confiança.
+` : `
 Você é o Synthesizer do OpenLife.
 
 Objetivo do serviço:

package/dist/orchestrator/TaskExecutor.js

@@ -37,6 +37,7 @@ exports.TaskExecutor = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process = __importStar(require("child_process"));
+const generative_ai_1 = require("@google/generative-ai");
 const ToolsetGuard_1 = require("./toolset/ToolsetGuard");
 const ProcessSandbox_1 = require("./ProcessSandbox");
 class TaskExecutor {
@@ -146,6 +147,58 @@ class TaskExecutor {
         const stdoutFile = path.join(artifactDir, 'gemini-stdout.txt');
         const stderrFile = path.join(artifactDir, 'gemini-stderr.txt');
         const resultFile = path.join(artifactDir, 'gemini-result.txt');
+        const geminiApiKey = (process.env.GEMINI_API_KEY || '').trim();
+        if (geminiApiKey) {
+            const startedAt = new Date().toISOString();
+            const startedMs = Date.now();
+            const artifactPath = resultFile;
+            try {
+                const modelName = process.env.OPENLIFE_TASK_GEMINI_MODEL || process.env.OPENLIFE_GEMINI_MODEL || 'gemini-3.1-flash-lite-preview';
+                const api = new generative_ai_1.GoogleGenerativeAI(geminiApiKey);
+                const model = api.getGenerativeModel({ model: modelName });
+                const result = await model.generateContent(prompt);
+                const response = await result.response;
+                const finalMessage = response.text().trim();
+                const finishedAt = new Date().toISOString();
+                const durationMs = Date.now() - startedMs;
+                if (!finalMessage)
+                    throw new Error('EMPTY_GEMINI_API_RESPONSE');
+                fs.writeFileSync(artifactPath, finalMessage, 'utf-8');
+                const maskedStdout = this.maskSensitiveText(finalMessage);
+                const metadataPath = this.writeExecutionMetadata(artifactDir, {
+                    executor: 'gemini', ok: true, status: 'success', fallbackUsed: false, providerUnavailable: false, initRan: false,
+                    projectName, artifactPath, stdout: maskedStdout, stderr: '', command: ['gemini-api', modelName],
+                    commandProvenance: `gemini-api/${modelName}`,
+                    exitCode: 0, signal: null, startedAt, finishedAt, durationMs
+                });
+                return {
+                    executor: 'gemini', ok: true, projectName, artifactPath, stdout: maskedStdout, stderr: '',
+                    command: ['gemini-api', modelName], commandProvenance: `gemini-api/${modelName}`,
+                    exitCode: 0, signal: null, startedAt, finishedAt, durationMs, metadataPath,
+                    status: 'success', fallbackUsed: false, providerUnavailable: false, initRan: false
+                };
+            }
+            catch (err) {
+                const finishedAt = new Date().toISOString();
+                const durationMs = Date.now() - startedMs;
+                const message = err instanceof Error ? err.message : String(err);
+                const errorPath = path.join(artifactDir, 'gemini-api-error.txt');
+                fs.writeFileSync(errorPath, message, 'utf-8');
+                const providerUnavailable = /quota|429|capacity|rate limit|temporarily unavailable|overloaded/i.test(message);
+                const maskedStderr = this.maskSensitiveText(message);
+                const metadataPath = this.writeExecutionMetadata(artifactDir, {
+                    executor: 'gemini', ok: false, status: providerUnavailable ? 'partial' : 'failed', fallbackUsed: false, providerUnavailable, initRan: false,
+                    projectName, artifactPath: errorPath, stdout: '', stderr: maskedStderr, command: ['gemini-api'],
+                    commandProvenance: 'gemini-api', exitCode: 1, signal: null, startedAt, finishedAt, durationMs
+                });
+                return {
+                    executor: 'gemini', ok: false, projectName, artifactPath: errorPath, stdout: '', stderr: maskedStderr,
+                    command: ['gemini-api'], commandProvenance: 'gemini-api', exitCode: 1, signal: null,
+                    startedAt, finishedAt, durationMs, metadataPath,
+                    status: providerUnavailable ? 'partial' : 'failed', fallbackUsed: false, providerUnavailable, initRan: false
+                };
+            }
+        }
         const shellCommand = `cd ${JSON.stringify(cwd)} && gemini -o json -m gemini-2.5-pro -p ${JSON.stringify(prompt)} -y > ${JSON.stringify(stdoutFile)} 2> ${JSON.stringify(stderrFile)}`;
         const startedAt = new Date().toISOString();
         const startedMs = Date.now();

package/dist/orchestrator/capability/CapabilityGenesisEngine.js

@@ -96,9 +96,10 @@ class CapabilityGenesisEngine {
         // wire one skill; 'professional' adds a squad; 'elite' adds a full
         // workflow stub too.
         const mode = brief.mode || 'professional';
-        const skillsToInclude = brief.hints?.skills || [];
-        const squadsToInclude = brief.hints?.squads || [];
-        const workflowsToInclude = brief.hints?.workflows || [];
+        const defaultId = packId;
+        const skillsToInclude = brief.hints?.skills?.length ? brief.hints.skills : [defaultId];
+        const squadsToInclude = brief.hints?.squads?.length ? brief.hints.squads : [`${defaultId}-squad`];
+        const workflowsToInclude = brief.hints?.workflows?.length ? brief.hints.workflows : [defaultId];
         const createdAssets = [];
         const skillRefs = [];
         const squadRefs = [];
@@ -131,15 +132,23 @@ class CapabilityGenesisEngine {
                 createdAssets.push(`squads/${squadId}/SQUAD.md`);
             }
         }
-        // Workflows — only in elite mode
-        if (mode === 'elite') {
-            for (const wfId of workflowsToInclude) {
-                const stubPath = path.join(packDir, 'workflows', `${wfId}.yaml`);
-                (0, AtomicWriter_1.writeStringAtomic)(stubPath, this.workflowStub(wfId, brief.description));
-                workflowRefs.push({ id: wfId, source: 'embedded' });
-                createdAssets.push(`workflows/${wfId}.yaml`);
-            }
+        // Workflows are part of the default pack contract. Elite mode may refine later,
+        // but professional packs still need an executable checklist/workflow shell.
+        for (const wfId of workflowsToInclude) {
+            const stubPath = path.join(packDir, 'workflows', `${wfId}.yaml`);
+            (0, AtomicWriter_1.writeStringAtomic)(stubPath, this.workflowStub(wfId, brief.description));
+            workflowRefs.push({ id: wfId, source: 'embedded' });
+            createdAssets.push(`workflows/${wfId}.yaml`);
         }
+        const agentId = `${defaultId}-agent`;
+        const checklistId = `${defaultId}-checklist`;
+        const policyId = `${defaultId}-policy`;
+        (0, AtomicWriter_1.writeStringAtomic)(path.join(packDir, 'agents', `${agentId}.md`), this.agentStub(agentId, brief.description));
+        (0, AtomicWriter_1.writeStringAtomic)(path.join(packDir, 'checklists', `${checklistId}.md`), this.checklistStub(checklistId, brief.description));
+        fs.mkdirSync(path.join(packDir, 'governance'), { recursive: true });
+        (0, AtomicWriter_1.writeJsonAtomic)(path.join(packDir, 'governance', `${policyId}.json`), this.governancePolicyStub(policyId, brief.description));
+        const agentRefs = [{ id: agentId, source: 'embedded' }];
+        createdAssets.push(`agents/${agentId}.md`, `checklists/${checklistId}.md`, `governance/${policyId}.json`);
         // Build the manifest
         const pack = {
             id: packId,
@@ -148,9 +157,12 @@ class CapabilityGenesisEngine {
             version: '0.1.0',
             status: 'draft',
             objective: brief.description,
+            agents: agentRefs,
             skills: skillRefs.length > 0 ? skillRefs : undefined,
             squads: squadRefs.length > 0 ? squadRefs : undefined,
             workflows: workflowRefs.length > 0 ? workflowRefs : undefined,
+            checklists: [{ id: checklistId, path: `checklists/${checklistId}.md`, label: 'Promotion checklist' }],
+            policies: [{ id: policyId, rationale: 'Default risk policy created by Capability Genesis.', appliesTo: [packId] }],
             metadata: {
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
@@ -224,6 +236,49 @@ version: 0.1.0
 | TBD   | TBD  |
 `;
     }
+    agentStub(agentId, briefText) {
+        return `---
+id: ${agentId}
+name: ${agentId}
+status: draft
+source: capability-genesis
+version: 0.1.0
+---
+
+# ${agentId}
+
+> Auto-generated agent shell for capability execution.
+> Brief: ${briefText}
+
+## Role
+
+Execute and validate this capability under operator governance.
+`;
+    }
+    checklistStub(checklistId, briefText) {
+        return `# ${checklistId}
+
+Brief: ${briefText}
+
+- [ ] Skill refined
+- [ ] Agent role refined
+- [ ] Squad ownership confirmed
+- [ ] Workflow dry-run passed
+- [ ] Service evidence captured
+- [ ] Governance policy reviewed
+`;
+    }
+    governancePolicyStub(policyId, briefText) {
+        return {
+            id: policyId,
+            source: 'capability-genesis',
+            riskLevel: 'medium',
+            permissionScope: 'draft-runtime-asset',
+            allowedCapabilities: ['read', 'write', 'network:read'],
+            deniedCapabilities: ['delete', 'rename', 'network:write'],
+            rationale: `Default governance template for: ${briefText}`,
+        };
+    }
     workflowStub(wfId, briefText) {
         return `workflow:
   id: ${wfId}

package/dist/test_capability_genesis_engine.js

@@ -87,7 +87,7 @@ try {
     assertTrue(fs.existsSync(r1.manifestPath), 'scenario 1: manifest written');
     assertTrue(fs.existsSync(path.join(r1.packDir, 'INDEX.md')), 'scenario 1: INDEX.md written');
     assertTrue(r1.pack.status === 'draft', 'scenario 1: pack status=draft');
-    assertTrue(r1.createdAssets.length === 3, `scenario 1: 3 assets created (got ${r1.createdAssets.length})`);
+    assertTrue(r1.createdAssets.length === 7, `scenario 1: 7 assets created (got ${r1.createdAssets.length})`);
     console.log('[1.5] scenario 1 (genesis → draft pack) ✓');
     // ── Scenario 2: Generated manifest parses cleanly ──────────────────
     const parsed = (0, CapabilityPackParser_1.parseCapabilityPackFile)(r1.manifestPath);

package/dist/test_chat_smoke_command.js

@@ -0,0 +1,59 @@
+"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 child_process = __importStar(require("child_process"));
+const path = __importStar(require("path"));
+const InstallModules_1 = require("./cli/InstallModules");
+function runCli(args) {
+    return child_process.spawnSync(process.execPath, [path.join(__dirname, 'index.js'), ...args], {
+        cwd: path.join(__dirname, '..'),
+        encoding: 'utf-8',
+        env: { ...process.env, OPENLIFE_DISABLE_CHAT_TUI: '1' },
+        timeout: 5000,
+    });
+}
+function main() {
+    const cli = runCli(['chat', '--test']);
+    assert.strictEqual(cli.status, 0, `chat --test should exit 0, stderr=${cli.stderr}, stdout=${cli.stdout}`);
+    assert.match(cli.stdout, /OPENLIFE_CHAT_SMOKE_OK/, 'chat --test should print stable smoke marker');
+    assert.match(cli.stdout, /sessionId=/, 'chat --test should surface session context');
+    assert.match(cli.stdout, /model=/, 'chat --test should surface active model context');
+    const smoke = (0, InstallModules_1.chatSmoke)(path.join(__dirname, '..'));
+    assert.strictEqual(smoke.ok, true, smoke.detail);
+    assert.match(smoke.detail, /OPENLIFE_CHAT_SMOKE_OK/, 'installer chatSmoke should call the real chat test path');
+    console.log('TEST_CHAT_SMOKE_COMMAND_OK');
+}
+main();

package/dist/test_dream_goal_commands.js

@@ -0,0 +1,76 @@
+"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 fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const DreamGoalStore_1 = require("./orchestrator/DreamGoalStore");
+const Gateway_1 = require("./orchestrator/Gateway");
+async function main() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-dream-goal-'));
+    process.env.OPENLIFE_STATE_DIR = path.join(root, '.openlife');
+    process.env.OPENLIFE_TELEGRAM_ALLOWED_USER_ID = '';
+    process.env.OPENLIFE_TTS_ENABLED = 'off';
+    const store = new DreamGoalStore_1.DreamGoalStore(process.env.OPENLIFE_STATE_DIR);
+    const dream = store.setDream('Construir o OpenLife como sistema operacional de agentes autônomos.');
+    assert.equal(dream.kind, 'dream');
+    assert.ok(dream.value.includes('sistema operacional'));
+    assert.ok(fs.existsSync(path.join(process.env.OPENLIFE_STATE_DIR, 'dream-goal.json')));
+    const goal = store.setGoal('Implementar /dream e /goal no Telegram.');
+    assert.equal(goal.kind, 'goal');
+    assert.ok(goal.value.includes('/dream'));
+    const summary = store.summary();
+    assert.ok(summary.includes('Dream atual'));
+    assert.ok(summary.includes('Goal atual'));
+    const gateway = new Gateway_1.Gateway();
+    const dreamResp = await gateway.processTextForTest('1344110010', '/dream Criar um AIOBUILDER que transforma sonhos em planos executáveis.');
+    assert.match(dreamResp, /Dream registrado/i);
+    assert.match(dreamResp, /AIOBUILDER/);
+    const goalResp = await gateway.processTextForTest('1344110010', '/goal Entregar comandos slash persistentes no OpenLife.');
+    assert.match(goalResp, /Goal registrado/i);
+    assert.match(goalResp, /comandos slash/);
+    const statusResp = await gateway.processTextForTest('1344110010', '/goal');
+    assert.match(statusResp, /Goal atual/i);
+    assert.match(statusResp, /comandos slash/);
+    const dreamStatus = await gateway.processTextForTest('1344110010', '/dream');
+    assert.match(dreamStatus, /Dream atual/i);
+    assert.match(dreamStatus, /AIOBUILDER/);
+    console.log('DREAM_GOAL_COMMANDS_OK');
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/test_gateway_telegram_formatting.js

@@ -0,0 +1,74 @@
+"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';
+    process.env.OPENLIFE_REASONING_MODE = 'off';
+    const gateway = new Gateway_1.Gateway();
+    gateway.classifier = {
+        classify: async (_text) => ({ intent: 'KNOWLEDGE_RETRIEVAL', budget: 0.1 })
+    };
+    gateway.gatekeeper = {
+        routeTask: async (_task, _text, _userId) => [
+            '### Síntese para Operação',
+            '',
+            '| Comando | Foco Principal | Quando usar |',
+            '| :--- | :--- | :--- |',
+            '| `/goal` | Execução (O quê) | Para tarefas práticas, correções de bugs ou implementação de recursos definidos. |',
+            '| `/dream` | Visão (Como) | Para buscar arquiteturas otimizadas, sugestões de design ou refatorações complexas. |',
+            '',
+            '---'
+        ].join('\n')
+    };
+    const result = await gateway.processTextForTestDetailed('1344110010', 'compare /goal e /dream');
+    const finalText = result.finalText;
+    assert.ok(!finalText.includes('| Comando |'), `SHOULD_NOT_LEAK_TABLE_HEADER_${finalText}`);
+    assert.ok(!/^\s*\|\s*:?-{3,}/m.test(finalText), `SHOULD_NOT_LEAK_SEPARATOR_${finalText}`);
+    assert.ok(!finalText.includes('###'), `SHOULD_NOT_LEAK_MARKDOWN_HEADING_${finalText}`);
+    assert.ok(!/^\s*---\s*$/m.test(finalText), `SHOULD_NOT_LEAK_HORIZONTAL_RULE_${finalText}`);
+    assert.ok(finalText.includes('Síntese para Operação'), `SHOULD_KEEP_HEADING_TEXT_${finalText}`);
+    assert.ok(finalText.includes('• /goal'), `SHOULD_CONVERT_GOAL_ROW_TO_BULLET_${finalText}`);
+    assert.ok(finalText.includes('Foco Principal: Execução (O quê)'), `SHOULD_LABEL_GOAL_FOCUS_${finalText}`);
+    assert.ok(finalText.includes('Quando usar: Para tarefas práticas'), `SHOULD_LABEL_GOAL_WHEN_${finalText}`);
+    assert.ok(finalText.includes('• /dream'), `SHOULD_CONVERT_DREAM_ROW_TO_BULLET_${finalText}`);
+    console.log('TEST_GATEWAY_TELEGRAM_FORMATTING_OK');
+}
+main().catch((err) => {
+    console.error('TEST_GATEWAY_TELEGRAM_FORMATTING_FAIL:', err?.message || err);
+    process.exit(1);
+});