@openlife/cli 1.7.13 → 1.8.2

package/dist/orchestrator/Gateway.js

@@ -41,6 +41,7 @@ const telegraf_1 = require("telegraf");
 const filters_1 = require("telegraf/filters");
 const IntentClassifier_1 = require("./IntentClassifier");
 const Gatekeeper_1 = require("./Gatekeeper");
+const DreamGoalStore_1 = require("./DreamGoalStore");
 const VoiceManager_1 = require("./VoiceManager");
 const axios_1 = __importDefault(require("axios"));
 const fs = __importStar(require("fs"));
@@ -91,6 +92,21 @@ class Gateway {
     static redactBotToken(text) {
         return String(text).replace(/(\d{6,12}):[A-Za-z0-9_-]{20,}/g, '$1:[REDACTED]');
     }
+    static classifyTelegramLaunchError(err) {
+        const raw = err instanceof Error ? err.message : String(err || '');
+        const detail = Gateway.redactBotToken(raw).slice(0, 500);
+        if (raw.includes('409') || raw.includes('terminated by other getUpdates request') || raw.toLowerCase().includes('conflict')) {
+            return {
+                ok: false,
+                error: 'telegram_polling_conflict',
+                recoveryOptions: ['stop_conflicting_instance', 'replace_token', 'skip_telegram_for_now'],
+                detail,
+            };
+        }
+        if (!raw)
+            return { ok: true };
+        return { ok: false, error: 'telegram_launch_failed', recoveryOptions: ['check_token', 'switch_to_webhook', 'skip_telegram_for_now'], detail };
+    }
     /**
      * Validate the configured TELEGRAM_BOT_TOKEN by calling getMe.
      * Returns `{ ok: true, botId, botUsername }` on success;
@@ -344,16 +360,60 @@ class Gateway {
                 await ctx.reply("Erro no módulo de visão ao baixar a imagem.");
             }
         });
-        this.bot.launch().catch((err) => {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (msg.includes('409') || msg.includes('terminated by other getUpdates request')) {
-                console.error('[GATEWAY] Telegram 409 Conflict: outra instância está conectada com este bot. Mantendo processo vivo para healthcheck; Telegram polling fica desativado nesta instância.');
-                return;
+        // Decide Telegram delivery mode:
+        //   - OPENLIFE_TELEGRAM_MODE=polling | webhook | auto (default: auto)
+        //   - "auto" → webhook if a Railway env var is present, else polling.
+        // This is the simplest UX for the "Railway + local" topology: Railway
+        // deploys boot in webhook mode (no polling conflict with local), local
+        // dev boots in polling mode (no webhook URL needed). User changes
+        // nothing.
+        const mode = String(process.env.OPENLIFE_TELEGRAM_MODE || 'auto').toLowerCase();
+        const onRailway = !!(process.env.RAILWAY_ENVIRONMENT || process.env.RAILWAY_PUBLIC_DOMAIN || process.env.RAILWAY_STATIC_URL);
+        const useWebhook = mode === 'webhook' || (mode === 'auto' && onRailway);
+        if (useWebhook) {
+            const webhookPath = process.env.OPENLIFE_WEBHOOK_PATH || '/api/v1/telegram/webhook';
+            // Register webhook handler on the existing Express app — no separate
+            // HTTP server, no port conflict. Telegraf's webhookCallback returns
+            // an Express-compatible middleware that parses updates.
+            // Important: do not mount the callback at `webhookPath` while also
+            // passing `webhookPath` into Telegraf. Express strips the mount
+            // prefix before the middleware sees `req.url`, so Telegraf would
+            // see `/` and skip the update, causing Telegram to receive 404.
+            this.app.use(this.bot.webhookCallback(webhookPath));
+            const rawDomain = process.env.OPENLIFE_WEBHOOK_DOMAIN
+                || process.env.RAILWAY_PUBLIC_DOMAIN
+                || process.env.RAILWAY_STATIC_URL
+                || '';
+            if (rawDomain) {
+                const domain = rawDomain.startsWith('http') ? rawDomain : `https://${rawDomain}`;
+                const fullUrl = `${domain.replace(/\/$/, '')}${webhookPath}`;
+                this.bot.telegram.setWebhook(fullUrl).then(() => {
+                    console.log(`[GATEWAY] Telegram em modo WEBHOOK @ ${fullUrl}`);
+                }).catch((err) => {
+                    console.error('[GATEWAY] setWebhook falhou:', err instanceof Error ? err.message : String(err));
+                });
             }
-            console.error('[GATEWAY] Falha ao iniciar Telegram bot:', err);
-            process.exit(1);
-        });
-        console.log("[GATEWAY] Telegram Bot escutando com suporte Multimodal (Voz/Visão).");
+            else {
+                console.warn('[GATEWAY] Webhook mode ativado mas OPENLIFE_WEBHOOK_DOMAIN (ou RAILWAY_PUBLIC_DOMAIN) não está definido. Telegram não saberá onde entregar mensagens. Defina o domínio público antes de subir.');
+            }
+            console.log("[GATEWAY] Telegram Bot pronto (modo webhook — sem polling).");
+        }
+        else {
+            // Default polling mode (local dev, single-instance bots).
+            // Clear any previously-registered webhook before polling, otherwise
+            // Telegram rejects getUpdates with 409. Best-effort, non-fatal.
+            this.bot.telegram.deleteWebhook({ drop_pending_updates: false }).catch(() => { });
+            this.bot.launch().catch((err) => {
+                const classified = Gateway.classifyTelegramLaunchError(err);
+                if ('error' in classified && classified.error === 'telegram_polling_conflict') {
+                    console.error(`[GATEWAY] Telegram 409 Conflict: outra instância está conectada com este bot. Recovery: ${classified.recoveryOptions.join(' | ')}. Detail: ${classified.detail}`);
+                    return;
+                }
+                console.error('[GATEWAY] Falha ao iniciar Telegram bot:', err);
+                process.exit(1);
+            });
+            console.log("[GATEWAY] Telegram Bot escutando (modo polling) com suporte Multimodal (Voz/Visão).");
+        }
     }
     async shutdown(reason = 'manual') {
         if (this.isShuttingDown)
@@ -543,12 +603,131 @@ class Gateway {
             return true;
         return userId === this.allowedTelegramUserId;
     }
+    shouldRespondByVoice(text) {
+        const normalized = text.toLowerCase().trim();
+        if (/^\/voice\b|^\/voz\b/.test(normalized))
+            return true;
+        return /\b(responda|responder|manda|mande|envia|envie|fale|fala)\b[\s\S]{0,80}\b(por|em)\s+(voz|áudio|audio)\b/i.test(normalized)
+            || /\bquero\s+(ouvir|áudio|audio|voz)\b/i.test(normalized);
+    }
+    stripVoiceDirective(text) {
+        let cleaned = text.replace(/^\/(voice|voz)\s*/i, '').trim();
+        cleaned = cleaned
+            .replace(/\b(responda|responder|manda|mande|envia|envie)\s+(por|em)\s+(voz|áudio|audio)\b[:,\s-]*/ig, '')
+            .replace(/\b(por favor,?\s*)?(responda|responder)\s+(isso\s+)?(por|em)\s+(voz|áudio|audio)\b/ig, '')
+            .trim();
+        return cleaned || text;
+    }
+    voiceUnavailableMessage(err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        const safeDetail = this.governance.redact(detail).slice(0, 500);
+        return [
+            'Não consegui gerar a voz neste momento, então deixei em texto.',
+            `Motivo técnico: ${safeDetail}`,
+            'Para ativar voz sob demanda, configure um provider TTS no Railway: OPENAI_API_KEY ou ELEVENLABS_API_KEY.'
+        ].join('\n');
+    }
+    isMarkdownTableSeparator(line) {
+        return /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(line);
+    }
+    splitMarkdownTableRow(line) {
+        let stripped = line.trim();
+        if (stripped.startsWith('|'))
+            stripped = stripped.slice(1);
+        if (stripped.endsWith('|'))
+            stripped = stripped.slice(0, -1);
+        return stripped.split('|').map(cell => this.stripInlineMarkdown(cell.trim()));
+    }
+    renderMarkdownTableForTelegram(tableBlock) {
+        if (tableBlock.length < 3)
+            return tableBlock.join('\n');
+        const headers = this.splitMarkdownTableRow(tableBlock[0]);
+        if (headers.length < 2)
+            return tableBlock.join('\n');
+        const rows = [];
+        for (const row of tableBlock.slice(2)) {
+            const cells = this.splitMarkdownTableRow(row);
+            if (!cells.length)
+                continue;
+            const heading = cells[0] || 'Item';
+            const values = cells.slice(1);
+            rows.push(`• ${heading}`);
+            for (let i = 1; i < headers.length; i += 1) {
+                const label = headers[i];
+                const value = values[i - 1] || '';
+                if (label && value)
+                    rows.push(`  ${label}: ${value}`);
+            }
+        }
+        return rows.join('\n');
+    }
+    rewriteMarkdownTablesForTelegram(text) {
+        if (!text.includes('|'))
+            return text;
+        const lines = text.split('\n');
+        const output = [];
+        let i = 0;
+        let inFence = false;
+        while (i < lines.length) {
+            const line = lines[i];
+            if (line.trimStart().startsWith('```')) {
+                inFence = !inFence;
+                output.push(line);
+                i += 1;
+                continue;
+            }
+            if (!inFence && line.includes('|') && i + 1 < lines.length && this.isMarkdownTableSeparator(lines[i + 1])) {
+                const tableBlock = [line, lines[i + 1]];
+                let j = i + 2;
+                while (j < lines.length && lines[j].trim() !== '' && lines[j].includes('|')) {
+                    tableBlock.push(lines[j]);
+                    j += 1;
+                }
+                output.push(this.renderMarkdownTableForTelegram(tableBlock));
+                i = j;
+                continue;
+            }
+            output.push(line);
+            i += 1;
+        }
+        return output.join('\n');
+    }
+    stripInlineMarkdown(text) {
+        return text
+            .replace(/`([^`]+)`/g, '$1')
+            .replace(/\*\*([^*]+)\*\*/g, '$1')
+            .replace(/__([^_]+)__/g, '$1')
+            .replace(/~~([^~]+)~~/g, '$1')
+            .replace(/\*([^*\n]+)\*/g, '$1')
+            .replace(/(?<!\w)_([^_\n]+)_(?!\w)/g, '$1');
+    }
+    formatForTelegramPlainText(text) {
+        const withoutTables = this.rewriteMarkdownTablesForTelegram(text);
+        return withoutTables
+            .split('\n')
+            .map(line => line
+            .replace(/^\s*#{1,6}\s+/, '')
+            .replace(/^\s*>\s?/, ''))
+            .filter(line => !/^\s*---+\s*$/.test(line))
+            .map(line => this.stripInlineMarkdown(line))
+            .join('\n')
+            .replace(/\n{3,}/g, '\n\n')
+            .trim();
+    }
     async processInput(ctx, userId, text) {
         if (!this.isAuthorizedUser(userId)) {
             console.warn(`[GATEWAY] Acesso negado para userId=${userId}`);
             await this.safeReply(ctx, 'Acesso negado por policy de segurança deste bot.');
             return;
         }
+        const wantsVoiceReply = this.shouldRespondByVoice(text);
+        const effectiveText = wantsVoiceReply ? this.stripVoiceDirective(text) : text;
+        const dreamGoalStore = new DreamGoalStore_1.DreamGoalStore();
+        const dreamGoalResponse = dreamGoalStore.handleSlashCommand(effectiveText);
+        if (dreamGoalResponse) {
+            await this.safeReply(ctx, dreamGoalResponse);
+            return;
+        }
         // Fast ACK pattern: fire a placeholder reply in parallel with the actual
         // classifier+gatekeeper work. When the work completes, edit the ACK with
         // the real answer (Telegraf editMessageText). Falls back to a fresh
@@ -588,21 +767,21 @@ class Gateway {
         const stopTyping = this.startTypingIndicator(ctx);
         const trace = [];
         try {
-            trace.push(`🔎 classify_intent: "${text.slice(0, 80).replace(/\n/g, ' ')}${text.length > 80 ? '...' : ''}"`);
-            const task = await this.classifier.classify(text);
+            trace.push(`🔎 classify_intent: "${effectiveText.slice(0, 80).replace(/\n/g, ' ')}${effectiveText.length > 80 ? '...' : ''}"`);
+            const task = await this.classifier.classify(effectiveText);
             trace.push(`🧭 route_task: "${String(task.intent)}"`);
-            const response = await this.gatekeeper.routeTask(task, text, userId);
+            const response = await this.gatekeeper.routeTask(task, effectiveText, userId);
             trace.push(`✅ finalize_reply: "${String(task.intent)}"`);
-            const safeResponse = this.governance.redact(response);
+            const safeResponse = this.formatForTelegramPlainText(this.governance.redact(response));
             const finalResponse = this.reasoningMode === 'always' ? `${trace.join('\n')}\n\n${safeResponse}` : safeResponse;
-            if (this.ttsEnabled && typeof ctx.sendVoice === 'function') {
+            if ((this.ttsEnabled || wantsVoiceReply) && typeof ctx.sendVoice === 'function') {
                 try {
                     const audioPath = await this.voiceManager.generateSpeech(finalResponse);
                     await ctx.sendVoice({ source: audioPath }, { caption: finalResponse });
                 }
                 catch (ttsError) {
                     console.log("[GATEWAY] Fallback para texto (Erro no TTS).", ttsError);
-                    await sendFinal(finalResponse);
+                    await sendFinal(wantsVoiceReply ? `${finalResponse}\n\n${this.voiceUnavailableMessage(ttsError)}` : finalResponse);
                 }
             }
             else {

package/dist/orchestrator/ModelManager.js

@@ -73,7 +73,13 @@ class ModelManager {
         const parts = input.split('/');
         const providerStr = parts[0];
         const name = parts.slice(1).join('/');
-        const validProviders = ['openai-api', 'openai-cli', 'anthropic', 'gemini-api', 'gemini-cli', 'ollama', 'openrouter'];
+        const validProviders = [
+            'openai-api', 'openai-cli', 'anthropic', 'gemini-api', 'gemini-cli', 'ollama', 'openrouter',
+            'xai', 'deepseek', 'groq', 'together', 'mistral',
+            'bedrock', 'qwen', 'kimi', 'minimax', 'glm', 'huggingface', 'nvidia-nim', 'perplexity',
+            'vllm', 'sglang', 'llamacpp', 'lmstudio',
+            'litellm', 'clawrouter', 'custom-openai',
+        ];
         const provider = providerStr.toLowerCase();
         if (!validProviders.includes(provider)) {
             throw new Error(`Provedor não suportado: '${provider}'. Provedores válidos: ${validProviders.join(', ')}.`);

package/dist/orchestrator/OrchestrationLoop.js

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

package/dist/orchestrator/ParallelOrchestrationLoop.js

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

package/dist/orchestrator/RuntimePolicy.js

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

package/dist/orchestrator/ServiceCompletionPolicy.js

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

package/dist/orchestrator/SynthesizerAgent.js

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

package/dist/orchestrator/TaskExecutor.js

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

package/dist/orchestrator/capability/CapabilityGenesisEngine.js

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

package/dist/test_capability_genesis_engine.js

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