@openlife/cli 1.7.3

package/dist/test_install_flow.js

@@ -0,0 +1,70 @@
+"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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const InstallFlow_1 = require("./cli/InstallFlow");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function main() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-install-flow-'));
+    fs.writeFileSync(path.join(root, 'models.json'), '{}', 'utf-8');
+    fs.writeFileSync(path.join(root, 'executor-policy.json'), '{}', 'utf-8');
+    fs.writeFileSync(path.join(root, 'governance-policy.json'), '{}', 'utf-8');
+    fs.writeFileSync(path.join(root, 'voice.config.json'), '{}', 'utf-8');
+    fs.mkdirSync(path.join(root, '.artifacts'), { recursive: true });
+    fs.writeFileSync(path.join(root, '.artifacts', 'security-events.jsonl'), '', 'utf-8');
+    fs.writeFileSync(path.join(root, 'OPENLIFE_PROJECT.md'), '# test', 'utf-8');
+    const flow = new InstallFlow_1.InstallFlow(root);
+    const result = flow.run({ profile: 'autonomous', host: 'claude-code' });
+    assert(fs.existsSync(result.manifestPath), 'install manifest should exist');
+    assert(fs.existsSync(result.reportPath), 'install flow report should exist');
+    assert(result.profile === 'autonomous', 'profile should be autonomous');
+    assert(result.nextCommands.some((cmd) => cmd.includes('openlife agent start')), 'should include autonomous next command');
+    const summary = flow.renderSummary(result).join('\n');
+    assert(summary.includes('OpenLife Setup concluído'), 'summary should include success title');
+    assert(summary.includes('Próximos comandos'), 'summary should include next commands section');
+    console.log('TEST_INSTALL_FLOW_OK');
+}
+try {
+    main();
+}
+catch (error) {
+    console.error(error.message || error);
+    process.exit(1);
+}

package/dist/test_install_flow_host_validation.js

