@openlife/cli 1.7.3

package/dist/test_deep_research_capability.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * test_deep_research_capability.ts — Story 3.4
+ *
+ * Asserts the bundled `.catalog/capabilities/deep-research/` pack exists,
+ * parses cleanly via CapabilityPackParser, and exposes the 5 skills + 1
+ * squad + 1 workflow promised by the Hermes brief.
+ *
+ * This is a seed-asset regression: if anyone moves/breaks the deep-research
+ * pack, this test fails fast.
+ */
+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 CapabilityPackParser_1 = require("./orchestrator/capability/CapabilityPackParser");
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+const packDir = path.join(process.cwd(), '.catalog', 'capabilities', 'deep-research');
+assertTrue(fs.existsSync(packDir), `pack dir exists at ${packDir}`);
+const manifestPath = path.join(packDir, 'capability.yaml');
+assertTrue(fs.existsSync(manifestPath), 'capability.yaml present');
+console.log('[3.4] manifest present ✓');
+const r = (0, CapabilityPackParser_1.parseCapabilityPackFile)(manifestPath);
+assertTrue(r.ok, `manifest parses cleanly (errors=${JSON.stringify(r.errors)})`);
+const pack = r.pack;
+assertTrue(pack.id === 'deep-research', 'id matches');
+assertTrue(pack.status === 'draft', 'status starts at draft');
+console.log('[3.4] manifest parses ✓');
+// Hermes brief asks for: 5 skills + 1 squad + 1 workflow.
+const skillIds = new Set((pack.skills || []).map((s) => s.id));
+const expectedSkills = ['source-credibility-scoring', 'evidence-synthesis', 'contradiction-analysis', 'advanced-query-planning', 'executive-briefing'];
+for (const s of expectedSkills) {
+    assertTrue(skillIds.has(s), `skill '${s}' present`);
+}
+console.log(`[3.4] ${expectedSkills.length}/5 expected skills present ✓`);
+const squadIds = new Set((pack.squads || []).map((s) => s.id));
+assertTrue(squadIds.has('research-squad'), 'research-squad present');
+console.log('[3.4] research-squad present ✓');
+const workflowIds = new Set((pack.workflows || []).map((s) => s.id));
+assertTrue(workflowIds.has('deep-research-flow'), 'deep-research-flow present');
+console.log('[3.4] deep-research-flow present ✓');
+// All embedded refs must have corresponding files.
+for (const s of expectedSkills) {
+    assertTrue(fs.existsSync(path.join(packDir, 'skills', `${s}.md`)), `skill file ${s}.md exists`);
+}
+assertTrue(fs.existsSync(path.join(packDir, 'squads', 'research-squad', 'SQUAD.md')), 'research-squad SQUAD.md exists');
+assertTrue(fs.existsSync(path.join(packDir, 'workflows', 'deep-research-flow.yaml')), 'deep-research-flow.yaml exists');
+console.log('[3.4] all embedded files present ✓');
+// INDEX.md
+assertTrue(fs.existsSync(path.join(packDir, 'INDEX.md')), 'INDEX.md present');
+console.log('[3.4] INDEX.md present ✓');
+console.log('TEST_DEEP_RESEARCH_CAPABILITY_OK');

package/dist/test_designmd_import_registry.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DesignMdImporter_1 = require("./design/DesignMdImporter");
+const DesignMdRegistry_1 = require("./design/DesignMdRegistry");
+const importer = new DesignMdImporter_1.DesignMdImporter();
+const imported = importer.importFromVendor('vendor/awesome-design-md');
+if (!imported.length)
+    throw new Error('expected imported profiles');
+const reg = new DesignMdRegistry_1.DesignMdRegistry();
+const list = reg.list();
+if (!list.length)
+    throw new Error('expected registry list');
+const one = reg.get(list[0].id);
+if (!one.meta || !one.design)
+    throw new Error('expected profile details');
+console.log('TEST_DESIGNMD_IMPORT_REGISTRY_OK');

package/dist/test_designmd_mode.js

@@ -0,0 +1,50 @@
+"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 ReversaAgent_1 = require("./reversa/ReversaAgent");
+const DesignMdMode_1 = require("./design/DesignMdMode");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const r = new ReversaAgent_1.ReversaAgent();
+const s = r.setMode('designmd', 'voltagent-claude');
+if (s.mode !== 'designmd')
+    throw new Error('reversa mode not set');
+const dm = new DesignMdMode_1.DesignMdMode('testws');
+const applied = dm.applyProfile({ id: 'voltagent-claude', source: 'awesome-design-md', title: 'Claude style', appliedAt: new Date().toISOString() }, '# DESIGN\n\nSample', { force: true });
+if (!applied.id)
+    throw new Error('design profile not applied');
+if (!fs.existsSync(path.join(process.cwd(), 'DESIGN.md')))
+    throw new Error('DESIGN.md not written');
+console.log('TEST_DESIGNMD_MODE_OK');

