@openlife/cli 1.7.3

package/dist/test_reversa_contracts_e2e.js

@@ -0,0 +1,48 @@
+"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 ReversaAgent_1 = require("./reversa/ReversaAgent");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const r = new ReversaAgent_1.ReversaAgent();
+r.setMode('designmd', 'claude');
+r.runAll('contract e2e');
+const finalPath = path.join(process.cwd(), '.reversa', 'final-contracts.md');
+if (!fs.existsSync(finalPath))
+    throw new Error('final contracts file missing');
+const txt = fs.readFileSync(finalPath, 'utf-8');
+if (!txt.includes('validation_ok: true'))
+    throw new Error('contracts validation should be true');
+console.log('TEST_REVERSA_CONTRACTS_E2E_OK');

package/dist/test_reversa_export_and_strict.js

@@ -0,0 +1,51 @@
+"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 ReversaAgent_1 = require("./reversa/ReversaAgent");
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const r = new ReversaAgent_1.ReversaAgent();
+r.setMode('designmd', 'claude');
+r.runAll('strict test');
+const jsonPath = r.exportContractsJson();
+if (!fs.existsSync(jsonPath))
+    throw new Error('final-contracts.json missing');
+const data = JSON.parse(fs.readFileSync(jsonPath, 'utf-8'));
+if (!data?.validation?.ok)
+    throw new Error('validation should be ok');
+const out = (0, child_process_1.execSync)('node dist/index.js aiobuilder generate-ui dashboard --strict-contracts', { encoding: 'utf-8' });
+if (!out.includes('dashboard'))
+    throw new Error('strict generate-ui did not run');
+console.log('TEST_REVERSA_EXPORT_STRICT_OK');

package/dist/test_reversa_full_execution.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ReversaAgent_1 = require("./reversa/ReversaAgent");
+const r = new ReversaAgent_1.ReversaAgent();
+r.setMode('designmd', 'claude');
+const p1 = r.runPhase('reconnaissance', 'phase test');
+if (p1.phase !== 'reconnaissance')
+    throw new Error('runPhase should set requested phase');
+const p2 = r.runAll('all test');
+if (p2.phase !== 'review')
+    throw new Error('runAll should end in review');
+console.log('TEST_REVERSA_FULL_EXECUTION_OK');

package/dist/test_reversa_lite.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ReversaAgent_1 = require("./reversa/ReversaAgent");
+const r = new ReversaAgent_1.ReversaAgent();
+const s1 = r.resume();
+const s2 = r.advance('phase progress');
+if (!s1.phase || !s2.phase)
+    throw new Error('reversa state must have phase');
+console.log('TEST_REVERSA_LITE_OK');

