@openlife/cli 1.7.5 → 1.7.7

package/dist/test_install_wizard.js

@@ -3,12 +3,15 @@
 // 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)
+//   1) profile          (choice: 0=framework, 1=autonomous, 2=both)
 //   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)
+//   3) wantsApiKeys     (yesNo)
+//   3a-d) [if Y] OPENAI / ANTHROPIC / GEMINI / OPENROUTER pastes (text)
+//   4) wantsOAuth       (yesNo)
+//   5) model order      (text: blank or comma list)
+//   6) telegram?        (yesNo, autonomous only)
+//   7) skip doctor?     (yesNo)
+//   8) confirm preview  (yesNo)
 //
 // When pre-existing install detected, an extra choice prompt fires FIRST:
 //   0) abort  1) reinstall  2) repair
@@ -76,8 +79,8 @@ function writeExistingInstall(root) {
 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]);
+        // profile=framework(0), host=claude-code(0), apiKeys=N, oauth=N, models='', skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([0, 0, false, false, '', false, true]);
         const wizard = new InstallWizard_1.InstallWizard(root, provider);
         const result = await wizard.run();
         assert(result.ok === true, 'scenario1: expected ok=true');
@@ -88,7 +91,8 @@ async function scenario1HappyPathFrameworkClaudeCode() {
         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');
+        // SKIPPED_API_KEYS warning is expected when wantsApiKeys=false
+        assert(Array.isArray(result.warnings) && result.warnings.some((w) => w.includes('SKIPPED_API_KEYS')), 'scenario1: should warn SKIPPED_API_KEYS when api-key prompt skipped');
         console.log('✅ scenario 1: happy path framework + claude-code');
     }
     finally {
@@ -98,8 +102,8 @@ async function scenario1HappyPathFrameworkClaudeCode() {
 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]);
+        // profile=autonomous(1), host=claude-code(0), apiKeys=N, oauth=N, models='', telegram=true, skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([1, 0, false, false, '', true, false, true]);
         const wizard = new InstallWizard_1.InstallWizard(root, provider);
         const result = await wizard.run();
         assert(result.ok === true, 'scenario2: expected ok=true');
@@ -107,7 +111,8 @@ async function scenario2HappyPathAutonomousClaudeCode() {
             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');
+        // SKIPPED_API_KEYS warning is expected when wantsApiKeys=false
+        assert(Array.isArray(result.warnings) && result.warnings.some((w) => w.includes('SKIPPED_API_KEYS')), 'scenario2: should warn SKIPPED_API_KEYS when api-key prompt skipped');
         console.log('✅ scenario 2: happy path autonomous + claude-code');
     }
     finally {
@@ -117,8 +122,8 @@ async function scenario2HappyPathAutonomousClaudeCode() {
 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]);
+        // framework, claude-code, apiKeys=N, oauth=N, blank models, skipDoctor=false, confirm=false (abort)
+        const provider = new InstallWizard_1.CannedAnswerProvider([0, 0, false, false, '', false, false]);
         const wizard = new InstallWizard_1.InstallWizard(root, provider);
         const result = await wizard.run();
         assert(result.ok === false, 'scenario3: expected ok=false');
@@ -156,8 +161,8 @@ 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]);
+        // 2=repair, then full flow: framework, claude-code, apiKeys=N, oauth=N, '', skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([2, 0, 0, false, false, '', false, true]);
         const wizard = new InstallWizard_1.InstallWizard(root, provider);
         const result = await wizard.run();
         assert(result.ok === true, 'scenario5: expected ok=true');
@@ -175,8 +180,8 @@ 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]);
+        // 1=reinstall, framework, claude-code, apiKeys=N, oauth=N, '', skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([1, 0, 0, false, false, '', false, true]);
         const wizard = new InstallWizard_1.InstallWizard(root, provider);
         const result = await wizard.run();
         assert(result.ok === true, 'scenario6: expected ok=true');
@@ -192,8 +197,8 @@ async function scenario6PreExistingReinstall() {
 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]);
+        // framework, host=1 (gemini-cli, not yet supported), apiKeys=N, oauth=N, blank models, skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([0, 1, false, false, '', 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');
@@ -212,8 +217,8 @@ 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]);
+        // framework, claude-code, apiKeys=N, oauth=N, models=custom, skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([0, 0, false, false, models, false, true]);
         const wizard = new InstallWizard_1.InstallWizard(root, provider);
         const result = await wizard.run();
         assert(result.ok === true, 'scenario8: expected ok=true');
@@ -252,6 +257,89 @@ async function scenario9OutOfAnswersThrows() {
         cleanup(root);
     }
 }
