@openlife/cli 1.7.3

package/dist/index.js

@@ -0,0 +1,2575 @@
+#!/usr/bin/env node
+"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 dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+dotenv.config({ path: path.join(__dirname, '..', '.env') });
+const commander_1 = require("commander");
+const IntentClassifier_1 = require("./orchestrator/IntentClassifier");
+// Story 12.1 — small unknown→message helper used across CLI handlers.
+function errMsg(e) {
+    if (e instanceof Error)
+        return e.message;
+    if (e && typeof e === 'object' && 'message' in e && typeof e.message === 'string') {
+        return e.message;
+    }
+    return String(e);
+}
+function errStdout(e) {
+    if (e && typeof e === 'object' && 'stdout' in e) {
+        const v = e.stdout;
+        if (typeof v === 'string')
+            return v;
+    }
+    return '';
+}
+function errStderr(e) {
+    if (e && typeof e === 'object' && 'stderr' in e) {
+        const v = e.stderr;
+        if (typeof v === 'string')
+            return v;
+    }
+    return '';
+}
+// Heavy runtime classes are intentionally loaded lazily by the commands that need them.
+// This keeps deterministic CLI commands (`--help`, `plugin`, `context`, tests) from
+// hanging on optional gateway/model dependencies during module import.
+const ModelManager_1 = require("./orchestrator/ModelManager");
+const child_process = __importStar(require("child_process"));
+const util_1 = require("util");
+const SystemInstaller_1 = require("./cli/SystemInstaller");
+const SystemDoctor_1 = require("./orchestrator/SystemDoctor");
+const WorldClassCommands_1 = require("./cli/WorldClassCommands");
+const InstallBanner_1 = require("./cli/InstallBanner");
+const DreamOrganizer_1 = require("./cli/DreamOrganizer");
+const InstallFlow_1 = require("./cli/InstallFlow");
+const InstallWizard_1 = require("./cli/InstallWizard");
+const InstallHeadless_1 = require("./cli/InstallHeadless");
+const ServiceState_1 = require("./orchestrator/ServiceState");
+const MissionState_1 = require("./orchestrator/MissionState");
+const JobLifecycle_1 = require("./orchestrator/JobLifecycle");
+const RuntimeRegistry_1 = require("./orchestrator/RuntimeRegistry");
+const ReversaAgent_1 = require("./reversa/ReversaAgent");
+const TeammateBoard_1 = require("./orchestrator/TeammateBoard");
+const SkillLearningLoop_1 = require("./orchestrator/SkillLearningLoop");
+const DesignMdMode_1 = require("./design/DesignMdMode");
+const ExternalCatalogRegistry_1 = require("./orchestrator/ExternalCatalogRegistry");
+const SecurityDownloadGuard_1 = require("./orchestrator/SecurityDownloadGuard");
+const DesignMdImporter_1 = require("./design/DesignMdImporter");
+const DesignMdRegistry_1 = require("./design/DesignMdRegistry");
+const EnterpriseAgenticCore_1 = require("./orchestrator/EnterpriseAgenticCore");
+const exec = (0, util_1.promisify)(child_process.exec);
+const program = new commander_1.Command();
+function tryHandleDesignConversation(message) {
+    const text = message.trim();
+    const lower = text.toLowerCase();
+    const importer = new DesignMdImporter_1.DesignMdImporter();
+    const dm = new DesignMdMode_1.DesignMdMode();
+    const reversa = new ReversaAgent_1.ReversaAgent();
+    const wantsOpenDesignImport = /(import|carreg|baix|sync|sincroniz|traz|adicion)/i.test(text) && /(open\s*design|opendesign|getdesign)/i.test(text);
+    const wantsDesignMode = /(ativ|set|usar|trocar|mudar|habilit|enable)/i.test(text) && /(designmd|design\s*mode|modo\s*design)/i.test(text);
+    const wantsGenerateUi = /(gerar|gera|criar|cria|montar|fazer|faz|produce|build|generate)/i.test(text) && /(ui|interface|tela|layout|frontend|painel|dashboard)/i.test(text);
+    const wantsRefine = /^(refinar|refina|refine|iterar|itera|iterate|melhorar|melhora|polir)\b/i.test(text);
+    // Import Open Design por conversa
+    if (wantsOpenDesignImport) {
+        const pathMatch = text.match(/(?:em|from|de)\s+([^\n]+)$/i);
+        const vendorPath = (pathMatch?.[1] || 'vendor/open-design').trim();
+        if (!fs.existsSync(vendorPath)) {
+            return JSON.stringify({ error: 'vendor_not_found', vendorPath, hint: 'Clone open-design into this path or informe um caminho existente.' }, null, 2);
+        }
+        const guard = new SecurityDownloadGuard_1.SecurityDownloadGuard();
+        const scan = guard.scanExtractedDir(vendorPath);
+        if (!scan.ok) {
+            return JSON.stringify({ error: 'security_guard_blocked', scan }, null, 2);
+        }
+        const result = importer.importFromOpenDesign(vendorPath);
+        return JSON.stringify({ action: 'designmd.import', source: 'open-design', vendorPath, result }, null, 2);
+    }
+    // Definir modo designmd por conversa
+    if (wantsDesignMode) {
+        const profileMatch = text.match(/perfil\s+([a-zA-Z0-9._-]+)/i) || text.match(/profile\s+([a-zA-Z0-9._-]+)/i);
+        const profileId = profileMatch?.[1] || 'user-conversational-profile';
+        return JSON.stringify(reversa.setMode('designmd', profileId), null, 2);
+    }
+    // Refinar draft existente por conversa contínua (multi-turn)
+    if (wantsRefine) {
+        const featureRaw = text.replace(/^(refinar|refina|refine|iterar|itera|iterate|melhorar|melhora|polir)\s*/i, '').trim();
+        const statePath = require('path').join(process.cwd(), '.reversa', 'ui-drafts', '_conversation-state.json');
+        const remembered = require('fs').existsSync(statePath)
+            ? JSON.parse(require('fs').readFileSync(statePath, 'utf-8'))
+            : {};
+        const feature = featureRaw || remembered.lastFeature;
+        if (!feature) {
+            return 'Não identifiquei a feature para refinamento. Ex: "refinar dashboard financeiro"';
+        }
+        const featureSlug = feature.replace(/\s+/g, '-').toLowerCase();
+        const draftPath = require('path').join(process.cwd(), '.reversa', 'ui-drafts', `${featureSlug}.md`);
+        if (!require('fs').existsSync(draftPath)) {
+            return `Draft não encontrado para "${feature}". Gere primeiro com: openlife ask "gerar ui para ${feature}"`;
+        }
+        const current = require('fs').readFileSync(draftPath, 'utf-8');
+        const patchText = [
+            '',
+            '## Conversational Refinement',
+            `- User request: ${text}`,
+            '- Applied: stronger hierarchy, denser operator actions, clearer error recovery copy, stricter token invariants.',
+            '- Next: validate with stakeholders and promote to implementation tasks.'
+        ].join('\n');
+        require('fs').writeFileSync(draftPath, `${current}${patchText}\n`, 'utf-8');
+        return JSON.stringify({ action: 'aiobuilder.refine-ui', feature, output: { type: 'text-draft', path: draftPath } }, null, 2);
+    }
+    // Gerar UI por conversa com consistency-check implícito
+    if (wantsGenerateUi && !lower.includes('aiobuilder mode')) {
+        const featureMatch = text.match(/(?:para|for)\s+([a-zA-Z0-9._\-\s]+)/i);
+        const featureName = (featureMatch?.[1] || 'feature').trim();
+        const state = reversa.resume();
+        const mode = state.mode || 'default';
+        const profile = state.designProfileId || 'none';
+        const profiles = dm.listProfiles();
+        const activeProfile = profiles.find((p) => p.id === profile);
+        const effectiveSource = activeProfile?.source || 'user-conversation';
+        const effectiveChecksum = activeProfile?.checksum || `user-${Buffer.from(featureName).toString('hex').slice(0, 16)}`;
+        if (mode !== 'designmd') {
+            return 'Para engenharia de precisão visual, ative o modo designmd (ex.: "ative designmd").';
+        }
+        const outputDir = require('path').join(process.cwd(), '.reversa', 'ui-drafts');
+        require('fs').mkdirSync(outputDir, { recursive: true });
+        const featureSlug = featureName.replace(/\s+/g, '-').toLowerCase();
+        const outFile = require('path').join(outputDir, `${featureSlug}.md`);
+        const draft = [
+            `# UI Draft — ${featureName}`,
+            '',
+            `mode: ${mode}`,
+            `profile: ${profile}`,
+            `source: ${effectiveSource}`,
+            `checksum: ${effectiveChecksum}`,
+            '',
+            '## Generation Log',
+            '- Step 1/4: Loaded active DESIGN.md profile context',
+            '- Step 2/4: Applied precision and consistency rules',
+            '- Step 3/4: Incorporated final-contracts constraints',
+            '- Step 4/4: Produced textual UI draft',
+            '',
+            '## Initial Textual Design Output',
+            `- Feature: ${featureName}`,
+            '- Layout: premium enterprise shell with operational sidebar and command bar',
+            '- Core blocks: KPI row, status cards, teams matrix, skill networks table',
+            '- Interaction model: granular refresh, retry per panel, safe error boundaries',
+            '- Visual governance: no token drift from active design profile',
+        ].join('\n');
+        require('fs').writeFileSync(outFile, draft, 'utf-8');
+        const conversationStatePath = require('path').join(process.cwd(), '.reversa', 'ui-drafts', '_conversation-state.json');
+        const prevState = require('fs').existsSync(conversationStatePath)
+            ? JSON.parse(require('fs').readFileSync(conversationStatePath, 'utf-8'))
+            : {};
+        prevState.lastFeature = featureName;
+        prevState.lastFeatureSlug = featureSlug;
+        prevState.updatedAt = new Date().toISOString();
+        require('fs').writeFileSync(conversationStatePath, JSON.stringify(prevState, null, 2), 'utf-8');
+        return JSON.stringify({
+            action: 'aiobuilder.generate-ui',
+            featureName,
+            strictContracts: true,
+            consistencyCheck: true,
+            output: { type: 'text-draft', path: outFile },
+            context: {
+                designContext: {
+                    mode,
+                    profile,
+                    source: effectiveSource,
+                    checksum: effectiveChecksum,
+                },
+                precisionRules: [
+                    'Maintain token consistency across pages/components',
+                    'Preserve spacing/typography scale from DESIGN.md',
+                    'Reject visual drift that breaks profile identity',
+                ],
+            },
+        }, null, 2);
+    }
+    return null;
+}
+program
+    .name('openlife')
+    .description('OPEN-LIFE Córtex Orquestrador (Dual-Core)')
+    .version('1.0.0');
+program
+    .command('install')
+    .description('Onboarding unificado: instala CLI ou Agente Autônomo')
+    .option('--mode <mode>', 'cli | autonomous')
+    .option('--resume', 'retoma estado salvo do setup')
+    .option('--host <host>', 'host principal de execução', 'claude-code')
+    .option('--skip-doctor', 'pula check automático do doctor')
+    .option('--models <chain>', 'ordem de modelos, separado por vírgula')
+    .option('--model-1 <provider/model>', 'modelo primário (opcional no setup guiado)')
+    .option('--model-2 <provider/model>', 'fallback 1 (opcional)')
+    .option('--model-3 <provider/model>', 'fallback 2 (opcional)')
+    .option('--telegram-token <token>', 'token do bot do Telegram (opcional)')
+    .option('--telegram-chat-id <chatId>', 'chat id padrão do Telegram (opcional)')
+    .option('--default-agent-name <name>', 'renomeia agente padrão (modo autônomo)')
+    .option('--additional-agent-name <name>', 'cria agente adicional (modo autônomo)')
+    .option('--headless', 'executa sem interação usando flags/arquivo')
+    .option('--from-file <path>', 'carrega configuração JSON de setup')
+    .action((options) => {
+    const fileCfg = options.fromFile ? (0, InstallHeadless_1.loadHeadlessConfig)(options.fromFile) : {};
+    // Explicit pick avoids smuggling models (string[] from file, string from CLI)
+    // through the same field — its only consumer reads options.models directly.
+    const effective = {
+        mode: options.mode || fileCfg.mode,
+        host: options.host || fileCfg.host,
+        telegramToken: options.telegramToken || fileCfg.telegramToken,
+        telegramChatId: options.telegramChatId || fileCfg.telegramChatId,
+        defaultAgentName: options.defaultAgentName || fileCfg.defaultAgentName,
+        additionalAgentName: options.additionalAgentName || fileCfg.additionalAgentName,
+        model1: options.model1,
+        model2: options.model2,
+        model3: options.model3,
+    };
+    const guidedModels = [effective.model1, effective.model2, effective.model3].filter((m) => !!m);
+    if (guidedModels.length > 0 && !options.model1) {
+        console.error('❌ Setup guiado inválido: --model-1 é obrigatório quando usar --model-2+');
+        process.exitCode = 1;
+        return;
+    }
+    const modelOrder = guidedModels.length > 0
+        ? guidedModels
+        : (typeof options.models === 'string' ? options.models.split(',').map((m) => m.trim()).filter(Boolean) : undefined);
+    const wizard = new InstallWizard_1.HeadlessInstallWizard();
+    const lines = wizard.run({
+        mode: effective.mode,
+        resume: !!options.resume,
+        host: effective.host || 'claude-code',
+        skipDoctor: !!options.skipDoctor,
+        telegramToken: effective.telegramToken,
+        telegramChatId: effective.telegramChatId,
+        defaultAgentName: effective.defaultAgentName,
+        additionalAgentName: effective.additionalAgentName,
+        modelOrder
+    });
+    for (const line of lines)
+        console.log(line);
+});
+// ============================================================================
+// INIT — Interactive install wizard (Story 3.5)
+// ============================================================================
+program.command('init')
+    .description('Interactive install wizard — guided setup for OpenLife into the chosen host CLI')
+    .action(async () => {
+    // Lazy require preserves the lazy-import contract (`src/index.ts:11-13`).
+    const { InstallWizard, ReadlineAnswerProvider } = require('./cli/InstallWizard');
+    const { InstallFlow } = require('./cli/InstallFlow');
+    const provider = new ReadlineAnswerProvider();
+    const wizard = new InstallWizard(process.cwd(), provider);
+    try {
+        const result = await wizard.run();
+        if (!result.ok) {
+            console.log(JSON.stringify(result, null, 2));
+            process.exitCode = result.reason === 'user_aborted' ? 0 : 1;
+            return;
+        }
+        const flow = new InstallFlow();
+        const installResult = flow.run(result.options);
+        for (const line of flow.renderSummary(installResult))
+            console.log(line);
+        if (result.warnings && result.warnings.length) {
+            console.log('');
+            console.log('⚠️  Warnings:');
+            for (const w of result.warnings)
+                console.log(`  - ${w}`);
+        }
+    }
+    finally {
+        // Release the readline interface so the CLI exits cleanly.
+        provider.close?.();
+    }
+});
+// ============================================================================
+// AUTENTICAÇÃO (AUTH)
+// ============================================================================
+const authCmd = program.command('auth').description('Gerencia a autenticação nativa sem uso de API Keys');
+authCmd.command('gemini')
+    .description('Realiza o login OAuth via Google para o Gemini CLI')
+    .action(async () => {
+    console.log("🔐 Iniciando autenticação nativa do Gemini (Google OAuth)...");
+    try {
+        await exec('gemini auth');
+        console.log("✅ Autenticação Gemini concluída com sucesso! Modelos 3.0+ liberados.");
+    }
+    catch {
+        console.log("ℹ️ Autenticação manual necessária. Rode no seu terminal: gemini auth");
+    }
+});
+authCmd.command('openai')
+    .alias('codex')
+    .description('Realiza o login OAuth para o OpenAI Codex CLI (GPT-5.4) e valida automaticamente')
+    .action(async () => {
+    console.log("🔐 Iniciando autenticação nativa da OpenAI (ChatGPT OAuth)...");
+    console.log("Se o navegador não abrir, copie o link exibido abaixo e conclua o login.");
+    try {
+        const { stdout } = await exec('codex login status');
+        if (stdout.toLowerCase().includes('logged in')) {
+            console.log(`✅ ${stdout.trim()}`);
+            return;
+        }
+    }
+    catch { }
+    try {
+        // codex login normalmente fica aguardando callback local; usamos timeout curto só para capturar URL
+        await exec('codex login', { timeout: 7000 });
+    }
+    catch (e) {
+        const out = `${errStdout(e)}\n${errStderr(e)}`;
+        const m = out.match(/https:\/\/auth\.openai\.com\/oauth\/authorize\S+/);
+        if (m?.[0]) {
+            console.log(`🌐 Link de autenticação: ${m[0]}`);
+            console.log('Após concluir no navegador, este comando pode ser rodado novamente para validar status.');
+        }
+        else {
+            console.log('ℹ️ Não consegui capturar o link automático. Rode: codex login --device-auth');
+        }
+    }
+    try {
+        const { stdout } = await exec('codex login status');
+        if (stdout.toLowerCase().includes('logged in')) {
+            console.log(`✅ ${stdout.trim()}`);
+        }
+        else {
+            console.log(`⚠️ Status atual: ${stdout.trim()}`);
+        }
+    }
+    catch {
+        console.log('⚠️ Não foi possível validar status agora. Rode: codex login status');
+    }
+});
+// ============================================================================
+// GESTÃO DE MODELOS E FALLBACKS
+// ============================================================================
+const modelsCmd = program.command('models').description('Gestão do ciclo de vida e roteamento de Modelos Inteligentes');
+modelsCmd.command('status')
+    .description('Exibe o modelo primário e a cadeia de fallbacks atual')
+    .action(() => {
+    const manager = new ModelManager_1.ModelManager();
+    const config = manager.getModelConfig();
+    console.log(`\n🧠 OPEN-LIFE: Status de Modelos Cognitivos`);
+    console.log(`=================================================`);
+    console.log(`⭐ Primário: ${config.primary.raw}`);
+    console.log(`\n🛡️  Cadeia de Fallbacks (Ordem de Execução de Failover):`);
+    if (config.fallbacks.length === 0) {
+        console.log(`   [Nenhum fallback configurado. Risco de falha única!]`);
+    }
+    else {
+        config.fallbacks.forEach((f, i) => {
+            console.log(`   ${i + 1}. ${f.raw}`);
+        });
+    }
+    console.log(`=================================================\n`);
+});
+modelsCmd.command('set <provider/model>')
+    .description('Define o modelo cognitivo padrão (ex: gemini-cli/gemini-3.1-pro-preview)')
+    .action((modelString) => {
+    try {
+        const manager = new ModelManager_1.ModelManager();
+        const config = manager.getModelConfig();
+        const newPrimary = manager.parseModelString(modelString);
+        config.primary = newPrimary;
+        manager.saveConfig(config);
+        console.log(`✅ Modelo primário atualizado com sucesso para: ${newPrimary.raw}`);
+    }
+    catch (e) {
+        console.error(`❌ Erro: ${errMsg(e)}`);
+    }
+});
+const fallbacksCmd = modelsCmd.command('fallbacks').description('Gerencia a cadeia de tolerância a falhas (Fallbacks)');
+fallbacksCmd.command('list')
+    .action(() => {
+    const manager = new ModelManager_1.ModelManager();
+    const config = manager.getModelConfig();
+    console.log(`\n🛡️  Cadeia de Fallbacks Atual:`);
+    config.fallbacks.forEach((f, i) => console.log(`   ${i + 1}. ${f.raw}`));
+    console.log();
+});
+fallbacksCmd.command('add <provider/model>')
+    .action((modelString) => {
+    try {
+        const manager = new ModelManager_1.ModelManager();
+        const config = manager.getModelConfig();
+        const newFallback = manager.parseModelString(modelString);
+        if (config.fallbacks.some(f => f.raw === newFallback.raw)) {
+            console.log(`⚠️ O modelo ${newFallback.raw} já está na lista de fallbacks.`);
+            return;
+        }
+        config.fallbacks.push(newFallback);
+        manager.saveConfig(config);
+        console.log(`✅ Fallback adicionado. Nova Ordem de Segurança:`);
+        config.fallbacks.forEach((f, i) => console.log(`   ${i + 1}. ${f.raw}`));
+    }
+    catch (e) {
+        console.error(`❌ Erro: ${errMsg(e)}`);
+    }
+});
+fallbacksCmd.command('remove <provider/model>')
+    .action((modelString) => {
+    try {
+        const manager = new ModelManager_1.ModelManager();
+        const config = manager.getModelConfig();
+        const parsed = manager.parseModelString(modelString);
+        config.fallbacks = config.fallbacks.filter(f => f.raw !== parsed.raw);
+        manager.saveConfig(config);
+        console.log(`✅ Fallback ${parsed.raw} removido do sistema de segurança.`);
+    }
+    catch (e) {
+        console.error(`❌ Erro: ${errMsg(e)}`);
+    }
+});
+fallbacksCmd.command('clear')
+    .action(() => {
+    const manager = new ModelManager_1.ModelManager();
+    const config = manager.getModelConfig();
+    config.fallbacks = [];
+    manager.saveConfig(config);
+    console.log(`✅ Cadeia de fallbacks esvaziada.`);
+});
+// ============================================================================
+// CORE ORQUESTRADOR
+// ============================================================================
+program
+    .command('ask <mensagem...>')
+    .description('Envia uma intenção direta ao Gatekeeper via Terminal')
+    .option('--mode <mode>', 'task | service')
+    .action(async (mensagemArgs, options) => {
+    const mensagem = mensagemArgs.join(' ');
+    console.log(`\n> Você: "${mensagem}"\n`);
+    const designHandled = tryHandleDesignConversation(mensagem);
+    if (designHandled) {
+        console.log(`\n> OPEN-LIFE: ${designHandled}\n`);
+        process.exit(0);
+    }
+    const timeoutMs = Number(process.env.OPENLIFE_ASK_TIMEOUT_MS || 90000);
+    const classifier = new IntentClassifier_1.IntentClassifier();
+    const { Gatekeeper } = require('./orchestrator/Gatekeeper');
+    const gatekeeper = new Gatekeeper();
+    const run = async () => {
+        const task = await classifier.classify(mensagem);
+        const modeRaw = (options?.mode || '').toString().toLowerCase();
+        const mode = modeRaw === 'service' ? 'service' : modeRaw === 'task' ? 'task' : undefined;
+        return gatekeeper.routeTask(task, mensagem, 'default', mode ? { mode } : undefined);
+    };
+    try {
+        const resposta = await Promise.race([
+            run(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout após ${timeoutMs}ms no comando ask`)), timeoutMs))
+        ]);
+        console.log(`\n> OPEN-LIFE: ${resposta}\n`);
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(`\n> OPEN-LIFE [erro]: ${errMsg(err)}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command('phase1-check')
+    .description('Roda os checks mínimos da Fase 1 para validar o runtime principal')
+    .action(async () => {
+    let exitCode = 0;
+    const MASTER_TIMEOUT_MS = Number(process.env.OPENLIFE_PHASE1_TIMEOUT_MS || 30000);
+    const masterTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error(`PHASE1_CHECK_TIMEOUT after ${MASTER_TIMEOUT_MS}ms — provavelmente Gatekeeper/Brain/Gateway constructor ou check travou esperando LLM/recurso externo`)), MASTER_TIMEOUT_MS));
+    try {
+        // Wrap both construction and run inside race — TestHarness constructor instantiates
+        // Brain/Gatekeeper/Gateway/etc which may block synchronously
+        const results = await Promise.race([
+            (async () => {
+                const { TestHarness } = require('./orchestrator/TestHarness');
+                const harness = new TestHarness();
+                return await harness.runPhase1Checks();
+            })(),
+            masterTimeout
+        ]);
+        console.log('\n🔎 OPEN-LIFE Phase 1 Check');
+        console.log('=================================================');
+        for (const result of results) {
+            console.log(`${result.ok ? '✅' : '❌'} ${result.name}: ${result.detail}`);
+        }
+        console.log('=================================================\n');
+        const failed = results.filter((r) => !r.ok);
+        if (failed.length > 0)
+            exitCode = 1;
+    }
+    catch (error) {
+        console.error('phase1-check failed:', errMsg(error));
+        exitCode = 1;
+    }
+    // Force deterministic exit — TestHarness instantiates Gateway → Telegraf, leaving
+    // event-loop handles open. Same root-cause pattern as Story 1.2 `ask` exit fix.
+    // Override timeout via OPENLIFE_PHASE1_TIMEOUT_MS (default 30s).
+    process.exit(exitCode);
+});
+const systemCmd = program.command('system').description('Instalação, bootstrap e status do OpenLife');
+systemCmd.command('install')
+    .description('Fluxo guiado de instalação (rápido e intuitivo)')
+    .option('--profile <profile>', 'framework | autonomous', 'framework')
+    .option('--host <host>', 'host principal de execução', 'claude-code')
+    .option('--skip-doctor', 'pula check automático do doctor')
+    .option('--models <chain>', 'ordem de modelos, separado por vírgula. Ex: openai-cli/gpt-5.4,gemini-cli/gemini-3.1-pro-preview')
+    .option('--model-1 <provider/model>', 'modelo primário (obrigatório para setup guiado)')
+    .option('--model-2 <provider/model>', 'fallback 1 (opcional)')
+    .option('--model-3 <provider/model>', 'fallback 2 (opcional)')
+    .option('--model-4 <provider/model>', 'fallback 3 (opcional)')
+    .action((options) => {
+    console.log((0, InstallBanner_1.installationBanner)());
+    const installFlow = new InstallFlow_1.InstallFlow();
+    const profile = (options.profile || 'framework').toLowerCase();
+    const safeProfile = profile === 'autonomous' ? 'autonomous' : 'framework';
+    const guidedModels = [options.model1, options.model2, options.model3, options.model4].filter((m) => !!m);
+    if (guidedModels.length > 0 && !options.model1) {
+        console.error('❌ Setup guiado inválido: --model-1 é obrigatório quando usar --model-2+');
+        process.exitCode = 1;
+        return;
+    }
+    const modelOrder = guidedModels.length > 0
+        ? guidedModels
+        : (typeof options.models === 'string' ? options.models.split(',').map((m) => m.trim()).filter(Boolean) : undefined);
+    const result = installFlow.run({
+        profile: safeProfile,
+        host: options.host || 'claude-code',
+        skipDoctor: !!options.skipDoctor,
+        modelOrder
+    });
+    for (const line of installFlow.renderSummary(result)) {
+        console.log(line);
+    }
+});
+systemCmd.command('setup')
+    .description('Alias de system install para onboarding completo')
+    .option('--profile <profile>', 'framework | autonomous', 'framework')
+    .option('--host <host>', 'host principal de execução', 'claude-code')
+    .option('--skip-doctor', 'pula check automático do doctor')
+    .option('--models <chain>', 'ordem de modelos, separado por vírgula. Ex: openai-cli/gpt-5.4,gemini-cli/gemini-3.1-pro-preview')
+    .option('--model-1 <provider/model>', 'modelo primário (obrigatório para setup guiado)')
+    .option('--model-2 <provider/model>', 'fallback 1 (opcional)')
+    .option('--model-3 <provider/model>', 'fallback 2 (opcional)')
+    .option('--model-4 <provider/model>', 'fallback 3 (opcional)')
+    .action((options) => {
+    console.log((0, InstallBanner_1.installationBanner)());
+    const installFlow = new InstallFlow_1.InstallFlow();
+    const profile = (options.profile || 'framework').toLowerCase();
+    const safeProfile = profile === 'autonomous' ? 'autonomous' : 'framework';
+    const guidedModels = [options.model1, options.model2, options.model3, options.model4].filter((m) => !!m);
+    if (guidedModels.length > 0 && !options.model1) {
+        console.error('❌ Setup guiado inválido: --model-1 é obrigatório quando usar --model-2+');
+        process.exitCode = 1;
+        return;
+    }
+    const modelOrder = guidedModels.length > 0
+        ? guidedModels
+        : (typeof options.models === 'string' ? options.models.split(',').map((m) => m.trim()).filter(Boolean) : undefined);
+    const result = installFlow.run({
+        profile: safeProfile,
+        host: options.host || 'claude-code',
+        skipDoctor: !!options.skipDoctor,
+        modelOrder
+    });
+    for (const line of installFlow.renderSummary(result)) {
+        console.log(line);
+    }
+});
+systemCmd.command('uninstall')
+    .description('Remove OpenLife artifacts installed into the host CLI (reversible install). Does NOT touch .openlife/ state.')
+    .option('--host <host>', 'host to uninstall from (claude-code | gemini-cli | codex)')
+    .action((options) => {
+    const { HostInstaller, HostNotYetSupportedError } = require('./cli/HostInstaller');
+    const { validateHost, detectHostFromEnv, DEFAULT_HOST } = require('./cli/InstallFlow');
+    const host = options.host ? validateHost(options.host) : (detectHostFromEnv() || DEFAULT_HOST);
+    try {
+        const result = new HostInstaller().uninstall(host, { targetRoot: process.cwd() });
+        console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+    }
+    catch (err) {
+        if (err instanceof HostNotYetSupportedError) {
+            const hostErr = err;
+            console.log(JSON.stringify({ ok: false, error: hostErr.code, host, message: hostErr.message }, null, 2));
+            process.exitCode = 1;
+        }
+        else {
+            console.error(JSON.stringify({ ok: false, error: 'uninstall_failed', message: errMsg(err) }, null, 2));
+            process.exitCode = 1;
+        }
+    }
+});
+systemCmd.command('status')
+    .description('Mostra status básico da instalação do sistema')
+    .action(() => {
+    const installer = new SystemInstaller_1.SystemInstaller();
+    console.log(JSON.stringify(installer.status(), null, 2));
+});
+systemCmd.command('doctor')
+    .description('Roda checkup básico do sistema e runtime local')
+    .action(() => {
+    const doctor = new SystemDoctor_1.SystemDoctor();
+    const results = doctor.run();
+    for (const result of results) {
+        console.log(`${result.ok ? '✅' : '❌'} ${result.name}: ${result.detail}`);
+    }
+});
+systemCmd.command('init-project')
+    .description('Cria o arquivo base de contexto do projeto OpenLife')
+    .action(() => {
+    const installer = new SystemInstaller_1.SystemInstaller();
+    const file = installer.initProject();
+    console.log(`✅ Projeto inicializado em: ${file}`);
+});
+systemCmd.command('doctor-world')
+    .description('Roda diagnóstico world-class do sistema')
+    .action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    for (const line of world.doctorWorld())
+        console.log(line);
+});
+systemCmd.command('bootstrap-world')
+    .description('Prepara artefatos de bootstrap world-class')
+    .action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(`✅ Bootstrap world-class: ${world.bootstrapWorld()}`);
+});
+const memoryCmd = program.command('memory').description('Operações de memória do OpenLife');
+memoryCmd.command('status').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify(world.memoryStatus(), null, 2));
+});
+memoryCmd.command('provider-list').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(world.memoryProviderList().join('\n'));
+});
+memoryCmd.command('provider-use <name>').action((name) => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(`✅ Provider ativo salvo em: ${world.memoryProviderUse(name)}`);
+});
+memoryCmd.command('test <name>').action((name) => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(world.memoryTest(name));
+});
+memoryCmd.command('search <query...>').description('Pesquisa memória por texto e retorna contexto').action(async (queryArgs) => {
+    const { OmniMemory } = await Promise.resolve().then(() => __importStar(require('./memory/OmniMemory')));
+    const memory = new OmniMemory();
+    const query = queryArgs.join(' ');
+    const result = await memory.search(query);
+    console.log(result);
+});
+const swarmCmd = program.command('swarm').description('Operações de swarm e consenso');
+swarmCmd.command('run')
+    .argument('[goal...]', 'objetivo do swarm', [])
+    .action((goalArgs) => {
+    const goal = Array.isArray(goalArgs) ? goalArgs.join(' ') : String(goalArgs || '');
+    const now = new Date().toISOString();
+    const artifact = {
+        type: 'openlife.swarm.run',
+        status: 'completed',
+        goal: goal || 'diagnóstico geral',
+        pipeline: ['planner', 'executor', 'reviewer', 'synthesizer'],
+        stages: [
+            { role: 'planner', status: 'completed', summary: 'Plano determinístico criado para execução local.' },
+            { role: 'executor', status: 'completed', summary: 'Executor local registrou artefato de swarm.' },
+            { role: 'reviewer', status: 'completed', summary: 'Review mínimo aprovado; sem ações destrutivas.' },
+            { role: 'synthesizer', status: 'completed', summary: 'Síntese final pronta.' }
+        ],
+        createdAt: now
+    };
+    const out = path.join(process.cwd(), '.openlife', 'swarm-last-run.json');
+    fs.mkdirSync(path.dirname(out), { recursive: true });
+    fs.writeFileSync(out, JSON.stringify(artifact, null, 2), 'utf-8');
+    console.log(JSON.stringify({ ok: true, artifactPath: out, ...artifact }, null, 2));
+});
+swarmCmd.command('consensus-test').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(world.swarmConsensusTest());
+});
+const governanceCmd = program.command('governance').description('Operações de governança e risco');
+governanceCmd.command('status').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify(world.governanceStatus(), null, 2));
+});
+governanceCmd.command('audit').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(world.governanceAudit());
+});
+governanceCmd.command('risk-check <goal>').action((goal) => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify(world.governanceRiskCheck(goal), null, 2));
+});
+governanceCmd.command('consent <scope> <userId>').action((scope, userId) => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(world.governanceConsentApprove(userId, scope));
+});
+// Story 14.2 (v1.5) — Governance scope ledger (SHA-chained, tamper-evident).
+const governanceLedgerCmd = governanceCmd.command('ledger').description('Inspeciona o ledger SHA-chained de decisões de governança (Story 14.2, v1.5)');
+governanceLedgerCmd.command('show')
+    .description('Imprime todas as entradas do ledger em JSON')
+    .option('--tail <n>', 'imprime apenas as últimas N entradas')
+    .action((options) => {
+    const { GovernanceScopeLedger } = require('./orchestrator/GovernanceScopeLedger');
+    const entries = new GovernanceScopeLedger().read();
+    const tail = options.tail ? Number(options.tail) : undefined;
+    const out = tail && tail > 0 ? entries.slice(-tail) : entries;
+    console.log(JSON.stringify({ ok: true, count: out.length, entries: out }, null, 2));
+});
+governanceLedgerCmd.command('verify')
+    .description('Verifica a integridade da cadeia SHA do ledger')
+    .action(() => {
+    const { GovernanceScopeLedger } = require('./orchestrator/GovernanceScopeLedger');
+    const result = new GovernanceScopeLedger().verify();
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok)
+        process.exitCode = 1;
+});
+const governancePolicyCmd = governanceCmd.command('policy').description('Inspeção da política de governança ativa');
+governancePolicyCmd.command('show').description('Exibe o conteúdo de governance-policy.json').action(() => {
+    const fs = require('fs');
+    const path = require('path');
+    const candidates = [
+        path.join(process.cwd(), 'governance-policy.json'),
+        path.join(process.cwd(), '.catalog', 'governance-policy.json'),
+        path.join(process.cwd(), '.openlife', 'governance-policy.json')
+    ];
+    const found = candidates.find((p) => fs.existsSync(p));
+    if (!found) {
+        console.log(JSON.stringify({ ok: false, error: 'policy_not_found', searched: candidates }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const raw = fs.readFileSync(found, 'utf-8');
+        const parsed = JSON.parse(raw);
+        console.log(JSON.stringify({ ok: true, source: found, policy: parsed }, null, 2));
+    }
+    catch (err) {
+        console.log(JSON.stringify({ ok: false, source: found, error: 'parse_error', message: errMsg(err) }, null, 2));
+        process.exitCode = 1;
+    }
+});
+const benchmarkCmd = program.command('benchmark').description('Operações de benchmark do OpenLife');
+benchmarkCmd.command('run').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(`✅ Benchmark run salvo em: ${world.benchmarkRun()}`);
+});
+benchmarkCmd.command('compare').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(world.benchmarkCompare());
+});
+benchmarkCmd.command('report').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(world.benchmarkReport());
+});
+const agentsCmd = program.command('agents').description('Operações de agentes');
+agentsCmd.command('list')
+    .description('lista agentes reais carregados do registry')
+    .action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify(world.agentsListReal(), null, 2));
+});
+agentsCmd.command('create <id>')
+    .option('--role <role>', 'papel do agente', 'specialist')
+    .option('--notes <notes>', 'notas adicionais', '')
+    .action((id, options) => {
+    const fs = require('fs');
+    const path = require('path');
+    const base = path.join(process.cwd(), '.catalog', 'agents', id);
+    fs.mkdirSync(base, { recursive: true });
+    const content = `# ${id}\n\nrole: ${options.role || 'specialist'}\nstatus: draft\ncreatedAt: ${new Date().toISOString()}\n\n## Notes\n${options.notes || 'n/a'}\n`;
+    fs.writeFileSync(path.join(base, 'AGENT.md'), content, 'utf-8');
+    console.log(JSON.stringify({ ok: true, path: path.join(base, 'AGENT.md') }, null, 2));
+});
+agentsCmd.command('show <id>')
+    .description('Exibe metadata de um agente do .catalog/agents/<id>')
+    .action((id) => {
+    const fs = require('fs');
+    const path = require('path');
+    const base = path.join(process.cwd(), '.catalog', 'agents', id);
+    const agentFile = path.join(base, 'AGENT.md');
+    if (!fs.existsSync(agentFile)) {
+        console.log(JSON.stringify({ ok: false, error: 'agent_not_found', id, expected: agentFile }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const raw = fs.readFileSync(agentFile, 'utf-8');
+    const meta = {};
+    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+        for (const line of fmMatch[1].split('\n')) {
+            const m = line.match(/^([a-zA-Z0-9_-]+):\s*(.+)$/);
+            if (m)
+                meta[m[1]] = m[2].trim();
+        }
+    }
+    for (const key of ['role', 'status', 'createdAt']) {
+        const m = raw.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'));
+        if (m && !meta[key])
+            meta[key] = m[1].trim();
+    }
+    const capabilities = [];
+    const capSection = raw.match(/##\s*Capabilities?\n([\s\S]*?)(?:\n##|$)/i);
+    if (capSection) {
+        for (const line of capSection[1].split('\n')) {
+            const m = line.match(/^[-*]\s+(.+)$/);
+            if (m)
+                capabilities.push(m[1].trim());
+        }
+    }
+    console.log(JSON.stringify({ ok: true, id, path: agentFile, metadata: meta, capabilities, sizeBytes: raw.length }, null, 2));
+});
+const squadsCmd = program.command('squads').description('Operações de squads');
+squadsCmd.command('list')
+    .description('lista squads reais carregadas do registry')
+    .action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify(world.squadsListReal(), null, 2));
+});
+squadsCmd.command('create <id>')
+    .option('--domain <domain>', 'domínio da squad', 'general')
+    .option('--notes <notes>', 'notas adicionais', '')
+    .action((id, options) => {
+    const fs = require('fs');
+    const path = require('path');
+    const base = path.join(process.cwd(), '.catalog', 'squads', id);
+    fs.mkdirSync(base, { recursive: true });
+    const content = `# ${id}\n\ndomain: ${options.domain || 'general'}\nstatus: draft\ncreatedAt: ${new Date().toISOString()}\n\n## Notes\n${options.notes || 'n/a'}\n`;
+    fs.writeFileSync(path.join(base, 'SQUAD.md'), content, 'utf-8');
+    console.log(JSON.stringify({ ok: true, path: path.join(base, 'SQUAD.md') }, null, 2));
+});
+const skillsCmd = program.command('skills').description('Operações de skills');
+skillsCmd.command('list')
+    .description('lista skills reais carregadas do registry')
+    .action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify(world.skillsListReal(), null, 2));
+});
+skillsCmd.command('create <id>')
+    .option('--notes <notes>', 'notas adicionais', '')
+    .action((id, options) => {
+    const fs = require('fs');
+    const path = require('path');
+    const base = path.join(process.cwd(), '.catalog', 'skills', id);
+    fs.mkdirSync(base, { recursive: true });
+    const content = `---\nname: ${id}\ndescription: draft skill\n---\n\n# ${id}\n\n## Notes\n${options.notes || 'n/a'}\n`;
+    fs.writeFileSync(path.join(base, 'SKILL.md'), content, 'utf-8');
+    console.log(JSON.stringify({ ok: true, path: path.join(base, 'SKILL.md') }, null, 2));
+});
+function readCatalogText(kind, canonicalFile) {
+    const root = path.join(process.cwd(), '.catalog', kind);
+    if (!fs.existsSync(root))
+        return [];
+    return fs.readdirSync(root)
+        .filter((id) => fs.existsSync(path.join(root, id, canonicalFile)))
+        .map((id) => {
+        const sourcePath = path.join(root, id, canonicalFile);
+        const raw = fs.readFileSync(sourcePath, 'utf-8');
+        return { id, score: 0, sourcePath, matched: [], raw };
+    });
+}
+function tokenizeForRoute(text) {
+    const normalized = text.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, ' ');
+    const synonyms = {
+        landing: ['landing', 'page', 'pagina', 'frontend', 'design', 'copy'],
+        deploy: ['deploy', 'github', 'railway', 'vercel', 'cloudflare', 'hostinger'],
+        media: ['imagem', 'image', 'video', 'voz', 'voice', 'audio', 'tts', 'stt', 'gemini', 'openai'],
+        security: ['security', 'seguranca', 'cyber', 'audit', 'vulnerability', 'token', 'secret'],
+        data: ['data', 'dados', 'analytics', 'quality', 'sql', 'supabase'],
+        marketing: ['ads', 'copy', 'brand', 'sales', 'traffic', 'growth', 'marketing', 'hormozi'],
+        telegram: ['telegram', 'bot', 'gateway', 'webhook', 'polling'],
+        code: ['code', 'codigo', 'github', 'review', 'cli', 'typescript', 'node', 'codex']
+    };
+    const base = normalized.split(/[^a-z0-9]+/).filter((t) => t.length >= 3);
+    const out = new Set(base);
+    for (const token of base)
+        for (const extra of synonyms[token] || [])
+            out.add(extra);
+    return Array.from(out);
+}
+function rankCatalog(kind, canonicalFile, query, limit = 8) {
+    const terms = tokenizeForRoute(query);
+    return readCatalogText(kind, canonicalFile)
+        .map((item) => {
+        const raw = typeof item.raw === 'string' ? item.raw : '';
+        const hay = `${item.id}\\n${raw}`.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, ' ');
+        const matched = terms.filter((t) => hay.includes(t));
+        const idBoost = terms.filter((t) => item.id.toLowerCase().includes(t)).length * 3;
+        const score = matched.length + idBoost;
+        return { id: item.id, score, sourcePath: item.sourcePath, matched: matched.slice(0, 12) };
+    })
+        .filter((x) => x.score > 0)
+        .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
+        .slice(0, limit);
+}
+function slugifyCatalogId(input) {
+    return input.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 72) || `auto-${Date.now()}`;
+}
+function writeAutoCatalog(kind, id, fileName, body) {
+    const dir = path.join(process.cwd(), '.catalog', kind, id);
+    fs.mkdirSync(dir, { recursive: true });
+    const out = path.join(dir, fileName);
+    if (!fs.existsSync(out))
+        fs.writeFileSync(out, body, 'utf-8');
+    return out;
+}
+function autoCreateForRoute(goal, intent, route, options) {
+    const prefix = slugifyCatalogId(options.createPrefix || intent || goal);
+    const created = [];
+    const topScore = (items) => items?.[0]?.score || 0;
+    const now = new Date().toISOString();
+    if (topScore(route.agents) < options.minScore) {
+        const id = slugifyCatalogId(`${prefix}-agent`);
+        const out = writeAutoCatalog('agents', id, 'AGENT.md', `---\nid: ${id}\nname: ${id}\nrole: specialist\nsource: aiobuilder-auto-route\nstatus: draft\ncreatedAt: ${now}\nintent: ${intent}\n---\n\n# ${id}\n\nAuto-criado pelo OpenLife porque o roteador não encontrou agente com cobertura suficiente.\n\n## Goal\n${goal}\n\n## Guardrails\n- Revisar antes de promoção para active.\n- Não usar segredos no arquivo.\n`);
+        created.push({ type: 'agent', id, path: out, reason: 'insufficient-agent-coverage' });
+    }
+    if (topScore(route.squads) < options.minScore) {
+        const id = slugifyCatalogId(`${prefix}-squad`);
+        const out = writeAutoCatalog('squads', id, 'SQUAD.md', `---\nid: ${id}\nname: ${id}\ndomain: ${intent}\nsource: aiobuilder-auto-route\nstatus: draft\ncreatedAt: ${now}\n---\n\n# ${id}\n\nAuto-criada pelo OpenLife porque o roteador não encontrou squad com cobertura suficiente.\n\n## Mission\n${goal}\n\n## Minimum artifacts\n- agente principal: ${prefix}-agent\n- índice de uso: este SQUAD.md\n- workflow inicial: revisar fluxo após primeira execução\n- espelho Obsidian: opcional/reference only, não runtime\n`);
+        created.push({ type: 'squad', id, path: out, reason: 'insufficient-squad-coverage' });
+    }
+    if (topScore(route.skills) < options.minScore) {
+        const id = slugifyCatalogId(`${prefix}-skill`);
+        const out = writeAutoCatalog('skills', id, 'SKILL.md', `---\nid: ${id}\nname: ${id}\nsource: aiobuilder-auto-route\nstatus: draft\ncreatedAt: ${now}\ndescription: Skill draft auto-criada para ${intent}\n---\n\n# ${id}\n\n<description>\nSkill draft auto-criada para cobrir lacuna operacional detectada no roteamento: ${goal}\n</description>\n\n## When to use\nUse quando a missão envolver: ${goal}\n\n## Procedure\n1. Validar contexto e riscos.\n2. Executar passos mínimos com ferramentas disponíveis.\n3. Registrar evidência e atualizar esta skill após uso real.\n\n## Guardrails\n- Não guardar segredos.\n- Promover de draft para active só após validação real.\n`);
+        created.push({ type: 'skill', id, path: out, reason: 'insufficient-skill-coverage' });
+    }
+    return created;
+}
+function classifyRouteIntent(goal) {
+    const t = goal.toLowerCase();
+    if (/telegram|bot|gateway|webhook/.test(t))
+        return 'telegram-runtime';
+    if (/landing|pagina|page|design|copy|ads|brand|sales|marketing/.test(t))
+        return 'product-growth';
+    if (/security|seguran|cyber|audit|token|secret/.test(t))
+        return 'security';
+    if (/data|dados|analytics|sql|supabase/.test(t))
+        return 'data';
+    if (/deploy|railway|github|vercel|cloudflare|code|codigo|review/.test(t))
+        return 'engineering';
+    return 'general';
+}
+const routeCmd = program.command('route').description('Roteamento inteligente por intenção para squads, agentes e skills');
+routeCmd.command('intent <goal...>')
+    .description('recomenda squads/agentes/skills para uma missão')
+    .option('--limit <n>', 'limite por categoria', '8')
+    .option('--auto-create', 'cria drafts de agent/squad/skill quando houver lacuna de cobertura', false)
+    .option('--min-score <n>', 'score mínimo por categoria antes de auto-criar', '1')
+    .option('--create-prefix <prefix>', 'prefixo/id base para artefatos auto-criados')
+    .action((goalParts, options) => {
+    const goal = goalParts.join(' ');
+    const limit = Math.max(1, Number(options.limit || '8'));
+    const intent = classifyRouteIntent(goal);
+    const payload = {
+        type: 'openlife.route.intent',
+        ok: true,
+        goal,
+        intent,
+        squads: rankCatalog('squads', 'SQUAD.md', goal, limit),
+        agents: rankCatalog('agents', 'AGENT.md', goal, limit),
+        skills: rankCatalog('skills', 'SKILL.md', goal, limit),
+        generatedAt: new Date().toISOString()
+    };
+    if (options.autoCreate) {
+        const minScore = Math.max(0, Number(options.minScore || '1'));
+        payload.autoCreate = {
+            enabled: true,
+            minScore,
+            created: autoCreateForRoute(goal, intent, payload, { minScore, createPrefix: options.createPrefix })
+        };
+    }
+    else {
+        payload.autoCreate = { enabled: false, created: [] };
+    }
+    console.log(JSON.stringify(payload, null, 2));
+});
+const mcpCmd = program.command('mcp').description('Operações de MCP');
+mcpCmd.command('create <id>')
+    .option('--transport <transport>', 'stdio|http', 'stdio')
+    .option('--entry <entry>', 'command/url de entrada', '')
+    .action((id, options) => {
+    const fs = require('fs');
+    const path = require('path');
+    const base = path.join(process.cwd(), '.catalog', 'mcps', id);
+    fs.mkdirSync(base, { recursive: true });
+    const content = {
+        id,
+        transport: options.transport || 'stdio',
+        entry: options.entry || '',
+        status: 'draft',
+        createdAt: new Date().toISOString()
+    };
+    fs.writeFileSync(path.join(base, 'mcp.json'), JSON.stringify(content, null, 2), 'utf-8');
+    console.log(JSON.stringify({ ok: true, path: path.join(base, 'mcp.json') }, null, 2));
+});
+const catalogCmd = program.command('catalog').description('Diagnóstico do catálogo runtime do OpenLife');
+function countCatalogFiles(kind, canonicalFile) {
+    const root = path.join(process.cwd(), '.catalog', kind);
+    if (!fs.existsSync(root))
+        return { root, total: 0, demo: 0, test: 0, canonical: 0, items: [] };
+    const items = fs.readdirSync(root).filter((name) => fs.statSync(path.join(root, name)).isDirectory()).sort();
+    return {
+        root,
+        total: items.length,
+        demo: items.filter((id) => /(^demo-|demo$)/i.test(id)).length,
+        test: items.filter((id) => /(^test-|test$)/i.test(id)).length,
+        canonical: items.filter((id) => fs.existsSync(path.join(root, id, canonicalFile))).length,
+        items: items.slice(0, 25)
+    };
+}
+catalogCmd.command('doctor')
+    .option('--strict', 'modo produção: falha se houver demo/test no catálogo runtime', false)
+    .action((options) => {
+    const agents = countCatalogFiles('agents', 'AGENT.md');
+    const squads = countCatalogFiles('squads', 'SQUAD.md');
+    const skills = countCatalogFiles('skills', 'SKILL.md');
+    const mcps = countCatalogFiles('mcps', 'mcp.json');
+    const demoTestTotal = agents.demo + agents.test + squads.demo + squads.test + skills.demo + skills.test + mcps.demo + mcps.test;
+    const checks = [
+        { name: 'agents:min-300', ok: agents.total >= 300, detail: `${agents.total} agentes` },
+        { name: 'agents:canonical-files', ok: agents.canonical === agents.total, detail: `${agents.canonical}/${agents.total} AGENT.md` },
+        { name: 'squads:min-real', ok: squads.total >= 2, detail: `${squads.total} squads` },
+        { name: 'skills:available', ok: skills.total >= 1, detail: `${skills.total} skills catalogadas` },
+        { name: 'mcps:available', ok: mcps.total >= 1, detail: `${mcps.total} MCPs catalogados` },
+        { name: 'catalog:no-demo-test-strict', ok: !options.strict || demoTestTotal === 0, detail: `${demoTestTotal} itens demo/test detectados` },
+    ];
+    const ok = checks.every((c) => c.ok);
+    const warnings = demoTestTotal > 0 ? [{ name: 'catalog:demo-test-present', detail: `${demoTestTotal} itens demo/test ainda existem; use --strict para bloquear produção.` }] : [];
+    console.log(JSON.stringify({ type: 'openlife.catalog.doctor', ok, strict: Boolean(options.strict), checks, warnings, summary: { agents, squads, skills, mcps } }, null, 2));
+    if (!ok)
+        process.exitCode = 1;
+});
+catalogCmd.command('list').action(() => {
+    console.log(JSON.stringify({ type: 'openlife.catalog.list', agents: countCatalogFiles('agents', 'AGENT.md'), squads: countCatalogFiles('squads', 'SQUAD.md'), skills: countCatalogFiles('skills', 'SKILL.md'), mcps: countCatalogFiles('mcps', 'mcp.json') }, null, 2));
+});
+const teamsCmd = program.command('teams').description('Administração de times de agentes por domínio');
+teamsCmd.command('list')
+    .action(() => {
+    const fs = require('fs');
+    const path = require('path');
+    const file = path.join(process.cwd(), '.catalog', 'teams.json');
+    const data = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : [];
+    console.log(JSON.stringify(data, null, 2));
+});
+teamsCmd.command('upsert <id>')
+    .option('--domain <domain>', 'domínio: sales|social|support|general', 'general')
+    .option('--description <description>', 'descrição do time', '')
+    .option('--sla <sla>', 'perfil de SLA: fast|balanced|strict', 'balanced')
+    .action((id, options) => {
+    const fs = require('fs');
+    const path = require('path');
+    const dir = path.join(process.cwd(), '.catalog');
+    const file = path.join(dir, 'teams.json');
+    fs.mkdirSync(dir, { recursive: true });
+    const arr = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : [];
+    const next = { id, domain: options.domain || 'general', description: options.description || '', slaProfile: options.sla || 'balanced', members: [] };
+    const idx = arr.findIndex((x) => x.id === id);
+    if (idx >= 0)
+        arr[idx] = { ...arr[idx], ...next };
+    else
+        arr.push(next);
+    fs.writeFileSync(file, JSON.stringify(arr, null, 2), 'utf-8');
+    console.log(JSON.stringify({ ok: true, file, id }, null, 2));
+});
+const networksCmd = program.command('networks').description('Administração de redes de skills por domínio');
+networksCmd.command('list')
+    .action(() => {
+    const fs = require('fs');
+    const path = require('path');
+    const file = path.join(process.cwd(), '.catalog', 'skill-networks.json');
+    const data = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : [];
+    console.log(JSON.stringify(data, null, 2));
+});
+networksCmd.command('upsert <id>')
+    .option('--domain <domain>', 'domínio: sales|social|support|general', 'general')
+    .option('--capabilities <capabilities>', 'csv de capabilities', '')
+    .action((id, options) => {
+    const fs = require('fs');
+    const path = require('path');
+    const dir = path.join(process.cwd(), '.catalog');
+    const file = path.join(dir, 'skill-networks.json');
+    fs.mkdirSync(dir, { recursive: true });
+    const arr = fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : [];
+    const capabilities = String(options.capabilities || '').split(',').map((s) => s.trim()).filter(Boolean);
+    const next = { id, domain: options.domain || 'general', nodes: [{ id: `${id}-node-1`, capabilities }] };
+    const idx = arr.findIndex((x) => x.id === id);
+    if (idx >= 0)
+        arr[idx] = { ...arr[idx], ...next };
+    else
+        arr.push(next);
+    fs.writeFileSync(file, JSON.stringify(arr, null, 2), 'utf-8');
+    console.log(JSON.stringify({ ok: true, file, id }, null, 2));
+});
+const mediaCmd = program.command('media').description('Roteamento e telemetria de mídia (vision/stt/tts)');
+mediaCmd.command('route').description('Configura preferência de Gemini para mídia').option('--prefer-gemini <value>', 'true|false', 'true').action((options) => {
+    const value = String(options.preferGemini || 'true').toLowerCase() === 'true' ? 'true' : 'false';
+    const envPath = path.join(process.cwd(), '.env');
+    const current = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf-8') : '';
+    const without = current
+        .split('\n')
+        .filter(line => !line.startsWith('OPENLIFE_PREFER_GEMINI_FOR_MEDIA='))
+        .join('\n')
+        .replace(/\n+$/, '');
+    const next = `${without}\nOPENLIFE_PREFER_GEMINI_FOR_MEDIA=${value}\n`;
+    fs.writeFileSync(envPath, next, 'utf-8');
+    console.log(`✅ OPENLIFE_PREFER_GEMINI_FOR_MEDIA=${value} salvo em ${envPath}`);
+});
+mediaCmd.command('route-status').description('Mostra status da preferência e resumo dos logs de roteamento').option('--tail <n>', 'quantidade de eventos recentes', '20').action((options) => {
+    const envPath = path.join(process.cwd(), '.env');
+    const envRaw = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf-8') : '';
+    const preferLine = envRaw.split('\n').find(line => line.startsWith('OPENLIFE_PREFER_GEMINI_FOR_MEDIA='));
+    const prefer = preferLine ? preferLine.split('=')[1] : 'true';
+    const logPath = path.join(process.cwd(), '.openlife', 'media-routing.log.jsonl');
+    const tail = Math.max(1, Number(options.tail || '20'));
+    const events = fs.existsSync(logPath)
+        ? fs.readFileSync(logPath, 'utf-8').split('\n').filter(Boolean).map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean)
+        : [];
+    const counters = {};
+    for (const ev of events) {
+        const key = `${ev.kind}:${ev.provider}`;
+        if (!counters[key])
+            counters[key] = { success: 0, failed: 0 };
+        if (ev.status === 'success')
+            counters[key].success += 1;
+        else
+            counters[key].failed += 1;
+    }
+    console.log('🎛️ Media routing status');
+    console.log(`- prefer_gemini_for_media: ${prefer}`);
+    console.log(`- log_file: ${logPath}`);
+    console.log(`- total_events: ${events.length}`);
+    console.log('- counters:');
+    Object.entries(counters).forEach(([k, v]) => console.log(`  • ${k} -> success=${v.success}, failed=${v.failed}`));
+    console.log(`- last_${tail}_events:`);
+    events.slice(-tail).forEach((ev) => {
+        console.log(`  • ${ev.ts} | ${ev.kind} | ${ev.provider} | ${ev.status}${ev.detail ? ` | ${ev.detail}` : ''}`);
+    });
+});
+mediaCmd.command('doctor').description('Valida routing Gemini-first e fallback de mídia sem executar chamadas externas').option('--require-fallback', 'exige evidência de fallback bem-sucedido nos logs', false).action((options) => {
+    const envPath = path.join(process.cwd(), '.env');
+    const envRaw = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf-8') : '';
+    const preferLine = envRaw.split('\n').find(line => line.startsWith('OPENLIFE_PREFER_GEMINI_FOR_MEDIA='));
+    const prefer = preferLine ? preferLine.split('=')[1] : 'true';
+    const logPath = path.join(process.cwd(), '.openlife', 'media-routing.log.jsonl');
+    const events = fs.existsSync(logPath)
+        ? fs.readFileSync(logPath, 'utf-8').split('\n').filter(Boolean).map((line) => { try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        } }).filter(Boolean)
+        : [];
+    const geminiFailures = events.filter((ev) => ev.kind === 'tts' && ev.provider === 'gemini' && ev.status === 'failed').length;
+    const openaiSuccess = events.filter((ev) => ev.kind === 'tts' && ev.provider === 'openai' && ev.status === 'success').length;
+    const fallbackObserved = geminiFailures > 0 && openaiSuccess > 0;
+    const checks = [
+        { name: 'media:prefer-gemini-default', ok: prefer === 'true', detail: `OPENLIFE_PREFER_GEMINI_FOR_MEDIA=${prefer}` },
+        { name: 'media:log-readable', ok: fs.existsSync(logPath) || !options.requireFallback, detail: logPath },
+        { name: 'media:fallback-observed', ok: !options.requireFallback || fallbackObserved, detail: `gemini_failed=${geminiFailures}, openai_success=${openaiSuccess}` },
+    ];
+    const ok = checks.every((c) => c.ok);
+    console.log(JSON.stringify({ type: 'openlife.media.doctor', ok, checks, counters: { geminiTtsFailed: geminiFailures, openaiTtsSuccess: openaiSuccess }, logPath }, null, 2));
+    if (!ok)
+        process.exitCode = 1;
+});
+mediaCmd.command('read-image <imagePath>').description('Lê imagem via Gemini CLI com fallback de modelos e log detalhado').option('--prompt <text>', 'prompt de extração', 'Extraia texto e descreva a estrutura desta imagem.').action(async (imagePath, options) => {
+    const absPath = path.isAbsolute(imagePath) ? imagePath : path.join(process.cwd(), imagePath);
+    if (!fs.existsSync(absPath)) {
+        console.error(`❌ Arquivo não encontrado: ${absPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    const { promisify } = await Promise.resolve().then(() => __importStar(require('util')));
+    const { execFile } = await Promise.resolve().then(() => __importStar(require('child_process')));
+    const runExecFile = promisify(execFile);
+    const prompt = String(options.prompt || 'Extraia texto e descreva a estrutura desta imagem.');
+    const models = ['gemini-3.1-flash-lite-preview', 'gemini-2.5-flash', 'gemini-3.1-pro-preview'];
+    const logPath = path.join(process.cwd(), '.openlife', 'media-routing.log.jsonl');
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    let lastErr = null;
+    for (const model of models) {
+        try {
+            const args = ['-o', 'json', '-m', model, '-p', `${prompt} @${absPath}`, '-y'];
+            const { stdout } = await runExecFile('gemini', args, { maxBuffer: 1024 * 1024 * 10, timeout: 180000 });
+            const idx = stdout.indexOf('{');
+            if (idx === -1)
+                throw new Error('Resposta JSON inválida do Gemini CLI.');
+            const parsed = JSON.parse(stdout.slice(idx));
+            const text = String(parsed.response || parsed.text || '').trim();
+            fs.appendFileSync(logPath, JSON.stringify({ ts: new Date().toISOString(), kind: 'vision', provider: `gemini:${model}`, status: 'success', detail: 'media read-image' }) + '\n');
+            console.log(`✅ provider=gemini:${model}`);
+            console.log(text || '[sem texto retornado]');
+            return;
+        }
+        catch (error) {
+            lastErr = error;
+            const msg = errMsg(error);
+            fs.appendFileSync(logPath, JSON.stringify({ ts: new Date().toISOString(), kind: 'vision', provider: `gemini:${model}`, status: 'failed', detail: msg }) + '\n');
+            const retryable = /429|resource_exhausted|capacity|rate limit|quota/i.test(msg);
+            if (!retryable)
+                break;
+        }
+    }
+    console.error(`❌ Falha leitura de imagem via Gemini fallback-chain: ${errMsg(lastErr)}`);
+    process.exitCode = 1;
+});
+const orchestrationCmd = program.command('orchestration').description('Contrato e snapshot de orquestração');
+orchestrationCmd.command('contract').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify(world.orchestrationContract(), null, 2));
+});
+orchestrationCmd.command('snapshot').action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    const file = world.writeOrchestrationSnapshot({ contract: world.orchestrationContract() });
+    console.log(`✅ Snapshot salvo em: ${file}`);
+});
+mcpCmd.command('status')
+    .option('--real', 'flag legacy/deprecated — comportamento default agora é status real (mantido pra backwards compat)')
+    .action((_options) => {
+    // Pre-Story 2.2 (P2): required --real flag, errored out without it. Fixed: default
+    // behavior now returns real runtime status. --real flag accepted but no-op for compat.
+    // See docs/stories/epic-feature-completeness/2.2.story.md
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify(world.mcpStatusReal(), null, 2));
+});
+program
+    .command('status')
+    .description('Status universal do OpenLife (determinístico)')
+    .action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify({
+        agents: world.agentsListReal().total,
+        squads: world.squadsListReal().total,
+        skills: world.skillsListReal().total,
+        mcp: world.mcpStatusReal().checks
+    }, null, 2));
+});
+program
+    .command('doctor')
+    .description('Doctor universal com severidade')
+    .action(() => {
+    const world = new WorldClassCommands_1.WorldClassCommands();
+    console.log(JSON.stringify(world.doctorWorldDetailed(), null, 2));
+});
+program
+    .command('restart')
+    .description('Reinício controlado do daemon OpenLife')
+    .action(async () => {
+    try {
+        const { exec } = await Promise.resolve().then(() => __importStar(require('child_process')));
+        exec('pkill -f "openlife.js start --daemon|dist/index.js start --daemon" || true', () => {
+            console.log('🔁 Processos anteriores encerrados. Inicie novamente com: node bin/openlife.js start --daemon');
+        });
+    }
+    catch (e) {
+        console.error(`❌ restart falhou: ${errMsg(e)}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command('update')
+    .description('Atualiza dependências, recompila o core e valida status do sistema (modo dev)')
+    .action(async () => {
+    console.log('🔄 OPEN-LIFE update: npm install + build + system status');
+    try {
+        const { stdout, stderr } = await exec('npm install && npm run build && node bin/openlife.js system status', { cwd: process.cwd(), maxBuffer: 1024 * 1024 * 10 });
+        if (stdout?.trim())
+            console.log(stdout.trim());
+        if (stderr?.trim())
+            console.error(stderr.trim());
+        console.log('✅ openlife update concluído com sucesso.');
+    }
+    catch (e) {
+        const so = errStdout(e);
+        if (so)
+            console.log(so);
+        const se = errStderr(e);
+        if (se)
+            console.error(se);
+        console.error(`❌ openlife update falhou: ${errMsg(e)}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command('up')
+    .description('Inicialização one-shot: doctor rápido + start do agente em daemon')
+    .action(async () => {
+    try {
+        const world = new WorldClassCommands_1.WorldClassCommands();
+        const checks = world.doctorWorldDetailed();
+        const blockers = checks.filter(c => !c.ok && c.severity === 'blocker');
+        if (blockers.length > 0) {
+            console.error('❌ openlife up abortado: doctor encontrou blockers.');
+            for (const b of blockers) {
+                console.error(`- ${b.name}: ${b.detail}`);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        const token = (process.env.TELEGRAM_BOT_TOKEN || '').trim();
+        if (!/^\d{6,}:[A-Za-z0-9_-]{20,}$/.test(token)) {
+            console.error('❌ TELEGRAM_BOT_TOKEN inválido. Esperado formato <digits>:<secret>.');
+            process.exitCode = 1;
+            return;
+        }
+        const res = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+        const data = (await res.json());
+        if (!data?.ok) {
+            console.error(`❌ TELEGRAM_BOT_TOKEN rejeitado pelo Telegram: ${data?.description || 'erro desconhecido'}`);
+            process.exitCode = 1;
+            return;
+        }
+        await exec('pkill -f "openlife.js start --daemon|dist/index.js start --daemon" || true', { cwd: process.cwd() });
+        console.log(`✅ Telegram autenticado: @${data?.result?.username || 'unknown'}`);
+        console.log('🚀 openlife up: iniciando daemon...');
+        const { Gateway } = require('./orchestrator/Gateway');
+        const gateway = new Gateway();
+        gateway.start();
+    }
+    catch (e) {
+        console.error(`❌ openlife up falhou: ${errMsg(e)}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command('agent <verb>')
+    .description('Alias compatível com documentação: agent install|start|status → autonomous lifecycle')
+    .action(async (verb) => {
+    const childProc = require('child_process');
+    const pathMod = require('path');
+    const cliEntry = pathMod.join(__dirname, 'index.js');
+    let argv;
+    switch (verb) {
+        case 'install':
+            argv = [cliEntry, 'install', '--mode=autonomous'];
+            break;
+        case 'start':
+            argv = [cliEntry, 'start', '--daemon'];
+            break;
+        case 'status':
+            argv = [cliEntry, 'status'];
+            break;
+        default:
+            console.error(`❌ verb desconhecido: "${verb}". Use: install | start | status`);
+            console.error(`   (Aliases para os verbs reais: install --mode=autonomous, start --daemon, status)`);
+            process.exit(1);
+    }
+    const r = childProc.spawnSync(process.execPath, argv, { stdio: 'inherit' });
+    process.exit(r.status ?? 0);
+});
+program
+    .command('start')
+    .option('-d, --daemon', 'Roda em background ouvindo Telegram e Cron Jobs')
+    .description('Inicia o metabolismo do Organismo Vivo')
+    .action(async (options) => {
+    if (options.daemon) {
+        const token = (process.env.TELEGRAM_BOT_TOKEN || '').trim();
+        if (!/^\d{6,}:[A-Za-z0-9_-]{20,}$/.test(token)) {
+            console.error("❌ TELEGRAM_BOT_TOKEN inválido. Esperado formato <digits>:<secret>.");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const res = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+            const data = (await res.json());
+            if (!data?.ok) {
+                console.error(`❌ TELEGRAM_BOT_TOKEN rejeitado pelo Telegram: ${data?.description || 'erro desconhecido'}`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(`✅ Telegram autenticado: @${data?.result?.username || 'unknown'}`);
+        }
+        catch (e) {
+            console.error(`❌ Falha ao validar TELEGRAM_BOT_TOKEN no Telegram: ${errMsg(e)}`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log("Iniciando OPEN-LIFE em Background...");
+        const { Gateway } = require('./orchestrator/Gateway');
+        const gateway = new Gateway();
+        gateway.start();
+        let shuttingDown = false;
+        const shutdown = async (signal) => {
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            console.log(`\n[DAEMON] Recebido ${signal}, iniciando shutdown gracioso...`);
+            const force = setTimeout(() => {
+                console.error('[DAEMON] Shutdown timeout (5s), forçando exit');
+                process.exit(1);
+            }, 5000);
+            force.unref();
+            try {
+                await gateway.shutdown(signal);
+                process.exit(0);
+            }
+            catch (e) {
+                console.error('[DAEMON] Erro durante shutdown:', e);
+                process.exit(1);
+            }
+        };
+        process.on('SIGTERM', () => void shutdown('SIGTERM'));
+        process.on('SIGINT', () => void shutdown('SIGINT'));
+    }
+    else {
+        console.log("Use a flag --daemon para rodar de forma persistente.");
+    }
+});
+const smokeCmd = program.command('smoke').description('Smokes formais de produção/local');
+smokeCmd.command('railway').action(() => {
+    const url = process.env.OPENLIFE_RAILWAY_URL || 'https://openlife-01-production.up.railway.app/';
+    const r = child_process.spawnSync('curl', ['-sS', '-o', '/tmp/openlife_smoke_body.txt', '-w', 'HTTP:%{http_code}', url], { encoding: 'utf-8' });
+    const body = fs.existsSync('/tmp/openlife_smoke_body.txt') ? fs.readFileSync('/tmp/openlife_smoke_body.txt', 'utf-8').slice(0, 500) : '';
+    const ok = r.status === 0 && /HTTP:200/.test(r.stdout || '');
+    console.log(JSON.stringify({ type: 'openlife.smoke.railway', ok, url, status: r.stdout, body }, null, 2));
+    if (!ok)
+        process.exitCode = 1;
+});
+smokeCmd.command('telegram').action(() => {
+    const token = process.env.TELEGRAM_BOT_TOKEN || '';
+    if (!/^\d{6,}:[A-Za-z0-9_-]{20,}$/.test(token)) {
+        console.log(JSON.stringify({ ok: false, error: 'telegram_token_missing_or_invalid' }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const r = child_process.spawnSync('curl', ['-sS', `https://api.telegram.org/bot${token}/getMe`], { encoding: 'utf-8' });
+    let parsed = {};
+    try {
+        parsed = JSON.parse(r.stdout || '{}');
+    }
+    catch { }
+    if (parsed.result?.token)
+        parsed.result.token = '[REDACTED]';
+    console.log(JSON.stringify({ type: 'openlife.smoke.telegram', ok: Boolean(parsed.ok), bot: parsed.result ? { id: parsed.result.id, username: parsed.result.username, first_name: parsed.result.first_name } : null }, null, 2));
+    if (!parsed.ok)
+        process.exitCode = 1;
+});
+program
+    .command('dream <entry...>')
+    .alias('/dream')
+    .description('Organiza automaticamente diário/notas pessoais')
+    .action((entryArgs) => {
+    const organizer = new DreamOrganizer_1.DreamOrganizer();
+    const raw = entryArgs.join(' ');
+    const note = organizer.organize(raw);
+    const file = organizer.save(note);
+    console.log(`✅ /dream organizado em: ${file}`);
+    console.log(JSON.stringify(note, null, 2));
+});
+const serviceCmd = program.command('service').description('Operações de serviço (mode service)');
+serviceCmd.command('list')
+    .option('--limit <limit>', 'limite', '100')
+    .action((options) => {
+    const store = new ServiceState_1.ServiceStateStore();
+    const limit = Number(options.limit || 100);
+    console.log(JSON.stringify(store.list(Number.isFinite(limit) ? limit : 100), null, 2));
+});
+serviceCmd.command('create <serviceId>')
+    .option('--objective <objective>', 'objetivo contínuo', 'Serviço operacional OpenLife')
+    .option('--risk <risk>', 'low|medium|high', 'medium')
+    .action((serviceId, options) => {
+    const store = new ServiceState_1.ServiceStateStore();
+    const now = new Date().toISOString();
+    const state = { workspaceId: 'default', serviceId, objective: options.objective, status: 'active', riskProfile: (['low', 'medium', 'high'].includes(options.risk) ? options.risk : 'medium'), slo: {}, kpis: {}, budget: { hardStop: false }, missionIds: [], createdAt: now, updatedAt: now };
+    const dir = path.join(process.cwd(), '.artifacts', 'workspaces', 'default', 'services');
+    fs.mkdirSync(dir, { recursive: true });
+    const out = path.join(dir, `${serviceId}.json`);
+    fs.writeFileSync(out, JSON.stringify(state, null, 2), 'utf-8');
+    console.log(JSON.stringify({ ok: true, path: out, service: state }, null, 2));
+});
+serviceCmd.command('status <serviceId>')
+    .description('Mostra status do serviço')
+    .action((serviceId) => {
+    const store = new ServiceState_1.ServiceStateStore();
+    const service = store.getById(serviceId);
+    if (!service) {
+        console.log(`❌ Serviço não encontrado: ${serviceId}`);
+        return;
+    }
+    console.log(JSON.stringify(service, null, 2));
+});
+serviceCmd.command('pause <serviceId>')
+    .description('Pausa serviço')
+    .option('--reason <reason>', 'motivo', 'Pausado manualmente pelo operador')
+    .action((serviceId, options) => {
+    const store = new ServiceState_1.ServiceStateStore();
+    const updated = store.setStatus(serviceId, 'paused', options.reason);
+    if (!updated) {
+        console.log(`❌ Serviço não encontrado: ${serviceId}`);
+        return;
+    }
+    console.log(`⏸️ Serviço pausado: ${serviceId}`);
+});
+serviceCmd.command('resume <serviceId>')
+    .description('Retoma serviço')
+    .option('--reason <reason>', 'motivo', 'Retomado manualmente pelo operador')
+    .action((serviceId, options) => {
+    const store = new ServiceState_1.ServiceStateStore();
+    const updated = store.setStatus(serviceId, 'active', options.reason);
+    if (!updated) {
+        console.log(`❌ Serviço não encontrado: ${serviceId}`);
+        return;
+    }
+    console.log(`▶️ Serviço retomado: ${serviceId}`);
+});
+serviceCmd.command('events <serviceId>')
+    .description('Lista eventos recentes do serviço')
+    .option('--limit <limit>', 'quantidade de eventos', '50')
+    .action((serviceId, options) => {
+    const store = new ServiceState_1.ServiceStateStore();
+    const limit = Number(options.limit || 50);
+    const events = store.listEvents(serviceId, Number.isFinite(limit) ? limit : 50);
+    if (!events.length) {
+        console.log(`ℹ️ Sem eventos para serviço: ${serviceId}`);
+        return;
+    }
+    console.log(JSON.stringify(events, null, 2));
+});
+const taskCmd = program.command('task').description('Operações de tarefa (mode task)');
+taskCmd.command('list')
+    .option('--limit <limit>', 'limite', '100')
+    .action((options) => {
+    const dir = path.join(process.cwd(), '.artifacts', 'missions');
+    const limit = Number(options.limit || 100);
+    const files = fs.existsSync(dir) ? fs.readdirSync(dir).filter((f) => f.endsWith('.json') && !f.endsWith('.thought-trace.json')).slice(-(Number.isFinite(limit) ? limit : 100)) : [];
+    const items = files.map((f) => JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8')));
+    console.log(JSON.stringify(items, null, 2));
+});
+taskCmd.command('run <goal...>')
+    .option('--service <serviceId>', 'serviço contínuo associado', '')
+    .action((goalArgs, options) => {
+    const goal = goalArgs.join(' ');
+    const taskId = `task_${Date.now()}`;
+    const now = new Date().toISOString();
+    const state = { taskId, goal, mode: options.service ? 'service' : 'task', status: 'completed', createdAt: now, updatedAt: now, attempts: [], chosenAgents: [], chosenSquads: [], chosenSkills: [], routeMode: 'single', memoryCandidates: [], governanceEvents: [], userId: 'cli', plan: [], successCriteria: [], reviewFindings: [], artifacts: [] };
+    const store = new MissionState_1.MissionStateStore();
+    const out = store.persist(state);
+    if (options.service) {
+        // v1.3 — explicit-only contract. CLI passing --service constitutes
+        // the operator's explicit opt-in, so we synthesize the human actor
+        // from the OS user (or 'cli-operator' fallback) plus the canonical
+        // consent scope.
+        const actor = process.env.OPENLIFE_OPERATOR_ID || process.env.USER || 'cli-operator';
+        new ServiceState_1.ServiceStateStore().promoteTaskToService(state, options.service, goal, {
+            actor,
+            consentScope: 'task_promotion',
+            reason: 'cli --service flag',
+        });
+    }
+    console.log(JSON.stringify({ ok: true, taskId, path: out, state }, null, 2));
+});
+taskCmd.command('status <taskId>')
+    .description('Mostra status da tarefa')
+    .action((taskId) => {
+    const missionPath = path.join(process.cwd(), '.artifacts', 'missions', `${taskId}.json`);
+    if (!fs.existsSync(missionPath)) {
+        console.log(`❌ Task não encontrada: ${taskId}`);
+        return;
+    }
+    const mission = JSON.parse(fs.readFileSync(missionPath, 'utf-8'));
+    console.log(JSON.stringify(mission, null, 2));
+});
+const jobCmd = program.command('job').description('Lifecycle de jobs autônomos');
+jobCmd.command('list')
+    .option('--limit <limit>', 'limite', '50')
+    .action((options) => {
+    const store = new JobLifecycle_1.JobLifecycleStore();
+    const limit = Number(options.limit || 50);
+    console.log(JSON.stringify(store.list(limit), null, 2));
+});
+jobCmd.command('events <jobId>')
+    .action((jobId) => {
+    const store = new JobLifecycle_1.JobLifecycleStore();
+    console.log(JSON.stringify(store.events(jobId), null, 2));
+});
+const runtimeCmd = program.command('runtime').description('Runtime registry unificado');
+runtimeCmd.command('probe').action(() => {
+    const rr = new RuntimeRegistry_1.RuntimeRegistry();
+    console.log(JSON.stringify(rr.probe(), null, 2));
+});
+runtimeCmd.command('list').action(() => {
+    const rr = new RuntimeRegistry_1.RuntimeRegistry();
+    console.log(JSON.stringify(rr.list(), null, 2));
+});
+const reversaCmd = program.command('reversa').description('Reversa-lite reverse-spec pipeline');
+reversaCmd.command('status').action(() => {
+    const r = new ReversaAgent_1.ReversaAgent();
+    console.log(JSON.stringify(r.resume(), null, 2));
+});
+reversaCmd.command('next')
+    .option('--note <note>', 'nota de avanço', 'checkpoint avançado')
+    .action((options) => {
+    const r = new ReversaAgent_1.ReversaAgent();
+    console.log(JSON.stringify(r.advance(options.note), null, 2));
+});
+reversaCmd.command('mode')
+    .option('--set <mode>', 'default | designmd')
+    .option('--profile <profileId>', 'design profile id')
+    .action((options) => {
+    const r = new ReversaAgent_1.ReversaAgent();
+    if (!options.set) {
+        console.log(JSON.stringify(r.resume(), null, 2));
+        return;
+    }
+    console.log(JSON.stringify(r.setMode(options.set, options.profile), null, 2));
+});
+reversaCmd.command('run-phase <phase>')
+    .option('--note <note>', 'phase note', 'phase run')
+    .action((phase, options) => {
+    const r = new ReversaAgent_1.ReversaAgent();
+    console.log(JSON.stringify(r.runPhase(phase, options.note), null, 2));
+});
+reversaCmd.command('run-all')
+    .option('--note <note>', 'run note', 'run all')
+    .action((options) => {
+    const r = new ReversaAgent_1.ReversaAgent();
+    console.log(JSON.stringify(r.runAll(options.note), null, 2));
+});
+reversaCmd.command('export-json').action(() => {
+    const r = new ReversaAgent_1.ReversaAgent();
+    console.log(JSON.stringify({ path: r.exportContractsJson() }, null, 2));
+});
+const sourcesCmd = program.command('sources').description('Catálogo de fontes externas (skills/squads/agents/mcps)');
+sourcesCmd.command('list').action(() => {
+    const reg = new ExternalCatalogRegistry_1.ExternalCatalogRegistry();
+    console.log(JSON.stringify(reg.list(), null, 2));
+});
+sourcesCmd.command('guard-check <url>').action((url) => {
+    const guard = new SecurityDownloadGuard_1.SecurityDownloadGuard();
+    console.log(JSON.stringify(guard.validateUrl(url), null, 2));
+});
+sourcesCmd.command('scaffold <type> <id>')
+    .description('cria scaffold local de referência para skill|squad|agent|mcp')
+    .option('--notes <notes>', 'notas adicionais', '')
+    .action((type, id, options) => {
+    const fs = require('fs');
+    const path = require('path');
+    const allowed = new Set(['skill', 'squad', 'agent', 'mcp']);
+    if (!allowed.has(type)) {
+        console.error('type inválido: use skill|squad|agent|mcp');
+        process.exit(2);
+    }
+    const base = path.join(process.cwd(), '.catalog', `${type}s`, id);
+    fs.mkdirSync(base, { recursive: true });
+    const content = `# ${type}:${id}\n\nstatus: reference\ncreatedAt: ${new Date().toISOString()}\n\n## Notes\n${options.notes || 'n/a'}\n`;
+    fs.writeFileSync(path.join(base, 'REFERENCE.md'), content, 'utf-8');
+    console.log(JSON.stringify({ ok: true, path: path.join(base, 'REFERENCE.md') }, null, 2));
+});
+sourcesCmd.command('import-ref <type> <id> <url>')
+    .description('importa referência remota com guardrail para .catalog')
+    .action(async (type, id, url) => {
+    const fs = require('fs');
+    const path = require('path');
+    const guard = new SecurityDownloadGuard_1.SecurityDownloadGuard();
+    const urlCheck = guard.validateUrl(url);
+    if (!urlCheck.ok) {
+        console.error(JSON.stringify({ error: 'untrusted_source', urlCheck }, null, 2));
+        process.exit(5);
+    }
+    const { spawnSync } = require('child_process');
+    const r = spawnSync('bash', ['-lc', `curl -L --max-time 20 ${JSON.stringify(url)}`], { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 3 });
+    const body = r.status === 0 ? (r.stdout || '') : '';
+    const base = path.join(process.cwd(), '.catalog', `${type}s`, id);
+    fs.mkdirSync(base, { recursive: true });
+    const out = path.join(base, 'IMPORTED_REFERENCE.md');
+    fs.writeFileSync(out, `# Imported ${type}:${id}\n\nsource: ${url}\nimportedAt: ${new Date().toISOString()}\n\n---\n\n${body}`.slice(0, 120000), 'utf-8');
+    console.log(JSON.stringify({ ok: true, path: out, source: url }, null, 2));
+});
+const teammateCmd = program.command('teammate').description('Agents as teammates board');
+teammateCmd.command('list').action(() => {
+    const store = new TeammateBoard_1.TeammateBoardStore();
+    console.log(JSON.stringify(store.list(), null, 2));
+});
+teammateCmd.command('upsert <id> <owner> <status> <title>')
+    .option('--blocker <blocker>', 'blocker', '')
+    .option('--comment <comment>', 'comment', '')
+    .action((id, owner, status, title, options) => {
+    const store = new TeammateBoard_1.TeammateBoardStore();
+    store.upsert({ id, workspaceId: 'default', owner, status, title, blockers: options.blocker ? [options.blocker] : [], comments: options.comment ? [options.comment] : [], updatedAt: new Date().toISOString() });
+    console.log('OK');
+});
+const learningCmd = program.command('learning').description('Governed skill learning loop');
+learningCmd.command('add <taskId> <summary>').action((taskId, summary) => {
+    const store = new SkillLearningLoop_1.SkillLearningLoopStore();
+    console.log(JSON.stringify(store.add(taskId, summary), null, 2));
+});
+learningCmd.command('list').action(() => {
+    const store = new SkillLearningLoop_1.SkillLearningLoopStore();
+    console.log(JSON.stringify(store.list(), null, 2));
+});
+const contextCmd = program.command('context').description('Contexto institucional do OpenLife');
+contextCmd.command('init')
+    .option('--name <name>', 'nome institucional', 'OpenLife Institutional Context')
+    .action((options) => {
+    console.log(JSON.stringify(new EnterpriseAgenticCore_1.InstitutionalContextStore().init(options.name), null, 2));
+});
+contextCmd.command('doctor').action(() => {
+    const result = new EnterpriseAgenticCore_1.InstitutionalContextStore().doctor();
+    if (!result.ok)
+        process.exitCode = 1;
+    console.log(JSON.stringify(result, null, 2));
+});
+contextCmd.command('summary').action(() => {
+    console.log(JSON.stringify(new EnterpriseAgenticCore_1.InstitutionalContextStore().summary(), null, 2));
+});
+function printCliResult(result) {
+    if (!result?.ok)
+        process.exitCode = 1;
+    console.log(JSON.stringify(result, null, 2));
+}
+const pluginCmd = program.command('plugin').description('Marketplace interno de plugins/skills governados');
+pluginCmd.command('install <id>')
+    .option('--risk <risk>', 'low|medium|high', 'low')
+    .option('--capability <capability>', 'capacidade do plugin', (value, previous) => previous.concat([value]), [])
+    .action((id, options) => {
+    printCliResult(new EnterpriseAgenticCore_1.PluginManifestStore().install(id, options.capability || [], options.risk));
+});
+pluginCmd.command('list').action(() => {
+    console.log(JSON.stringify(new EnterpriseAgenticCore_1.PluginManifestStore().list(), null, 2));
+});
+pluginCmd.command('inspect <id>').action((id) => {
+    printCliResult(new EnterpriseAgenticCore_1.PluginManifestStore().inspect(id));
+});
+pluginCmd.command('disable <id>').action((id) => {
+    printCliResult(new EnterpriseAgenticCore_1.PluginManifestStore().setStatus(id, 'disabled'));
+});
+pluginCmd.command('enable <id>').action((id) => {
+    printCliResult(new EnterpriseAgenticCore_1.PluginManifestStore().setStatus(id, 'installed'));
+});
+const pilotCmd = program.command('pilot').description('Pilotos mensuráveis para serviços/capacidades OpenLife');
+pilotCmd.command('create <id>')
+    .option('--metric <metric>', 'métrica de sucesso')
+    .option('--service <service>', 'serviço associado', 'unassigned')
+    .action((id, options) => {
+    printCliResult(new EnterpriseAgenticCore_1.PilotStore().create(id, options.metric || '', options.service));
+});
+pilotCmd.command('list').action(() => {
+    console.log(JSON.stringify(new EnterpriseAgenticCore_1.PilotStore().list(), null, 2));
+});
+pilotCmd.command('report <id>').action((id) => {
+    printCliResult(new EnterpriseAgenticCore_1.PilotStore().report(id));
+});
+pilotCmd.command('complete <id>')
+    .option('--outcome <outcome>', 'resultado do piloto', 'completed')
+    .action((id, options) => {
+    printCliResult(new EnterpriseAgenticCore_1.PilotStore().complete(id, options.outcome));
+});
+const evalCmd = program.command('eval').description('Avaliação/LLM-as-judge interno para missões');
+evalCmd.command('judge')
+    .requiredOption('--mission <mission>', 'id da missão')
+    .option('--criteria <criteria>', 'critérios separados por vírgula', 'quality,governance,actionability')
+    .action((options) => {
+    printCliResult(new EnterpriseAgenticCore_1.MissionEvaluationStore().judge(options.mission, options.criteria));
+});
+evalCmd.command('report <mission>').action((mission) => {
+    printCliResult(new EnterpriseAgenticCore_1.MissionEvaluationStore().report(mission));
+});
+evalCmd.command('list')
+    .description('Lista as avaliações persistidas em .openlife/evaluations/ (Story 13.2)')
+    .option('--verdict <verdict>', 'filtra por ready_for_review | needs_iteration')
+    .option('--min-score <score>', 'score mínimo (0-100)')
+    .option('--source <source>', 'filtra por source (brain | heuristic)')
+    .action((options) => {
+    const all = new EnterpriseAgenticCore_1.MissionEvaluationStore().list();
+    let filtered = Array.isArray(all) ? all : [];
+    if (options.verdict) {
+        filtered = filtered.filter((e) => e && e.verdict === options.verdict);
+    }
+    if (options.minScore !== undefined) {
+        const min = Number(options.minScore);
+        if (!Number.isNaN(min))
+            filtered = filtered.filter((e) => typeof e?.score === 'number' && e.score >= min);
+    }
+    if (options.source) {
+        // 'brain' = explicit source field; 'heuristic' = source missing or anything else.
+        filtered = filtered.filter((e) => {
+            const src = (e && e.source) || 'heuristic';
+            return src === options.source;
+        });
+    }
+    console.log(JSON.stringify({ ok: true, count: filtered.length, evaluations: filtered }, null, 2));
+});
+const learnCmd = program.command('learn').description('Feedback loop que transforma revisão humana em evolução');
+learnCmd.command('from-last-run')
+    .requiredOption('--mission <mission>', 'id da missão')
+    .option('--feedback <feedback>', 'feedback humano ou operacional', '')
+    .action((options) => {
+    printCliResult(new EnterpriseAgenticCore_1.LearningLoopStore().fromLastRun(options.mission, options.feedback));
+});
+learnCmd.command('list').action(() => {
+    console.log(JSON.stringify(new EnterpriseAgenticCore_1.LearningLoopStore().list(), null, 2));
+});
+const enterpriseCmd = program.command('enterprise').description('Diagnóstico agregado do núcleo enterprise-agentic');
+enterpriseCmd.command('doctor').action(() => {
+    const result = new EnterpriseAgenticCore_1.EnterpriseDoctor().run();
+    if (!result.ok)
+        process.exitCode = 1;
+    console.log(JSON.stringify(result, null, 2));
+});
+const designmdCmd = program.command('designmd').description('DESIGN.md mode manager');
+designmdCmd.command('status').action(() => {
+    const dm = new DesignMdMode_1.DesignMdMode();
+    console.log(JSON.stringify(dm.status(), null, 2));
+});
+designmdCmd.command('import')
+    .option('--vendor <vendorPath>', 'vendor path', 'vendor/awesome-design-md')
+    .option('--source <source>', 'awesome-design-md | open-design', 'awesome-design-md')
+    .action((options) => {
+    const guard = new SecurityDownloadGuard_1.SecurityDownloadGuard();
+    const scan = guard.scanExtractedDir(options.vendor);
+    if (!scan.ok) {
+        console.error(JSON.stringify({ error: 'security_guard_blocked', scan }, null, 2));
+        process.exit(4);
+    }
+    const importer = new DesignMdImporter_1.DesignMdImporter();
+    const result = options.source === 'open-design'
+        ? importer.importFromOpenDesign(options.vendor)
+        : importer.importFromVendor(options.vendor);
+    console.log(JSON.stringify({ security: scan, source: options.source, result }, null, 2));
+});
+designmdCmd.command('list').action(() => {
+    const registry = new DesignMdRegistry_1.DesignMdRegistry();
+    console.log(JSON.stringify(registry.list(), null, 2));
+});
+designmdCmd.command('show <profileId>').action((profileId) => {
+    const registry = new DesignMdRegistry_1.DesignMdRegistry();
+    const p = registry.get(profileId);
+    console.log(JSON.stringify(p.meta, null, 2));
+});
+designmdCmd.command('apply <profileId> <source> <title> <designPath>').action((profileId, source, title, designPath) => {
+    const dm = new DesignMdMode_1.DesignMdMode();
+    const content = require('fs').readFileSync(designPath, 'utf-8');
+    console.log(JSON.stringify(dm.applyProfile({ id: profileId, source, title, appliedAt: new Date().toISOString() }, content), null, 2));
+});
+// Workflow execution surface (Story 4.3 — workflow engine CLI)
+const workflowCmd = program.command('workflow').description('OpenLife workflow engine — list, validate, run, status, resume, abort');
+workflowCmd.command('list')
+    .description('List available workflows (composite: .catalog/workflows/ ∪ dist-templates/workflows/)')
+    .action(() => {
+    const { FileWorkflowProvider } = require('./orchestrator/providers/FileWorkflowProvider');
+    const provider = new FileWorkflowProvider();
+    const entries = provider.list();
+    console.log(JSON.stringify({ ok: true, count: entries.length, workflows: entries }, null, 2));
+});
+workflowCmd.command('validate <workflowFile>')
+    .description('Validate a workflow YAML file against the schema')
+    .action((workflowFile) => {
+    const { parseWorkflowFile } = require('./orchestrator/workflow/WorkflowParser');
+    const resolved = path.isAbsolute(workflowFile) ? workflowFile : path.resolve(process.cwd(), workflowFile);
+    const r = parseWorkflowFile(resolved);
+    if (!r.ok) {
+        console.log(JSON.stringify({ ok: false, errors: r.errors }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify({ ok: true, workflowId: r.workflow.id, steps: r.workflow.sequence.length }, null, 2));
+});
+workflowCmd.command('run <workflowFile>')
+    .description('Execute a workflow (--dry-run uses the simulated executor; default)')
+    .option('--dry-run', 'simulate steps without invoking real LLMs', true)
+    .action(async (workflowFile, opts) => {
+    const { parseWorkflowFile } = require('./orchestrator/workflow/WorkflowParser');
+    const { WorkflowEngine } = require('./orchestrator/workflow/WorkflowEngine');
+    const resolved = path.isAbsolute(workflowFile) ? workflowFile : path.resolve(process.cwd(), workflowFile);
+    const r = parseWorkflowFile(resolved);
+    if (!r.ok) {
+        console.log(JSON.stringify({ ok: false, error: 'workflow_parse_failed', errors: r.errors }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const engine = new WorkflowEngine();
+    const state = await engine.run(r.workflow);
+    console.log(JSON.stringify({ ok: state.status === 'completed' || state.status === 'awaiting_input', state }, null, 2));
+    if (state.status === 'failed' || state.status === 'aborted')
+        process.exitCode = 1;
+});
+workflowCmd.command('status <runId>')
+    .description('Show the persisted state of a workflow run')
+    .action((runId) => {
+    const { WorkflowEngine } = require('./orchestrator/workflow/WorkflowEngine');
+    const engine = new WorkflowEngine();
+    const state = engine.status(runId);
+    if (!state) {
+        console.log(JSON.stringify({ ok: false, error: 'run_not_found', runId }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify({ ok: true, state }, null, 2));
+});
+workflowCmd.command('resume <workflowFile> <runId>')
+    .description('Resume a paused or crashed workflow run from the last checkpoint')
+    .action(async (workflowFile, runId) => {
+    const { parseWorkflowFile } = require('./orchestrator/workflow/WorkflowParser');
+    const { WorkflowEngine } = require('./orchestrator/workflow/WorkflowEngine');
+    const resolved = path.isAbsolute(workflowFile) ? workflowFile : path.resolve(process.cwd(), workflowFile);
+    const r = parseWorkflowFile(resolved);
+    if (!r.ok) {
+        console.log(JSON.stringify({ ok: false, error: 'workflow_parse_failed', errors: r.errors }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const engine = new WorkflowEngine();
+    try {
+        const state = await engine.resume(r.workflow, runId);
+        console.log(JSON.stringify({ ok: state.status === 'completed', state }, null, 2));
+        if (state.status === 'failed' || state.status === 'aborted')
+            process.exitCode = 1;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(JSON.stringify({ ok: false, error: 'resume_failed', message: msg }, null, 2));
+        process.exitCode = 1;
+    }
+});
+workflowCmd.command('abort <runId>')
+    .description('Mark a workflow run as aborted and clear its checkpoint')
+    .option('--reason <reason>', 'human-readable abort reason', 'manual')
+    .action((runId, opts) => {
+    const { WorkflowEngine } = require('./orchestrator/workflow/WorkflowEngine');
+    const engine = new WorkflowEngine();
+    const state = engine.abort(runId, opts.reason);
+    if (!state) {
+        console.log(JSON.stringify({ ok: false, error: 'run_not_found', runId }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify({ ok: true, state }, null, 2));
+});
+// Mission checkpoint inspection (Story 6.2 — autonomy layer)
+const missionCmd = program.command('mission').description('Inspect mission state and checkpoints');
+missionCmd.command('checkpoint <missionId>')
+    .description('Show the latest persisted checkpoint for a mission (if any)')
+    .action((missionId) => {
+    const { MissionCheckpointStore } = require('./orchestrator/MissionState');
+    const store = new MissionCheckpointStore();
+    const ckpt = store.getLatestCheckpoint(missionId);
+    if (!ckpt) {
+        console.log(JSON.stringify({ ok: false, error: 'no_checkpoint', missionId }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify({ ok: true, ...ckpt }, null, 2));
+});
+missionCmd.command('checkpoints')
+    .description('List all missionIds with persisted checkpoints')
+    .action(() => {
+    const { MissionCheckpointStore } = require('./orchestrator/MissionState');
+    const store = new MissionCheckpointStore();
+    const ids = store.list();
+    console.log(JSON.stringify({ ok: true, count: ids.length, missionIds: ids }, null, 2));
+});
+missionCmd.command('clear-checkpoint <missionId>')
+    .description('Remove the persisted checkpoint for a mission')
+    .action((missionId) => {
+    const { MissionCheckpointStore } = require('./orchestrator/MissionState');
+    const store = new MissionCheckpointStore();
+    const had = store.getLatestCheckpoint(missionId) !== null;
+    store.clear(missionId);
+    console.log(JSON.stringify({ ok: true, missionId, cleared: had }, null, 2));
+});
+const aiobuilderCmd = program.command('aiobuilder').description('AIOBUILDER operations');
+aiobuilderCmd.command('mode')
+    .option('--set <mode>', 'default | designmd')
+    .option('--profile <profileId>', 'design profile id')
+    .action((options) => {
+    const r = new ReversaAgent_1.ReversaAgent();
+    if (!options.set) {
+        console.log(JSON.stringify(r.resume(), null, 2));
+        return;
+    }
+    console.log(JSON.stringify(r.setMode(options.set, options.profile), null, 2));
+});
+aiobuilderCmd.command('create-agent <id>')
+    .option('--role <role>', 'papel', 'specialist')
+    .option('--notes <notes>', 'notas', '')
+    .action((id, options) => {
+    const base = path.join(process.cwd(), '.catalog', 'agents', id);
+    fs.mkdirSync(base, { recursive: true });
+    const out = path.join(base, 'AGENT.md');
+    fs.writeFileSync(out, `---\nid: ${id}\nname: ${id}\nrole: ${options.role}\nsource: aiobuilder\n---\n\n# ${id}\n\n${options.notes || 'Criado pelo AIOBUILDER.'}\n`, 'utf-8');
+    console.log(JSON.stringify({ ok: true, type: 'agent', path: out }, null, 2));
+});
+aiobuilderCmd.command('create-squad <id>')
+    .option('--domain <domain>', 'domínio', 'general')
+    .option('--notes <notes>', 'notas', '')
+    .action((id, options) => {
+    const base = path.join(process.cwd(), '.catalog', 'squads', id);
+    fs.mkdirSync(base, { recursive: true });
+    const out = path.join(base, 'SQUAD.md');
+    fs.writeFileSync(out, `---\nid: ${id}\ndomain: ${options.domain}\nsource: aiobuilder\n---\n\n# ${id}\n\n${options.notes || 'Criada pelo AIOBUILDER.'}\n`, 'utf-8');
+    console.log(JSON.stringify({ ok: true, type: 'squad', path: out }, null, 2));
+});
+aiobuilderCmd.command('validate-catalog').action(() => {
+    const agents = countCatalogFiles('agents', 'AGENT.md');
+    const squads = countCatalogFiles('squads', 'SQUAD.md');
+    const ok = agents.total >= 300 && squads.total >= 2;
+    console.log(JSON.stringify({ ok, agents, squads }, null, 2));
+    if (!ok)
+        process.exitCode = 1;
+});
+aiobuilderCmd.command('generate-ui <featureName>')
+    .option('--strict-contracts', 'require valid final contracts', false)
+    .option('--consistency-check', 'require active design profile with checksum/source', false)
+    .action((featureName, options) => {
+    const r = new ReversaAgent_1.ReversaAgent().resume();
+    const mode = r.mode || 'default';
+    const profile = r.designProfileId || 'none';
+    const contractsPath = require('path').join(process.cwd(), '.reversa', 'final-contracts.md');
+    const fs = require('fs');
+    const contractsSummary = fs.existsSync(contractsPath) ? fs.readFileSync(contractsPath, 'utf-8').slice(0, 1500) : 'No final contracts found';
+    if (options?.strictContracts) {
+        const jsonPath = require('path').join(process.cwd(), '.reversa', 'final-contracts.json');
+        if (!fs.existsSync(jsonPath)) {
+            console.error('strict-contracts enabled: final-contracts.json missing');
+            process.exit(2);
+        }
+        const data = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
+        if (!data?.validation?.ok) {
+            console.error('strict-contracts enabled: contracts validation failed');
+            process.exit(3);
+        }
+    }
+    const dm = new DesignMdMode_1.DesignMdMode();
+    const profiles = dm.listProfiles();
+    const activeProfile = profiles.find((p) => p.id === profile);
+    if (options?.consistencyCheck) {
+        if (mode !== 'designmd' || !activeProfile?.checksum || !activeProfile?.source) {
+            console.error('consistency-check enabled: missing designmd mode/profile/checksum/source');
+            process.exit(5);
+        }
+    }
+    const context = {
+        designContext: {
+            mode,
+            profile,
+            source: activeProfile?.source || 'unknown',
+            checksum: activeProfile?.checksum || 'unknown',
+        },
+        precisionRules: [
+            'Maintain token consistency across pages/components',
+            'Preserve spacing/typography scale from DESIGN.md',
+            'Reject visual drift that breaks profile identity',
+        ],
+    };
+    const outputDir = require('path').join(process.cwd(), '.reversa', 'ui-drafts');
+    fs.mkdirSync(outputDir, { recursive: true });
+    const featureSlug = featureName.replace(/\s+/g, '-').toLowerCase();
+    const outFile = require('path').join(outputDir, `${featureSlug}.md`);
+    const draft = [
+        `# UI Draft — ${featureName}`,
+        '',
+        `mode: ${mode}`,
+        `profile: ${profile}`,
+        `source: ${activeProfile?.source || 'unknown'}`,
+        `checksum: ${activeProfile?.checksum || 'unknown'}`,
+        '',
+        '## Generation Log',
+        '- Step 1/4: Loaded active DESIGN.md profile context',
+        '- Step 2/4: Applied precision and consistency rules',
+        '- Step 3/4: Merged final-contracts constraints',
+        '- Step 4/4: Produced textual UI draft',
+        '',
+        '## Initial Textual Design Output',
+        `- Feature: ${featureName}`,
+        '- Layout: premium enterprise shell with operational sidebar and command bar',
+        '- Core blocks: KPI row, status cards, teams matrix, skill networks table',
+        '- Interaction model: granular refresh, retry per panel, safe error boundaries',
+        '- Visual governance: no token drift from active design profile',
+        '',
+        '## Contracts Snapshot',
+        contractsSummary
+    ].join('\n');
+    fs.writeFileSync(outFile, draft, 'utf-8');
+    console.log('🧠 AIOBUILDER: iniciando ferramenta de design automática...');
+    console.log('🎨 Step 1/4: contexto DESIGN.md carregado');
+    console.log('📏 Step 2/4: regras de precisão/consistência aplicadas');
+    console.log('🧩 Step 3/4: contratos finais incorporados');
+    console.log('✍️ Step 4/4: draft textual produzido');
+    console.log(JSON.stringify({ featureName, mode, profile, prompt: `Generate UI for ${featureName} following DESIGN.md profile ${profile}`, contractsSummary, context, output: { type: 'text-draft', path: outFile } }, null, 2));
+});
+aiobuilderCmd.command('chat <mensagem...>')
+    .description('Executa intents de design por linguagem natural (import, mode, generate, refine)')
+    .action((mensagemArgs) => {
+    const mensagem = mensagemArgs.join(' ').trim();
+    const result = tryHandleDesignConversation(mensagem);
+    if (!result) {
+        console.log('Nenhuma intenção de design identificada. Tente: importar open design, ativar designmd perfil X, gerar interface, refinar.');
+        return;
+    }
+    console.log(result);
+});
+// AIOBuilder CLI completion (Story 5.4 — close 10 sub-command parity gap)
+// Each sub-command delegates to SquadCreator / SkillCreator / WorkflowEngine
+// with lazy require. Maintains aditividade: pre-existing aliases (create-agent,
+// create-squad, generate-ui) keep working.
+aiobuilderCmd.command('discover')
+    .description('Brownfield discovery — maps codebase + impact of a planned change')
+    .option('--dry-run', 'simulate without invoking real LLMs', true)
+    .action(async () => {
+    const { parseWorkflowFile } = require('./orchestrator/workflow/WorkflowParser');
+    const { WorkflowEngine } = require('./orchestrator/workflow/WorkflowEngine');
+    const wfFile = path.resolve(__dirname, '..', 'dist-templates', 'workflows', 'brownfield-discovery.yaml');
+    const r = parseWorkflowFile(wfFile);
+    if (!r.ok) {
+        console.log(JSON.stringify({ ok: false, error: 'workflow_load_failed', errors: r.errors }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const engine = new WorkflowEngine();
+    const state = await engine.run(r.workflow);
+    console.log(JSON.stringify({ ok: state.status === 'completed', action: 'aiobuilder.discover', state }, null, 2));
+});
+aiobuilderCmd.command('plan')
+    .description('Generate plan, risks, and squad/skill picks for a goal')
+    .option('--goal <goal>', 'goal description', '')
+    .action(async (opts) => {
+    const { parseWorkflowFile } = require('./orchestrator/workflow/WorkflowParser');
+    const { WorkflowEngine } = require('./orchestrator/workflow/WorkflowEngine');
+    const wfFile = path.resolve(__dirname, '..', 'dist-templates', 'workflows', 'story-development-cycle.yaml');
+    const r = parseWorkflowFile(wfFile);
+    if (!r.ok) {
+        console.log(JSON.stringify({ ok: false, error: 'workflow_load_failed', errors: r.errors }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const engine = new WorkflowEngine();
+    // Plan = phase 1 only (Create) — operator runs full SDC separately
+    const state = await engine.run(r.workflow, { goal: opts.goal });
+    console.log(JSON.stringify({ ok: state.status === 'completed', action: 'aiobuilder.plan', state }, null, 2));
+});
+aiobuilderCmd.command('build')
+    .description('Execute the development cycle for a story (delegates to greenfield-fullstack workflow)')
+    .option('--story <storyId>', 'story id', '')
+    .action(async (opts) => {
+    const { parseWorkflowFile } = require('./orchestrator/workflow/WorkflowParser');
+    const { WorkflowEngine } = require('./orchestrator/workflow/WorkflowEngine');
+    const wfFile = path.resolve(__dirname, '..', 'dist-templates', 'workflows', 'greenfield-fullstack.yaml');
+    const r = parseWorkflowFile(wfFile);
+    if (!r.ok) {
+        console.log(JSON.stringify({ ok: false, error: 'workflow_load_failed', errors: r.errors }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const engine = new WorkflowEngine();
+    const state = await engine.run(r.workflow, { storyId: opts.story });
+    console.log(JSON.stringify({ ok: state.status === 'completed', action: 'aiobuilder.build', state }, null, 2));
+});
+aiobuilderCmd.command('test')
+    .description('Run the canonical test suite and report results')
+    .action(() => {
+    const { spawnSync } = require('child_process');
+    const r = spawnSync('npm', ['run', 'test:all'], { encoding: 'utf-8', cwd: process.cwd() });
+    console.log(JSON.stringify({
+        ok: r.status === 0,
+        action: 'aiobuilder.test',
+        exitCode: r.status,
+        summary: r.stdout?.split('\n').filter((l) => /TEST_.*_OK/.test(l)).length || 0,
+    }, null, 2));
+    if (r.status !== 0)
+        process.exitCode = 1;
+});
+aiobuilderCmd.command('preview')
+    .description('Prepare a preview URL for the current branch (v1.3 will wire to Vercel/Railway)')
+    .action(() => {
+    console.log(JSON.stringify({
+        ok: true,
+        action: 'aiobuilder.preview',
+        note: 'preview deployment integration deferred to v1.3 capability genesis epic',
+        next: 'manually push to feature branch + open PR for now',
+    }, null, 2));
+});
+aiobuilderCmd.command('release')
+    .description('Run QA loop + open PR (delegates to qa-loop workflow)')
+    .action(async () => {
+    const { parseWorkflowFile } = require('./orchestrator/workflow/WorkflowParser');
+    const { WorkflowEngine } = require('./orchestrator/workflow/WorkflowEngine');
+    const wfFile = path.resolve(__dirname, '..', 'dist-templates', 'workflows', 'qa-loop.yaml');
+    const r = parseWorkflowFile(wfFile);
+    if (!r.ok) {
+        console.log(JSON.stringify({ ok: false, error: 'workflow_load_failed', errors: r.errors }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const engine = new WorkflowEngine();
+    const state = await engine.run(r.workflow);
+    console.log(JSON.stringify({ ok: state.status === 'completed', action: 'aiobuilder.release', state }, null, 2));
+});
+aiobuilderCmd.command('infra')
+    .description('Infrastructure report (placeholder — real integration v1.3)')
+    .action(() => {
+    console.log(JSON.stringify({
+        ok: true,
+        action: 'aiobuilder.infra',
+        note: 'infra integration deferred to v1.3',
+        checks: ['supabase: TBD', 'railway: TBD', 'env: TBD'],
+    }, null, 2));
+});
+aiobuilderCmd.command('score')
+    .description('Show squad/skill scores from .artifacts/squad-scores.json')
+    .action(() => {
+    const scorePath = path.join(process.cwd(), '.artifacts', 'squad-scores.json');
+    if (!fs.existsSync(scorePath)) {
+        console.log(JSON.stringify({ ok: true, action: 'aiobuilder.score', scores: {}, note: 'no scores recorded yet' }, null, 2));
+        return;
+    }
+    const scores = JSON.parse(fs.readFileSync(scorePath, 'utf-8'));
+    console.log(JSON.stringify({ ok: true, action: 'aiobuilder.score', scores }, null, 2));
+});
+aiobuilderCmd.command('evolve')
+    .description('Run analyze() on every squad and report improvement suggestions')
+    .action(() => {
+    const { SquadCreator } = require('./orchestrator/SquadCreator');
+    const sc = new SquadCreator();
+    const squads = sc.list();
+    const reports = squads.map((s) => sc.analyze(s.id)).filter(Boolean);
+    console.log(JSON.stringify({
+        ok: true,
+        action: 'aiobuilder.evolve',
+        squadCount: squads.length,
+        reports,
+    }, null, 2));
+});
+aiobuilderCmd.command('ship')
+    .description('Full pipeline: discover → plan → build → test → release')
+    .option('--dry-run', 'do not invoke real LLMs', true)
+    .action(async () => {
+    const { parseWorkflowFile } = require('./orchestrator/workflow/WorkflowParser');
+    const { WorkflowEngine } = require('./orchestrator/workflow/WorkflowEngine');
+    const stages = ['brownfield-discovery', 'story-development-cycle', 'qa-loop'];
+    const engine = new WorkflowEngine();
+    const results = [];
+    for (const stageId of stages) {
+        const wfFile = path.resolve(__dirname, '..', 'dist-templates', 'workflows', `${stageId}.yaml`);
+        const r = parseWorkflowFile(wfFile);
+        if (!r.ok) {
+            results.push({ stage: stageId, ok: false, error: 'workflow_load_failed', errors: r.errors });
+            break;
+        }
+        const state = await engine.run(r.workflow);
+        results.push({ stage: stageId, ok: state.status === 'completed', runId: state.runId, status: state.status });
+        if (state.status !== 'completed')
+            break;
+    }
+    const allOk = results.every((r) => r.ok);
+    console.log(JSON.stringify({ ok: allOk, action: 'aiobuilder.ship', stages: results }, null, 2));
+    if (!allOk)
+        process.exitCode = 1;
+});
+aiobuilderCmd.command('build-skill <id>')
+    .description('Create a new skill from dist-templates/skill-template/')
+    .option('--name <name>', 'human-readable name', '')
+    .option('--description <description>', 'one-paragraph description', '')
+    .option('--when <text>', 'when to use (single bullet)', 'TBD')
+    .option('--step <text>', 'first procedure step', 'TBD')
+    .action((id, opts) => {
+    const { SkillCreator } = require('./orchestrator/SkillCreator');
+    const sc = new SkillCreator();
+    const r = sc.create({
+        id,
+        name: opts.name || id,
+        description: opts.description || '',
+        whenToUse: [opts.when],
+        procedure: [opts.step],
+    });
+    console.log(JSON.stringify({ action: 'aiobuilder.build-skill', ...r }, null, 2));
+    if (!r.ok)
+        process.exitCode = 1;
+});
+aiobuilderCmd.command('canonize <type> <id>')
+    .description('Promote a squad or skill from draft → active and record canonization event')
+    .action((type, id) => {
+    if (type !== 'squad' && type !== 'skill') {
+        console.log(JSON.stringify({ ok: false, action: 'aiobuilder.canonize', error: 'invalid_type', detail: 'must be `squad` or `skill`' }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const root = type === 'squad' ? '.catalog/squads' : '.catalog/skills';
+    const file = path.join(process.cwd(), root, id, type === 'squad' ? 'SQUAD.md' : 'SKILL.md');
+    if (!fs.existsSync(file)) {
+        console.log(JSON.stringify({ ok: false, action: 'aiobuilder.canonize', error: 'not_found', detail: file }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const content = fs.readFileSync(file, 'utf-8');
+    const updated = content.replace(/^status:\s*draft\s*$/m, 'status: active');
+    fs.writeFileSync(file, updated, 'utf-8');
+    // Record canonization event
+    const logFile = path.join(process.cwd(), '.openlife', 'canonization-log.jsonl');
+    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+    fs.appendFileSync(logFile, JSON.stringify({ ts: new Date().toISOString(), type, id, action: 'canonize' }) + '\n');
+    console.log(JSON.stringify({ ok: true, action: 'aiobuilder.canonize', type, id }, null, 2));
+});
+// ─── Story 3.3: aiobuilder create-capability ─────────────────────────
+aiobuilderCmd.command('create-capability <description>')
+    .description('Genesis Engine: produce a draft Capability Pack from a free-text brief')
+    .option('--id <id>', 'explicit pack id (slug)')
+    .option('--mode <mode>', 'quick | professional | elite', 'professional')
+    .option('--actor <actor>', 'actor recorded in the lifecycle ledger', 'cli')
+    .option('--skills <csv>', 'comma-separated skill ids to include')
+    .option('--squads <csv>', 'comma-separated squad ids to include')
+    .option('--workflows <csv>', 'comma-separated workflow ids to include (elite mode only)')
+    .action((description, opts) => {
+    const { CapabilityGenesisEngine } = require('./orchestrator/capability/CapabilityGenesisEngine');
+    const engine = new CapabilityGenesisEngine();
+    const csv = (s) => s ? s.split(',').map((x) => x.trim()).filter(Boolean) : [];
+    const r = engine.generate({
+        description,
+        packId: opts.id,
+        mode: opts.mode,
+        actor: opts.actor || 'cli',
+        hints: {
+            skills: csv(opts.skills),
+            squads: csv(opts.squads),
+            workflows: csv(opts.workflows),
+        },
+    });
+    console.log(JSON.stringify(r, null, 2));
+    if (!r.ok)
+        process.exitCode = 1;
+});
+// ─── Story 3.2: top-level `openlife create …` aliases ────────────────
+// Thin forwarders to aiobuilder verbs. AIOBUILDER remains canonical maestro
+// per locked decision 1 in plan; this is just a friendlier help surface.
+const createCmd = program.command('create').description('Guided creator surface (forwards to aiobuilder)');
+createCmd.command('capability <description>')
+    .description('Forward to: openlife aiobuilder create-capability <description>')
+    .option('--id <id>', 'explicit pack id')
+    .option('--mode <mode>', 'quick | professional | elite', 'professional')
+    .option('--actor <actor>', 'actor for lifecycle ledger', 'cli')
+    .option('--skills <csv>', 'comma-separated skill ids')
+    .option('--squads <csv>', 'comma-separated squad ids')
+    .option('--workflows <csv>', 'comma-separated workflow ids (elite only)')
+    .action((description, opts) => {
+    const { CapabilityGenesisEngine } = require('./orchestrator/capability/CapabilityGenesisEngine');
+    const engine = new CapabilityGenesisEngine();
+    const csv = (s) => s ? s.split(',').map((x) => x.trim()).filter(Boolean) : [];
+    const r = engine.generate({
+        description,
+        packId: opts.id,
+        mode: opts.mode || 'professional',
+        actor: opts.actor || 'cli',
+        hints: { skills: csv(opts.skills), squads: csv(opts.squads), workflows: csv(opts.workflows) },
+    });
+    console.log(JSON.stringify(r, null, 2));
+    if (!r.ok)
+        process.exitCode = 1;
+});
+createCmd.command('squad <id>')
+    .description('Forward to: openlife aiobuilder create-squad <id>')
+    .option('--description <text>', 'short squad description', 'Created via openlife create squad')
+    .option('--agents <csv>', 'comma-separated agent ids (defaults to <id>-lead,<id>-executor)')
+    .action((id, opts) => {
+    const { SquadCreator } = require('./orchestrator/SquadCreator');
+    const sc = new SquadCreator();
+    const agentIds = opts.agents ? opts.agents.split(',').map((s) => s.trim()).filter(Boolean) : [`${id}-lead`, `${id}-executor`];
+    const r = sc.create({
+        id,
+        name: id,
+        description: opts.description || `Squad ${id}`,
+        agents: agentIds.map((aid) => ({ id: aid, name: aid, role: aid.endsWith('-lead') ? 'lead' : 'executor' })),
+    });
+    console.log(JSON.stringify(r, null, 2));
+    if (!r.ok)
+        process.exitCode = 1;
+});
+createCmd.command('skill <id>')
+    .description('Forward to: openlife aiobuilder build-skill <id>')
+    .option('--description <text>', 'short skill description', 'Created via openlife create skill')
+    .action((id, opts) => {
+    const { SkillCreator } = require('./orchestrator/SkillCreator');
+    const sc = new SkillCreator();
+    const r = sc.create({
+        id, name: id, description: opts.description || `Skill ${id}`,
+        whenToUse: [opts.description || `use ${id}`],
+        procedure: ['TBD — refine after creation'],
+    });
+    console.log(JSON.stringify(r, null, 2));
+    if (!r.ok)
+        process.exitCode = 1;
+});
+createCmd.command('agent <id>')
+    .description('Forward to: openlife aiobuilder create-agent <id>')
+    .action((id) => {
+    // Forward to the existing aiobuilder create-agent handler shape.
+    // We reuse its implementation by calling commander programmatically.
+    program.parseAsync(['node', 'openlife', 'aiobuilder', 'create-agent', id]).catch(() => { process.exitCode = 1; });
+});
+createCmd.command('workflow <id>')
+    .description('Stub: workflow creation lands via capability pack genesis (use create capability)')
+    .action((id) => {
+    console.log(JSON.stringify({
+        ok: false,
+        error: 'use_create_capability',
+        hint: `workflows are authored as part of a capability pack; run: openlife create capability "<brief>" --mode elite --workflows ${id}`,
+    }, null, 2));
+    process.exitCode = 1;
+});
+// ─── Story 5.1: openlife cron ────────────────────────────────────────
+const cronCmd = program.command('cron').description('CronManager — schedule recurring missions');
+cronCmd.command('create <id> <expression>')
+    .description('Create a cron job (5-field syntax)')
+    .option('--payload <json>', 'JSON payload to fire with', '{}')
+    .action((id, expression, opts) => {
+    try {
+        const { CronManager } = require('./orchestrator/CronManager');
+        const cm = new CronManager();
+        let payload = {};
+        try {
+            payload = JSON.parse(opts.payload || '{}');
+        }
+        catch { /* keep empty */ }
+        const job = cm.create(id, expression, payload);
+        console.log(JSON.stringify({ ok: true, job }, null, 2));
+    }
+    catch (e) {
+        const code = e.code || 'unknown';
+        console.log(JSON.stringify({ ok: false, error: code, detail: e.message }, null, 2));
+        process.exitCode = 1;
+    }
+});
+cronCmd.command('list').description('List cron jobs').action(() => {
+    const { CronManager } = require('./orchestrator/CronManager');
+    const cm = new CronManager();
+    console.log(JSON.stringify({ ok: true, jobs: cm.list() }, null, 2));
+});
+cronCmd.command('pause <id>').description('Pause a cron job').action((id) => {
+    const { CronManager } = require('./orchestrator/CronManager');
+    const cm = new CronManager();
+    const ok = cm.pause(id);
+    console.log(JSON.stringify({ ok, id }, null, 2));
+    if (!ok)
+        process.exitCode = 1;
+});
+cronCmd.command('resume <id>').description('Resume a paused cron job').action((id) => {
+    const { CronManager } = require('./orchestrator/CronManager');
+    const cm = new CronManager();
+    const ok = cm.resume(id);
+    console.log(JSON.stringify({ ok, id }, null, 2));
+    if (!ok)
+        process.exitCode = 1;
+});
+cronCmd.command('run <id>').description('Fire a cron job immediately').action(async (id) => {
+    const { CronManager } = require('./orchestrator/CronManager');
+    const cm = new CronManager();
+    const r = await cm.runNow(id);
+    console.log(JSON.stringify(r, null, 2));
+    if (!r.ok)
+        process.exitCode = 1;
+});
+cronCmd.command('remove <id>').description('Remove a cron job').action((id) => {
+    const { CronManager } = require('./orchestrator/CronManager');
+    const cm = new CronManager();
+    const ok = cm.remove(id);
+    console.log(JSON.stringify({ ok, id }, null, 2));
+    if (!ok)
+        process.exitCode = 1;
+});
+// ─── Story 5.2: openlife profile ────────────────────────────────────
+const profileCmd = program.command('profile').description('ProfileManager — per-profile catalog scope, memory namespace, toolsets');
+profileCmd.command('list').description('List profiles').action(() => {
+    const { ProfileManager } = require('./cli/ProfileManager');
+    const pm = new ProfileManager();
+    const active = pm.active();
+    console.log(JSON.stringify({ ok: true, activeProfileId: active.profileId, profiles: pm.list() }, null, 2));
+});
+profileCmd.command('create <id>').description('Create a profile').option('--name <name>', 'human-readable name').option('--description <desc>').option('--toolsets <csv>', 'allowed toolsets', '*')
+    .action((id, opts) => {
+    try {
+        const { ProfileManager } = require('./cli/ProfileManager');
+        const pm = new ProfileManager();
+        const toolsetAllowed = (opts.toolsets || '*').split(',').map((s) => s.trim()).filter(Boolean);
+        const p = pm.create({ id, name: opts.name || id, description: opts.description, toolsetAllowed });
+        console.log(JSON.stringify({ ok: true, profile: p }, null, 2));
+    }
+    catch (e) {
+        const code = e.code || 'unknown';
+        console.log(JSON.stringify({ ok: false, error: code, detail: e.message }, null, 2));
+        process.exitCode = 1;
+    }
+});
+profileCmd.command('use <id>').description('Set the active profile').action((id) => {
+    const { ProfileManager } = require('./cli/ProfileManager');
+    const pm = new ProfileManager();
+    const r = pm.use(id);
+    console.log(JSON.stringify(r, null, 2));
+    if (!r.ok)
+        process.exitCode = 1;
+});
+profileCmd.command('show <id>').description('Show a profile').action((id) => {
+    const { ProfileManager } = require('./cli/ProfileManager');
+    const pm = new ProfileManager();
+    const p = pm.show(id);
+    if (!p) {
+        console.log(JSON.stringify({ ok: false, error: 'not_found' }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify({ ok: true, profile: p }, null, 2));
+});
+profileCmd.command('export <id>').description('Export a profile as JSON to stdout').action((id) => {
+    const { ProfileManager } = require('./cli/ProfileManager');
+    const pm = new ProfileManager();
+    const p = pm.export(id);
+    if (!p) {
+        console.log(JSON.stringify({ ok: false, error: 'not_found' }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify(p, null, 2));
+});
+profileCmd.command('import <file>').description('Import a profile from a JSON file').action((file) => {
+    try {
+        const { ProfileManager } = require('./cli/ProfileManager');
+        const fsLocal = require('fs');
+        const data = JSON.parse(fsLocal.readFileSync(file, 'utf-8'));
+        const pm = new ProfileManager();
+        const r = pm.import(data);
+        console.log(JSON.stringify(r, null, 2));
+        if (!r.ok)
+            process.exitCode = 1;
+    }
+    catch (e) {
+        console.log(JSON.stringify({ ok: false, error: 'import_failed', detail: e.message }, null, 2));
+        process.exitCode = 1;
+    }
+});
+program.parse(process.argv);