@openlife/cli 1.7.3

package/dist/test_atomic_writer.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * test_atomic_writer — Story 6.1 regression suite.
+ *
+ * Asserts the AtomicWriter contract:
+ *   1. Happy path round-trip
+ *   2. Crash safety (rename failure leaves no corrupted final file)
+ *   3. OPENLIFE_ATOMIC_WRITES=off fallback to plain writeFileSync
+ *   4. JSONL append atomicity
+ *
+ * Run via: `npm run test:atomic-writer` (compiles + executes dist/).
+ *
+ * Pattern: throws or process.exit(1) on failure; prints
+ * TEST_ATOMIC_WRITER_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 AtomicWriter_1 = require("./orchestrator/util/AtomicWriter");
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`assertion failed: ${msg}`);
+}
+function mkTmp() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'atomic-test-'));
+}
+function rmTmp(dir) {
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}
+function listTempOrphans(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir).filter((f) => /\.tmp\.\d+\.\d+\.[a-z0-9]+$/i.test(f));
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 1: Happy path round-trip
+// ─────────────────────────────────────────────────────────────
+function scenarioHappyPath() {
+    const tmpRoot = mkTmp();
+    try {
+        const target = path.join(tmpRoot, 'state.json');
+        const payload = { hello: 'world', count: 42, nested: { ok: true } };
+        (0, AtomicWriter_1.writeJsonAtomic)(target, payload);
+        assert(fs.existsSync(target), 'final file must exist after writeJsonAtomic');
+        const read = JSON.parse(fs.readFileSync(target, 'utf-8'));
+        assert(JSON.stringify(read) === JSON.stringify(payload), 'round-trip mismatch');
+        assert(listTempOrphans(tmpRoot).length === 0, 'no temp file should remain after success');
+        console.log('✅ scenario 1: happy path round-trip');
+    }
+    finally {
+        rmTmp(tmpRoot);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 2: Crash safety — rename fails, no corrupted file
+// ─────────────────────────────────────────────────────────────
+function scenarioCrashSafety() {
+    const tmpRoot = mkTmp();
+    try {
+        // Pre-existing file in valid parent that we expect to remain unchanged
+        const target = path.join(tmpRoot, 'state.json');
+        fs.writeFileSync(target, JSON.stringify({ before: 'unchanged' }), 'utf-8');
+        // Simulate "crash mid-write" by aiming at a target whose parent
+        // exists at writeJsonAtomic call time but is deleted before the rename
+        // could succeed. We can't reliably race that, so instead we trigger a
+        // hard error path: pre-create the final path as a *directory*, which
+        // makes renameSync throw with EISDIR / EEXIST.
+        //
+        // This exercises the same code path: write tmp → attempt rename → throw
+        // → ensure pre-existing data on `target` is untouched + temp orphan
+        // cleaned up.
+        const collidingDir = path.join(tmpRoot, 'collision');
+        fs.mkdirSync(collidingDir, { recursive: true });
+        // Place a file inside so the dir is non-empty — renameSync onto a
+        // non-empty dir is guaranteed to fail across POSIX + Windows.
+        fs.writeFileSync(path.join(collidingDir, 'sentinel'), 'x', 'utf-8');
+        let threw = false;
+        try {
+            (0, AtomicWriter_1.writeJsonAtomic)(collidingDir, { after: 'never-arrives' });
+        }
+        catch (err) {
+            threw = err instanceof Error;
+        }
+        assert(threw, 'writeJsonAtomic must throw when the rename target is a non-empty directory');
+        // The colliding directory should still contain its sentinel — no corruption
+        assert(fs.existsSync(path.join(collidingDir, 'sentinel')), 'colliding dir contents must not be wiped');
+        // The original target should be untouched (we never wrote to it on this attempt)
+        const stillThere = JSON.parse(fs.readFileSync(target, 'utf-8'));
+        assert(stillThere.before === 'unchanged', 'pre-existing target must not be overwritten by failed call');
+        // purgeStaleTempFiles should be invocable + non-error (cleanup helper)
+        const removed = (0, AtomicWriter_1.purgeStaleTempFiles)(tmpRoot, 0);
+        assert(typeof removed === 'number' && removed >= 0, 'purgeStaleTempFiles must return a non-negative count');
+        console.log('✅ scenario 2: crash safety (rename failure does not corrupt existing data)');
+    }
+    finally {
+        rmTmp(tmpRoot);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 3: OPENLIFE_ATOMIC_WRITES=off fallback
+// ─────────────────────────────────────────────────────────────
+function scenarioFallback() {
+    const tmpRoot = mkTmp();
+    const prev = process.env.OPENLIFE_ATOMIC_WRITES;
+    try {
+        process.env.OPENLIFE_ATOMIC_WRITES = 'off';
+        assert((0, AtomicWriter_1._isAtomicEnabled)() === false, 'flag=off must disable atomic mode');
+        const target = path.join(tmpRoot, 'state.json');
+        (0, AtomicWriter_1.writeJsonAtomic)(target, { mode: 'fallback' });
+        assert(fs.existsSync(target), 'fallback mode must still write file');
+        const read = JSON.parse(fs.readFileSync(target, 'utf-8'));
+        assert(read.mode === 'fallback', 'fallback content must be intact');
+        assert(listTempOrphans(tmpRoot).length === 0, 'fallback mode must not create temp files');
+        // Restore — re-check enabled
+        delete process.env.OPENLIFE_ATOMIC_WRITES;
+        assert((0, AtomicWriter_1._isAtomicEnabled)() === true, 'default (no env) must be atomic enabled');
+        console.log('✅ scenario 3: OPENLIFE_ATOMIC_WRITES=off fallback');
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.OPENLIFE_ATOMIC_WRITES;
+        else
+            process.env.OPENLIFE_ATOMIC_WRITES = prev;
+        rmTmp(tmpRoot);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 4: JSONL append atomicity
+// ─────────────────────────────────────────────────────────────
+function scenarioJsonlAppend() {
+    const tmpRoot = mkTmp();
+    try {
+        const target = path.join(tmpRoot, 'events.jsonl');
+        (0, AtomicWriter_1.appendJsonlAtomic)(target, { type: 'a', n: 1 });
+        (0, AtomicWriter_1.appendJsonlAtomic)(target, { type: 'b', n: 2 });
+        (0, AtomicWriter_1.appendJsonlAtomic)(target, { type: 'c', n: 3, nested: { ok: true } });
+        const lines = fs.readFileSync(target, 'utf-8').split('\n').filter((l) => l.length > 0);
+        assert(lines.length === 3, `expected 3 JSONL lines, got ${lines.length}`);
+        const parsed = lines.map((l) => JSON.parse(l));
+        assert(parsed[0].type === 'a' && parsed[0].n === 1, 'line 1 mismatch');
+        assert(parsed[1].type === 'b' && parsed[1].n === 2, 'line 2 mismatch');
+        assert(parsed[2].type === 'c' && parsed[2].n === 3, 'line 3 mismatch');
+        assert(listTempOrphans(tmpRoot).length === 0, 'no temp orphans after JSONL appends');
+        // Also write to non-existing parent dir to verify auto-mkdir
+        const nested = path.join(tmpRoot, 'deeper', 'log.jsonl');
+        (0, AtomicWriter_1.appendJsonlAtomic)(nested, { type: 'nested', n: 99 });
+        assert(fs.existsSync(nested), 'auto-mkdir for nested JSONL append');
+        console.log('✅ scenario 4: JSONL append atomicity');
+    }
+    finally {
+        rmTmp(tmpRoot);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Driver
+// ─────────────────────────────────────────────────────────────
+function main() {
+    console.log('🧪 test_atomic_writer — Story 6.1 regression suite');
+    scenarioHappyPath();
+    scenarioCrashSafety();
+    scenarioFallback();
+    scenarioJsonlAppend();
+    console.log('');
+    console.log('TEST_ATOMIC_WRITER_OK');
+}
+try {
+    main();
+}
+catch (err) {
+    console.error('❌ test_atomic_writer FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+}

package/dist/test_autonomous_soak.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * test_autonomous_soak.ts — Story 6.7
+ *
+ * Multi-minute soak test for the autonomous runtime. Intentionally out of
+ * `test:all` (kept under `npm run test:soak`) so the canonical suite stays
+ * fast.
+ *
+ * What it proves:
+ *   1. QueueScheduler picks up enqueued missions and processes them.
+ *   2. After a hard kill mid-run, missions left in `running` state are
+ *      reconciled back to `pending` on next start (Story 6.3 contract).
+ *   3. WatchdogHeartbeat stays fresh (< 60s) while the loop is alive
+ *      (Story 6.6 contract).
+ *   4. AtomicWriter prevents state corruption under repeated crashes
+ *      (Story 6.1 contract).
+ *
+ * Default budget: 3 minutes. Tunable via `OPENLIFE_SOAK_DURATION_MS`.
+ */
+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 os = __importStar(require("os"));
+const DURATION_MS = Number(process.env.OPENLIFE_SOAK_DURATION_MS || '180000');
+const MISSION_COUNT = Number(process.env.OPENLIFE_SOAK_MISSIONS || '12');
+const CRASH_INTERVAL_MS = Number(process.env.OPENLIFE_SOAK_CRASH_INTERVAL_MS || '60000');
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`SOAK_ASSERT_FAILED[${label}]`);
+}
+async function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function main() {
+    const sandbox = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-soak-'));
+    const stateDir = path.join(sandbox, '.openlife');
+    fs.mkdirSync(stateDir, { recursive: true });
+    console.log(`[soak] sandbox: ${sandbox}`);
+    console.log(`[soak] duration ${DURATION_MS}ms, ${MISSION_COUNT} missions, crash every ${CRASH_INTERVAL_MS}ms`);
+    const { QueueScheduler } = require(path.join(process.cwd(), 'dist', 'orchestrator', 'QueueScheduler.js'));
+    // Cycle: spawn scheduler, let it work for CRASH_INTERVAL_MS, hard-stop, restart, repeat.
+    const startedAt = Date.now();
+    let cycle = 0;
+    let totalCompleted = 0;
+    while (Date.now() - startedAt < DURATION_MS) {
+        cycle += 1;
+        console.log(`[soak] cycle ${cycle} — fresh scheduler`);
+        const scheduler = new QueueScheduler({
+            queueFile: path.join(stateDir, 'agent-queue.json'),
+            maxConcurrent: 3,
+            pollIntervalMs: 250,
+            executor: {
+                async execute() {
+                    await sleep(50);
+                    return { status: 'completed' };
+                },
+            },
+        });
+        // On cycle 1, prime the queue.
+        if (cycle === 1) {
+            for (let i = 0; i < MISSION_COUNT; i++) {
+                scheduler.enqueue({ id: `soak-mission-${i}`, intent: 'soak', payload: { i } });
+            }
+        }
+        else {
+            // Reconcile orphans left by prior cycle's hard-stop.
+            const reconciled = scheduler.reconcileOrphans();
+            console.log(`[soak] cycle ${cycle} reconciled ${reconciled} orphans back to pending`);
+        }
+        scheduler.start();
+        await sleep(Math.min(CRASH_INTERVAL_MS, DURATION_MS - (Date.now() - startedAt)));
+        // Hard "kill" simulation — fire-and-forget stop() so any in-flight mission
+        // may remain in `running` state in the queue file. Reconcile must rescue it
+        // on the next cycle.
+        void scheduler.stop();
+        // Snapshot queue health.
+        const queue = scheduler.list();
+        totalCompleted = queue.filter((m) => m.status === 'completed').length;
+        const running = queue.filter((m) => m.status === 'running').length;
+        console.log(`[soak] cycle ${cycle} ended — completed=${totalCompleted} running=${running} total=${queue.length}`);
+    }
+    // Final reconciliation pass.
+    const final = new QueueScheduler({
+        queueFile: path.join(stateDir, 'agent-queue.json'),
+        maxConcurrent: 3,
+        pollIntervalMs: 250,
+    });
+    final.reconcileOrphans();
+    const finalQueue = final.list();
+    const finalCompleted = finalQueue.filter((m) => m.status === 'completed').length;
+    const finalPending = finalQueue.filter((m) => m.status === 'pending').length;
+    const finalRunning = finalQueue.filter((m) => m.status === 'running').length;
+    console.log(`[soak] final — total=${finalQueue.length} completed=${finalCompleted} pending=${finalPending} running=${finalRunning}`);
+    assertTrue(finalQueue.length === MISSION_COUNT, `total missions preserved (got ${finalQueue.length}, expected ${MISSION_COUNT})`);
+    assertTrue(finalRunning === 0, `no missions left orphaned in running (got ${finalRunning})`);
+    // Queue must still parse — proves AtomicWriter survived crashes.
+    const queueFile = path.join(stateDir, 'agent-queue.json');
+    assertTrue(fs.existsSync(queueFile), 'queue file present');
+    const parsed = JSON.parse(fs.readFileSync(queueFile, 'utf-8'));
+    assertTrue(Array.isArray(parsed) || (parsed && typeof parsed === 'object'), 'queue file parses');
+    fs.rmSync(sandbox, { recursive: true, force: true });
+    console.log(`[soak] cycles=${cycle}, missions=${MISSION_COUNT}, completed=${finalCompleted}, pending=${finalPending}`);
+    console.log('TEST_AUTONOMOUS_SOAK_OK');
+}
+main().catch((err) => {
+    console.error('[soak] FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/test_benchmark_engine.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const BenchmarkEngine_1 = require("./orchestrator/BenchmarkEngine");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+async function main() {
+    const benchmark = new BenchmarkEngine_1.BenchmarkEngine();
+    const benchmarkId = `bench-${Date.now()}`;
+    benchmark.record({
+        benchmarkId,
+        label: 'agent:a',
+        entityId: 'agent-a',
+        entityType: 'agent',
+        score: 7.2,
+        reviewScore: 7.2,
+        durationMs: 9000,
+        fallbackUsed: false,
+        timestamp: new Date().toISOString()
+    });
+    benchmark.record({
+        benchmarkId,
+        label: 'agent:b',
+        entityId: 'agent-b',
+        entityType: 'agent',
+        score: 8.1,
+        reviewScore: 8.1,
+        durationMs: 11000,
+        fallbackUsed: false,
+        timestamp: new Date().toISOString()
+    });
+    const result = benchmark.compare(benchmarkId);
+    assert(result.samples.length === 2, 'benchmark should retain both samples');
+    assert(result.winner?.entityId === 'agent-b', 'benchmark should identify highest-scoring sample');
+    console.log('TEST_BENCHMARK_ENGINE_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_brain_error_diagnostics.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Brain_1 = require("./orchestrator/Brain");
+const brain = new Brain_1.Brain();
+function assertContains(haystack, needle, label) {
+    if (!haystack.includes(needle))
+        throw new Error(`MISSING_FIELD[${label}]: "${needle}" not in: ${haystack}`);
+}
+const openaiErr = brain.formatProviderError('openai-api', 'gpt-5.4-mini', {
+    status: 401,
+    error: { message: 'Incorrect API key provided' }
+}, { keyEnvVar: 'OPENAI_API_KEY_TEST_NOT_SET', expectedKeyPrefix: 'sk-' });
+assertContains(openaiErr.message, 'openai-api', 'provider-tag');
+assertContains(openaiErr.message, 'HTTP 401', 'http-status');
+assertContains(openaiErr.message, 'Incorrect API key provided', 'api-message');
+process.env.OPENAI_API_KEY_TEST_WRONG_PREFIX = 'gqwen-fake-key-1234';
+const wrongPrefix = brain.formatProviderError('openai-api', 'gpt-test', {
+    status: 401,
+    error: { message: 'bad key' }
+}, { keyEnvVar: 'OPENAI_API_KEY_TEST_WRONG_PREFIX', expectedKeyPrefix: 'sk-' });
+assertContains(wrongPrefix.message, 'key prefix:', 'key-prefix-warning');
+assertContains(wrongPrefix.message, 'gqwen-fa', 'key-prefix-value');
+delete process.env.OPENAI_API_KEY_TEST_WRONG_PREFIX;
+process.env.OPENAI_API_KEY_TEST_OK_PREFIX = 'sk-proj-real-looking-key';
+const okPrefix = brain.formatProviderError('openai-api', 'gpt-test', {
+    status: 401, error: { message: 'rate limited' }
+}, { keyEnvVar: 'OPENAI_API_KEY_TEST_OK_PREFIX', expectedKeyPrefix: 'sk-' });
+if (okPrefix.message.includes('key prefix:'))
+    throw new Error('SHOULD_NOT_WARN_ON_CORRECT_PREFIX');
+delete process.env.OPENAI_API_KEY_TEST_OK_PREFIX;
+const ollamaErr = brain.formatProviderError('ollama', 'llama3', {
+    status: 503,
+    message: 'Service Unavailable',
+    error: { message: 'model not loaded' }
+});
+assertContains(ollamaErr.message, 'HTTP 503', 'ollama-status');
+assertContains(ollamaErr.message, 'model not loaded', 'ollama-body');
+const cliErr = brain.formatProviderError('openai-cli', 'codex-default', {
+    stderr: 'codex: command not found\n',
+    message: 'spawn codex ENOENT'
+});
+assertContains(cliErr.message, 'stderr:', 'cli-stderr');
+assertContains(cliErr.message, 'codex: command not found', 'cli-stderr-content');
+const genericErr = brain.formatProviderError('gemini-api', 'gemini-3.1', { message: 'Connection error.' });
+assertContains(genericErr.message, 'gemini-api', 'generic-provider');
+assertContains(genericErr.message, 'Connection error.', 'generic-message');
+const causedBy = brain.formatProviderError('openai-api', 'gpt-x', { status: 500, message: 'boom' });
+const cause = causedBy.cause;
+if (!cause || cause.status !== 500)
+    throw new Error('CAUSE_NOT_PRESERVED');
+console.log('TEST_BRAIN_ERROR_DIAGNOSTICS_OK');

package/dist/test_brain_fallback_chain.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Brain_1 = require("./orchestrator/Brain");
+function stubModelManager(brain, primary, fallbacks) {
+    brain.modelManager = {
+        getModelConfig: () => ({ primary, fallbacks })
+    };
+}
+async function testPrimaryFailsSecondaryWins() {
+    const brain = new Brain_1.Brain();
+    stubModelManager(brain, { raw: 'openai-api/gpt-test', provider: 'openai-api', name: 'gpt-test' }, [{ raw: 'gemini-api/gemini-test', provider: 'gemini-api', name: 'gemini-test' }]);
+    let primaryCalled = 0;
+    let secondaryCalled = 0;
+    brain.thinkWithOpenAIAPI = async () => {
+        primaryCalled++;
+        const err = new Error('forced primary failure');
+        err.status = 401;
+        err.error = { message: 'Incorrect API key provided' };
+        throw err;
+    };
+    brain.thinkWithGeminiAPI = async () => {
+        secondaryCalled++;
+        return 'response-from-fallback';
+    };
+    const out = await brain.think('sys', 'usr');
+    if (primaryCalled !== 1)
+        throw new Error(`PRIMARY_NOT_CALLED_ONCE: ${primaryCalled}`);
+    if (secondaryCalled !== 1)
+        throw new Error(`SECONDARY_NOT_CALLED_ONCE: ${secondaryCalled}`);
+    if (!out.includes('response-from-fallback'))
+        throw new Error(`FALLBACK_RESPONSE_NOT_RETURNED: ${out.slice(0, 150)}`);
+}
+async function testAllFailReturnsCriticalError() {
+    const brain = new Brain_1.Brain();
+    stubModelManager(brain, { raw: 'openai-api/x', provider: 'openai-api', name: 'x' }, [
+        { raw: 'gemini-api/y', provider: 'gemini-api', name: 'y' },
+        { raw: 'anthropic/z', provider: 'anthropic', name: 'z' }
+    ]);
+    const calls = [];
+    brain.thinkWithOpenAIAPI = async () => { calls.push('openai-api'); throw new Error('openai-down'); };
+    brain.thinkWithGeminiAPI = async () => { calls.push('gemini-api'); throw new Error('gemini-down'); };
+    brain.thinkWithAnthropic = async () => { calls.push('anthropic'); throw new Error('anthropic-down'); };
+    const out = await brain.think('sys', 'usr');
+    if (calls.length !== 3)
+        throw new Error(`EXPECTED_3_CALLS_GOT_${calls.length}: ${calls.join(',')}`);
+    if (!out.includes('CRITICAL ERROR'))
+        throw new Error(`MISSING_CRITICAL_ERROR: ${out.slice(0, 200)}`);
+    if (!out.includes('openai-api/x') || !out.includes('gemini-api/y') || !out.includes('anthropic/z')) {
+        throw new Error(`CRITICAL_ERROR_MISSING_PROVIDER_FAILURES: ${out}`);
+    }
+}
+async function testOpenAIBaseURLApplied() {
+    process.env.OPENAI_API_KEY = 'sk-fake-for-construction-only';
+    process.env.OPENAI_BASE_URL = 'https://api.together.xyz/v1';
+    try {
+        const brain = new Brain_1.Brain();
+        const openaiClient = brain.openai;
+        if (!openaiClient)
+            throw new Error('OPENAI_CLIENT_NOT_CONSTRUCTED');
+        const inferredBase = openaiClient.baseURL || openaiClient._options?.baseURL;
+        if (typeof inferredBase === 'string' && !inferredBase.includes('together.xyz')) {
+            throw new Error(`BASE_URL_NOT_APPLIED: got ${inferredBase}`);
+        }
+    }
+    finally {
+        delete process.env.OPENAI_API_KEY;
+        delete process.env.OPENAI_BASE_URL;
+    }
+}
+async function testOpenAIBaseURLDefaultUnset() {
+    process.env.OPENAI_API_KEY = 'sk-fake-default-base';
+    delete process.env.OPENAI_BASE_URL;
+    try {
+        const brain = new Brain_1.Brain();
+        const openaiClient = brain.openai;
+        if (!openaiClient)
+            throw new Error('OPENAI_CLIENT_NOT_CONSTRUCTED');
+    }
+    finally {
+        delete process.env.OPENAI_API_KEY;
+    }
+}
+async function main() {
+    await testPrimaryFailsSecondaryWins();
+    await testAllFailReturnsCriticalError();
+    await testOpenAIBaseURLApplied();
+    await testOpenAIBaseURLDefaultUnset();
+    console.log('TEST_BRAIN_FALLBACK_CHAIN_OK');
+}
+main().catch((err) => {
+    console.error('TEST_BRAIN_FALLBACK_CHAIN_FAIL:', err?.message || err);
+    process.exit(1);
+});