+async function scenario10WithApiKeysPersists() {
+    const root = tempRoot();
+    try {
+        // framework, claude-code, apiKeys=Y, paste 4 keys (openai+anthropic, skip gemini+openrouter),
+        // oauth=N, blank models, skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([
+            0, 0,
+            true, // wantsApiKeys
+            'openai-test-key', // openai paste (non-secret test fixture)
+            'anthropic-test-key', // anthropic paste (non-secret test fixture)
+            '', // gemini skip
+            '', // openrouter skip
+            false, // wantsOAuth
+            '', // models
+            false, // skipDoctor
+            true, // confirm
+        ]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === true, 'scenario10: expected ok=true');
+        if (!result.ok)
+            return;
+        // .env should contain the pasted keys
+        const envPath = path.join(root, '.env');
+        assert(fs.existsSync(envPath), 'scenario10: .env should exist after wizard');
+        const envContent = fs.readFileSync(envPath, 'utf-8');
+        assert(envContent.includes('OPENAI_API_KEY=openai-test-key'), 'scenario10: .env should have OPENAI_API_KEY');
+        assert(envContent.includes('ANTHROPIC_API_KEY=anthropic-test-key'), 'scenario10: .env should have ANTHROPIC_API_KEY');
+        assert(!envContent.includes('GEMINI_API_KEY='), 'scenario10: .env should NOT have GEMINI_API_KEY (skipped)');
+        // SKIPPED_API_KEYS warning should NOT fire when at least one key was provided
+        if (result.warnings) {
+            assert(!result.warnings.some((w) => w.includes('SKIPPED_API_KEYS')), 'scenario10: should NOT warn SKIPPED_API_KEYS when keys were provided');
+        }
+        console.log('✅ scenario 10: API keys collected and persisted to .env');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario11AbortDoesNotPersistApiKeys() {
+    const root = tempRoot();
+    try {
+        const provider = new InstallWizard_1.CannedAnswerProvider([
+            0, 0,
+            true,
+            'openai-abort-test-key',
+            '',
+            '',
+            '',
+            false,
+            '',
+            false,
+            false,
+        ]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === false, 'scenario11: expected ok=false');
+        assert(!fs.existsSync(path.join(root, '.env')), 'scenario11: aborted wizard must not write .env');
+        console.log('✅ scenario 11: abort after API-key collection does not persist .env');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+async function scenario12ProfileBothMapsToAutonomous() {
+    const root = tempRoot();
+    try {
+        // profile=both(2), claude-code, apiKeys=N, oauth=N, models='', telegram=true (autonomous path),
+        // skipDoctor=false, confirm=true
+        const provider = new InstallWizard_1.CannedAnswerProvider([2, 0, false, false, '', true, false, true]);
+        const wizard = new InstallWizard_1.InstallWizard(root, provider);
+        const result = await wizard.run();
+        assert(result.ok === true, 'scenario11: expected ok=true');
+        if (!result.ok)
+            return;
+        assert(result.options.profile === 'autonomous', 'scenario11: profile=both should map internally to autonomous');
+        assert(Array.isArray(result.warnings) && result.warnings.some((w) => w.includes('INSTALLING_BOTH')), 'scenario11: should emit INSTALLING_BOTH warning so caller knows both layers were intended');
+        console.log('✅ scenario 11: profile=both maps to autonomous with INSTALLING_BOTH warning');
+    }
+    finally {
+        cleanup(root);
+    }
+}
 async function main() {
     console.log('🧪 test_install_wizard — Story 3.5 regression suite');
     await scenario1HappyPathFrameworkClaudeCode();
@@ -263,6 +351,9 @@ async function main() {
     await scenario7UnsupportedHostGeminiCli();
     await scenario8CustomModelChain();
     await scenario9OutOfAnswersThrows();
+    await scenario10WithApiKeysPersists();
+    await scenario11AbortDoesNotPersistApiKeys();
+    await scenario12ProfileBothMapsToAutonomous();
     console.log('');
     console.log('TEST_INSTALL_WIZARD_OK');
 }

package/dist/test_logs_command.js

@@ -0,0 +1,177 @@
+"use strict";
+// test_logs_command — verifies filter / tail / since semantics + duration
+// parser of `openlife logs`.
+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 LogsCommand_1 = require("./cli/LogsCommand");
+function assert(cond, msg) {
+    if (!cond) {
+        console.error(`❌ ASSERT FAILED: ${msg}`);
+        process.exit(1);
+    }
+}
+function tempRoot() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-logs-'));
+    fs.mkdirSync(path.join(root, '.openlife'), { recursive: true });
+    return root;
+}
+function cleanup(root) {
+    try {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+function writeJsonl(root, filename, entries) {
+    fs.writeFileSync(path.join(root, '.openlife', filename), entries.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+}
+function scenarioDurationParser() {
+    assert((0, LogsCommand_1.parseDurationToSeconds)('30s') === 30, '30s → 30');
+    assert((0, LogsCommand_1.parseDurationToSeconds)('5m') === 300, '5m → 300');
+    assert((0, LogsCommand_1.parseDurationToSeconds)('1h') === 3600, '1h → 3600');
+    assert((0, LogsCommand_1.parseDurationToSeconds)('2d') === 172800, '2d → 172800');
+    assert((0, LogsCommand_1.parseDurationToSeconds)('bogus') === null, 'bogus → null');
+    assert((0, LogsCommand_1.parseDurationToSeconds)('-1m') === null, 'negative → null');
+    console.log('✅ scenario 1: parseDurationToSeconds covers s/m/h/d + rejects garbage');
+}
+function scenarioTailDefault() {
+    const root = tempRoot();
+    try {
+        const entries = [];
+        const now = Date.now();
+        for (let i = 0; i < 50; i++) {
+            entries.push({ ts: new Date(now - (50 - i) * 1000).toISOString(), summary: `entry ${i}` });
+        }
+        writeJsonl(root, 'governance-ledger.jsonl', entries);
+        const collected = (0, LogsCommand_1.collectLogs)({ root, tail: 5 });
+        assert(collected.length === 5, `expected 5 entries, got ${collected.length}`);
+        assert(collected[collected.length - 1].parsed.summary === 'entry 49', 'last entry should be the newest');
+        console.log('✅ scenario 2: tail=5 returns last 5 chronological entries');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioFilterBySubsystem() {
+    const root = tempRoot();
+    try {
+        const now = Date.now();
+        const govEntries = [
+            { ts: new Date(now).toISOString(), summary: 'gov-entry' },
+        ];
+        const mediaEntries = [
+            { ts: new Date(now).toISOString(), summary: 'media-entry' },
+        ];
+        writeJsonl(root, 'governance-ledger.jsonl', govEntries);
+        writeJsonl(root, 'media-routing.log.jsonl', mediaEntries);
+        const govOnly = (0, LogsCommand_1.collectLogs)({ root, filter: 'governance' });
+        assert(govOnly.length === 1, `expected 1 governance entry, got ${govOnly.length}`);
+        assert(govOnly[0].subsystem === 'governance-ledger', 'subsystem should match');
+        const mediaOnly = (0, LogsCommand_1.collectLogs)({ root, filter: 'media' });
+        assert(mediaOnly.length === 1, `expected 1 media entry, got ${mediaOnly.length}`);
+        assert(mediaOnly[0].subsystem === 'media-routing', 'media subsystem name');
+        console.log('✅ scenario 3: --filter narrows by subsystem id');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioSinceFiltersOldEntries() {
+    const root = tempRoot();
+    try {
+        const now = Date.now();
+        const entries = [
+            { ts: new Date(now - 3600_000).toISOString(), summary: 'one-hour-ago' },
+            { ts: new Date(now - 60_000).toISOString(), summary: 'one-minute-ago' },
+            { ts: new Date(now - 5_000).toISOString(), summary: 'five-seconds-ago' },
+        ];
+        writeJsonl(root, 'governance-ledger.jsonl', entries);
+        const recent = (0, LogsCommand_1.collectLogs)({ root, since: '5m' });
+        assert(recent.length === 2, `expected 2 entries within 5m, got ${recent.length}`);
+        assert(!recent.some((e) => e.parsed.summary === 'one-hour-ago'), 'one-hour-ago should be excluded');
+        console.log('✅ scenario 4: --since=5m excludes older entries');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioRenderHumanAndJson() {
+    const root = tempRoot();
+    try {
+        writeJsonl(root, 'governance-ledger.jsonl', [
+            { ts: new Date().toISOString(), summary: 'test summary' },
+        ]);
+        const entries = (0, LogsCommand_1.collectLogs)({ root });
+        const human = (0, LogsCommand_1.renderLogsHuman)(entries);
+        assert(human.includes('[governance-ledger]'), 'human render includes subsystem');
+        assert(human.includes('test summary'), 'human render includes summary');
+        const jsonLine = (0, LogsCommand_1.renderLogsJson)(entries);
+        const parsed = JSON.parse(jsonLine);
+        assert(parsed.subsystem === 'governance-ledger', 'json render preserves subsystem');
+        console.log('✅ scenario 5: human + JSON renderers both produce expected shape');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioNoEntriesGracefullyHandled() {
+    const root = tempRoot();
+    try {
+        const entries = (0, LogsCommand_1.collectLogs)({ root });
+        assert(entries.length === 0, 'no jsonl files → empty result');
+        const human = (0, LogsCommand_1.renderLogsHuman)(entries);
+        assert(human.includes('no entries'), 'human render reports empty');
+        console.log('✅ scenario 6: empty state renders helpful message');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function main() {
+    console.log('🧪 test_logs_command — jsonl viewer');
+    scenarioDurationParser();
+    scenarioTailDefault();
+    scenarioFilterBySubsystem();
+    scenarioSinceFiltersOldEntries();
+    scenarioRenderHumanAndJson();
+    scenarioNoEntriesGracefullyHandled();
+    console.log('');
+    console.log('TEST_LOGS_COMMAND_OK');
+}
+main();

package/dist/test_status_command.js

@@ -0,0 +1,218 @@
+"use strict";
+// test_status_command — verifies the shape and overall-derivation logic of
+// `openlife status`. Uses a temp .openlife/ scratch dir so we don't rely on
+// (or pollute) the maintainer's local runtime state.
+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 StatusCommand_1 = require("./cli/StatusCommand");
+function assert(cond, msg) {
+    if (!cond) {
+        console.error(`❌ ASSERT FAILED: ${msg}`);
+        process.exit(1);
+    }
+}
+function tempRoot() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-status-'));
+    fs.mkdirSync(path.join(root, '.openlife'), { recursive: true });
+    return root;
+}
+function cleanup(root) {
+    try {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+function writeJson(root, filename, payload) {
+    fs.writeFileSync(path.join(root, '.openlife', filename), JSON.stringify(payload, null, 2), 'utf-8');
+}
+function writeJsonl(root, filename, entries) {
+    fs.writeFileSync(path.join(root, '.openlife', filename), entries.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+}
+function scenarioEmpty() {
+    const root = tempRoot();
+    try {
+        const report = (0, StatusCommand_1.buildStatusReport)(root);
+        assert(report.overall === 'down', 'empty state should be down (no heartbeat, no executors)');
+        assert(report.heartbeat.present === false, 'no heartbeat in empty state');
+        assert(report.governance.ledgerPresent === false, 'no governance ledger in empty state');
+        assert(report.executors.length === 0, 'no executors in empty state');
+        assert(report.notes.includes('no_heartbeat'), 'should note no_heartbeat');
+        console.log('✅ scenario 1: empty state → overall=down with no_heartbeat note');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioHealthy() {
+    const root = tempRoot();
+    try {
+        const now = Date.now();
+        writeJson(root, 'heartbeat.json', { pid: 12345, host: 'test-host', ts: now, uptime_s: 100, startedAt: now - 100_000 });
+        writeJson(root, 'runtime-policy-status.json', {
+            executors: {
+                openai: { executor: 'openai', available: true, reason: 'ok', updatedAt: new Date(now).toISOString() },
+                anthropic: { executor: 'anthropic', available: true, reason: 'ok', updatedAt: new Date(now).toISOString() },
+            },
+        });
+        writeJsonl(root, 'governance-ledger.jsonl', [
+            { index: 1, ts: new Date(now).toISOString(), entryHash: 'aaa' },
+            { index: 2, ts: new Date(now).toISOString(), entryHash: 'bbb' },
+        ]);
+        const report = (0, StatusCommand_1.buildStatusReport)(root);
+        assert(report.overall === 'healthy', `expected healthy, got ${report.overall} (notes: ${report.notes.join(',')})`);
+        assert(report.heartbeat.fresh === true, 'fresh heartbeat expected');
+        assert(report.executors.length === 2, 'two executors expected');
+        assert(report.executors.every((e) => e.available), 'all executors available');
+        assert(report.governance.entryCount === 2, 'two ledger entries expected');
+        assert(report.governance.lastEntryHash === 'bbb', 'last entry hash is bbb');
+        console.log('✅ scenario 2: healthy heartbeat + all executors + ledger → overall=healthy');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioDegradedOneExecutorDown() {
+    const root = tempRoot();
+    try {
+        const now = Date.now();
+        writeJson(root, 'heartbeat.json', { pid: 1, host: 'h', ts: now, uptime_s: 1, startedAt: now });
+        writeJson(root, 'runtime-policy-status.json', {
+            executors: {
+                openai: { executor: 'openai', available: true, reason: 'ok' },
+                anthropic: { executor: 'anthropic', available: false, reason: 'auth expired', category: 'auth' },
+            },
+        });
+        const report = (0, StatusCommand_1.buildStatusReport)(root);
+        assert(report.overall === 'degraded', `expected degraded, got ${report.overall}`);
+        assert(report.notes.some((n) => n.startsWith('executors_down:')), 'should note specific executors down');
+        console.log('✅ scenario 3: one executor down → overall=degraded');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioDownAllExecutorsDown() {
+    const root = tempRoot();
+    try {
+        const now = Date.now();
+        writeJson(root, 'heartbeat.json', { pid: 1, host: 'h', ts: now, uptime_s: 1, startedAt: now });
+        writeJson(root, 'runtime-policy-status.json', {
+            executors: {
+                openai: { executor: 'openai', available: false, reason: 'rate limit' },
+                anthropic: { executor: 'anthropic', available: false, reason: 'auth expired' },
+            },
+        });
+        const report = (0, StatusCommand_1.buildStatusReport)(root);
+        assert(report.overall === 'down', `expected down, got ${report.overall}`);
+        assert(report.notes.includes('all_executors_down'), 'should note all_executors_down');
+        console.log('✅ scenario 4: all executors down → overall=down');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioStaleHeartbeat() {
+    const root = tempRoot();
+    try {
+        const staleTs = Date.now() - (StatusCommand_1.HEARTBEAT_FRESH_S + 30) * 1000;
+        writeJson(root, 'heartbeat.json', { pid: 1, host: 'h', ts: staleTs, uptime_s: 9999, startedAt: staleTs - 1000 });
+        writeJson(root, 'runtime-policy-status.json', {
+            executors: { openai: { executor: 'openai', available: true, reason: 'ok' } },
+        });
+        const report = (0, StatusCommand_1.buildStatusReport)(root);
+        assert(report.overall === 'degraded', `expected degraded for stale beat, got ${report.overall}`);
+        assert(report.heartbeat.fresh === false, 'stale heartbeat is not fresh');
+        assert(report.notes.some((n) => n.startsWith('heartbeat_warning_')), 'should warn about stale heartbeat');
+        console.log('✅ scenario 5: stale heartbeat → overall=degraded with heartbeat_warning note');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioDeadHeartbeat() {
+    const root = tempRoot();
+    try {
+        const deadTs = Date.now() - (StatusCommand_1.HEARTBEAT_STALE_S + 60) * 1000;
+        writeJson(root, 'heartbeat.json', { pid: 1, host: 'h', ts: deadTs, uptime_s: 9999, startedAt: deadTs - 1000 });
+        writeJson(root, 'runtime-policy-status.json', {
+            executors: { openai: { executor: 'openai', available: true, reason: 'ok' } },
+        });
+        const report = (0, StatusCommand_1.buildStatusReport)(root);
+        assert(report.overall === 'down', `expected down for dead beat, got ${report.overall}`);
+        assert(report.notes.some((n) => n.startsWith('heartbeat_stale_')), 'should note heartbeat_stale_<age>s');
+        console.log('✅ scenario 6: dead heartbeat → overall=down');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function scenarioCorruptLedgerHandled() {
+    const root = tempRoot();
+    try {
+        const now = Date.now();
+        writeJson(root, 'heartbeat.json', { pid: 1, host: 'h', ts: now, uptime_s: 1, startedAt: now });
+        writeJson(root, 'runtime-policy-status.json', {
+            executors: { openai: { executor: 'openai', available: true, reason: 'ok' } },
+        });
+        // Write a corrupt last line — must not throw.
+        fs.writeFileSync(path.join(root, '.openlife', 'governance-ledger.jsonl'), '{"index":1,"entryHash":"good","ts":"' + new Date(now).toISOString() + '"}\n{not-valid-json\n', 'utf-8');
+        const report = (0, StatusCommand_1.buildStatusReport)(root);
+        assert(report.governance.entryCount === 2, 'should count both lines (parseability separate from count)');
+        // Last entry was corrupt → lastEntryHash undefined; gracefully degraded, doesn't throw.
+        assert(report.governance.lastEntryHash === undefined, 'corrupt last line yields no entryHash');
+        console.log('✅ scenario 7: corrupt ledger line handled gracefully');
+    }
+    finally {
+        cleanup(root);
+    }
+}
+function main() {
+    console.log('🧪 test_status_command — runtime state aggregator');
+    scenarioEmpty();
+    scenarioHealthy();
+    scenarioDegradedOneExecutorDown();
+    scenarioDownAllExecutorsDown();
+    scenarioStaleHeartbeat();
+    scenarioDeadHeartbeat();
+    scenarioCorruptLedgerHandled();
+    console.log('');
+    console.log('TEST_STATUS_COMMAND_OK');
+}
+main();