@openlife/cli 1.7.3

package/dist/test_host_installer.js

@@ -0,0 +1,259 @@
+"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.3 — HostInstaller regression test.
+ *
+ * Asserts:
+ * 1. installForClaudeCode copies the 5 agents, 4 slash commands, and MCP snippet to the right paths
+ * 2. Re-running install reports all files as 'skipped-identical' (idempotency)
+ * 3. Modifying a destination file then re-installing creates a .bak and reports 'updated'
+ * 4. installForGeminiCli throws HostNotYetSupportedError with code 'HOST_NOT_YET_SUPPORTED'
+ * 5. installForCodex throws HostNotYetSupportedError
+ * 6. install('claude-code', ...) dispatcher works
+ * 7. InstallFlow.run({ host: 'claude-code' }) in a temp dir produces host install files AND
+ *    install-flow-report.json mentions hostInstall
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const HostInstaller_1 = require("./cli/HostInstaller");
+const InstallFlow_1 = require("./cli/InstallFlow");
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`ASSERTION_FAILED: ${msg}`);
+}
+function mkTemp(prefix = 'openlife-hostinstaller-test-') {
+    return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+const EXPECTED_AGENTS = [
+    'openlife-maestro.md',
+    'openlife-lyra.md',
+    'openlife-forge.md',
+    'openlife-atlas.md',
+    'openlife-genesis.md'
+];
+const EXPECTED_COMMANDS = ['status.md', 'ask.md', 'doctor.md', 'dream.md'];
+function testInstallForClaudeCodeCreatesAllFiles() {
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        const result = installer.installForClaudeCode({ targetRoot: tempRoot });
+        assert(result.host === 'claude-code', `host should be claude-code, got ${result.host}`);
+        assert(result.targetRoot === tempRoot, 'targetRoot should round-trip');
+        assert(Array.isArray(result.files) && result.files.length > 0, 'files[] should be populated');
+        // Agents
+        for (const agent of EXPECTED_AGENTS) {
+            const dst = path.join(tempRoot, '.claude', 'agents', agent);
+            assert(fs.existsSync(dst), `agent file missing: ${dst}`);
+        }
+        // Commands
+        for (const cmd of EXPECTED_COMMANDS) {
+            const dst = path.join(tempRoot, '.claude', 'commands', 'openlife', cmd);
+            assert(fs.existsSync(dst), `command file missing: ${dst}`);
+        }
+        // MCP snippet
+        const mcpDst = path.join(tempRoot, '.openlife', 'install-mcp-snippet.json');
+        assert(fs.existsSync(mcpDst), `mcp snippet missing: ${mcpDst}`);
+        assert(result.mcpSnippetPath === mcpDst, `mcpSnippetPath should match staged path; got ${result.mcpSnippetPath}`);
+        // Every emitted action should be 'created' on a fresh temp dir.
+        const createds = result.files.filter((f) => f.action === 'created').length;
+        assert(createds === result.files.length, `all actions should be 'created' on fresh install; got ${createds}/${result.files.length}`);
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testIdempotentReinstall() {
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.installForClaudeCode({ targetRoot: tempRoot });
+        // Re-run — every action should now be 'skipped-identical'.
+        const second = installer.installForClaudeCode({ targetRoot: tempRoot });
+        const skipped = second.files.filter((f) => f.action === 'skipped-identical').length;
+        assert(skipped === second.files.length, `all actions should be 'skipped-identical' on re-install; got ${skipped}/${second.files.length}: ${JSON.stringify(second.files.map((f) => f.action))}`);
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testUpdatedActionWritesBackup() {
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.installForClaudeCode({ targetRoot: tempRoot });
+        // Mutate one destination file so the next install sees a diff.
+        const target = path.join(tempRoot, '.claude', 'agents', 'openlife-maestro.md');
+        assert(fs.existsSync(target), `precondition: ${target} should exist after first install`);
+        fs.writeFileSync(target, '# user-edited\n', 'utf-8');
+        const second = installer.installForClaudeCode({ targetRoot: tempRoot });
+        const updated = second.files.find((f) => f.destination === target);
+        assert(updated !== undefined, `expected an action for ${target} in second install`);
+        assert(updated.action === 'updated', `expected 'updated' action for mutated file; got '${updated.action}'`);
+        assert(typeof updated.backupPath === 'string' && updated.backupPath.endsWith('.bak'), `expected .bak backupPath; got '${updated.backupPath}'`);
+        assert(fs.existsSync(updated.backupPath), `backup file should exist on disk: ${updated.backupPath}`);
+        const bakContent = fs.readFileSync(updated.backupPath, 'utf-8');
+        assert(bakContent === '# user-edited\n', `backup should preserve the user's edit; got: ${bakContent}`);
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testGeminiCliInstallsRealTemplates() {
+    // Sprint 2 / Stories 9.3 + 9.5 — gemini-cli no longer throws
+    // HostNotYetSupportedError; it now copies dist-templates/gemini-cli/ into
+    // the target. The full coverage lives in test_host_installers_gemini_codex.ts.
+    // Here we only assert this installer no longer signals "not yet supported".
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        let caught = null;
+        try {
+            installer.installForGeminiCli({ targetRoot: tempRoot });
+        }
+        catch (err) {
+            caught = err;
+        }
+        assert(!(caught instanceof HostInstaller_1.HostNotYetSupportedError), 'gemini-cli installer should no longer throw HostNotYetSupportedError (Story 9.3)');
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testCodexInstallsRealTemplates() {
+    // Sprint 2 / Story 9.4 — codex installer is now real. Mirror of the
+    // gemini-cli check above. Detailed assertions live in
+    // test_host_installers_gemini_codex.ts.
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        let caught = null;
+        try {
+            installer.installForCodex({ targetRoot: tempRoot });
+        }
+        catch (err) {
+            caught = err;
+        }
+        assert(!(caught instanceof HostInstaller_1.HostNotYetSupportedError), 'codex installer should no longer throw HostNotYetSupportedError (Story 9.4)');
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testDispatcherDispatchesClaudeCode() {
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        const result = installer.install('claude-code', { targetRoot: tempRoot });
+        assert(result.host === 'claude-code', `dispatcher should produce claude-code result; got ${result.host}`);
+        assert(fs.existsSync(path.join(tempRoot, '.claude', 'agents', 'openlife-maestro.md')), 'dispatcher should have produced agent files');
+        // Sprint 2 / Stories 9.3 + 9.4 — gemini-cli and codex are now real
+        // installers. The dispatcher should produce a real result, not throw.
+        const geminiResult = installer.install('gemini-cli', { targetRoot: tempRoot });
+        assert(geminiResult.host === 'gemini-cli', `dispatcher should produce gemini-cli result; got ${geminiResult.host}`);
+        const codexResult = installer.install('codex', { targetRoot: tempRoot });
+        assert(codexResult.host === 'codex', `dispatcher should produce codex result; got ${codexResult.host}`);
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testInstallFlowWiresHostInstaller() {
+    const tempRoot = mkTemp();
+    try {
+        const flow = new InstallFlow_1.InstallFlow(tempRoot);
+        const result = flow.run({ profile: 'framework', host: 'claude-code', skipDoctor: true });
+        assert(result.hostInstall !== undefined, 'InstallFlow result should include hostInstall');
+        // Should NOT be the skipped envelope for claude-code.
+        assert(!('skipped' in result.hostInstall && result.hostInstall.skipped), `claude-code host install should not be skipped; got: ${JSON.stringify(result.hostInstall)}`);
+        const hi = result.hostInstall;
+        assert(hi.host === 'claude-code', `hostInstall.host should be claude-code; got ${hi.host}`);
+        assert(Array.isArray(hi.files) && hi.files.length > 0, 'hostInstall.files should be populated');
+        // Real files on disk
+        for (const agent of EXPECTED_AGENTS) {
+            assert(fs.existsSync(path.join(tempRoot, '.claude', 'agents', agent)), `InstallFlow should have produced agent: ${agent}`);
+        }
+        for (const cmd of EXPECTED_COMMANDS) {
+            assert(fs.existsSync(path.join(tempRoot, '.claude', 'commands', 'openlife', cmd)), `InstallFlow should have produced command: ${cmd}`);
+        }
+        // install-flow-report.json must mention hostInstall
+        assert(fs.existsSync(result.reportPath), `report should be written at ${result.reportPath}`);
+        const reportRaw = fs.readFileSync(result.reportPath, 'utf-8');
+        assert(reportRaw.includes('hostInstall'), `install-flow-report.json should mention hostInstall; got: ${reportRaw.slice(0, 200)}...`);
+        const parsed = JSON.parse(reportRaw);
+        assert(parsed.hostInstall, 'parsed report.hostInstall should be truthy');
+        assert(parsed.hostInstall.host === 'claude-code', "report.hostInstall.host should be 'claude-code'");
+        // renderSummary should mention the host install line.
+        const summary = flow.renderSummary(result).join('\n');
+        assert(summary.includes('Host install:'), `renderSummary should mention 'Host install:'; got:\n${summary}`);
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testInstallFlowDegradesForUnsupportedHost() {
+    // Sprint 2 / Stories 9.3 + 9.4 — gemini-cli is no longer "unsupported", it
+    // is fully installable. This test now asserts the host install succeeded
+    // and a real report was written, instead of asserting graceful degradation.
+    const tempRoot = mkTemp();
+    try {
+        const flow = new InstallFlow_1.InstallFlow(tempRoot);
+        const result = flow.run({ profile: 'framework', host: 'gemini-cli', skipDoctor: true });
+        assert(result.hostInstall !== undefined, 'InstallFlow result should include hostInstall envelope');
+        const envelope = result.hostInstall;
+        assert(envelope.skipped !== true, `gemini-cli is now supported; envelope should not be skipped (got: ${JSON.stringify(envelope)})`);
+        assert(envelope.host === 'gemini-cli', `envelope host should be 'gemini-cli'; got ${envelope.host}`);
+        assert(fs.existsSync(result.reportPath), 'install-flow-report.json should be written');
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+async function main() {
+    testInstallForClaudeCodeCreatesAllFiles();
+    testIdempotentReinstall();
+    testUpdatedActionWritesBackup();
+    testGeminiCliInstallsRealTemplates();
+    testCodexInstallsRealTemplates();
+    testDispatcherDispatchesClaudeCode();
+    testInstallFlowWiresHostInstaller();
+    testInstallFlowDegradesForUnsupportedHost();
+    console.log('TEST_HOST_INSTALLER_OK');
+}
+main().catch((err) => {
+    console.error('TEST_HOST_INSTALLER_FAIL:', err?.message || err);
+    process.exit(1);
+});

package/dist/test_host_installers_gemini_codex.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * test_host_installers_gemini_codex.ts — Stories 9.3 + 9.4 + 9.5
+ *
+ * Asserts that installForGeminiCli + installForCodex are no longer stubs,
+ * mirror the claude-code pattern, and produce reversible uninstall.
+ */
+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 HostInstaller_1 = require("./cli/HostInstaller");
+function assertTrue(cond, label) {
+    if (!cond)
+        throw new Error(`ASSERT_FAILED[${label}]`);
+}
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'host-install-gc-'));
+try {
+    const installer = new HostInstaller_1.HostInstaller();
+    // ── 1. gemini-cli install populates .gemini/ ────────────────────────
+    const target1 = path.join(tmp, 'gemini-host');
+    fs.mkdirSync(target1, { recursive: true });
+    const r1 = installer.installForGeminiCli({ targetRoot: target1 });
+    assertTrue(r1.host === 'gemini-cli', '[9.3] result host');
+    assertTrue(fs.existsSync(path.join(target1, '.gemini', 'agents')), '[9.3] .gemini/agents created');
+    const agents = fs.readdirSync(path.join(target1, '.gemini', 'agents')).filter((f) => f.startsWith('openlife-'));
+    assertTrue(agents.length >= 5, `[9.3] >=5 agents installed (got ${agents.length})`);
+    assertTrue(fs.existsSync(path.join(target1, '.gemini', 'commands', 'openlife')), '[9.3] commands namespace created');
+    const cmds = fs.readdirSync(path.join(target1, '.gemini', 'commands', 'openlife'));
+    assertTrue(cmds.length >= 4, `[9.3] >=4 commands installed (got ${cmds.length})`);
+    assertTrue(fs.existsSync(path.join(target1, '.openlife', 'install-mcp-snippet-gemini-cli.json')), '[9.3] mcp snippet staged');
+    console.log('[9.3] installForGeminiCli produced .gemini/{agents,commands,mcp} ✓');
+    // ── 2. codex install populates .codex/ ─────────────────────────────
+    const target2 = path.join(tmp, 'codex-host');
+    fs.mkdirSync(target2, { recursive: true });
+    const r2 = installer.installForCodex({ targetRoot: target2 });
+    assertTrue(r2.host === 'codex', '[9.4] result host');
+    assertTrue(fs.existsSync(path.join(target2, '.codex', 'agents')), '[9.4] .codex/agents created');
+    assertTrue(fs.existsSync(path.join(target2, '.openlife', 'install-mcp-snippet-codex.json')), '[9.4] mcp snippet staged');
+    console.log('[9.4] installForCodex produced .codex/{agents,commands,mcp} ✓');
+    // ── 3. uninstall is reversible for gemini-cli ──────────────────────
+    const u1 = installer.uninstallForGeminiCli({ targetRoot: target1 });
+    assertTrue(u1.host === 'gemini-cli', '[9.3] uninstall result');
+    const remainingAgents = fs.existsSync(path.join(target1, '.gemini', 'agents'))
+        ? fs.readdirSync(path.join(target1, '.gemini', 'agents')).filter((f) => f.startsWith('openlife-'))
+        : [];
+    assertTrue(remainingAgents.length === 0, `[9.3] uninstall removes openlife-* agents (got ${remainingAgents.length})`);
+    assertTrue(!fs.existsSync(path.join(target1, '.openlife', 'install-mcp-snippet-gemini-cli.json')), '[9.3] uninstall removes mcp snippet');
+    console.log('[9.3] uninstallForGeminiCli reversible ✓');
+    // ── 4. uninstall is reversible for codex ───────────────────────────
+    const u2 = installer.uninstallForCodex({ targetRoot: target2 });
+    assertTrue(u2.host === 'codex', '[9.4] uninstall result');
+    console.log('[9.4] uninstallForCodex reversible ✓');
+    // ── 5. dist-templates layout was scaffolded by 9.5 ─────────────────
+    assertTrue(fs.existsSync(path.join(process.cwd(), 'dist-templates', 'gemini-cli', 'agents')), '[9.5] dist-templates/gemini-cli/agents exists');
+    assertTrue(fs.existsSync(path.join(process.cwd(), 'dist-templates', 'codex', 'agents')), '[9.5] dist-templates/codex/agents exists');
+    console.log('[9.5] dist-templates scaffolding present ✓');
+}
+finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+}
+console.log('TEST_HOST_INSTALLERS_GEMINI_CODEX_OK');

package/dist/test_host_uninstaller.js

@@ -0,0 +1,295 @@
+"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.4 — HostInstaller uninstall regression test.
+ *
+ * Asserts:
+ * 1. Install then uninstall — every Story-3.3 artifact (5 agents, 4 commands, MCP snippet) is removed
+ * 2. Re-uninstall is idempotent — all actions are 'skipped-not-found'
+ * 3. User-edit preservation via .bak — install → user edits → reinstall (creates .bak) → uninstall
+ *    restores the user's edit by renaming .bak back over the destination (NOT deleted)
+ * 4. Untouched user files — files in .claude/agents/ without the openlife- prefix survive
+ * 5. uninstallForGeminiCli throws HostNotYetSupportedError
+ * 6. uninstallForCodex throws HostNotYetSupportedError
+ * 7. Dispatcher uninstall('claude-code', ...) works and rejects unsupported hosts
+ * 8. CLI command `openlife system uninstall --host claude-code` is wired and prints JSON
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const HostInstaller_1 = require("./cli/HostInstaller");
+function assert(cond, msg) {
+    if (!cond)
+        throw new Error(`ASSERTION_FAILED: ${msg}`);
+}
+function mkTemp(prefix = 'openlife-hostuninstaller-test-') {
+    return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+const EXPECTED_AGENTS = [
+    'openlife-maestro.md',
+    'openlife-lyra.md',
+    'openlife-forge.md',
+    'openlife-atlas.md',
+    'openlife-genesis.md'
+];
+const EXPECTED_COMMANDS = ['status.md', 'ask.md', 'doctor.md', 'dream.md'];
+function testUninstallRemovesAllInstalledArtifacts() {
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.installForClaudeCode({ targetRoot: tempRoot });
+        // Sanity: install really put the files there.
+        for (const agent of EXPECTED_AGENTS) {
+            assert(fs.existsSync(path.join(tempRoot, '.claude', 'agents', agent)), `precondition: ${agent} should exist after install`);
+        }
+        const result = installer.uninstallForClaudeCode({ targetRoot: tempRoot });
+        assert(result.host === 'claude-code', `host should be claude-code; got ${result.host}`);
+        assert(result.targetRoot === tempRoot, 'targetRoot should round-trip');
+        assert(Array.isArray(result.files) && result.files.length > 0, 'files[] should be populated');
+        // Every agent file should be gone.
+        for (const agent of EXPECTED_AGENTS) {
+            const dst = path.join(tempRoot, '.claude', 'agents', agent);
+            assert(!fs.existsSync(dst), `agent should be removed: ${dst}`);
+        }
+        // Every command file should be gone.
+        for (const cmd of EXPECTED_COMMANDS) {
+            const dst = path.join(tempRoot, '.claude', 'commands', 'openlife', cmd);
+            assert(!fs.existsSync(dst), `command should be removed: ${dst}`);
+        }
+        // MCP snippet gone.
+        const mcpDst = path.join(tempRoot, '.openlife', 'install-mcp-snippet.json');
+        assert(!fs.existsSync(mcpDst), `mcp snippet should be removed: ${mcpDst}`);
+        // .openlife/ itself MUST survive (runtime state).
+        const stateDir = path.join(tempRoot, '.openlife');
+        assert(fs.existsSync(stateDir), '.openlife/ runtime state directory must NOT be removed');
+        // The openlife/ commands namespace directory should be removed (it was all ours and is now empty).
+        const cmdsNs = path.join(tempRoot, '.claude', 'commands', 'openlife');
+        assert(!fs.existsSync(cmdsNs), `empty openlife/ commands namespace should be removed: ${cmdsNs}`);
+        // Counted: 5 agents + 4 commands + 1 mcp snippet = 10 removals.
+        const removed = result.files.filter((f) => f.action === 'removed').length;
+        assert(removed === 10, `expected 10 'removed' actions (5 agents + 4 commands + 1 mcp); got ${removed}: ` +
+            JSON.stringify(result.files.map((f) => `${path.basename(f.destination)}:${f.action}`)));
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testIdempotentReUninstall() {
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.installForClaudeCode({ targetRoot: tempRoot });
+        installer.uninstallForClaudeCode({ targetRoot: tempRoot });
+        const second = installer.uninstallForClaudeCode({ targetRoot: tempRoot });
+        // On the second uninstall, everything should be 'skipped-not-found'.
+        const skipped = second.files.filter((f) => f.action === 'skipped-not-found').length;
+        assert(skipped === second.files.length, `all actions should be 'skipped-not-found' on re-uninstall; got ${skipped}/${second.files.length}: ` +
+            JSON.stringify(second.files.map((f) => f.action)));
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testUserEditPreservedViaBakRestore() {
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.installForClaudeCode({ targetRoot: tempRoot });
+        // User edits the agent. Then reinstalling will move the edit to .bak and overwrite.
+        const target = path.join(tempRoot, '.claude', 'agents', 'openlife-maestro.md');
+        const userEditContent = '# user-edited content — must survive uninstall\n';
+        fs.writeFileSync(target, userEditContent, 'utf-8');
+        const second = installer.installForClaudeCode({ targetRoot: tempRoot });
+        const updateAction = second.files.find((f) => f.destination === target);
+        assert(updateAction !== undefined && updateAction.action === 'updated', `precondition: reinstall after user-edit should report 'updated'; got ${JSON.stringify(updateAction)}`);
+        const bakPath = `${target}.bak`;
+        assert(fs.existsSync(bakPath), `precondition: .bak should exist at ${bakPath}`);
+        // Uninstall — .bak should be renamed back over the destination; user's edit survives.
+        const result = installer.uninstallForClaudeCode({ targetRoot: tempRoot });
+        const restoredAction = result.files.find((f) => f.destination === target);
+        assert(restoredAction !== undefined, `expected an action for ${target} in uninstall result`);
+        assert(restoredAction.action === 'restored-from-bak', `expected 'restored-from-bak'; got '${restoredAction.action}'`);
+        assert(restoredAction.backupPath === bakPath, `restoredAction.backupPath should be ${bakPath}; got ${restoredAction.backupPath}`);
+        // The destination must exist again WITH the user's content.
+        assert(fs.existsSync(target), `restored file should exist at ${target}`);
+        const finalContent = fs.readFileSync(target, 'utf-8');
+        assert(finalContent === userEditContent, `user's edit must survive uninstall; got: ${JSON.stringify(finalContent)}`);
+        // And the .bak should be gone (it was renamed, not deleted).
+        assert(!fs.existsSync(bakPath), `.bak should be consumed by rename; still present at ${bakPath}`);
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testUntouchedUserFilesSurvive() {
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.installForClaudeCode({ targetRoot: tempRoot });
+        // Drop a user-owned file (no openlife- prefix) in .claude/agents/.
+        const userFile = path.join(tempRoot, '.claude', 'agents', 'user-custom.md');
+        fs.writeFileSync(userFile, '# my custom agent — leave me alone\n', 'utf-8');
+        installer.uninstallForClaudeCode({ targetRoot: tempRoot });
+        assert(fs.existsSync(userFile), `user-owned file MUST NOT be removed: ${userFile}`);
+        const content = fs.readFileSync(userFile, 'utf-8');
+        assert(content === '# my custom agent — leave me alone\n', `user file content must be untouched; got: ${JSON.stringify(content)}`);
+        // And the parent .claude/agents/ should still exist because it contains user-custom.md.
+        assert(fs.existsSync(path.join(tempRoot, '.claude', 'agents')), '.claude/agents/ should survive if it still contains user files');
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testGeminiCliUninstallReversible() {
+    // Sprint 2 / Story 9.3 — gemini-cli uninstall is now a real reversible
+    // operation. The detailed coverage lives in
+    // test_host_installers_gemini_codex.ts; here we just assert it no longer
+    // throws HostNotYetSupportedError.
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.installForGeminiCli({ targetRoot: tempRoot });
+        let caught = null;
+        try {
+            installer.uninstallForGeminiCli({ targetRoot: tempRoot });
+        }
+        catch (err) {
+            caught = err;
+        }
+        assert(!(caught instanceof HostInstaller_1.HostNotYetSupportedError), 'gemini-cli uninstall should not throw HostNotYetSupportedError (Story 9.3)');
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testCodexUninstallReversible() {
+    // Mirror of the gemini-cli check above (Story 9.4).
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.installForCodex({ targetRoot: tempRoot });
+        let caught = null;
+        try {
+            installer.uninstallForCodex({ targetRoot: tempRoot });
+        }
+        catch (err) {
+            caught = err;
+        }
+        assert(!(caught instanceof HostInstaller_1.HostNotYetSupportedError), 'codex uninstall should not throw HostNotYetSupportedError (Story 9.4)');
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testDispatcherUninstallDispatchesClaudeCode() {
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.install('claude-code', { targetRoot: tempRoot });
+        const result = installer.uninstall('claude-code', { targetRoot: tempRoot });
+        assert(result.host === 'claude-code', `dispatcher should produce claude-code result; got ${result.host}`);
+        assert(!fs.existsSync(path.join(tempRoot, '.claude', 'agents', 'openlife-maestro.md')), 'dispatcher should have removed agent files');
+        // Sprint 2 / Stories 9.3 + 9.4 — dispatcher delegates uninstall to real
+        // implementations for gemini-cli and codex. We install + uninstall a
+        // fresh tempRoot to verify the dispatcher does not throw.
+        const gtempRoot = mkTemp();
+        try {
+            installer.installForGeminiCli({ targetRoot: gtempRoot });
+            const geminiResult = installer.uninstall('gemini-cli', { targetRoot: gtempRoot });
+            assert(geminiResult.host === 'gemini-cli', `dispatcher should produce gemini-cli uninstall result; got ${geminiResult.host}`);
+        }
+        finally {
+            fs.rmSync(gtempRoot, { recursive: true, force: true });
+        }
+        const ctempRoot = mkTemp();
+        try {
+            installer.installForCodex({ targetRoot: ctempRoot });
+            const codexResult = installer.uninstall('codex', { targetRoot: ctempRoot });
+            assert(codexResult.host === 'codex', `dispatcher should produce codex uninstall result; got ${codexResult.host}`);
+        }
+        finally {
+            fs.rmSync(ctempRoot, { recursive: true, force: true });
+        }
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+function testCliCommandWired() {
+    // Spawn the CLI in a temp dir as cwd, after installing into it.
+    // We DO NOT rely on end-to-end correctness here — unit tests above cover that. This test
+    // only verifies the command is registered and prints a parseable JSON envelope.
+    const tempRoot = mkTemp();
+    try {
+        const installer = new HostInstaller_1.HostInstaller();
+        installer.installForClaudeCode({ targetRoot: tempRoot });
+        const distIndex = path.resolve(__dirname, 'index.js');
+        assert(fs.existsSync(distIndex), `precondition: ${distIndex} must exist (run npm run build)`);
+        const proc = (0, child_process_1.spawnSync)(process.execPath, [distIndex, 'system', 'uninstall', '--host', 'claude-code'], { cwd: tempRoot, encoding: 'utf-8', timeout: 30000 });
+        assert(proc.status === 0, `CLI exit code should be 0; got ${proc.status}. stderr: ${proc.stderr}`);
+        // stdout should be valid JSON with ok:true.
+        const stdout = proc.stdout || '';
+        let parsed;
+        try {
+            parsed = JSON.parse(stdout);
+        }
+        catch (e) {
+            throw new Error(`CLI stdout should be JSON; got: ${stdout.slice(0, 400)}`);
+        }
+        assert(parsed.ok === true, `JSON should have ok:true; got: ${JSON.stringify(parsed).slice(0, 200)}`);
+        assert(parsed.host === 'claude-code', `JSON.host should be claude-code; got ${parsed.host}`);
+        assert(Array.isArray(parsed.files), 'JSON.files should be an array');
+    }
+    finally {
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+}
+async function main() {
+    testUninstallRemovesAllInstalledArtifacts();
+    testIdempotentReUninstall();
+    testUserEditPreservedViaBakRestore();
+    testUntouchedUserFilesSurvive();
+    testGeminiCliUninstallReversible();
+    testCodexUninstallReversible();
+    testDispatcherUninstallDispatchesClaudeCode();
+    testCliCommandWired();
+    console.log('TEST_HOST_UNINSTALLER_OK');
+}
+main().catch((err) => {
+    console.error('TEST_HOST_UNINSTALLER_FAIL:', err?.message || err);
+    process.exit(1);
+});