@openlife/cli 1.7.6 → 1.7.9

package/dist/test_agent_creator.js

@@ -0,0 +1,237 @@
+"use strict";
+// test_agent_creator — verifies the authoring pipeline for standalone agents.
+// Each scenario uses a temp catalog root so we don't touch the maintainer's
+// real `.catalog/agents/`.
+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 AgentCreator_1 = require("./orchestrator/AgentCreator");
+function assert(cond, msg) {
+    if (!cond) {
+        console.error(`❌ ASSERT FAILED: ${msg}`);
+        process.exit(1);
+    }
+}
+function tempCatalog() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-agentcreator-'));
+    const agents = path.join(root, 'agents');
+    const skills = path.join(root, 'skills');
+    const squads = path.join(root, 'squads');
+    fs.mkdirSync(agents, { recursive: true });
+    fs.mkdirSync(skills, { recursive: true });
+    fs.mkdirSync(squads, { recursive: true });
+    return { root, agents, skills, squads };
+}
+function cleanup(root) {
+    try {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+    catch { /* best effort */ }
+}
+function scenarioMinimalProposal() {
+    const cat = tempCatalog();
+    try {
+        const creator = new AgentCreator_1.AgentCreator({ catalogRoot: cat.agents, skillsCatalogRoot: cat.skills, squadsCatalogRoot: cat.squads });
+        const result = creator.create({ id: 'minimal-agent', name: 'Minimal', role: 'specialist' });
+        assert(result.ok === true, 'minimal proposal should succeed');
+        if (!result.ok)
+            return;
+        assert(fs.existsSync(result.filePath), 'AGENT.md file written');
+        const body = fs.readFileSync(result.filePath, 'utf-8');
+        assert(body.includes('id: minimal-agent'), 'frontmatter contains id');
+        assert(body.includes('## Goal'), 'has Goal section');
+        assert(body.includes('## Commands'), 'has Commands section');
+        assert(body.includes('## Dependencies'), 'has Dependencies section');
+        assert(body.includes('## Persona'), 'has Persona section');
+        assert(body.includes('## Guardrails'), 'has Guardrails section');
+        console.log('✅ scenario 1: minimal proposal renders full 5-section AGENT.md');
+    }
+    finally {
+        cleanup(cat.root);
+    }
+}
+function scenarioFullProposalWithCrossRefs() {
+    const cat = tempCatalog();
+    try {
+        // Create a referenced skill + squad first so cross-refs resolve.
+        fs.mkdirSync(path.join(cat.skills, 'planning-skill'), { recursive: true });
+        fs.writeFileSync(path.join(cat.skills, 'planning-skill', 'SKILL.md'), '---\nid: planning-skill\n---\n', 'utf-8');
+        fs.mkdirSync(path.join(cat.squads, 'ops-squad'), { recursive: true });
+        fs.writeFileSync(path.join(cat.squads, 'ops-squad', 'SQUAD.md'), '---\nid: ops-squad\nname: ops\nstatus: active\n---\n', 'utf-8');
+        const creator = new AgentCreator_1.AgentCreator({ catalogRoot: cat.agents, skillsCatalogRoot: cat.skills, squadsCatalogRoot: cat.squads });
+        const result = creator.create({
+            id: 'full-agent',
+            name: 'Full Agent',
+            role: 'planner',
+            domain: 'ops',
+            expertise: ['planning', 'routing'],
+            primarySkills: ['planning-skill'],
+            parentSquad: 'ops-squad',
+            whenToUse: 'When operators need a structured plan.',
+            identity: 'Methodical planner.',
+            style: 'Concrete, step-driven.',
+            focus: 'Operational planning.',
+        });
+        assert(result.ok === true, 'full proposal should succeed');
+        if (!result.ok)
+            return;
+        const validation = creator.validate('full-agent');
+        assert(validation.ok === true, `validation should pass, got errors: ${validation.errors.join(',')}`);
+        assert(validation.warnings.length === 0, `no warnings expected, got: ${validation.warnings.join(',')}`);
+        console.log('✅ scenario 2: full proposal with valid cross-refs passes validation cleanly');
+    }
+    finally {
+        cleanup(cat.root);
+    }
+}
+function scenarioOrphanCrossRefsBecomeWarnings() {
+    const cat = tempCatalog();
+    try {
+        const creator = new AgentCreator_1.AgentCreator({ catalogRoot: cat.agents, skillsCatalogRoot: cat.skills, squadsCatalogRoot: cat.squads });
+        const result = creator.create({
+            id: 'orphan-agent',
+            name: 'Orphan',
+            role: 'specialist',
+            primarySkills: ['missing-skill'],
+            parentSquad: 'missing-squad',
+        });
+        assert(result.ok === true, 'creation succeeds even with orphan refs (validation surfaces them later)');
+        const v = creator.validate('orphan-agent');
+        assert(v.ok === true, 'validation passes — orphans are warnings, not errors');
+        assert(v.warnings.length === 2, `expected 2 warnings, got ${v.warnings.length}`);
+        assert(v.warnings.some((w) => w.includes('missing-skill')), 'warning mentions missing skill');
+        assert(v.warnings.some((w) => w.includes('missing-squad')), 'warning mentions missing squad');
+        console.log('✅ scenario 3: orphan skill/squad refs become warnings, not errors');
+    }
+    finally {
+        cleanup(cat.root);
+    }
+}
+function scenarioInvalidIdRejected() {
+    const cat = tempCatalog();
+    try {
+        const creator = new AgentCreator_1.AgentCreator({ catalogRoot: cat.agents, skillsCatalogRoot: cat.skills, squadsCatalogRoot: cat.squads });
+        const result = creator.create({ id: '!invalid id!', name: 'X', role: 'specialist' });
+        assert(result.ok === false, 'invalid id should be rejected');
+        if (result.ok)
+            return;
+        assert(result.error === 'invalid_agent_id', `expected invalid_agent_id, got ${result.error}`);
+        console.log('✅ scenario 4: invalid id (special chars / spaces) rejected up front');
+    }
+    finally {
+        cleanup(cat.root);
+    }
+}
+function scenarioDuplicateAgentRejected() {
+    const cat = tempCatalog();
+    try {
+        const creator = new AgentCreator_1.AgentCreator({ catalogRoot: cat.agents, skillsCatalogRoot: cat.skills, squadsCatalogRoot: cat.squads });
+        creator.create({ id: 'dup-test', name: 'Dup', role: 'specialist' });
+        const second = creator.create({ id: 'dup-test', name: 'Dup2', role: 'specialist' });
+        assert(second.ok === false, 'second create should fail');
+        if (second.ok)
+            return;
+        assert(second.error === 'agent_already_exists', `expected agent_already_exists, got ${second.error}`);
+        console.log('✅ scenario 5: duplicate agent rejected without overwriting');
+    }
+    finally {
+        cleanup(cat.root);
+    }
+}
+function scenarioListAndAnalyze() {
+    const cat = tempCatalog();
+    try {
+        const creator = new AgentCreator_1.AgentCreator({ catalogRoot: cat.agents, skillsCatalogRoot: cat.skills, squadsCatalogRoot: cat.squads });
+        creator.create({ id: 'agent-a', name: 'A', role: 'specialist', status: 'active' });
+        creator.create({ id: 'agent-b', name: 'B', role: 'planner', status: 'draft' });
+        const all = creator.list();
+        assert(all.length === 2, `expected 2 agents, got ${all.length}`);
+        const onlyDraft = creator.list({ status: 'draft' });
+        assert(onlyDraft.length === 1, 'filter by status=draft returns 1');
+        assert(onlyDraft[0].id === 'agent-b', 'correct one returned');
+        const analysis = creator.analyze('agent-a');
+        assert(analysis !== null, 'analyze finds existing agent');
+        assert(analysis.commandCount >= 1, 'at least one command (help fallback) reported');
+        assert(analysis.suggestions.length >= 0, 'suggestions array returned (may be empty)');
+        console.log('✅ scenario 6: list + analyze report accurate catalog shape');
+    }
+    finally {
+        cleanup(cat.root);
+    }
+}
+function scenarioCustomCommandsAndGuardrails() {
+    const cat = tempCatalog();
+    try {
+        const creator = new AgentCreator_1.AgentCreator({ catalogRoot: cat.agents, skillsCatalogRoot: cat.skills, squadsCatalogRoot: cat.squads });
+        const result = creator.create({
+            id: 'rich-cmds',
+            name: 'Rich',
+            role: 'specialist',
+            commands: [
+                { name: 'plan', description: 'Generate a step-by-step plan' },
+                { name: 'review', description: 'Review work against criteria' },
+            ],
+            guardrails: ['Never push without operator approval', 'Always log audit events'],
+        });
+        assert(result.ok === true, 'create succeeds');
+        if (!result.ok)
+            return;
+        const body = fs.readFileSync(result.filePath, 'utf-8');
+        assert(body.includes('name: plan'), 'custom plan command rendered');
+        assert(body.includes('name: review'), 'custom review command rendered');
+        assert(body.includes('Never push without operator approval'), 'custom guardrail rendered');
+        const analysis = creator.analyze('rich-cmds');
+        assert(analysis.commandCount === 2, `expected 2 commands counted, got ${analysis.commandCount}`);
+        console.log('✅ scenario 7: custom commands + guardrails flow through to AGENT.md');
+    }
+    finally {
+        cleanup(cat.root);
+    }
+}
+function main() {
+    console.log('🧪 test_agent_creator — authoring pipeline for standalone agents');
+    scenarioMinimalProposal();
+    scenarioFullProposalWithCrossRefs();
+    scenarioOrphanCrossRefsBecomeWarnings();
+    scenarioInvalidIdRejected();
+    scenarioDuplicateAgentRejected();
+    scenarioListAndAnalyze();
+    scenarioCustomCommandsAndGuardrails();
+    console.log('');
+    console.log('TEST_AGENT_CREATOR_OK');
+}
+main();

package/dist/test_install_wizard.js

@@ -296,7 +296,32 @@ async function scenario10WithApiKeysPersists() {
         cleanup(root);
     }
 }
-async function scenario11ProfileBothMapsToAutonomous() {
+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),
@@ -327,7 +352,8 @@ async function main() {
     await scenario8CustomModelChain();
     await scenario9OutOfAnswersThrows();
     await scenario10WithApiKeysPersists();
-    await scenario11ProfileBothMapsToAutonomous();
+    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();