@openlife/cli 1.7.3

package/dist/test_multi_host_docs_parity.js

@@ -0,0 +1,125 @@
+"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 });
+/*
+ * Story 3.6 — multi-host install docs parity regression test.
+ *
+ * Asserts:
+ * 1. INSTALL.md mentions all three hosts (claude-code, gemini-cli, codex)
+ * 2. INSTALL.md mentions `openlife init`, `openlife system setup`, `openlife system uninstall`
+ * 3. INSTALL.md mentions at least one host-detection env var (CLAUDECODE, GEMINI_CONFIG_DIR, CODEX_HOME)
+ * 4. README.md links to INSTALL.md
+ * 5. docs/install/{claude-code,gemini-cli,codex}.md all exist
+ * 6. Each per-host doc has > 500 characters (not a stub-of-a-stub)
+ * 7. Each per-host doc mentions its own host name
+ * 8. gemini-cli + codex docs mention `HOST_NOT_YET_SUPPORTED` or "reserved for v1.1" so the
+ *    deferral is explicit and the doc cannot drift into claiming support that does not exist.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`ASSERTION_FAILED: ${msg}`);
+}
+const ROOT = path.resolve(__dirname, '..');
+const INSTALL_MD = path.join(ROOT, 'INSTALL.md');
+const README_MD = path.join(ROOT, 'README.md');
+const INSTALL_DOCS_DIR = path.join(ROOT, 'docs', 'install');
+function readFile(file) {
+    assert(fs.existsSync(file), `${file} must exist`);
+    return fs.readFileSync(file, 'utf-8');
+}
+function testInstallMdMentionsAllHosts() {
+    const content = readFile(INSTALL_MD);
+    for (const host of ['claude-code', 'gemini-cli', 'codex']) {
+        assert(content.includes(host), `INSTALL.md must mention host "${host}"`);
+    }
+}
+function testInstallMdMentionsKeyCommands() {
+    const content = readFile(INSTALL_MD);
+    for (const cmd of ['openlife init', 'openlife system setup', 'openlife system uninstall']) {
+        assert(content.includes(cmd), `INSTALL.md must mention command "${cmd}"`);
+    }
+}
+function testInstallMdMentionsDetectionEnvVar() {
+    const content = readFile(INSTALL_MD);
+    const envVars = ['CLAUDECODE', 'GEMINI_CONFIG_DIR', 'CODEX_HOME'];
+    const found = envVars.filter((v) => content.includes(v));
+    assert(found.length >= 1, `INSTALL.md must mention at least one host-detection env var (one of ${envVars.join(', ')}); got 0`);
+}
+function testReadmeLinksToInstallMd() {
+    const content = readFile(README_MD);
+    // Accept any of: bare link, markdown link, or relative reference
+    const linkPatterns = ['INSTALL.md', '(INSTALL.md)', '[INSTALL.md]'];
+    const matched = linkPatterns.some((p) => content.includes(p));
+    assert(matched, 'README.md must link to INSTALL.md');
+}
+function testPerHostDocsExist() {
+    for (const host of ['claude-code', 'gemini-cli', 'codex']) {
+        const file = path.join(INSTALL_DOCS_DIR, `${host}.md`);
+        assert(fs.existsSync(file), `docs/install/${host}.md must exist`);
+    }
+}
+function testPerHostDocsSubstantive() {
+    for (const host of ['claude-code', 'gemini-cli', 'codex']) {
+        const file = path.join(INSTALL_DOCS_DIR, `${host}.md`);
+        const content = readFile(file);
+        assert(content.length > 500, `docs/install/${host}.md too short (${content.length} chars) — should be > 500`);
+        assert(content.includes(host), `docs/install/${host}.md must mention its own host name "${host}"`);
+    }
+}
+function testReservedHostsAreExplicit() {
+    for (const host of ['gemini-cli', 'codex']) {
+        const file = path.join(INSTALL_DOCS_DIR, `${host}.md`);
+        const content = readFile(file);
+        const hasDeferralMarker = content.includes('HOST_NOT_YET_SUPPORTED') ||
+            /reserved for v1\.1/i.test(content);
+        assert(hasDeferralMarker, `docs/install/${host}.md must explicitly mark deferral (HOST_NOT_YET_SUPPORTED or "reserved for v1.1")`);
+    }
+}
+async function main() {
+    testInstallMdMentionsAllHosts();
+    testInstallMdMentionsKeyCommands();
+    testInstallMdMentionsDetectionEnvVar();
+    testReadmeLinksToInstallMd();
+    testPerHostDocsExist();
+    testPerHostDocsSubstantive();
+    testReservedHostsAreExplicit();
+    console.log('TEST_MULTI_HOST_DOCS_PARITY_OK');
+}
+main().catch((err) => {
+    console.error('TEST_MULTI_HOST_DOCS_PARITY_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_openlife_auto_creator_routing.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const slug = `quantum-biofabrication-${Date.now()}`;
+const goal = `orquestrar ${slug} com pesquisa, agente especialista, squad e skill operacional`;
+const runJson = (args) => {
+    const r = (0, child_process_1.spawnSync)('node', ['bin/openlife.js', ...args], { cwd: process.cwd(), encoding: 'utf-8' });
+    assert_1.strict.equal(r.status, 0, `${args.join(' ')} failed: ${r.stderr || r.stdout}`);
+    return JSON.parse(r.stdout);
+};
+const route = runJson(['route', 'intent', goal, '--auto-create', '--min-score', '999', '--create-prefix', slug, '--limit', '3']);
+assert_1.strict.equal(route.ok, true);
+assert_1.strict.equal(route.autoCreate.enabled, true);
+assert_1.strict.ok(route.autoCreate.created.length >= 3, 'should create agent, squad and skill drafts when coverage is insufficient');
+assert_1.strict.ok(route.autoCreate.created.some((x) => x.type === 'agent'));
+assert_1.strict.ok(route.autoCreate.created.some((x) => x.type === 'squad'));
+assert_1.strict.ok(route.autoCreate.created.some((x) => x.type === 'skill'));
+assert_1.strict.ok(route.autoCreate.created.some((x) => x.id.includes('squad')), 'slug normalization must preserve the letter u in squad');
+for (const item of route.autoCreate.created) {
+    assert_1.strict.ok(fs.existsSync(item.path), `created path missing: ${item.path}`);
+    const body = fs.readFileSync(item.path, 'utf-8');
+    assert_1.strict.ok(body.includes('source: aiobuilder-auto-route'));
+    assert_1.strict.ok(body.includes(goal));
+}
+const strict = runJson(['catalog', 'doctor', '--strict']);
+assert_1.strict.equal(strict.ok, true);
+assert_1.strict.equal(strict.summary.agents.demo + strict.summary.agents.test, 0);
+assert_1.strict.equal(strict.summary.squads.demo + strict.summary.squads.test, 0);
+assert_1.strict.equal(strict.summary.skills.demo + strict.summary.skills.test, 0);
+for (const item of route.autoCreate.created) {
+    fs.rmSync(path.dirname(item.path), { recursive: true, force: true });
+}
+console.log('TEST_OPENLIFE_AUTO_CREATOR_ROUTING_OK');

package/dist/test_openlife_evolution_surface.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runJson = (args) => {
+    const r = (0, child_process_1.spawnSync)('node', ['bin/openlife.js', ...args], { cwd: process.cwd(), encoding: 'utf-8' });
+    assert_1.strict.equal(r.status, 0, `${args.join(' ')} failed: ${r.stderr || r.stdout}`);
+    return JSON.parse(r.stdout);
+};
+const catalog = runJson(['catalog', 'doctor']);
+assert_1.strict.equal(catalog.ok, true);
+assert_1.strict.equal(catalog.warnings.length, 0, 'catalog doctor should not warn about demo/test assets after cleanup');
+assert_1.strict.ok(catalog.summary.agents.total >= 300, `expected >=300 agents, got ${catalog.summary.agents.total}`);
+const strictPayload = runJson(['catalog', 'doctor', '--strict']);
+assert_1.strict.equal(strictPayload.strict, true);
+assert_1.strict.equal(strictPayload.ok, true);
+assert_1.strict.ok(catalog.summary.squads.total >= 40, `expected >=40 squads, got ${catalog.summary.squads.total}`);
+const mediaDoctor = runJson(['media', 'doctor']);
+assert_1.strict.equal(mediaDoctor.ok, true);
+assert_1.strict.equal(mediaDoctor.checks.some((c) => c.name === 'media:prefer-gemini-default' && c.ok), true);
+const agents = runJson(['agents', 'list']);
+assert_1.strict.ok(agents.total >= 300, `expected runtime agents >=300, got ${agents.total}`);
+assert_1.strict.ok(String(agents.source).includes('.catalog/agents'));
+const swarm = runJson(['swarm', 'run', 'teste de superfície evolutiva']);
+assert_1.strict.equal(swarm.ok, true);
+assert_1.strict.ok(fs.existsSync(swarm.artifactPath));
+assert_1.strict.deepEqual(swarm.pipeline, ['planner', 'executor', 'reviewer', 'synthesizer']);
+const aiobuilder = runJson(['aiobuilder', 'validate-catalog']);
+assert_1.strict.equal(aiobuilder.ok, true);
+assert_1.strict.ok(aiobuilder.agents.total >= 300);
+const serviceId = `surface-${Date.now()}`;
+const service = runJson(['service', 'create', serviceId, '--objective', 'Teste de superfície service-centric']);
+assert_1.strict.equal(service.ok, true);
+const services = runJson(['service', 'list']);
+assert_1.strict.ok(Array.isArray(services));
+assert_1.strict.ok(services.some((s) => s.serviceId === serviceId));
+const task = runJson(['task', 'run', 'validar task run', '--service', serviceId]);
+assert_1.strict.equal(task.ok, true);
+assert_1.strict.ok(task.taskId);
+const taskPath = path.join(process.cwd(), '.artifacts', 'missions', `${task.taskId}.json`);
+assert_1.strict.ok(fs.existsSync(taskPath));
+console.log('TEST_OPENLIFE_EVOLUTION_SURFACE_OK');

package/dist/test_openlife_gatekeeper_routing.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const child_process_1 = require("child_process");
+const r = (0, child_process_1.spawnSync)('node', ['bin/openlife.js', 'ask', 'roteie esta missão: criar landing page com design copy e deploy no github'], {
+    cwd: process.cwd(),
+    encoding: 'utf-8',
+    env: { ...process.env, OPENLIFE_ASK_TIMEOUT_MS: '30000' }
+});
+assert_1.strict.equal(r.status, 0, r.stderr || r.stdout);
+assert_1.strict.ok(r.stdout.includes('Roteamento OpenLife:'), r.stdout);
+assert_1.strict.ok(r.stdout.includes('Squad:'), r.stdout);
+assert_1.strict.ok(r.stdout.includes('Agente:'), r.stdout);
+assert_1.strict.ok(r.stdout.includes('Skill:'), r.stdout);
+console.log('TEST_OPENLIFE_GATEKEEPER_ROUTING_OK');

package/dist/test_openlife_routing_surface.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const child_process_1 = require("child_process");
+const runJson = (args) => {
+    const r = (0, child_process_1.spawnSync)('node', ['bin/openlife.js', ...args], { cwd: process.cwd(), encoding: 'utf-8' });
+    assert_1.strict.equal(r.status, 0, `${args.join(' ')} failed: ${r.stderr || r.stdout}`);
+    return JSON.parse(r.stdout);
+};
+const catalog = runJson(['catalog', 'doctor', '--strict']);
+assert_1.strict.equal(catalog.ok, true);
+assert_1.strict.ok(catalog.summary.skills.total >= 50, `expected >=50 imported skills, got ${catalog.summary.skills.total}`);
+const skills = runJson(['skills', 'list']);
+assert_1.strict.ok(skills.total >= 50, `expected runtime skills >=50, got ${skills.total}`);
+assert_1.strict.ok(String(skills.source || skills.sources || '').includes('.catalog/skills'));
+assert_1.strict.ok(skills.items.some((s) => s.id === 'github'));
+assert_1.strict.ok(skills.items.some((s) => s.id === 'gemini'));
+const route = runJson(['route', 'intent', 'criar landing page com design, copy e deploy no github']);
+assert_1.strict.equal(route.ok, true);
+assert_1.strict.equal(route.type, 'openlife.route.intent');
+assert_1.strict.ok(route.intent);
+assert_1.strict.ok(Array.isArray(route.squads) && route.squads.length > 0, 'expected squad recommendations');
+assert_1.strict.ok(Array.isArray(route.agents) && route.agents.length > 0, 'expected agent recommendations');
+assert_1.strict.ok(Array.isArray(route.skills) && route.skills.length > 0, 'expected skill recommendations');
+assert_1.strict.ok(route.squads[0].score >= route.squads[route.squads.length - 1].score);
+assert_1.strict.ok(route.skills.some((s) => ['github', 'gemini', 'canvas', 'coding-agent'].includes(s.id)));
+console.log('TEST_OPENLIFE_ROUTING_SURFACE_OK');

package/dist/test_openlife_runtime_source_truth.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const AgentRegistry_1 = require("./orchestrator/AgentRegistry");
+const SquadRegistry_1 = require("./orchestrator/SquadRegistry");
+const WorldClassCommands_1 = require("./cli/WorldClassCommands");
+const forbidden = 'Life_Tech_IA/Segundo Cerebro_Rafael_Local/LARA';
+delete process.env.OPENLIFE_AGENT_ROOTS;
+delete process.env.OPENLIFE_SQUAD_ROOT;
+delete process.env.OPENLIFE_CLOUD_AGENTS_FILE;
+delete process.env.OPENLIFE_CLOUD_SQUADS_FILE;
+const agents = new AgentRegistry_1.AgentRegistry().all();
+const squads = new SquadRegistry_1.SquadRegistry().all();
+const world = new WorldClassCommands_1.WorldClassCommands();
+const agentList = world.agentsListReal();
+const squadList = world.squadsListReal();
+(0, assert_1.strict)(!agentList.source.includes(forbidden), `agents list source must not default to Obsidian/LARA: ${agentList.source}`);
+(0, assert_1.strict)(!squadList.source.includes(forbidden), `squads list source must not default to Obsidian/LARA: ${squadList.source}`);
+for (const agent of agents) {
+    (0, assert_1.strict)(!agent.sourcePath.includes(forbidden), `agent sourcePath must not default to Obsidian/LARA: ${agent.sourcePath}`);
+}
+for (const squad of squads) {
+    (0, assert_1.strict)(!squad.sourcePath.includes(forbidden), `squad sourcePath must not default to Obsidian/LARA: ${squad.sourcePath}`);
+}
+console.log('TEST_OPENLIFE_RUNTIME_SOURCE_TRUTH_OK');

package/dist/test_operating_system.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExecutionBoard_1 = require("./orchestrator/ExecutionBoard");
+const RoleHandoff_1 = require("./orchestrator/RoleHandoff");
+const CadenceEngine_1 = require("./orchestrator/CadenceEngine");
+const OperatingSystem_1 = require("./orchestrator/OperatingSystem");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const board = new ExecutionBoard_1.ExecutionBoard();
+    const handoff = new RoleHandoff_1.RoleHandoff();
+    const cadence = new CadenceEngine_1.CadenceEngine();
+    const ops = new OperatingSystem_1.OperatingSystem();
+    board.add({
+        id: 'ops-mission-1',
+        title: 'Missão operacional',
+        ownerRole: 'cpo',
+        status: 'done',
+        priority: 'medium',
+        dependencies: [],
+        slaHours: 48,
+        notes: 'teste ops'
+    });
+    handoff.create({
+        id: 'ops-handoff-1',
+        fromRole: 'cpo',
+        toRole: 'cto',
+        missionId: 'ops-mission-1',
+        summary: 'Executar a decisão técnica',
+        status: 'accepted'
+    });
+    cadence.schedule('review', 'Review ops-mission-1', 'cto', 'ops-mission-1');
+    const decision = ops.decide('ops-mission-1');
+    assert(decision.effectiveOwnerRole === 'cto', 'handoff should influence owner role');
+    assert(decision.shouldRelease === true, 'done mission with review and no blockers should be releasable');
+    const weekly = ops.scheduleWeeklyCadence();
+    assert(weekly.length === 3, 'weekly cadence should create planning/review/release events');
+    console.log('TEST_OPERATING_SYSTEM_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_optimization_loop.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PerformanceScorecard_1 = require("./orchestrator/PerformanceScorecard");
+const OptimizationLoop_1 = require("./orchestrator/OptimizationLoop");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const scorecard = new PerformanceScorecard_1.PerformanceScorecard();
+    const optimization = new OptimizationLoop_1.OptimizationLoop();
+    scorecard.record({
+        entityId: 'skill-research',
+        entityType: 'skill',
+        status: 'failed',
+        durationMs: 14000,
+        reviewScore: 4,
+        fallbackUsed: true,
+        timestamp: new Date().toISOString()
+    });
+    scorecard.record({
+        entityId: 'skill-research',
+        entityType: 'skill',
+        status: 'partial',
+        durationMs: 12000,
+        reviewScore: 5,
+        fallbackUsed: true,
+        timestamp: new Date().toISOString()
+    });
+    const suggestions = optimization.generateSuggestions();
+    assert(suggestions.length >= 1, 'should generate at least one optimization suggestion');
+    assert(suggestions.some((item) => item.entityId === 'skill-research'), 'should flag low-performing entity');
+    console.log('TEST_OPTIMIZATION_LOOP_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_orchestration_assets_lifecycle.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SquadAutoCreator_1 = require("./orchestrator/SquadAutoCreator");
+const SubagentLifecycle_1 = require("./orchestrator/SubagentLifecycle");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function cleanup(target) {
+    if (fs.existsSync(target))
+        fs.rmSync(target, { recursive: true, force: true });
+}
+async function main() {
+    const root = path.join(process.cwd(), '.artifacts', 'test-orchestration-assets-lifecycle');
+    const assetsDir = path.join(root, 'cloud-assets');
+    const lifecycleFile = path.join(root, 'cloud-subagents.json');
+    cleanup(root);
+    fs.mkdirSync(root, { recursive: true });
+    const creator = new SquadAutoCreator_1.SquadAutoCreator(assetsDir);
+    creator.create('goal one', 'squad-test');
+    creator.create('goal two', 'squad-test');
+    const squadDir = path.join(assetsDir, 'squads', 'squad-test');
+    assert(fs.existsSync(path.join(squadDir, 'principal-agent.json')), 'should create principal-agent.json');
+    assert(fs.existsSync(path.join(squadDir, 'usage-index.json')), 'should create usage-index.json');
+    assert(fs.existsSync(path.join(squadDir, 'workflow-initial.json')), 'should create workflow-initial.json');
+    assert(fs.existsSync(path.join(squadDir, 'operational-note.json')), 'should create operational-note.json');
+    assert(fs.existsSync(path.join(squadDir, 'versions')), 'should create versioned snapshots on repeated create');
+    const lifecycle = new SubagentLifecycle_1.SubagentLifecycle(lifecycleFile);
+    const item = lifecycle.create('Agent A', ['analyze']);
+    const trial = lifecycle.transition(item.id, 'trial');
+    assert(trial?.state === 'trial', 'should transition proposed -> trial');
+    const active = lifecycle.transition(item.id, 'active');
+    assert(active?.state === 'active', 'should transition trial -> active');
+    const invalid = lifecycle.transition(item.id, 'proposed');
+    assert(invalid === null, 'should reject invalid backward transition active -> proposed');
+    const archived = lifecycle.transition(item.id, 'archived');
+    assert(archived?.state === 'archived', 'should transition active -> archived');
+    console.log('TEST_ORCHESTRATION_ASSETS_LIFECYCLE_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_outcome_simulator.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const OutcomeSimulator_1 = require("./orchestrator/OutcomeSimulator");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const simulator = new OutcomeSimulator_1.OutcomeSimulator();
+    const highRisk = simulator.simulate({
+        goal: 'deploy prod com força',
+        governanceRisk: 'high',
+        preferredExecutors: ['codex', 'claude'],
+        basePolicy: { executionMode: 'elite', swarmMode: 'consensus', maxBranches: 4, rationale: 'base' }
+    });
+    assert(highRisk.predictedOutcome === 'blocked', 'high risk should predict blocked');
+    assert(highRisk.recommendedPolicy.swarmMode === 'none', 'high risk should reduce swarm mode');
+    const noFallback = simulator.simulate({
+        goal: 'task',
+        governanceRisk: 'low',
+        preferredExecutors: ['gemini'],
+        basePolicy: { executionMode: 'performance', swarmMode: 'parallel', maxBranches: 3, rationale: 'base' }
+    });
+    assert(noFallback.predictedOutcome === 'partial', 'single executor should predict partial');
+    const healthy = simulator.simulate({
+        goal: 'task',
+        governanceRisk: 'low',
+        preferredExecutors: ['gemini', 'claude', 'codex'],
+        basePolicy: { executionMode: 'balanced', swarmMode: 'light', maxBranches: 2, rationale: 'base' }
+    });
+    assert(healthy.predictedOutcome === 'success', 'multi fallback should predict success');
+    assert(healthy.recommendedExecutors[0] === 'codex', 'should prioritize codex in recommended order');
+    console.log('TEST_OUTCOME_SIMULATOR_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});