@openlife/cli 1.7.3

package/dist/orchestrator/OrgStructure.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgStructure = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class OrgStructure {
+    filePath;
+    constructor() {
+        this.filePath = path.join(process.cwd(), '.openlife', 'org-structure.json');
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        this.ensureDefault();
+    }
+    all() {
+        return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+    }
+    get(roleId) {
+        return this.all().find((role) => role.id === roleId) || null;
+    }
+    ensureDefault() {
+        if (fs.existsSync(this.filePath))
+            return;
+        const defaults = [
+            {
+                id: 'ceo',
+                title: 'CEO',
+                mission: 'Define direção estratégica, prioridades e decisões de alto impacto.',
+                responsibilities: ['strategy', 'prioritization', 'capital-allocation'],
+                defaultSquads: ['capital-ai', 'c-level-squad', 'advisory-board']
+            },
+            {
+                id: 'cto',
+                title: 'CTO',
+                mission: 'Garante arquitetura, runtime, qualidade técnica e evolução da plataforma.',
+                responsibilities: ['architecture', 'runtime', 'quality', 'release'],
+                defaultSquads: ['ai-builder', 'code-review', 'cloudflare-mini']
+            },
+            {
+                id: 'cpo',
+                title: 'CPO',
+                mission: 'Converte visão em roadmap, experiência e valor de produto.',
+                responsibilities: ['product', 'roadmap', 'ux'],
+                defaultSquads: ['design-squad', 'ultimate-landingpage', 'project-ops-squad']
+            },
+            {
+                id: 'coo',
+                title: 'COO',
+                mission: 'Coordena operação, execução intersquads e cadência de entrega.',
+                responsibilities: ['operations', 'execution', 'cadence'],
+                defaultSquads: ['project-ops-squad', 'conselho']
+            }
+        ];
+        fs.writeFileSync(this.filePath, JSON.stringify(defaults, null, 2), 'utf-8');
+    }
+}
+exports.OrgStructure = OrgStructure;

package/dist/orchestrator/OutcomeSimulator.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutcomeSimulator = void 0;
+class OutcomeSimulator {
+    simulate(input) {
+        const hasFallback = input.preferredExecutors.length > 1;
+        if (input.governanceRisk === 'high') {
+            return {
+                predictedOutcome: 'blocked',
+                recommendedPolicy: {
+                    executionMode: 'balanced',
+                    swarmMode: 'none',
+                    maxBranches: 1,
+                    rationale: 'Risco alto: reduzir superfície de execução e exigir trilha segura.'
+                },
+                recommendedExecutors: input.preferredExecutors,
+                rationale: 'Pré-simulação prevê bloqueio/alto risco; rota conservadora aplicada.'
+            };
+        }
+        if (!hasFallback) {
+            return {
+                predictedOutcome: 'partial',
+                recommendedPolicy: {
+                    ...input.basePolicy,
+                    executionMode: 'balanced',
+                    swarmMode: 'light',
+                    maxBranches: Math.max(1, Math.min(input.basePolicy.maxBranches, 2)),
+                    rationale: 'Sem fallback robusto: reduzir paralelismo e priorizar confiabilidade.'
+                },
+                recommendedExecutors: input.preferredExecutors,
+                rationale: 'Pré-simulação detectou cadeia sem fallback; ajuste para reduzir falha total.'
+            };
+        }
+        const recommendedExecutors = [...input.preferredExecutors].sort((a, b) => {
+            const score = (x) => (x === 'codex' ? 3 : x === 'claude' ? 2 : 1);
+            return score(b) - score(a);
+        });
+        return {
+            predictedOutcome: 'success',
+            recommendedPolicy: input.basePolicy,
+            recommendedExecutors,
+            rationale: 'Pré-simulação prevê alta chance de sucesso com fallback disponível.'
+        };
+    }
+}
+exports.OutcomeSimulator = OutcomeSimulator;