package/dist/test_designmd_mode_workspace.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DesignMdMode_1 = require("./design/DesignMdMode");
+const DesignMdImporter_1 = require("./design/DesignMdImporter");
+new DesignMdImporter_1.DesignMdImporter().importFromVendor('vendor/awesome-design-md');
+const mode = new DesignMdMode_1.DesignMdMode('testws2');
+const profiles = mode.listProfiles();
+if (!profiles.length)
+    throw new Error('profiles should exist');
+const applied = mode.applyByProfileId(profiles[0].id, { force: true });
+if (!applied.id)
+    throw new Error('applyByProfileId should apply');
+console.log('TEST_DESIGNMD_MODE_WORKSPACE_OK');

package/dist/test_dist_templates_layout.js

@@ -0,0 +1,135 @@
+"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.2 — dist-templates layout regression test.
+ *
+ * Asserts:
+ * 1. dist-templates/claude-code/{agents,commands/openlife,mcp} all exist
+ * 2. The 5 starter agents (MAESTRO/LYRA/FORGE/ATLAS/GENESIS) ship as `openlife-*.md`
+ * 3. Each agent file parses: YAML frontmatter with required keys (name, description), and a non-empty body
+ * 4. The 4 starter slash commands ship under commands/openlife/
+ * 5. Each slash command has a `description` in its frontmatter
+ * 6. The MCP manifest is valid JSON with a `name` field
+ * 7. dist-templates/ is included in package.json `files` so npm publishes it
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`ASSERTION_FAILED: ${msg}`);
+}
+const ROOT = path.resolve(__dirname, '..');
+const DIST = path.join(ROOT, 'dist-templates');
+const CC = path.join(DIST, 'claude-code');
+function parseFrontmatter(content) {
+    if (!content.startsWith('---\n')) {
+        throw new Error('Missing frontmatter opening "---\\n"');
+    }
+    const rest = content.slice(4);
+    const endIdx = rest.indexOf('\n---\n');
+    if (endIdx === -1)
+        throw new Error('Missing frontmatter closing "\\n---\\n"');
+    const fmRaw = rest.slice(0, endIdx);
+    const body = rest.slice(endIdx + 5).trim();
+    const fm = {};
+    for (const line of fmRaw.split('\n')) {
+        const m = line.match(/^([a-zA-Z0-9_-]+):\s*(.*)$/);
+        if (m)
+            fm[m[1]] = m[2].trim();
+    }
+    return { fm, body };
+}
+function testDirectoryLayout() {
+    assert(fs.existsSync(DIST), 'dist-templates/ must exist');
+    assert(fs.existsSync(CC), 'dist-templates/claude-code/ must exist');
+    assert(fs.existsSync(path.join(CC, 'agents')), 'agents/ must exist');
+    assert(fs.existsSync(path.join(CC, 'commands', 'openlife')), 'commands/openlife/ must exist');
+    assert(fs.existsSync(path.join(CC, 'mcp')), 'mcp/ must exist');
+    assert(fs.existsSync(path.join(DIST, 'README.md')), 'dist-templates/README.md must exist');
+}
+function testStarterAgents() {
+    const expected = ['openlife-maestro', 'openlife-lyra', 'openlife-forge', 'openlife-atlas', 'openlife-genesis'];
+    for (const name of expected) {
+        const file = path.join(CC, 'agents', `${name}.md`);
+        assert(fs.existsSync(file), `${file} must exist`);
+        const { fm, body } = parseFrontmatter(fs.readFileSync(file, 'utf-8'));
+        assert(fm.name === name, `${name}.md frontmatter.name must equal ${name}, got "${fm.name}"`);
+        assert(fm.description && fm.description.length > 30, `${name}.md description too short or missing`);
+        assert(body.length > 200, `${name}.md body too short (${body.length} chars) — system prompts should be substantive`);
+    }
+}
+function testStarterSlashCommands() {
+    const expected = ['status', 'ask', 'doctor', 'dream'];
+    for (const name of expected) {
+        const file = path.join(CC, 'commands', 'openlife', `${name}.md`);
+        assert(fs.existsSync(file), `${file} must exist`);
+        const { fm, body } = parseFrontmatter(fs.readFileSync(file, 'utf-8'));
+        assert(fm.description && fm.description.length > 10, `${name}.md needs a description`);
+        assert(body.length > 50, `${name}.md body too short`);
+    }
+}
+function testMcpManifest() {
+    const file = path.join(CC, 'mcp', 'openlife-orchestrator.json');
+    assert(fs.existsSync(file), `${file} must exist`);
+    const content = fs.readFileSync(file, 'utf-8');
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (err) {
+        throw new Error(`MCP manifest is not valid JSON: ${err.message}`);
+    }
+    assert(parsed.name === 'openlife-orchestrator', 'MCP manifest.name must be openlife-orchestrator');
+    assert(Array.isArray(parsed.tools) && parsed.tools.length > 0, 'MCP manifest.tools must be a non-empty array');
+    assert(typeof parsed.command === 'string' && parsed.command.length > 0, 'MCP manifest.command required');
+}
+function testPackageJsonIncludesTemplates() {
+    const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'));
+    assert(Array.isArray(pkg.files), 'package.json.files must be an array');
+    assert(pkg.files.includes('dist-templates'), `package.json.files must include "dist-templates" so npm distributes it; got: ${JSON.stringify(pkg.files)}`);
+}
+async function main() {
+    testDirectoryLayout();
+    testStarterAgents();
+    testStarterSlashCommands();
+    testMcpManifest();
+    testPackageJsonIncludesTemplates();
+    console.log('TEST_DIST_TEMPLATES_LAYOUT_OK');
+}
+main().catch((err) => {
+    console.error('TEST_DIST_TEMPLATES_LAYOUT_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_distributed_lock.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * test_distributed_lock — Story 6.4 regression suite.
+ *
+ * Four scenarios:
+ *   1. Acquire + release happy path; peek round-trips the record
+ *   2. Collision — second acquire on same key fails while first holds
+ *   3. TTL expiry — stale lock can be taken over after ttlMs elapses
+ *      (test uses a tiny ttlMs and a controlled busy-wait, no sleep)
+ *   4. Renew + steal-detection — renewing a lock we no longer own
+ *      (file overwritten by an attacker simulation) returns false
+ *
+ * Prints TEST_DISTRIBUTED_LOCK_OK on full pass.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const DistributedLock_1 = require("./orchestrator/util/DistributedLock");
+const AtomicWriter_1 = require("./orchestrator/util/AtomicWriter");
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`assertion failed: ${msg}`);
+}
+function mkTmp() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'lock-test-'));
+}
+function rmTmp(dir) {
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch { /* ignore */ }
+}
+function busyWait(ms) {
+    const deadline = Date.now() + ms;
+    while (Date.now() < deadline) { /* spin */ }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 1 — acquire + release happy path
+// ─────────────────────────────────────────────────────────────
+function scenarioHappyPath() {
+    const tmp = mkTmp();
+    try {
+        const lock = new DistributedLock_1.DistributedLock({ baseDir: path.join(tmp, 'locks') });
+        const r = lock.acquire('mission-001', 30_000, { startHeartbeat: false });
+        assert(r.ok, `expected ok=true, got: ${JSON.stringify(r)}`);
+        assert(typeof r.lockId === 'string' && r.lockId.length > 0, 'lockId must be present');
+        assert(fs.existsSync(r.filePath), 'lock file must exist on disk');
+        const peeked = lock.peek('mission-001');
+        assert(peeked !== null, 'peek must return record while held');
+        assert(peeked.pid === process.pid, 'pid round-trip');
+        assert(peeked.key === 'mission-001', 'key round-trip');
+        assert(peeked.ttlMs === 30_000, 'ttlMs round-trip');
+        lock.release(r.lockId);
+        assert(lock.peek('mission-001') === null, 'peek must return null after release');
+        console.log('✅ scenario 1: acquire + release + peek round-trip');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 2 — collision while held
+// ─────────────────────────────────────────────────────────────
+function scenarioCollision() {
+    const tmp = mkTmp();
+    try {
+        const baseDir = path.join(tmp, 'locks');
+        const lockA = new DistributedLock_1.DistributedLock({ baseDir });
+        const lockB = new DistributedLock_1.DistributedLock({ baseDir });
+        const a = lockA.acquire('shared', 30_000, { startHeartbeat: false });
+        assert(a.ok, 'A must acquire');
+        const b = lockB.acquire('shared', 30_000, { startHeartbeat: false });
+        assert(!b.ok, `B must collide, got ok=true: ${JSON.stringify(b)}`);
+        assert(b.ok === false && b.error === 'collision', `expected error=collision, got ${JSON.stringify(b)}`);
+        assert(b.ok === false && b.heldBy?.pid === process.pid, 'heldBy must report current pid');
+        lockA.release(a.lockId);
+        const bAgain = lockB.acquire('shared', 30_000, { startHeartbeat: false });
+        assert(bAgain.ok, 'B must acquire after A releases');
+        lockB.release(bAgain.lockId);
+        console.log('✅ scenario 2: collision while held');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 3 — TTL expiry takeover
+// ─────────────────────────────────────────────────────────────
+function scenarioTtlExpiry() {
+    const tmp = mkTmp();
+    try {
+        const baseDir = path.join(tmp, 'locks');
+        const lockA = new DistributedLock_1.DistributedLock({ baseDir });
+        const lockB = new DistributedLock_1.DistributedLock({ baseDir });
+        // A acquires with a tiny TTL, no heartbeat so it goes stale
+        const a = lockA.acquire('expiring', 50, { startHeartbeat: false });
+        assert(a.ok, 'A must acquire');
+        // Immediate B attempt collides
+        const bNow = lockB.acquire('expiring', 1000, { startHeartbeat: false });
+        assert(!bNow.ok, 'B must collide before TTL expires');
+        // Wait past TTL
+        busyWait(70);
+        const bLater = lockB.acquire('expiring', 1000, { startHeartbeat: false });
+        assert(bLater.ok, `B must take over after TTL, got: ${JSON.stringify(bLater)}`);
+        assert(bLater.ok && bLater.lockId !== a.lockId, 'B must have a new lockId');
+        // After takeover, A's renew should fail (different lockId on disk now)
+        const aRenew = lockA.renew(a.lockId);
+        assert(aRenew === false, "A's renew must fail after B took over");
+        lockB.release(bLater.lockId);
+        console.log('✅ scenario 3: TTL expiry takeover');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Scenario 4 — renew detects external overwrite (steal-detection)
+// ─────────────────────────────────────────────────────────────
+function scenarioStealDetection() {
+    const tmp = mkTmp();
+    try {
+        const baseDir = path.join(tmp, 'locks');
+        const lock = new DistributedLock_1.DistributedLock({ baseDir });
+        const a = lock.acquire('steal-test', 30_000, { startHeartbeat: false });
+        assert(a.ok, 'must acquire');
+        // Simulate an attacker / TTL takeover: overwrite the lock file with a
+        // different lockId
+        const stolen = {
+            pid: 99999,
+            host: 'attacker',
+            lockId: 'stolen-id',
+            key: 'steal-test',
+            acquiredAt: Date.now(),
+            ts: Date.now(),
+            ttlMs: 30_000,
+        };
+        (0, AtomicWriter_1.writeJsonAtomic)(a.filePath, stolen);
+        const renewed = lock.renew(a.lockId);
+        assert(renewed === false, 'renew must return false when our lockId no longer matches on disk');
+        // peek shows the stolen record (different pid)
+        const after = lock.peek('steal-test');
+        assert(after?.pid === 99999, 'peek reflects the new holder');
+        console.log('✅ scenario 4: renew detects external steal');
+    }
+    finally {
+        rmTmp(tmp);
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Driver
+// ─────────────────────────────────────────────────────────────
+function main() {
+    console.log('🧪 test_distributed_lock — Story 6.4 regression suite');
+    scenarioHappyPath();
+    scenarioCollision();
+    scenarioTtlExpiry();
+    scenarioStealDetection();
+    console.log('');
+    console.log('TEST_DISTRIBUTED_LOCK_OK');
+}
+try {
+    main();
+}
+catch (err) {
+    console.error('❌ test_distributed_lock FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+}

package/dist/test_distribution_installability.js

@@ -0,0 +1,67 @@
+"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"));
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+async function main() {
+    const root = path.resolve(__dirname, '..');
+    const requiredFiles = [
+        path.join(root, 'bin', 'openlife.js'),
+        path.join(root, 'scripts', 'postinstall-check.sh'),
+        path.join(root, 'scripts', 'openlife-autonomous-install.sh'),
+        path.join(root, 'docs', 'autonomous-install.md')
+    ];
+    for (const file of requiredFiles) {
+        assert(fileExists(file), `required distribution file missing: ${file}`);
+    }
+    const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8'));
+    assert(packageJson.bin?.openlife === './bin/openlife.js', 'package.json bin.openlife must point to ./bin/openlife.js');
+    assert(Boolean(packageJson.scripts?.postinstall), 'package.json must define scripts.postinstall');
+    const doc = fs.readFileSync(path.join(root, 'docs', 'autonomous-install.md'), 'utf-8');
+    assert(doc.includes('openlife agent install'), 'autonomous-install.md must document openlife agent install');
+    assert(doc.toLowerCase().includes('supervisor'), 'autonomous-install.md must include supervisor fallback instructions');
+    console.log('TEST_DISTRIBUTION_INSTALLABILITY_OK');
+}
+main().catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+});

package/dist/test_doctor_sandbox_check.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * test_doctor_sandbox_check.ts — Story 18.1 (v1.6)
+ *
+ * Asserts SystemDoctor's new `runtime:process-sandbox` check:
+ *   1. Returns a DoctorCheck shape.
+ *   2. ok=true on the current Node runner (the wrapper falls back
+ *      gracefully on Node 18 and reports enforcement state honestly
+ *      on Node 20+).
+ *   3. detail string contains the Node major version so operators can
+ *      tell at a glance whether enforcement is active.
+ *   4. The check appears in runRuntimeChecks() output.
+ *
+ * The test spawns a real `node -e` subprocess via ProcessSandbox —
+ * it's an integration-style probe but stays fast (<200ms).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SystemDoctor_1 = require("./orchestrator/SystemDoctor");
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+async function main() {
+    const doctor = new SystemDoctor_1.SystemDoctor();
+    const checks = await doctor.runRuntimeChecks();
+    const sandboxCheck = checks.find((c) => c.name === 'runtime:process-sandbox');
+    assertTrue(!!sandboxCheck, '[18.1] runtime:process-sandbox check is emitted');
+    assertTrue(typeof sandboxCheck.ok === 'boolean', '[18.1] check has boolean ok');
+    assertTrue(typeof sandboxCheck.detail === 'string' && sandboxCheck.detail.length > 0, '[18.1] check has non-empty detail');
+    // Detail should mention the Node major version so operators see at a glance.
+    assertTrue(/Node\s+\d+/.test(sandboxCheck.detail), `[18.1] detail mentions Node version (got: ${sandboxCheck.detail})`);
+    // On the test runner the wrapper should at minimum spawn a child successfully —
+    // graceful downgrade on Node 18 still produces ok=true. The only failure path
+    // we expect here is a wrapper bug (spawn failed or enforced flag inconsistent).
+    if (!sandboxCheck.ok) {
+        throw new Error(`[18.1] sandbox check failed unexpectedly: ${sandboxCheck.detail}`);
+    }
+    console.log(`[18.1] runtime:process-sandbox = ${sandboxCheck.ok ? '✅' : '❌'} ${sandboxCheck.detail}`);
+    console.log('TEST_DOCTOR_SANDBOX_CHECK_OK');
+}
+main().catch((err) => {
+    console.error('[doctor-sandbox-check] FAILED:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/test_dream_organizer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DreamOrganizer_1 = require("./cli/DreamOrganizer");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function main() {
+    const organizer = new DreamOrganizer_1.DreamOrganizer(process.cwd());
+    const raw = 'Hoje tive uma ideia de criar um motor de memória. Preciso estudar embeddings e depois implementar comando /dream. Também refleti sobre foco e disciplina.';
+    const note = organizer.organize(raw);
+    assert(note.categories.includes('ideias'), 'should classify ideas');
+    assert(note.categories.includes('aprendizado'), 'should classify learning');
+    assert(note.categories.includes('reflexoes'), 'should classify reflections');
+    assert(note.tags.includes('dream'), 'should include dream tag');
+    assert(note.summary.length > 10, 'should generate non-empty summary');
+    console.log('TEST_DREAM_ORGANIZER_OK');
+}
+try {
+    main();
+}
+catch (error) {
+    console.error(error.message || error);
+    process.exit(1);
+}

package/dist/test_dual_mode.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExecutionIntent_1 = require("./orchestrator/ExecutionIntent");
+const ExecutionRouter_1 = require("./orchestrator/ExecutionRouter");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+const router = new ExecutionRouter_1.ExecutionRouter();
+const defaultIntent = (0, ExecutionIntent_1.normalizeExecutionIntent)({ goal: 'foo' });
+assert(defaultIntent.mode === 'task', 'default mode should be task');
+assert(router.route(defaultIntent) === 'task', 'router should route default to task');
+const serviceIntent = (0, ExecutionIntent_1.normalizeExecutionIntent)({ goal: 'foo', mode: 'service' });
+assert(router.route(serviceIntent) === 'service', 'router should route explicit service');
+console.log('TEST_DUAL_MODE_OK');