@openlife/cli 1.7.13 → 1.8.2

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

package/dist/test_install_wizard_v2.js

@@ -0,0 +1,193 @@
+"use strict";
+// src/test_install_wizard_v2.ts
+// Smoke + invariant tests for the v1.8.0 Install Wizard 2.0.
+//
+// Covers:
+//  1. ProvidersCatalog consistency — every ProviderId has a catalog row.
+//  2. OAuth policy — Anthropic OAuth is blocked, Codex/Gemini/Grok allowed.
+//  3. Phase registry — all phases have unique ids and required fields.
+//  4. CannedIO driver — wizard can walk through happy-path with canned answers
+//     without throwing (early phases only — won't touch the filesystem).
+//
+// Pattern follows existing src/test_install_wizard.ts (canned-answer driver).
+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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const ProvidersCatalog_1 = require("./cli/install/ProvidersCatalog");
+const types_1 = require("./cli/install/types");
+const Phases_1 = require("./cli/install/Phases");
+const WizardIO_1 = require("./cli/install/WizardIO");
+const OAuthRunner_1 = require("./cli/install/OAuthRunner");
+let failed = 0;
+let passed = 0;
+function check(name, cond, detail) {
+    if (cond) {
+        passed++;
+        console.log(`  ✓ ${name}`);
+    }
+    else {
+        failed++;
+        console.error(`  ✗ ${name}${detail ? ` — ${detail}` : ''}`);
+    }
+}
+async function main() {
+    console.log('test_install_wizard_v2: starting');
+    // ── 1. ProvidersCatalog consistency ─────────────────────────────────
+    console.log('\n[1] ProvidersCatalog consistency');
+    check('catalog has at least 25 entries', ProvidersCatalog_1.PROVIDERS_CATALOG.length >= 25, `actual=${ProvidersCatalog_1.PROVIDERS_CATALOG.length}`);
+    // All entries have required fields
+    for (const p of ProvidersCatalog_1.PROVIDERS_CATALOG) {
+        check(`${p.id} has label`, p.label.length > 0);
+        check(`${p.id} has tier`, !!p.tier);
+        check(`${p.id} has tags`, p.tags.length > 0);
+    }
+    // No duplicate IDs
+    const seen = new Set();
+    let dupes = 0;
+    for (const p of ProvidersCatalog_1.PROVIDERS_CATALOG) {
+        if (seen.has(p.id))
+            dupes++;
+        seen.add(p.id);
+    }
+    check('no duplicate provider ids', dupes === 0, `dupes=${dupes}`);
+    // ── 2. OAuth policy enforcement ─────────────────────────────────────
+    console.log('\n[2] OAuth policy');
+    const oauthList = types_1.OAUTH_ENABLED_PROVIDERS;
+    check('OAUTH_ENABLED_PROVIDERS has openai-cli', oauthList.includes('openai-cli'));
+    check('OAUTH_ENABLED_PROVIDERS has gemini-cli', oauthList.includes('gemini-cli'));
+    check('OAUTH_ENABLED_PROVIDERS has xai (Grok)', oauthList.includes('xai'));
+    check('OAUTH_ENABLED_PROVIDERS excludes anthropic', !oauthList.includes('anthropic'), 'Anthropic OAuth must be policy-blocked');
+    // OAuth runner refuses Anthropic
+    const antResult = await (0, OAuthRunner_1.runOAuth)('anthropic', { dryRun: true });
+    check('runOAuth("anthropic") returns ok=false', antResult.ok === false, `detail=${antResult.detail}`);
+    check('runOAuth("anthropic") detail mentions POLICY_BLOCK', /POLICY_BLOCK/.test(antResult.detail));
+    // OAuth runner accepts Codex dry-run
+    const codexResult = await (0, OAuthRunner_1.runOAuth)('openai-cli', { dryRun: true });
+    check('runOAuth("openai-cli", dryRun) returns ok=true', codexResult.ok === true);
+    const geminiResult = await (0, OAuthRunner_1.runOAuth)('gemini-cli', { dryRun: true });
+    check('runOAuth("gemini-cli", dryRun) returns ok=true', geminiResult.ok === true);
+    // ── 3. Phase registry ───────────────────────────────────────────────
+    console.log('\n[3] Phase registry');
+    check('ALL_PHASES has at least 20 phases', Phases_1.ALL_PHASES.length >= 20, `actual=${Phases_1.ALL_PHASES.length}`);
+    const phaseIds = new Set();
+    let phaseDupes = 0;
+    for (const ph of Phases_1.ALL_PHASES) {
+        if (phaseIds.has(ph.id))
+            phaseDupes++;
+        phaseIds.add(ph.id);
+        check(`phase "${ph.id}" has label`, ph.label.length > 0);
+        check(`phase "${ph.id}" has run fn`, typeof ph.run === 'function');
+    }
+    check('no duplicate phase ids', phaseDupes === 0, `dupes=${phaseDupes}`);
+    // The first 3 phases (banner, existing-install, product-select) MUST be unconditional.
+    const banner = Phases_1.ALL_PHASES.find(p => p.id === '00-banner');
+    check('00-banner has no `when` condition', banner !== undefined && !banner.when);
+    const existing = Phases_1.ALL_PHASES.find(p => p.id === '01-existing-install');
+    check('01-existing-install has no `when` condition', existing !== undefined && !existing.when);
+    const productSel = Phases_1.ALL_PHASES.find(p => p.id === '02-product-select');
+    check('02-product-select has no `when` condition', productSel !== undefined && !productSel.when);
+    // Core / agent phases must have `when` conditions
+    const coreEnter = Phases_1.ALL_PHASES.find(p => p.id === '10-core-enter');
+    check('10-core-enter has `when` condition', coreEnter !== undefined && typeof coreEnter.when === 'function');
+    const agentEnter = Phases_1.ALL_PHASES.find(p => p.id === '20-agent-enter');
+    check('20-agent-enter has `when` condition', agentEnter !== undefined && typeof agentEnter.when === 'function');
+    // ── 4. Catalog ↔ OAuth consistency ──────────────────────────────────
+    console.log('\n[4] Catalog ↔ OAuth consistency');
+    for (const id of types_1.OAUTH_ENABLED_PROVIDERS) {
+        try {
+            const p = (0, ProvidersCatalog_1.getProvider)(id);
+            check(`OAuth provider "${id}" has oauthCli`, !!p.oauthCli, `oauthCli="${p.oauthCli}"`);
+        }
+        catch (err) {
+            check(`OAuth provider "${id}" exists in catalog`, false, err instanceof Error ? err.message : String(err));
+        }
+    }
+    // Every catalog entry with oauthCli set should appear in OAUTH_ENABLED_PROVIDERS
+    for (const p of (0, ProvidersCatalog_1.oauthProviders)()) {
+        check(`catalog OAuth "${p.id}" in OAUTH_ENABLED_PROVIDERS`, types_1.OAUTH_ENABLED_PROVIDERS.includes(p.id), `catalog declares oauthCli=${p.oauthCli} but type not allow-listed`);
+    }
+    // ── 5. CannedIO smoke (banner + existing-install only, no FS writes) ─
+    // Use a clean tmp dir so phase 01 hits the "no previous install" branch
+    // and doesn't prompt for abort/reinstall/repair.
+    console.log('\n[5] CannedIO smoke');
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-test-v2-'));
+    try {
+        const io = new WizardIO_1.CannedIO([
+            /* phase 00-banner: pause */ true,
+            /* phase 01-existing-install: pause */ true,
+        ]);
+        const phase00 = Phases_1.ALL_PHASES[0];
+        const phase01 = Phases_1.ALL_PHASES[1];
+        const ctx = {
+            root: tmpRoot,
+            products: [],
+            coreHosts: [],
+            coreProviders: [],
+            coreApiKeys: {},
+            agentAuthDecisions: [],
+            agentOAuthResults: [],
+            agentApiKeys: {},
+            warnings: [],
+        };
+        await phase00.run(ctx, io);
+        await phase01.run(ctx, io);
+        check('CannedIO drove first 2 phases without throwing', true);
+        check('CannedIO transcript captured output', io.transcript.length > 0);
+        check('ctx not aborted on clean tmpdir', !ctx.aborted);
+    }
+    catch (err) {
+        check('CannedIO drove first 2 phases without throwing', false, err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }
+    // ── Done ────────────────────────────────────────────────────────────
+    console.log('');
+    console.log(`Results: ${passed} passed, ${failed} failed`);
+    if (failed > 0) {
+        console.error('TEST_INSTALL_WIZARD_V2_FAIL');
+        process.exit(1);
+    }
+    console.log('✅ test_install_wizard_v2: all checks passed');
+}
+main().catch((err) => {
+    console.error('TEST_INSTALL_WIZARD_V2_UNCAUGHT', err);
+    process.exit(1);
+});

package/dist/test_on_demand_voice_reply.js

@@ -0,0 +1,65 @@
+"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 () => ({ intent: 'KNOWLEDGE_RETRIEVAL', budgetLimit: 0.01 }) };
+    gateway.gatekeeper = { routeTask: async (_task, input) => `Resposta final para: ${input}` };
+    gateway.voiceManager = { generateSpeech: async (_text) => '/tmp/openlife-on-demand-voice-test.mp3' };
+    const result = await gateway.processTextForTestDetailed('1344110010', '/voice explique o AIOBUILDER em uma frase');
+    assert.equal(result.events.some((e) => e.kind === 'voice'), true);
+    assert.equal(result.finalText.includes('Resposta final para: explique o AIOBUILDER em uma frase'), true);
+    assert.equal(result.finalText.includes('/voice'), false);
+    const noVoice = await gateway.processTextForTestDetailed('1344110010', 'explique o AIOBUILDER em uma frase');
+    assert.equal(noVoice.events.some((e) => e.kind === 'voice'), false);
+    assert.equal(noVoice.events.some((e) => e.kind === 'edit'), true);
+    const fallbackGateway = new Gateway_1.Gateway();
+    fallbackGateway.classifier = gateway.classifier;
+    fallbackGateway.gatekeeper = gateway.gatekeeper;
+    fallbackGateway.voiceManager = { generateSpeech: async () => { throw new Error('NO_TTS_PROVIDER'); } };
+    const fallback = await fallbackGateway.processTextForTestDetailed('1344110010', 'responda por voz: diga olá');
+    assert.equal(fallback.events.some((e) => e.kind === 'voice'), false);
+    assert.match(fallback.finalText, /Não consegui gerar a voz/);
+    assert.match(fallback.finalText, /OPENAI_API_KEY|ELEVENLABS_API_KEY/);
+    console.log('ON_DEMAND_VOICE_REPLY_OK');
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/test_remaining_sprints_contracts.js

@@ -0,0 +1,103 @@
+"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 fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const ServiceCompletionPolicy_1 = require("./orchestrator/ServiceCompletionPolicy");
+const ExecutionState_1 = require("./orchestrator/ExecutionState");
+const Gateway_1 = require("./orchestrator/Gateway");
+const CapabilityGenesisEngine_1 = require("./orchestrator/capability/CapabilityGenesisEngine");
+const CapabilityPackState_1 = require("./orchestrator/capability/CapabilityPackState");
+const ConsequenceForecaster_1 = require("./orchestrator/ConsequenceForecaster");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    // Sprint 2 — ServiceEvidence must be typed; generic artifacts/attempts alone are not enough.
+    const policy = new ServiceCompletionPolicy_1.ServiceCompletionPolicy();
+    const weak = (0, ExecutionState_1.createExecutionState)('weak', 'operate service', 'u1');
+    weak.plan = ['provision', 'integrate', 'validate'];
+    weak.successCriteria = policy.enforceCriteria(['resultado']);
+    weak.attempts.push({ role: 'executor', summary: 'exec ok', status: 'success', at: new Date().toISOString(), artifactPath: '.artifacts/a.txt' });
+    weak.attempts.push({ role: 'reviewer', summary: 'review ok', status: 'success', at: new Date().toISOString() });
+    weak.artifacts.push('.artifacts/a.txt');
+    assert(policy.evaluate(weak).complete === false, 'generic artifacts must not complete service without typed evidence');
+    const strong = (0, ExecutionState_1.createExecutionState)('strong', 'operate service', 'u1');
+    strong.plan = ['provision', 'integrate', 'validate'];
+    strong.successCriteria = policy.enforceCriteria(['resultado']);
+    strong.attempts = weak.attempts;
+    strong.artifacts = ['.artifacts/provision.txt', '.artifacts/e2e.txt'];
+    strong.serviceEvidence = [
+        { type: 'provisioning', status: 'passed', summary: 'runtime provisioned', artifactPath: '.artifacts/provision.txt', at: new Date().toISOString() },
+        { type: 'integration', status: 'passed', summary: 'modules integrated', artifactPath: '.artifacts/integration.txt', at: new Date().toISOString() },
+        { type: 'e2e', status: 'passed', summary: 'end-to-end passed', artifactPath: '.artifacts/e2e.txt', at: new Date().toISOString() },
+        { type: 'observability', status: 'passed', summary: 'logs/metrics captured', artifactPath: '.artifacts/observability.txt', at: new Date().toISOString() },
+        { type: 'operation', status: 'passed', summary: 'real operation command documented', artifactPath: '.artifacts/operation.txt', command: 'openlife service run svc', at: new Date().toISOString() },
+    ];
+    assert(policy.evaluate(strong).complete === true, 'typed service evidence should complete service');
+    // Sprint 3 — Telegram conflict classification must be deterministic and non-secret.
+    const conflict = Gateway_1.Gateway.classifyTelegramLaunchError(new Error('409: Conflict: terminated by other getUpdates request'));
+    assert('error' in conflict && conflict.error === 'telegram_polling_conflict', '409 must classify as polling conflict');
+    assert('recoveryOptions' in conflict && conflict.recoveryOptions.includes('stop_conflicting_instance'), '409 recovery must offer stop_conflicting_instance');
+    // Sprint 4 — Capability Genesis must create skill+squad+agent+workflow+checklist+governance+index by default.
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-remaining-sprints-'));
+    const catalogRoot = path.join(tmp, '.catalog', 'capabilities');
+    const stateStore = new CapabilityPackState_1.CapabilityPackStateStore({ stateDir: path.join(tmp, '.openlife', 'capability-state') });
+    const engine = new CapabilityGenesisEngine_1.CapabilityGenesisEngine({ catalogRoot, stateStore });
+    const generated = engine.generate({ description: 'customer support escalation capability', packId: 'customer-support-escalation', mode: 'professional', actor: 'tester' });
+    assert(generated.ok === true, 'capability genesis should succeed');
+    if (!generated.ok)
+        throw new Error('unreachable');
+    for (const rel of ['skills/customer-support-escalation.md', 'squads/customer-support-escalation-squad/SQUAD.md', 'agents/customer-support-escalation-agent.md', 'workflows/customer-support-escalation.yaml', 'checklists/customer-support-escalation-checklist.md', 'governance/customer-support-escalation-policy.json', 'INDEX.md']) {
+        assert(fs.existsSync(path.join(generated.packDir, rel)), `missing generated asset: ${rel}`);
+    }
+    assert(generated.pack.agents?.length === 1, 'manifest must include agent ref');
+    assert(generated.pack.checklists?.length === 1, 'manifest must include checklist ref');
+    assert(generated.pack.policies?.length === 1, 'manifest must include governance policy ref');
+    // Sprint 5 — consequence forecast must expose value scoring and now/24h/7d/30d horizons.
+    const basePolicy = { executionMode: 'balanced', swarmMode: 'none', maxBranches: 1, rationale: 'test' };
+    const forecast = new ConsequenceForecaster_1.ConsequenceForecaster().forecast('deploy production change safely', 'high', basePolicy, ['codex']);
+    assert(Array.isArray(forecast.valueScores) && forecast.valueScores.length >= 4, 'forecast must include value scores');
+    for (const h of ['now', '24h', '7d', '30d']) {
+        assert(forecast.horizons?.[h]?.impact, `missing horizon ${h}`);
+    }
+    console.log('TEST_REMAINING_SPRINTS_CONTRACTS_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_runtime_policy.js

@@ -10,12 +10,31 @@ async function main() {
     runtime.recordResult('gemini', false, 'quota exhausted');
     runtime.recordResult('claude', false, 'auth expired');
     runtime.recordResult('codex', true, 'ok');
-    const research = runtime.decide('RESEARCH_ANALYSIS');
-    assert(!research.preferred.includes('gemini'), 'gemini should enter cooldown after quota failure');
-    assert(research.preferred.includes('codex'), 'research should fallback to codex when gemini is unhealthy');
-    const engineering = runtime.decide('ENGINEERING_BUILD');
-    assert(!engineering.preferred.includes('claude'), 'claude should enter cooldown after auth failure');
-    assert(engineering.preferred[0] === 'codex', 'codex should become preferred when secondary executors cool down');
+    // Pass explicit executors so the test is deterministic regardless of the
+    // repo's models.json (otherwise getStrictModelExecutors() reads cwd's
+    // models.json and biases `base` to a single executor when the chain has
+    // length 1 — which is the case in this repo today). The test exercises
+    // the health/cooldown filter, not chain-detection from disk.
+    //
+    // Also unset GEMINI_API_KEY in this process so the runtime's gemini-api
+    // bypass (which keeps gemini preferred when the key is exported even if
+    // cooling down) doesn't mask the cooldown assertion. CI/local env may
+    // export it for other tests; we restore it after.
+    const previousGeminiKey = process.env.GEMINI_API_KEY;
+    delete process.env.GEMINI_API_KEY;
+    try {
+        const baseExecutors = ['gemini', 'claude', 'codex'];
+        const research = runtime.decide('RESEARCH_ANALYSIS', [...baseExecutors]);
+        assert(!research.preferred.includes('gemini'), 'gemini should enter cooldown after quota failure');
+        assert(research.preferred.includes('codex'), 'research should fallback to codex when gemini is unhealthy');
+        const engineering = runtime.decide('ENGINEERING_BUILD', [...baseExecutors]);
+        assert(!engineering.preferred.includes('claude'), 'claude should enter cooldown after auth failure');
+        assert(engineering.preferred[0] === 'codex', 'codex should become preferred when secondary executors cool down');
+    }
+    finally {
+        if (previousGeminiKey !== undefined)
+            process.env.GEMINI_API_KEY = previousGeminiKey;
+    }
     const snapshot = runtime.saveSnapshot();
     assert(!!snapshot, 'runtime policy snapshot should be saved');
     console.log('TEST_RUNTIME_POLICY_OK');

package/dist/test_service_completion_policy.js

@@ -22,6 +22,13 @@ async function main() {
     complete.attempts.push({ role: 'executor', summary: 'exec ok', status: 'success', at: new Date().toISOString(), artifactPath: '.artifacts/a.txt' });
     complete.attempts.push({ role: 'reviewer', summary: 'review ok', status: 'success', at: new Date().toISOString() });
     complete.artifacts.push('.artifacts/a.txt');
+    complete.serviceEvidence = [
+        { type: 'provisioning', status: 'passed', summary: 'provisioned', at: new Date().toISOString(), artifactPath: '.artifacts/provision.txt' },
+        { type: 'integration', status: 'passed', summary: 'integrated', at: new Date().toISOString(), artifactPath: '.artifacts/integration.txt' },
+        { type: 'e2e', status: 'passed', summary: 'e2e passed', at: new Date().toISOString(), artifactPath: '.artifacts/e2e.txt' },
+        { type: 'observability', status: 'passed', summary: 'observability captured', at: new Date().toISOString(), artifactPath: '.artifacts/observability.txt' },
+        { type: 'operation', status: 'passed', summary: 'operation documented', at: new Date().toISOString(), artifactPath: '.artifacts/operation.txt', command: 'openlife service run t2' },
+    ];
     const reportComplete = policy.evaluate(complete);
     assert(reportComplete.complete === true, 'should pass complete service report');
     console.log('TEST_SERVICE_COMPLETION_POLICY_OK');