package/dist/orchestrator/ParallelOrchestrationLoop.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParallelOrchestrationLoop = void 0;
+const ArbitrationAgent_1 = require("./ArbitrationAgent");
+const ArbitrationScorecard_1 = require("./ArbitrationScorecard");
+class ParallelOrchestrationLoop {
+    brain;
+    taskExecutor;
+    arbitrationAgent;
+    scorecard;
+    constructor(brain, taskExecutor) {
+        this.brain = brain;
+        this.taskExecutor = taskExecutor;
+        this.arbitrationAgent = new ArbitrationAgent_1.ArbitrationAgent(brain);
+        this.scorecard = new ArbitrationScorecard_1.ArbitrationScorecard();
+    }
+    async runResearchBranches(goal, taskId, maxBranches = 3) {
+        const baseBranches = [
+            `[Ramo 1] Faça uma análise objetiva do objetivo:\n${goal}`,
+            `[Ramo 2] Faça uma análise crítica e complementar do objetivo:\n${goal}`,
+            `[Ramo 3] Faça uma leitura estratégica e de alto nível do objetivo:\n${goal}`,
+            `[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 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
+        };
+    }
+}
+exports.ParallelOrchestrationLoop = ParallelOrchestrationLoop;

package/dist/orchestrator/PerformanceScorecard.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceScorecard = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class PerformanceScorecard {
+    filePath;
+    constructor() {
+        this.filePath = path.join(process.cwd(), '.artifacts', 'performance-scorecard.json');
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    }
+    record(entry) {
+        const all = this.getAll();
+        const current = all[entry.entityId] || {
+            entityId: entry.entityId,
+            entityType: entry.entityType,
+            runs: 0,
+            successes: 0,
+            partials: 0,
+            failures: 0,
+            avgReviewScore: 0,
+            avgDurationMs: 0,
+            fallbackRate: 0,
+            score: 0,
+            updatedAt: new Date().toISOString()
+        };
+        current.runs += 1;
+        if (entry.status === 'success')
+            current.successes += 1;
+        if (entry.status === 'partial')
+            current.partials += 1;
+        if (entry.status === 'failed')
+            current.failures += 1;
+        const reviewScore = entry.reviewScore || 0;
+        const durationMs = entry.durationMs || 0;
+        const fallback = entry.fallbackUsed ? 1 : 0;
+        current.avgReviewScore = this.runningAverage(current.avgReviewScore, reviewScore, current.runs);
+        current.avgDurationMs = this.runningAverage(current.avgDurationMs, durationMs, current.runs);
+        current.fallbackRate = this.runningAverage(current.fallbackRate, fallback, current.runs);
+        current.score = this.computeScore(current);
+        current.updatedAt = new Date().toISOString();
+        all[entry.entityId] = current;
+        fs.writeFileSync(this.filePath, JSON.stringify(all, null, 2), 'utf-8');
+    }
+    get(entityId) {
+        return this.getAll()[entityId] || null;
+    }
+    getAll() {
+        if (!fs.existsSync(this.filePath))
+            return {};
+        try {
+            return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    runningAverage(current, value, runs) {
+        if (runs <= 1)
+            return value;
+        return ((current * (runs - 1)) + value) / runs;
+    }
+    computeScore(current) {
+        return (current.successes * 2 +
+            current.partials * 0.5 -
+            current.failures * 1.5 +
+            current.avgReviewScore * 1.2 -
+            current.fallbackRate * 1.0 -
+            Math.min(current.avgDurationMs / 10000, 2));
+    }
+}
+exports.PerformanceScorecard = PerformanceScorecard;

package/dist/orchestrator/PlannerAgent.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlannerAgent = void 0;
+class PlannerAgent {
+    brain;
+    constructor(brain) {
+        this.brain = brain;
+    }
+    async plan(input, recentHistory) {
+        const prompt = `
+Você é o Planner do OpenLife.
+
+Objetivo do usuário:
+${input}
+
+Histórico recente:
+${recentHistory}
+
+Responda em JSON com:
+- normalizedGoal
+- plan (array curto, 3 a 6 passos)
+- successCriteria (array curto)
+- executionMode ('single' ou 'review_loop')
+`;
+        const raw = await this.brain.think('Planeje a execução de forma objetiva e estruturada.', prompt);
+        try {
+            const jsonStart = raw.indexOf('{');
+            const parsed = JSON.parse(jsonStart >= 0 ? raw.slice(jsonStart) : raw);
+            return {
+                normalizedGoal: parsed.normalizedGoal || input,
+                plan: Array.isArray(parsed.plan) ? parsed.plan : ['Executar a tarefa principal'],
+                successCriteria: Array.isArray(parsed.successCriteria) ? parsed.successCriteria : ['Entregar resultado útil e coerente'],
+                executionMode: parsed.executionMode === 'single' ? 'single' : 'review_loop'
+            };
+        }
+        catch {
+            return {
+                normalizedGoal: input,
+                plan: ['Entender objetivo', 'Executar tarefa principal', 'Validar resultado', 'Entregar síntese final'],
+                successCriteria: ['Resultado útil', 'Sem erro crítico', 'Resposta coerente'],
+                executionMode: 'review_loop'
+            };
+        }
+    }
+}
+exports.PlannerAgent = PlannerAgent;

package/dist/orchestrator/ProcessSandbox.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * ProcessSandbox — Story 15.1 (v1.5, research-track).
+ *
+ * Thin wrapper around `child_process.spawn` that injects Node's
+ * experimental `--permission` flag plus the per-capability `--allow-*`
+ * flags so a child node process runs inside a kernel-style sandbox.
+ *
+ * **Not wired anywhere yet** — see `docs/sandboxing-research.md` for the
+ * decision matrix. v1.5 ships this class so v1.6 can opt-in selectively
+ * (doctor script first, then TaskExecutor.runShellCommand).
+ *
+ * Graceful version downgrade:
+ *   • Node 20+ → injects `--permission` + the requested allow-list.
+ *   • Node 18  → spawns plain (no enforcement) and stamps
+ *     `result.enforced=false` so the caller can detect the downgrade.
+ *
+ * The wrapper does NOT execute anything by default. Callers must opt in
+ * by calling `.spawn(cmd, args, opts)`. There is no global side effect
+ * just by importing this module — keeping with OpenLife's lazy-import
+ * contract in src/index.ts.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessSandbox = void 0;
+const child_process = __importStar(require("child_process"));
+const MIN_PERMISSION_MAJOR = 20;
+class ProcessSandbox {
+    opts;
+    nodeMajor;
+    spawnImpl;
+    constructor(opts = {}) {
+        this.opts = opts;
+        this.nodeMajor = opts.nodeMajor ?? this.detectNodeMajor();
+        this.spawnImpl = opts.spawnImpl ?? child_process.spawn;
+    }
+    /** True when the running Node version supports the `--permission` flag. */
+    supportsEnforcement() {
+        return this.nodeMajor >= MIN_PERMISSION_MAJOR;
+    }
+    /**
+     * Build the flag list that `spawn` would prepend. Public for testability —
+     * the unit tests inspect this without spawning anything.
+     */
+    buildPermissionFlags() {
+        if (!this.supportsEnforcement())
+            return [];
+        const flags = ['--permission'];
+        for (const p of this.opts.allowFsRead || [])
+            flags.push(`--allow-fs-read=${p}`);
+        for (const p of this.opts.allowFsWrite || [])
+            flags.push(`--allow-fs-write=${p}`);
+        if (this.opts.allowChildProcess)
+            flags.push('--allow-child-process');
+        if (this.opts.allowWorker)
+            flags.push('--allow-worker');
+        if (this.opts.allowWasi)
+            flags.push('--allow-wasi');
+        if (this.opts.allowAddons)
+            flags.push('--allow-addons');
+        return flags;
+    }
+    /**
+     * Spawn `command` with `args`. When `command` is `node` (or absolute
+     * path ending in `/node`), the permission flags are inserted before
+     * the user's argv. Other commands are spawned plain — the wrapper is
+     * a no-op for non-node binaries, since Node's permission model only
+     * applies to spawning Node itself.
+     *
+     * The promise resolves with a result envelope; it never rejects.
+     * stdout/stderr are captured up to a generous default buffer.
+     */
+    async spawn(command, args = [], spawnOpts = {}) {
+        const isNode = /(?:^|\/)node(?:\.exe)?$/i.test(command) || command === 'node';
+        const permissionFlags = isNode ? this.buildPermissionFlags() : [];
+        const finalArgs = permissionFlags.length > 0 ? [...permissionFlags, ...args] : args;
+        const enforced = isNode && permissionFlags.length > 0;
+        return await new Promise((resolve) => {
+            const child = this.spawnImpl(command, finalArgs, { ...spawnOpts, stdio: ['ignore', 'pipe', 'pipe'] });
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (chunk) => { stdout += String(chunk); });
+            child.stderr?.on('data', (chunk) => { stderr += String(chunk); });
+            child.on('close', (code, signal) => {
+                resolve({ code, signal, enforced, appliedFlags: permissionFlags, stdout, stderr });
+            });
+            child.on('error', () => {
+                resolve({ code: 1, signal: null, enforced, appliedFlags: permissionFlags, stdout, stderr });
+            });
+        });
+    }
+    detectNodeMajor() {
+        const m = process.versions.node.match(/^(\d+)/);
+        return m ? Number(m[1]) : 0;
+    }
+}
+exports.ProcessSandbox = ProcessSandbox;

package/dist/orchestrator/PromotionPipeline.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromotionPipeline = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const MemoryNamespacePolicy_1 = require("../memory/MemoryNamespacePolicy");
+const MemoryPromotionFlow_1 = require("../memory/MemoryPromotionFlow");
+class PromotionPipeline {
+    filePath;
+    namespacePolicy;
+    memoryPromotion;
+    constructor() {
+        this.filePath = path.join(process.cwd(), '.artifacts', 'promotion-candidates.json');
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        this.namespacePolicy = new MemoryNamespacePolicy_1.MemoryNamespacePolicy();
+        this.memoryPromotion = new MemoryPromotionFlow_1.MemoryPromotionFlow();
+    }
+    add(candidate, context) {
+        const all = this.getAll();
+        all.push(candidate);
+        fs.writeFileSync(this.filePath, JSON.stringify(all, null, 2), 'utf-8');
+        const decision = this.namespacePolicy.decide(context || {});
+        void this.memoryPromotion.promote(candidate, decision.namespace, candidate.type === 'playbook' ? 'semantic' : 'episodic');
+    }
+    getAll() {
+        if (!fs.existsSync(this.filePath))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+    }
+    clear() {
+        fs.writeFileSync(this.filePath, JSON.stringify([], null, 2), 'utf-8');
+    }
+}
+exports.PromotionPipeline = PromotionPipeline;

package/dist/orchestrator/PromotionReviewGate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromotionReviewGate = void 0;
+class PromotionReviewGate {
+    approve(candidate) {
+        if (!candidate.summary || candidate.summary.trim().length < 20)
+            return false;
+        return true;
+    }
+}
+exports.PromotionReviewGate = PromotionReviewGate;