package/dist/test_royal_stack_golden.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * test_royal_stack_golden.ts — Story 7.3
+ *
+ * Golden end-to-end test for v1.2 "Royal Stack".
+ *
+ * Asserts that the three pillars (Workflow + Squad/Skill Creators + Autonomy)
+ * cooperate inside a single CLI session against an isolated working tree.
+ *
+ * Sequence (all under a temp directory rooted at .artifacts/test_royal_stack/):
+ *   1. Build a tiny squad via SquadCreator (rendered from dist-templates/).
+ *   2. Build a tiny skill via SkillCreator.
+ *   3. Validate both via the CLI.
+ *   4. List built-in workflows via the CLI — assert 4 are present.
+ *   5. Validate one of the built-in workflows.
+ *   6. Run a workflow in dry-run mode and assert the state file is persisted.
+ *   7. Acquire and release a distributed lock to prove autonomy primitives work.
+ *
+ * Budget: under 60 seconds, no network calls, no LLM spend.
+ */
+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 child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CLI = path.join(process.cwd(), 'dist', 'index.js');
+function cli(args, env) {
+    const r = (0, child_process_1.spawnSync)('node', [CLI, ...args], {
+        encoding: 'utf-8',
+        timeout: 30000,
+        env: { ...process.env, ...(env || {}) },
+    });
+    return { ok: r.status === 0, status: r.status, stdout: r.stdout || '', stderr: r.stderr || '' };
+}
+function parseJson(stdout) {
+    // CLI prints surrounding chatter; pluck the first {...} block.
+    const m = stdout.match(/\{[\s\S]*\}\s*$/);
+    if (!m)
+        throw new Error(`No JSON found in stdout:\n${stdout.slice(0, 400)}`);
+    return JSON.parse(m[0]);
+}
+function makeTempDir(prefix) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    return root;
+}
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+function main() {
+    const sandboxRoot = makeTempDir('openlife-royal-stack-');
+    console.log(`[golden] sandbox: ${sandboxRoot}`);
+    // Per-test catalog + state isolation via env overrides.
+    const env = {
+        OPENLIFE_STATE_DIR: path.join(sandboxRoot, '.openlife'),
+        OPENLIFE_SQUAD_ROOT: path.join(sandboxRoot, '.catalog', 'squads'),
+        OPENLIFE_SKILL_ROOT: path.join(sandboxRoot, '.catalog', 'skills'),
+    };
+    fs.mkdirSync(env.OPENLIFE_STATE_DIR, { recursive: true });
+    fs.mkdirSync(env.OPENLIFE_SQUAD_ROOT, { recursive: true });
+    fs.mkdirSync(env.OPENLIFE_SKILL_ROOT, { recursive: true });
+    try {
+        // === Pillar 1: SquadCreator + SkillCreator (in-process — these aren't yet
+        // exposed via the CLI under sandbox env in a single shot; we call the
+        // classes directly to keep the test hermetic and fast.) ===
+        const { SquadCreator } = require(path.join(process.cwd(), 'dist', 'orchestrator', 'SquadCreator.js'));
+        const { SkillCreator } = require(path.join(process.cwd(), 'dist', 'orchestrator', 'SkillCreator.js'));
+        const sc = new SquadCreator({ catalogRoot: env.OPENLIFE_SQUAD_ROOT });
+        const squadResult = sc.create({
+            id: 'rs-golden-squad',
+            name: 'royal-stack-golden',
+            description: 'Sentinel squad for the Royal Stack golden test.',
+            version: '1.0.0',
+            agents: [
+                { id: 'agent-one', role: 'planner', description: 'Plans the work.' },
+            ],
+            tasks: [
+                { id: 'task-one', title: 'Discover', description: 'Discover the scope.' },
+            ],
+        });
+        assertTrue(squadResult.ok, 'SquadCreator.create ok');
+        console.log(`[golden] squad created at ${squadResult.squadDir}`);
+        const squadValidation = sc.validate('rs-golden-squad');
+        assertTrue(squadValidation.ok, 'SquadCreator.validate ok');
+        const skc = new SkillCreator({ catalogRoot: env.OPENLIFE_SKILL_ROOT });
+        const skillResult = skc.create({
+            id: 'rs-golden-skill',
+            name: 'royal-stack-golden-skill',
+            description: 'Sentinel skill for the Royal Stack golden test.',
+            whenToUse: ['When validating the Royal Stack pipeline'],
+            procedure: ['Run the test', 'Inspect the artifacts'],
+        });
+        assertTrue(skillResult.ok, 'SkillCreator.create ok');
+        console.log(`[golden] skill created at ${skillResult.filePath}`);
+        // === Pillar 2: Workflow list/validate/run (via CLI, hits real WorkflowEngine) ===
+        const listResult = cli(['workflow', 'list'], env);
+        assertTrue(listResult.ok, `workflow list ok (status=${listResult.status})`);
+        const listPayload = parseJson(listResult.stdout);
+        assertTrue(listPayload.ok && Array.isArray(listPayload.workflows), 'workflow list payload shape');
+        assertTrue(listPayload.workflows.length >= 4, `workflow list >= 4 (got ${listPayload.workflows.length})`);
+        console.log(`[golden] workflow list: ${listPayload.workflows.map((w) => w.id).join(', ')}`);
+        const targetWorkflow = listPayload.workflows[0];
+        const validateResult = cli(['workflow', 'validate', targetWorkflow.filePath], env);
+        assertTrue(validateResult.ok, `workflow validate ${targetWorkflow.id} ok`);
+        const runResult = cli(['workflow', 'run', targetWorkflow.filePath, '--dry-run'], env);
+        assertTrue(runResult.ok, `workflow run --dry-run ok (status=${runResult.status})`);
+        const runPayload = parseJson(runResult.stdout);
+        assertTrue(runPayload.ok, 'workflow run payload ok');
+        const runId = runPayload.state?.runId;
+        assertTrue(typeof runId === 'string' && runId.length > 0, 'runId present');
+        console.log(`[golden] workflow run ${targetWorkflow.id} → runId=${runId} state=${runPayload.state?.status}`);
+        // Confirm state file was persisted under sandbox .openlife/
+        const stateFile = path.join(env.OPENLIFE_STATE_DIR, 'workflows', `${runId}.json`);
+        assertTrue(fs.existsSync(stateFile), `workflow state file persisted at ${stateFile}`);
+        const statusResult = cli(['workflow', 'status', runId], env);
+        assertTrue(statusResult.ok, 'workflow status ok');
+        // === Pillar 3: Autonomy primitives (DistributedLock in-process) ===
+        const { DistributedLock } = require(path.join(process.cwd(), 'dist', 'orchestrator', 'util', 'DistributedLock.js'));
+        const lock = new DistributedLock({ stateDir: env.OPENLIFE_STATE_DIR });
+        const acquired = lock.acquire('rs-golden-lock', 5000);
+        assertTrue(acquired.ok, 'lock acquire ok');
+        const reacquired = lock.acquire('rs-golden-lock', 5000);
+        assertTrue(!reacquired.ok, 'second lock acquire blocked while held');
+        lock.release(acquired.lockId); // returns void; throws on failure
+        // Peek confirms the lock is gone.
+        assertTrue(lock.peek('rs-golden-lock') === null, 'lock peek empty after release');
+        const reacquiredAfterRelease = lock.acquire('rs-golden-lock', 5000);
+        assertTrue(reacquiredAfterRelease.ok, 'lock re-acquirable after release');
+        lock.release(reacquiredAfterRelease.lockId);
+        console.log('[golden] all three pillars cooperate.');
+        console.log('TEST_ROYAL_STACK_GOLDEN_OK');
+    }
+    finally {
+        try {
+            fs.rmSync(sandboxRoot, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }
+}
+try {
+    main();
+}
+catch (err) {
+    console.error('[golden] FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+}

package/dist/test_runtime_health_backoff.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * test_runtime_health_backoff — Story 6.5 regression suite.
+ *
+ * Three scenarios:
+ *   1. Exponential schedule: failure N produces delay ≈ 10s * 2^(N-1)
+ *      with a 1h cap; explicit unit test on the pure function.
+ *   2. markFailure + markHealthy: failures accumulate, until extends with
+ *      backoff, markHealthy resets to failures=0 and clears
+ *      permanentlyDown.
+ *   3. Retry budget breach: more than MAX_FAILURES failures within the
+ *      window flips permanentlyDown=true and isCoolingDown()=true.
+ *
+ * Prints TEST_RUNTIME_HEALTH_BACKOFF_OK on full pass.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const RuntimeHealthMonitor_1 = require("./orchestrator/RuntimeHealthMonitor");
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`assertion failed: ${msg}`);
+}
+function mkTmp() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'rh-test-'));
+}
+function rmTmp(dir) {
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 1 — pure backoff function
+// ─────────────────────────────────────────────────────────────
+function scenarioBackoffFunction() {
+    assert((0, RuntimeHealthMonitor_1.exponentialBackoffDelayMs)(1) === RuntimeHealthMonitor_1.BASE_DELAY_MS, 'failure 1 = base');
+    assert((0, RuntimeHealthMonitor_1.exponentialBackoffDelayMs)(2) === RuntimeHealthMonitor_1.BASE_DELAY_MS * 2, 'failure 2 = 2x');
+    assert((0, RuntimeHealthMonitor_1.exponentialBackoffDelayMs)(3) === RuntimeHealthMonitor_1.BASE_DELAY_MS * 4, 'failure 3 = 4x');
+    assert((0, RuntimeHealthMonitor_1.exponentialBackoffDelayMs)(4) === RuntimeHealthMonitor_1.BASE_DELAY_MS * 8, 'failure 4 = 8x');
+    // Cap at MAX_DELAY_MS — failure count above the cap stays capped
+    assert((0, RuntimeHealthMonitor_1.exponentialBackoffDelayMs)(100) === RuntimeHealthMonitor_1.MAX_DELAY_MS, 'failure 100 = cap');
+    assert((0, RuntimeHealthMonitor_1.exponentialBackoffDelayMs)(0) === RuntimeHealthMonitor_1.BASE_DELAY_MS, 'failure 0 = base (defensive)');
+    console.log('✅ scenario 1: exponential backoff function (base + cap + clamp)');
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 2 — failure accumulation + recovery
+// ─────────────────────────────────────────────────────────────
+function scenarioAccumulateAndRecover() {
+    const tmp = mkTmp();
+    try {
+        const monitor = new RuntimeHealthMonitor_1.RuntimeHealthMonitor(tmp);
+        monitor.markFailure('codex', 'timeout');
+        const after1 = monitor.get('codex');
+        assert(after1?.failures === 1, 'failures after first call = 1');
+        assert(after1.until !== undefined, 'until must be set');
+        assert(after1.permanentlyDown !== true, 'must not be permanently down after one failure');
+        assert(monitor.isCoolingDown('codex') === true, 'must be cooling down');
+        monitor.markFailure('codex', 'timeout again');
+        const after2 = monitor.get('codex');
+        assert(after2?.failures === 2, 'failures after second call = 2');
+        // Until extends — second failure has a larger backoff than first
+        const after1UntilMs = new Date(after1.until).getTime();
+        const after2UntilMs = new Date(after2.until).getTime();
+        assert(after2UntilMs > after1UntilMs, `second until must be later: ${after2UntilMs} vs ${after1UntilMs}`);
+        // markHealthy resets
+        monitor.markHealthy('codex');
+        const recovered = monitor.get('codex');
+        assert(recovered?.failures === 0, 'failures reset on markHealthy');
+        assert(recovered.permanentlyDown !== true, 'permanentlyDown cleared on markHealthy');
+        assert(monitor.isCoolingDown('codex') === false, 'no longer cooling down after markHealthy');
+        console.log('✅ scenario 2: accumulate failures + markHealthy resets');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 3 — retry budget exhausted → permanentlyDown
+// ─────────────────────────────────────────────────────────────
+function scenarioBudgetExhausted() {
+    const tmp = mkTmp();
+    try {
+        const monitor = new RuntimeHealthMonitor_1.RuntimeHealthMonitor(tmp);
+        // Drive failures past MAX_FAILURES
+        for (let i = 0; i < RuntimeHealthMonitor_1.MAX_FAILURES + 2; i++) {
+            monitor.markFailure('gemini', `failure ${i + 1}`);
+        }
+        const final = monitor.get('gemini');
+        assert(final?.failures === RuntimeHealthMonitor_1.MAX_FAILURES + 2, `expected ${RuntimeHealthMonitor_1.MAX_FAILURES + 2} failures, got ${final?.failures}`);
+        assert(final.permanentlyDown === true, 'must be permanently down past budget');
+        assert(monitor.isCoolingDown('gemini') === true, 'permanentlyDown implies cooling down');
+        assert(final.until === undefined, 'permanentlyDown means no scheduled retry');
+        // markHealthy reverts even from permanentlyDown (manual reset surface)
+        monitor.markHealthy('gemini');
+        assert(monitor.get('gemini')?.permanentlyDown !== true, 'manual reset clears permanentlyDown');
+        console.log('✅ scenario 3: retry budget exhausted → permanentlyDown + manual reset');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Driver
+// ─────────────────────────────────────────────────────────────
+function main() {
+    console.log('🧪 test_runtime_health_backoff — Story 6.5 regression suite');
+    scenarioBackoffFunction();
+    scenarioAccumulateAndRecover();
+    scenarioBudgetExhausted();
+    console.log('');
+    console.log('TEST_RUNTIME_HEALTH_BACKOFF_OK');
+}
+try {
+    main();
+}
+catch (err) {
+    console.error('❌ test_runtime_health_backoff FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+}

package/dist/test_runtime_policy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimePolicy_1 = require("./orchestrator/RuntimePolicy");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const runtime = new RuntimePolicy_1.RuntimePolicy();
+    runtime.recordResult('gemini', false, 'quota exhausted');
+    runtime.recordResult('claude', false, 'auth expired');
+    runtime.recordResult('codex', true, 'ok');
+    const research = runtime.decide('RESEARCH_ANALYSIS');
+    assert(!research.preferred.includes('gemini'), 'gemini should enter cooldown after quota failure');
+    assert(research.preferred.includes('codex'), 'research should fallback to codex when gemini is unhealthy');
+    const engineering = runtime.decide('ENGINEERING_BUILD');
+    assert(!engineering.preferred.includes('claude'), 'claude should enter cooldown after auth failure');
+    assert(engineering.preferred[0] === 'codex', 'codex should become preferred when secondary executors cool down');
+    const snapshot = runtime.saveSnapshot();
+    assert(!!snapshot, 'runtime policy snapshot should be saved');
+    console.log('TEST_RUNTIME_POLICY_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_runtime_probe.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeProbe_1 = require("./orchestrator/RuntimeProbe");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const probe = new RuntimeProbe_1.RuntimeProbe();
+    const results = await probe.probeAll();
+    assert(results.length === 4, 'should probe all four executors');
+    assert(results.every((result) => Array.isArray(result.command) && result.command.length > 0), 'every probe should expose the command used');
+    assert(results.every((result) => typeof result.available === 'boolean'), 'every probe should report availability');
+    console.log('TEST_RUNTIME_PROBE_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});