@@ -0,0 +1,143 @@
+"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.1 — Host enum + validator regression test.
+ *
+ * Asserts:
+ * 1. validateHost accepts the 3 canonical hosts (claude-code, gemini-cli, codex)
+ * 2. validateHost rejects unknown values with clear error message
+ * 3. validateHost falls back to DEFAULT_HOST on empty/null/undefined
+ * 4. detectHostFromEnv picks the right host based on env signals
+ * 5. InstallFlow.run() with valid --host runs without throwing
+ * 6. InstallFlow.run() with invalid --host throws clear error
+ * 7. buildNextCommands no longer references the deprecated `mode set` command
+ */
+const InstallFlow_1 = require("./cli/InstallFlow");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`ASSERTION_FAILED: ${msg}`);
+}
+function testValidateHostAcceptsCanonical() {
+    for (const h of InstallFlow_1.VALID_HOSTS) {
+        const result = (0, InstallFlow_1.validateHost)(h);
+        assert(result === h, `validateHost('${h}') should return '${h}', got '${result}'`);
+    }
+}
+function testValidateHostRejectsUnknown() {
+    const cases = ['cursor', 'vscode', 'random', 'CLAUDE-CODE-TYPO', ''];
+    for (const bad of cases) {
+        if (bad === '')
+            continue; // empty falls to default — tested separately
+        let threw = false;
+        try {
+            (0, InstallFlow_1.validateHost)(bad);
+        }
+        catch (err) {
+            threw = true;
+            assert(err.message.includes('INVALID_HOST') && err.message.includes('claude-code'), `Error should mention INVALID_HOST and list valid hosts; got: ${err.message}`);
+        }
+        assert(threw, `validateHost('${bad}') should have thrown but didn't`);
+    }
+}
+function testValidateHostFallsBackToDefault() {
+    assert((0, InstallFlow_1.validateHost)(undefined) === InstallFlow_1.DEFAULT_HOST, 'undefined should fall to DEFAULT_HOST');
+    assert((0, InstallFlow_1.validateHost)(null) === InstallFlow_1.DEFAULT_HOST, 'null should fall to DEFAULT_HOST');
+    assert((0, InstallFlow_1.validateHost)('') === InstallFlow_1.DEFAULT_HOST, 'empty string should fall to DEFAULT_HOST');
+}
+function testValidateHostCaseInsensitive() {
+    assert((0, InstallFlow_1.validateHost)('CLAUDE-CODE') === 'claude-code', 'uppercase should normalize');
+    assert((0, InstallFlow_1.validateHost)('  Codex  ') === 'codex', 'whitespace + caps should normalize');
+}
+function testDetectHostFromEnv() {
+    assert((0, InstallFlow_1.detectHostFromEnv)({ CLAUDECODE: '1' }) === 'claude-code', 'CLAUDECODE → claude-code');
+    assert((0, InstallFlow_1.detectHostFromEnv)({ CLAUDE_PROJECT_DIR: '/x' }) === 'claude-code', 'CLAUDE_PROJECT_DIR → claude-code');
+    assert((0, InstallFlow_1.detectHostFromEnv)({ GEMINI_CONFIG_DIR: '/x' }) === 'gemini-cli', 'GEMINI_CONFIG_DIR → gemini-cli');
+    assert((0, InstallFlow_1.detectHostFromEnv)({ CODEX_HOME: '/x' }) === 'codex', 'CODEX_HOME → codex');
+    assert((0, InstallFlow_1.detectHostFromEnv)({}) === null, 'no env signals → null');
+}
+function testInstallFlowAcceptsValidHosts() {
+    // Run InstallFlow in a temp dir to avoid clobbering project state.
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-installflow-test-'));
+    try {
+        const flow = new InstallFlow_1.InstallFlow(tempRoot);
+        for (const h of InstallFlow_1.VALID_HOSTS) {
+            const result = flow.run({ profile: 'framework', host: h, skipDoctor: true });
+            assert(result.host === h, `InstallFlow with host ${h} should keep host in result`);
+            assert(result.nextCommands.some((c) => c.includes(`--host ${h}`)), `nextCommands should include --host ${h}: got ${JSON.stringify(result.nextCommands)}`);
+            // Story 3.1 fix: no `mode set` in nextCommands
+            assert(!result.nextCommands.some((c) => c.includes('mode set')), `nextCommands should NOT reference deprecated 'mode set'; got: ${JSON.stringify(result.nextCommands)}`);
+            assert(result.nextCommands.some((c) => c.includes('system setup')), `nextCommands should use 'system setup' instead; got: ${JSON.stringify(result.nextCommands)}`);
+        }
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testInstallFlowRejectsInvalidHost() {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-installflow-test-'));
+    try {
+        const flow = new InstallFlow_1.InstallFlow(tempRoot);
+        let threw = false;
+        try {
+            flow.run({ profile: 'framework', host: 'cursor', skipDoctor: true });
+        }
+        catch (err) {
+            threw = true;
+            assert(err.message.includes('INVALID_HOST'), `should throw INVALID_HOST; got: ${err.message}`);
+        }
+        assert(threw, 'InstallFlow.run with invalid host should throw');
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+async function main() {
+    testValidateHostAcceptsCanonical();
+    testValidateHostRejectsUnknown();
+    testValidateHostFallsBackToDefault();
+    testValidateHostCaseInsensitive();
+    testDetectHostFromEnv();
+    testInstallFlowAcceptsValidHosts();
+    testInstallFlowRejectsInvalidHost();
+    console.log('TEST_INSTALL_FLOW_HOST_VALIDATION_OK');
+}
+main().catch((err) => {
+    console.error('TEST_INSTALL_FLOW_HOST_VALIDATION_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_install_wizard.js

@@ -0,0 +1,272 @@
+"use strict";
+// Story 3.5 — Regression test for the interactive install wizard.
+// Uses CannedAnswerProvider so no real stdin/tty is required.
+//
+// Question order in wizard.run() (when no pre-existing install):
+//   1) profile          (choice: 0=framework, 1=autonomous)
+//   2) host             (choice: 0=claude-code, 1=gemini-cli, 2=codex)
+//   3) model order      (text: blank or comma list)
+//   4) telegram?        (yesNo, autonomous only)
+//   5) skip doctor?     (yesNo)
+//   6) confirm preview  (yesNo)
+//
+// When pre-existing install detected, an extra choice prompt fires FIRST:
+//   0) abort  1) reinstall  2) repair
+// Selecting abort short-circuits the rest of the flow.
+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 InstallWizard_1 = require("./cli/InstallWizard");
+function assert(cond, msg) {
+    if (!cond) {
+        console.error(`❌ ASSERT FAILED: ${msg}`);
+        process.exit(1);
+    }
+}
+function tempRoot() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-init-wizard-'));
+}
+function cleanup(root) {
+    try {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+function writeExistingInstall(root) {
+    const dir = path.join(root, '.openlife');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'install-manifest.json'), JSON.stringify({ installedAt: new Date().toISOString(), version: 'test' }, null, 2), 'utf-8');
+}
+async function scenario1HappyPathFrameworkClaudeCode() {
+    const root = tempRoot();
+    try {
+        // profile=framework(0), host=claude-code(0), models='', skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([0, 0, '', false, true]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === true, 'scenario1: expected ok=true');
+        if (!result.ok)
+            return;
+        assert(result.options.profile === 'framework', 'scenario1: profile should be framework');
+        assert(result.options.host === 'claude-code', 'scenario1: host should be claude-code');
+        assert(result.options.skipDoctor === false, 'scenario1: skipDoctor should be false');
+        assert(result.options.modelOrder === undefined, 'scenario1: modelOrder should be undefined when blank');
+        assert(result.preExistingAction === undefined, 'scenario1: no pre-existing action expected');
+        assert(!result.warnings, 'scenario1: no warnings expected for default claude-code');
+        console.log('✅ scenario 1: happy path framework + claude-code');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario2HappyPathAutonomousClaudeCode() {
+    const root = tempRoot();
+    try {
+        // profile=autonomous(1), host=claude-code(0), models='', telegram=true, skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([1, 0, '', true, false, true]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === true, 'scenario2: expected ok=true');
+        if (!result.ok)
+            return;
+        assert(result.options.profile === 'autonomous', 'scenario2: profile should be autonomous');
+        assert(result.options.host === 'claude-code', 'scenario2: host should be claude-code');
+        assert(!result.warnings, 'scenario2: no warnings when telegram already configured');
+        console.log('✅ scenario 2: happy path autonomous + claude-code');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario3UserAbortsOnConfirm() {
+    const root = tempRoot();
+    try {
+        // framework, claude-code, blank models, skipDoctor=false, confirm=false (abort)
+        const provider = new InstallWizard_1.CannedAnswerProvider([0, 0, '', false, false]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === false, 'scenario3: expected ok=false');
+        if (result.ok)
+            return;
+        assert(result.reason === 'user_aborted', 'scenario3: reason should be user_aborted');
+        assert(result.detail === 'preview_not_confirmed', 'scenario3: detail should be preview_not_confirmed');
+        console.log('✅ scenario 3: user aborts on confirm-preview');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario4PreExistingAbort() {
+    const root = tempRoot();
+    try {
+        writeExistingInstall(root);
+        // pre-existing prompt: 0=abort. No further questions should fire.
+        const provider = new InstallWizard_1.CannedAnswerProvider([0]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === false, 'scenario4: expected ok=false');
+        if (result.ok)
+            return;
+        assert(result.reason === 'user_aborted', 'scenario4: reason should be user_aborted');
+        assert(result.detail === 'pre_existing_install_abort', 'scenario4: detail should be pre_existing_install_abort');
+        assert(provider.remaining() === 0, 'scenario4: queue should be empty (no further questions asked)');
+        console.log('✅ scenario 4: pre-existing install + abort short-circuits');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario5PreExistingRepair() {
+    const root = tempRoot();
+    try {
+        writeExistingInstall(root);
+        // 2=repair, then full flow: framework, claude-code, '', skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([2, 0, 0, '', false, true]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === true, 'scenario5: expected ok=true');
+        if (!result.ok)
+            return;
+        assert(result.preExistingAction === 'repair', 'scenario5: preExistingAction should be repair');
+        assert(result.options.profile === 'framework', 'scenario5: profile should be framework');
+        console.log('✅ scenario 5: pre-existing install + repair');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario6PreExistingReinstall() {
+    const root = tempRoot();
+    try {
+        writeExistingInstall(root);
+        // 1=reinstall, framework, claude-code, '', skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([1, 0, 0, '', false, true]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === true, 'scenario6: expected ok=true');
+        if (!result.ok)
+            return;
+        assert(result.preExistingAction === 'reinstall', 'scenario6: preExistingAction should be reinstall');
+        console.log('✅ scenario 6: pre-existing install + reinstall');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario7UnsupportedHostGeminiCli() {
+    const root = tempRoot();
+    try {
+        // framework, host=1 (gemini-cli, not yet supported), blank models, skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([0, 1, '', false, true]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === true, 'scenario7: expected ok=true even with unsupported host');
+        if (!result.ok)
+            return;
+        assert(result.options.host === 'gemini-cli', 'scenario7: host should be gemini-cli');
+        assert(Array.isArray(result.warnings), 'scenario7: should have warnings array');
+        assert(result.warnings.some((w) => w.includes('HOST_NOT_YET_SUPPORTED')), 'scenario7: should warn HOST_NOT_YET_SUPPORTED');
+        console.log('✅ scenario 7: unsupported host (gemini-cli) accepted with warning');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario8CustomModelChain() {
+    const root = tempRoot();
+    try {
+        const models = 'gemini-api/gemini-3.1-pro-preview,openai-api/gpt-5.4-mini';
+        // framework, claude-code, models=custom, skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([0, 0, models, false, true]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === true, 'scenario8: expected ok=true');
+        if (!result.ok)
+            return;
+        assert(Array.isArray(result.options.modelOrder), 'scenario8: modelOrder should be array');
+        assert(result.options.modelOrder.length === 2, 'scenario8: modelOrder should have 2 entries');
+        assert(result.options.modelOrder[0] === 'gemini-api/gemini-3.1-pro-preview', 'scenario8: first model should be gemini-3.1-pro-preview');
+        assert(result.options.modelOrder[1] === 'openai-api/gpt-5.4-mini', 'scenario8: second model should be gpt-5.4-mini');
+        console.log('✅ scenario 8: custom model chain parsed correctly');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario9OutOfAnswersThrows() {
+    const root = tempRoot();
+    try {
+        // Provide too few answers: stop after profile.
+        const provider = new InstallWizard_1.CannedAnswerProvider([0]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        let threw = false;
+        let detail = '';
+        try {
+            await wizard.run();
+        }
+        catch (err) {
+            threw = true;
+            detail = err instanceof Error ? err.message : String(err);
+        }
+        assert(threw, 'scenario9: wizard should throw when canned queue is exhausted');
+        assert(detail.includes('WIZARD_TEST_OUT_OF_ANSWERS'), `scenario9: error should mention WIZARD_TEST_OUT_OF_ANSWERS; got: ${detail}`);
+        console.log('✅ scenario 9: CannedAnswerProvider throws WIZARD_TEST_OUT_OF_ANSWERS on dry queue');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function main() {
+    console.log('🧪 test_install_wizard — Story 3.5 regression suite');
+    await scenario1HappyPathFrameworkClaudeCode();
+    await scenario2HappyPathAutonomousClaudeCode();
+    await scenario3UserAbortsOnConfirm();
+    await scenario4PreExistingAbort();
+    await scenario5PreExistingRepair();
+    await scenario6PreExistingReinstall();
+    await scenario7UnsupportedHostGeminiCli();
+    await scenario8CustomModelChain();
+    await scenario9OutOfAnswersThrows();
+    console.log('');
+    console.log('TEST_INSTALL_WIZARD_OK');
+}
+main().catch((err) => {
+    console.error('❌ test_install_wizard failed:', err);
+    process.exit(1);
+});

package/dist/test_integration_gemini_live.js

@@ -0,0 +1,95 @@
+"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 });
+/*
+ * INT-01 — Live integration test against Gemini API.
+ *
+ * Requires GEMINI_API_KEY in .env. Makes ONE real API call.
+ * Cost: ~$0.0001 per run (negligible).
+ *
+ * NOT included in test:all. Run via: npm run test:integration-gemini
+ */
+const dotenv = __importStar(require("dotenv"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const Brain_1 = require("./orchestrator/Brain");
+dotenv.config();
+const LOG_PATH = path.join(process.cwd(), 'docs', 'audit', 'integrations', 'gemini.log');
+function logLine(line) {
+    fs.mkdirSync(path.dirname(LOG_PATH), { recursive: true });
+    fs.appendFileSync(LOG_PATH, `${new Date().toISOString()} ${line}\n`);
+}
+async function main() {
+    const key = process.env.GEMINI_API_KEY;
+    if (!key) {
+        throw new Error('MISSING_GEMINI_API_KEY: skipping live test');
+    }
+    const keyPrefix = key.slice(0, 6) + '...';
+    logLine(`START gemini live test (key prefix=${keyPrefix})`);
+    const brain = new Brain_1.Brain();
+    // Force Gemini-only chain: override fallbacks to nothing
+    brain.modelManager = {
+        getModelConfig: () => ({
+            primary: { provider: 'gemini-api', name: 'gemini-3.1-flash-lite-preview', raw: 'gemini-api/gemini-3.1-flash-lite-preview' },
+            fallbacks: []
+        })
+    };
+    const t0 = Date.now();
+    const response = await brain.think('You are an audit assistant. Reply with the literal string AUDIT-OK and nothing else.', 'ping');
+    const elapsed = Date.now() - t0;
+    if (!response || response.length < 3) {
+        logLine(`FAIL empty response`);
+        throw new Error(`GEMINI_EMPTY_RESPONSE: "${response}"`);
+    }
+    if (response.includes('CRITICAL ERROR')) {
+        logLine(`FAIL critical error: ${response.slice(0, 200)}`);
+        throw new Error(`GEMINI_CRITICAL_ERROR: ${response.slice(0, 200)}`);
+    }
+    const containsAuditOk = response.toUpperCase().includes('AUDIT-OK') || response.toUpperCase().includes('AUDIT OK');
+    logLine(`OK elapsed=${elapsed}ms response_length=${response.length} contains_audit_ok=${containsAuditOk}`);
+    logLine(`  response_preview="${response.slice(0, 100).replace(/\n/g, ' ')}"`);
+    console.log(`TEST_INTEGRATION_GEMINI_LIVE_OK (elapsed=${elapsed}ms, length=${response.length}, contains_audit_ok=${containsAuditOk})`);
+    console.log(`  log: ${LOG_PATH}`);
+    console.log(`  preview: ${response.slice(0, 80).replace(/\n/g, ' ')}`);
+}
+main().catch((err) => {
+    const msg = err?.message || String(err);
+    try {
+        logLine(`FAIL ${msg.slice(0, 300)}`);
+    }
+    catch { }
+    console.error('TEST_INTEGRATION_GEMINI_LIVE_FAIL:', msg);
+    process.exit(1);
+});