@openlife/cli 1.7.3

package/dist/test_cli_crud_roundtrip.js

@@ -0,0 +1,154 @@
+"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 child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const CLI = path.join(process.cwd(), 'dist', 'index.js');
+const RUN_ID = `test-crud-${process.pid}-${Date.now()}`;
+function rm(p) { try {
+    fs.rmSync(p, { recursive: true, force: true });
+}
+catch { } }
+function rmFromJson(filePath, idsKey, id) {
+    try {
+        if (!fs.existsSync(filePath))
+            return;
+        const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (data && typeof data === 'object' && Array.isArray(data[idsKey])) {
+            data[idsKey] = data[idsKey].filter((e) => e?.id !== id);
+            fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+        }
+        else if (Array.isArray(data)) {
+            const filtered = data.filter((e) => e?.id !== id);
+            fs.writeFileSync(filePath, JSON.stringify(filtered, null, 2));
+        }
+    }
+    catch { }
+}
+const ROUND_TRIPS = [
+    {
+        label: 'agents',
+        createArgs: ['agents', 'create', `${RUN_ID}-agent`, '--role', 'specialist', '--notes', 'crud-test'],
+        listArgs: ['agents', 'list'],
+        presentCheck: (out, id) => out.includes(id),
+        cleanup: (id) => rm(path.join(process.cwd(), '.catalog', 'agents', id))
+    },
+    {
+        label: 'squads',
+        createArgs: ['squads', 'create', `${RUN_ID}-squad`, '--domain', 'general', '--notes', 'crud-test'],
+        listArgs: ['squads', 'list'],
+        presentCheck: (out, id) => out.includes(id),
+        cleanup: (id) => rm(path.join(process.cwd(), '.catalog', 'squads', id))
+    },
+    {
+        label: 'skills',
+        createArgs: ['skills', 'create', `${RUN_ID}-skill`, '--notes', 'crud-test'],
+        listArgs: ['skills', 'list'],
+        presentCheck: (out, id) => out.includes(id),
+        cleanup: (id) => rm(path.join(process.cwd(), '.catalog', 'skills', id))
+    },
+    {
+        label: 'mcp',
+        createArgs: ['mcp', 'create', `${RUN_ID}-mcp`, '--transport', 'stdio', '--entry', 'echo'],
+        listArgs: ['mcp', 'status', '--real'],
+        presentCheck: (out, id) => out.includes(id) || out.includes('"mcporter"'), // mcp list isn't a thing; mcp status shows registry indirectly
+        cleanup: (id) => rm(path.join(process.cwd(), '.catalog', 'mcps', id))
+    },
+    {
+        label: 'teams',
+        createArgs: ['teams', 'upsert', `${RUN_ID}-team`, '--domain', 'general', '--description', 'crud-test', '--sla', 'balanced'],
+        listArgs: ['teams', 'list'],
+        presentCheck: (out, id) => out.includes(id),
+        cleanup: (id) => rmFromJson(path.join(process.cwd(), '.catalog', 'teams.json'), 'teams', id)
+    },
+    {
+        label: 'networks',
+        createArgs: ['networks', 'upsert', `${RUN_ID}-net`, '--domain', 'general', '--capabilities', 'cap1,cap2'],
+        listArgs: ['networks', 'list'],
+        presentCheck: (out, id) => out.includes(id),
+        cleanup: (id) => rmFromJson(path.join(process.cwd(), '.catalog', 'skill-networks.json'), 'networks', id)
+    }
+];
+function runSync(args) {
+    const r = (0, child_process_1.spawnSync)('node', [CLI, ...args], { encoding: 'utf-8', timeout: 15000 });
+    return { code: r.status, stdout: r.stdout || '', stderr: r.stderr || '' };
+}
+async function main() {
+    if (!fs.existsSync(CLI))
+        throw new Error(`MISSING_BUILD: ${CLI}`);
+    const failures = [];
+    const cleanupIds = [];
+    try {
+        for (const rt of ROUND_TRIPS) {
+            const id = rt.createArgs[rt.createArgs.indexOf(rt.label === 'teams' || rt.label === 'networks' ? 'upsert' : 'create') + 1];
+            cleanupIds.push({ rt, id });
+            // CREATE
+            const c = runSync(rt.createArgs);
+            if (c.code !== 0) {
+                failures.push(`[${rt.label}] CREATE exit=${c.code} stderr=${(c.stderr || '').slice(0, 150)}`);
+                continue;
+            }
+            // LIST + presence check
+            const l = runSync(rt.listArgs);
+            if (l.code !== 0 && l.code !== 1) {
+                failures.push(`[${rt.label}] LIST exit=${l.code} stderr=${(l.stderr || '').slice(0, 150)}`);
+                continue;
+            }
+            const combined = l.stdout + '\n' + l.stderr;
+            if (!rt.presentCheck(combined, id)) {
+                failures.push(`[${rt.label}] entity ${id} not visible in ${rt.listArgs.join(' ')} output`);
+                continue;
+            }
+        }
+    }
+    finally {
+        // Always cleanup
+        for (const { rt, id } of cleanupIds) {
+            try {
+                rt.cleanup(id);
+            }
+            catch { }
+        }
+    }
+    if (failures.length > 0) {
+        throw new Error(`CRUD_ROUNDTRIP_FAILURES (${failures.length}):\n${failures.join('\n')}`);
+    }
+    console.log(`TEST_CLI_CRUD_ROUNDTRIP_OK (${ROUND_TRIPS.length} entity types, runId=${RUN_ID})`);
+}
+main().catch((err) => {
+    console.error('TEST_CLI_CRUD_ROUNDTRIP_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_cli_diagnostics.js

@@ -0,0 +1,131 @@
+"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 child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+// Read-only diagnostics that should work without external creds.
+// CLI-02 + CLI-03 + CLI-04 consolidated.
+const SPECS = [
+    // CLI-04 — phase1-check (KNOWN BUG: hangs >35s; see Phase 5 finding P2-BUG-01)
+    { args: ['phase1-check'], label: 'phase1-check', classify: 'gap', reason: 'KNOWN BUG: hangs; needs Phase 5 fix' },
+    // Catalog
+    { args: ['catalog', 'list'], label: 'catalog list', classify: 'pass' },
+    { args: ['catalog', 'doctor'], label: 'catalog doctor', classify: 'graceful', reason: 'may report stale test entries (P3 known)' },
+    // Listings (no external deps — pure file reads)
+    { args: ['agents', 'list'], label: 'agents list', classify: 'pass' },
+    { args: ['squads', 'list'], label: 'squads list', classify: 'pass' },
+    { args: ['skills', 'list'], label: 'skills list', classify: 'pass' },
+    // Status surfaces
+    { args: ['models', 'status'], label: 'models status', classify: 'pass' },
+    { args: ['memory', 'status'], label: 'memory status', classify: 'pass' },
+    { args: ['memory', 'provider-list'], label: 'memory provider-list', classify: 'pass' },
+    { args: ['governance', 'status'], label: 'governance status', classify: 'pass' },
+    { args: ['governance', 'audit'], label: 'governance audit', classify: 'pass' },
+    { args: ['mcp', 'status'], label: 'mcp status', classify: 'pass' },
+    // Aggregate doctors
+    { args: ['system', 'doctor'], label: 'system doctor', classify: 'graceful', reason: 'may warn about optional CLIs (codex/gemini)' },
+    { args: ['system', 'status'], label: 'system status', classify: 'graceful' },
+    { args: ['media', 'doctor'], label: 'media doctor', classify: 'graceful' },
+    { args: ['media', 'route-status'], label: 'media route-status', classify: 'pass' },
+    { args: ['enterprise'], label: 'enterprise', classify: 'graceful', reason: 'aggregate doctor; degrades gracefully on missing state' },
+    // Orchestration
+    { args: ['orchestration', 'contract'], label: 'orchestration contract', classify: 'pass' },
+    { args: ['orchestration', 'snapshot'], label: 'orchestration snapshot', classify: 'pass' },
+    // Swarm — consensus-test does not call LLM (uses deterministic stubs)
+    { args: ['swarm', 'consensus-test'], label: 'swarm consensus-test', classify: 'graceful' },
+    // Live commands — recorded as GAP (Phase 4)
+    { args: ['system', 'doctor-world'], label: 'system doctor-world', classify: 'gap', reason: 'requires LLM' },
+    { args: ['benchmark', 'report'], label: 'benchmark report', classify: 'gap', reason: 'requires prior benchmark runs' }
+];
+function run(args, timeoutMs) {
+    return new Promise((resolve) => {
+        const t0 = Date.now();
+        const cliPath = path.join(process.cwd(), 'dist', 'index.js');
+        const child = (0, child_process_1.spawn)('node', [cliPath, ...args], { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (d) => { stdout += d.toString(); });
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        const killer = setTimeout(() => child.kill('SIGKILL'), timeoutMs);
+        child.on('exit', (code) => {
+            clearTimeout(killer);
+            resolve({ code, elapsed: Date.now() - t0, stdout: stdout.slice(0, 500), stderr: stderr.slice(0, 300) });
+        });
+    });
+}
+async function main() {
+    const results = [];
+    for (const spec of SPECS) {
+        // Short timeout for gap commands (already known broken/deferred) — saves test:all budget
+        const timeoutMs = spec.classify === 'gap' ? 2000 : 15000;
+        const r = await run(spec.args, timeoutMs);
+        results.push({ spec, ...r });
+    }
+    const failures = [];
+    const passCount = { pass: 0, graceful: 0, gap: 0 };
+    for (const r of results) {
+        const { spec, code, elapsed, stderr } = r;
+        if (spec.classify === 'pass') {
+            if (code !== 0) {
+                failures.push(`${spec.label} → exit=${code} (expected 0)${stderr ? ` stderr=${stderr.slice(0, 120)}` : ''}`);
+            }
+            else {
+                passCount.pass++;
+            }
+        }
+        else if (spec.classify === 'graceful') {
+            // Accept 0 or 1; flag if it crashed (null code = killed; -1/2+ = abnormal)
+            if (code === 0 || code === 1) {
+                passCount.graceful++;
+            }
+            else {
+                failures.push(`${spec.label} → crash exit=${code}${stderr ? ` stderr=${stderr.slice(0, 120)}` : ''}`);
+            }
+        }
+        else {
+            // gap: don't assert, just log
+            passCount.gap++;
+        }
+        void elapsed;
+    }
+    if (failures.length > 0) {
+        throw new Error(`DIAGNOSTICS_FAILURES (${failures.length}):\n${failures.join('\n')}`);
+    }
+    console.log(`TEST_CLI_DIAGNOSTICS_OK (pass=${passCount.pass}, graceful=${passCount.graceful}, gap=${passCount.gap}, total=${results.length})`);
+}
+main().catch((err) => {
+    console.error('TEST_CLI_DIAGNOSTICS_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_cli_doc_parity.js

@@ -0,0 +1,126 @@
+"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 child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const CLI = path.join(process.cwd(), 'dist', 'index.js');
+function getHelp(args = []) {
+    const r = (0, child_process_1.spawnSync)('node', [CLI, ...args, '--help'], { encoding: 'utf-8', timeout: 15000 });
+    return (r.stdout || '') + (r.stderr || '');
+}
+function assertCommandExists(args, label) {
+    const r = (0, child_process_1.spawnSync)('node', [CLI, ...args, '--help'], { encoding: 'utf-8', timeout: 15000 });
+    if (r.status !== 0) {
+        throw new Error(`MISSING_COMMAND[${label}]: \`openlife ${args.join(' ')}\` returned exit ${r.status}\nstdout: ${r.stdout}\nstderr: ${r.stderr}`);
+    }
+}
+const rootHelp = getHelp();
+const requiredTopLevel = ['agents', 'governance', 'install', 'start', 'status', 'agent'];
+for (const cmd of requiredTopLevel) {
+    if (!new RegExp(`(^|\\s)${cmd}\\b`, 'm').test(rootHelp)) {
+        throw new Error(`MISSING_TOP_LEVEL_COMMAND: "${cmd}" not present in root --help output`);
+    }
+}
+assertCommandExists(['agents'], 'agents-group');
+const agentsHelp = getHelp(['agents']);
+for (const sub of ['list', 'create', 'show']) {
+    if (!new RegExp(`\\b${sub}\\b`).test(agentsHelp)) {
+        throw new Error(`MISSING_SUBCOMMAND[agents ${sub}]: not in agents --help`);
+    }
+}
+const governanceHelp = getHelp(['governance']);
+for (const sub of ['status', 'audit', 'risk-check', 'consent', 'policy']) {
+    if (!new RegExp(`\\b${sub}\\b`).test(governanceHelp)) {
+        throw new Error(`MISSING_SUBCOMMAND[governance ${sub}]: not in governance --help`);
+    }
+}
+const policyHelp = getHelp(['governance', 'policy']);
+if (!/\bshow\b/.test(policyHelp))
+    throw new Error('MISSING_SUBCOMMAND[governance policy show]');
+const tmpAgentDir = path.join(process.cwd(), '.catalog', 'agents', 'test-cli-doc-parity-agent');
+const tmpAgentFile = path.join(tmpAgentDir, 'AGENT.md');
+fs.mkdirSync(tmpAgentDir, { recursive: true });
+fs.writeFileSync(tmpAgentFile, `---\nid: test-cli-doc-parity-agent\nrole: tester\nstatus: draft\n---\n\n# test-cli-doc-parity-agent\n\n## Capabilities\n- routing\n- diagnostics\n`, 'utf-8');
+try {
+    const showRes = (0, child_process_1.spawnSync)('node', [CLI, 'agents', 'show', 'test-cli-doc-parity-agent'], { encoding: 'utf-8', timeout: 15000 });
+    if (showRes.status !== 0) {
+        throw new Error(`AGENTS_SHOW_EXIT_${showRes.status}\nstdout: ${showRes.stdout}\nstderr: ${showRes.stderr}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(showRes.stdout);
+    }
+    catch {
+        throw new Error(`AGENTS_SHOW_NOT_JSON: ${showRes.stdout.slice(0, 200)}`);
+    }
+    if (!parsed.ok || parsed.id !== 'test-cli-doc-parity-agent')
+        throw new Error(`AGENTS_SHOW_WRONG_PAYLOAD: ${JSON.stringify(parsed)}`);
+    if (!Array.isArray(parsed.capabilities) || parsed.capabilities.length !== 2) {
+        throw new Error(`AGENTS_SHOW_CAPABILITIES_NOT_PARSED: ${JSON.stringify(parsed.capabilities)}`);
+    }
+    const missingRes = (0, child_process_1.spawnSync)('node', [CLI, 'agents', 'show', 'definitely-does-not-exist-xyz'], { encoding: 'utf-8', timeout: 15000 });
+    if (missingRes.status === 0)
+        throw new Error('AGENTS_SHOW_SHOULD_FAIL_FOR_MISSING_ID');
+    if (!/agent_not_found/.test(missingRes.stdout))
+        throw new Error(`AGENTS_SHOW_MISSING_PAYLOAD: ${missingRes.stdout}`);
+    const policyShowRes = (0, child_process_1.spawnSync)('node', [CLI, 'governance', 'policy', 'show'], { encoding: 'utf-8', timeout: 15000 });
+    let policyPayload;
+    try {
+        policyPayload = JSON.parse(policyShowRes.stdout);
+    }
+    catch {
+        throw new Error(`POLICY_SHOW_NOT_JSON: ${policyShowRes.stdout.slice(0, 200)}`);
+    }
+    if (typeof policyPayload.ok !== 'boolean')
+        throw new Error(`POLICY_SHOW_NO_OK_FIELD`);
+}
+finally {
+    fs.rmSync(tmpAgentDir, { recursive: true, force: true });
+}
+const installDocs = ['INSTALL.md', 'README.md'].filter((f) => fs.existsSync(path.join(process.cwd(), f)));
+const documentedVerbs = new Set();
+for (const doc of installDocs) {
+    const raw = fs.readFileSync(path.join(process.cwd(), doc), 'utf-8');
+    const matches = raw.matchAll(/\bopenlife\s+(agent|agents|install|start|status|governance|system)\b/g);
+    for (const m of matches)
+        documentedVerbs.add(m[1]);
+}
+for (const v of documentedVerbs) {
+    if (!new RegExp(`\\b${v}\\b`).test(rootHelp)) {
+        throw new Error(`DOC_DRIFT: docs reference "openlife ${v}" but root --help has no such command`);
+    }
+}
+console.log(`TEST_CLI_DOC_PARITY_OK (top-level=${requiredTopLevel.length}, docs-checked=${installDocs.join(',')}, doc-verbs=${[...documentedVerbs].join('|')})`);

package/dist/test_cli_help_surface.js

@@ -0,0 +1,106 @@
+"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 child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const TOP_LEVEL_COMMANDS = [
+    'install', 'ask', 'phase1-check', 'status', 'doctor', 'restart', 'update', 'up',
+    'agent', 'start', 'dream',
+    'auth', 'models', 'system', 'memory', 'swarm', 'governance', 'benchmark',
+    'agents', 'squads', 'skills', 'route', 'mcp', 'catalog', 'teams', 'networks',
+    'media', 'orchestration', 'smoke', 'service', 'task', 'job', 'runtime',
+    'reversa', 'sources', 'teammate', 'learning', 'context', 'plugin', 'pilot',
+    'eval', 'learn', 'enterprise', 'designmd', 'aiobuilder'
+];
+function runHelp(args, timeoutMs) {
+    return new Promise((resolve) => {
+        const t0 = Date.now();
+        const cliPath = path.join(process.cwd(), 'dist', 'index.js');
+        const child = (0, child_process_1.spawn)('node', [cliPath, ...args], { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdoutBytes = 0;
+        let stderr = '';
+        child.stdout?.on('data', (d) => { stdoutBytes += d.length; });
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        const killer = setTimeout(() => child.kill('SIGKILL'), timeoutMs);
+        child.on('exit', (code) => {
+            clearTimeout(killer);
+            resolve({ command: args.join(' '), code, elapsed: Date.now() - t0, stdoutBytes, stderr: stderr.slice(0, 200) });
+        });
+    });
+}
+async function main() {
+    const cliPath = path.join(process.cwd(), 'dist', 'index.js');
+    if (!fs.existsSync(cliPath))
+        throw new Error(`MISSING_BUILD: ${cliPath}`);
+    const failures = [];
+    const slow = [];
+    // Root help (expect verbose) + version (expect ~6 bytes for "1.0.0\n")
+    for (const { args, minBytes } of [{ args: ['--help'], minBytes: 50 }, { args: ['--version'], minBytes: 3 }]) {
+        const r = await runHelp(args, 5000);
+        if (r.code !== 0)
+            failures.push(`${r.command} → exit=${r.code} stderr=${r.stderr}`);
+        if (r.stdoutBytes < minBytes)
+            failures.push(`${r.command} → stdout too small (${r.stdoutBytes} bytes, expected >= ${minBytes})`);
+        if (r.elapsed > 3000)
+            slow.push(`${r.command} (${r.elapsed}ms)`);
+    }
+    // Per-group help
+    let okCount = 0;
+    for (const cmd of TOP_LEVEL_COMMANDS) {
+        const r = await runHelp([cmd, '--help'], 5000);
+        if (r.code !== 0) {
+            failures.push(`${cmd} --help → exit=${r.code} stderr=${r.stderr}`);
+            continue;
+        }
+        if (r.stdoutBytes < 10) {
+            failures.push(`${cmd} --help → empty stdout (only ${r.stdoutBytes} bytes)`);
+            continue;
+        }
+        if (r.elapsed > 3000)
+            slow.push(`${cmd} --help (${r.elapsed}ms)`);
+        okCount++;
+    }
+    if (failures.length > 0) {
+        throw new Error(`HELP_SURFACE_FAILURES (${failures.length}):\n${failures.join('\n')}`);
+    }
+    console.log(`TEST_CLI_HELP_SURFACE_OK (${okCount}/${TOP_LEVEL_COMMANDS.length} groups + 2 root invocations)`);
+    if (slow.length > 0)
+        console.log(`  SLOW (>3s): ${slow.join(', ')}`);
+}
+main().catch((err) => {
+    console.error('TEST_CLI_HELP_SURFACE_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_cli_service_commands.js

@@ -0,0 +1,83 @@
+"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 path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function run(cmd) {
+    return (0, child_process_1.execSync)(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+}
+const root = path.join(__dirname, '..');
+const artifacts = path.join(root, '.artifacts');
+const servicesDir = path.join(artifacts, 'workspaces', 'default', 'services');
+const eventsDir = path.join(servicesDir, 'events');
+const missionsDir = path.join(artifacts, 'missions');
+fs.mkdirSync(eventsDir, { recursive: true });
+fs.mkdirSync(missionsDir, { recursive: true });
+const serviceId = `svc_test_${Date.now()}`;
+const servicePath = path.join(servicesDir, `${serviceId}.json`);
+const service = {
+    serviceId,
+    objective: 'Teste CLI service commands',
+    status: 'active',
+    riskProfile: 'medium',
+    slo: {},
+    kpis: {},
+    budget: { hardStop: false },
+    missionIds: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+};
+fs.writeFileSync(servicePath, JSON.stringify(service, null, 2), 'utf-8');
+const statusOut = run(`node dist/index.js service status ${serviceId}`);
+assert(statusOut.includes('"serviceId":'), 'service status should print service json');
+run(`node dist/index.js service pause ${serviceId} --reason "teste pausa"`);
+const paused = JSON.parse(fs.readFileSync(servicePath, 'utf-8'));
+assert(paused.status === 'paused', 'service pause should set paused');
+run(`node dist/index.js service resume ${serviceId} --reason "teste resume"`);
+const resumed = JSON.parse(fs.readFileSync(servicePath, 'utf-8'));
+assert(resumed.status === 'active', 'service resume should set active');
+const eventsOut = run(`node dist/index.js service events ${serviceId} --limit 5`);
+assert(eventsOut.includes('service_paused') || eventsOut.includes('service_resumed'), 'service events should include status transitions');
+const taskId = `task_test_${Date.now()}`;
+const missionPath = path.join(missionsDir, `${taskId}.json`);
+fs.writeFileSync(missionPath, JSON.stringify({ taskId, status: 'completed', mode: 'task' }, null, 2), 'utf-8');
+const taskOut = run(`node dist/index.js task status ${taskId}`);
+assert(taskOut.includes('"taskId"'), 'task status should print task json');
+console.log('TEST_CLI_SERVICE_COMMANDS_OK');