@openlife/cli 1.7.14 → 1.8.2

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

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