@openlife/cli 1.8.2 → 1.9.3

package/dist/orchestrator/ProjectMetadata.js

@@ -0,0 +1,183 @@
+"use strict";
+// src/orchestrator/ProjectMetadata.ts
+// Read/write `.openlife/project.json` — records the project's mode
+// (greenfield / brownfield / not-applicable), detected stack, and
+// recommended entry workflow. Consumed by `/openlife:start` and the
+// install wizard's project-mode phase.
+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 });
+exports.projectMetadataPath = projectMetadataPath;
+exports.readProjectMetadata = readProjectMetadata;
+exports.writeProjectMetadata = writeProjectMetadata;
+exports.detectStack = detectStack;
+exports.detectMode = detectMode;
+exports.recommendWorkflow = recommendWorkflow;
+exports.buildMetadata = buildMetadata;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FILE_REL = path.join('.openlife', 'project.json');
+/** Resolve the metadata file path relative to a root (default: process.cwd()). */
+function projectMetadataPath(root = process.cwd()) {
+    return path.join(root, FILE_REL);
+}
+/** Read existing metadata, returning null if file is missing or unparseable. */
+function readProjectMetadata(root = process.cwd()) {
+    const fp = projectMetadataPath(root);
+    if (!fs.existsSync(fp))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+        if (!parsed.mode || !parsed.createdAt)
+            return null;
+        return {
+            mode: parsed.mode,
+            createdAt: parsed.createdAt,
+            updatedAt: parsed.updatedAt || parsed.createdAt,
+            detectedStack: parsed.detectedStack || [],
+            recommendedWorkflow: parsed.recommendedWorkflow || recommendWorkflow(parsed.mode, parsed.detectedStack || []),
+            notes: parsed.notes,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Write metadata, creating .openlife/ if necessary. */
+function writeProjectMetadata(meta, root = process.cwd()) {
+    const fp = projectMetadataPath(root);
+    fs.mkdirSync(path.dirname(fp), { recursive: true });
+    fs.writeFileSync(fp, JSON.stringify(meta, null, 2) + '\n');
+    return fp;
+}
+/**
+ * Detect the project's stack from cwd. Cheap heuristic — file presence only,
+ * does not parse contents. Used to suggest a default mode and a recommended
+ * workflow in the install wizard.
+ */
+function detectStack(root = process.cwd()) {
+    const stack = [];
+    if (fs.existsSync(path.join(root, 'package.json'))) {
+        stack.push('node');
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8'));
+            if (pkg.devDependencies?.typescript || pkg.dependencies?.typescript)
+                stack.push('typescript');
+            if (pkg.dependencies?.react || pkg.dependencies?.next)
+                stack.push('react');
+            if (pkg.dependencies?.vue || pkg.dependencies?.nuxt)
+                stack.push('vue');
+            if (pkg.dependencies?.svelte)
+                stack.push('svelte');
+            if (pkg.dependencies?.express || pkg.dependencies?.fastify || pkg.dependencies?.hono)
+                stack.push('node-server');
+        }
+        catch { /* ignore */ }
+    }
+    if (fs.existsSync(path.join(root, 'go.mod')))
+        stack.push('go');
+    if (fs.existsSync(path.join(root, 'Cargo.toml')))
+        stack.push('rust');
+    if (fs.existsSync(path.join(root, 'pyproject.toml')) || fs.existsSync(path.join(root, 'requirements.txt')))
+        stack.push('python');
+    if (fs.existsSync(path.join(root, 'Gemfile')))
+        stack.push('ruby');
+    if (fs.existsSync(path.join(root, 'composer.json')))
+        stack.push('php');
+    if (fs.existsSync(path.join(root, 'pubspec.yaml')))
+        stack.push('flutter');
+    if (fs.existsSync(path.join(root, 'docker-compose.yml')) || fs.existsSync(path.join(root, 'Dockerfile')))
+        stack.push('docker');
+    if (fs.existsSync(path.join(root, 'supabase')))
+        stack.push('supabase');
+    if (fs.existsSync(path.join(root, 'prisma')))
+        stack.push('prisma');
+    return stack;
+}
+/**
+ * Detect mode hint from cwd. Returns `brownfield` if cwd appears to be an
+ * established project (presence of stack files AND > 10 git commits OR a
+ * non-trivial src/ folder); `greenfield` otherwise.
+ */
+function detectMode(root = process.cwd()) {
+    const stack = detectStack(root);
+    if (stack.length === 0)
+        return 'greenfield';
+    const gitDir = path.join(root, '.git');
+    if (fs.existsSync(gitDir)) {
+        try {
+            const { execFileSync } = require('child_process');
+            const count = execFileSync('git', ['rev-list', '--count', 'HEAD'], {
+                cwd: root, encoding: 'utf-8', timeout: 5000,
+            }).trim();
+            if (parseInt(count, 10) > 10)
+                return 'brownfield';
+        }
+        catch { /* ignore */ }
+    }
+    // Has stack but no git history → likely greenfield setup-in-progress
+    return 'greenfield';
+}
+/** Map (mode, stack) to a recommended workflow id from dist-templates/workflows/. */
+function recommendWorkflow(mode, stack) {
+    if (mode === 'not-applicable')
+        return 'spec-pipeline';
+    const hasUI = stack.some((s) => ['react', 'vue', 'svelte', 'flutter'].includes(s));
+    const hasServer = stack.some((s) => ['node-server', 'go', 'rust', 'python', 'ruby', 'php'].includes(s));
+    if (mode === 'brownfield') {
+        // Brownfield always starts with discovery the first time.
+        return 'brownfield-discovery';
+    }
+    // Greenfield
+    if (hasUI && hasServer)
+        return 'greenfield-fullstack';
+    if (hasUI)
+        return 'greenfield-ui';
+    if (hasServer)
+        return 'greenfield-service';
+    return 'greenfield-fullstack';
+}
+/** Convenience: build a fresh ProjectMetadata for a chosen mode. */
+function buildMetadata(mode, root = process.cwd(), notes) {
+    const now = new Date().toISOString();
+    const stack = detectStack(root);
+    return {
+        mode,
+        createdAt: now,
+        updatedAt: now,
+        detectedStack: stack,
+        recommendedWorkflow: recommendWorkflow(mode, stack),
+        notes,
+    };
+}

package/dist/orchestrator/SkillRegistryV2.js

@@ -1,15 +1,60 @@
 "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 });
 exports.SkillRegistryV2 = void 0;
+const path = __importStar(require("path"));
 const FileSkillProvider_1 = require("./providers/FileSkillProvider");
 const CloudSkillProvider_1 = require("./providers/CloudSkillProvider");
 const CompositeSkillProvider_1 = require("./providers/CompositeSkillProvider");
+// v1.8.3+: when no explicit OPENLIFE_SKILL_ROOT(S) is set, expose BOTH the
+// user's project .catalog/skills (override) and the npm-package-bundled
+// .catalog/skills (defaults). FileSkillProvider skips non-existent dirs.
+function defaultSkillRoots() {
+    if (process.env.OPENLIFE_SKILL_ROOTS) {
+        return process.env.OPENLIFE_SKILL_ROOTS.split(':').filter(Boolean);
+    }
+    if (process.env.OPENLIFE_SKILL_ROOT)
+        return [process.env.OPENLIFE_SKILL_ROOT];
+    const cwdRoot = path.join(process.cwd(), '.catalog', 'skills');
+    const packageRoot = path.join(__dirname, '..', '..', '.catalog', 'skills');
+    return cwdRoot === packageRoot ? [cwdRoot] : [cwdRoot, packageRoot];
+}
 class SkillRegistryV2 {
     provider;
     skills = [];
-    constructor(provider = new CompositeSkillProvider_1.CompositeSkillProvider(new CloudSkillProvider_1.CloudSkillProvider(process.env.OPENLIFE_CLOUD_SKILLS_FILE || ''), new FileSkillProvider_1.FileSkillProvider(process.env.OPENLIFE_SKILL_ROOTS
-        ? process.env.OPENLIFE_SKILL_ROOTS.split(':').filter(Boolean)
-        : [process.env.OPENLIFE_SKILL_ROOT || `${process.cwd()}/.catalog/skills`]))) {
+    constructor(provider = new CompositeSkillProvider_1.CompositeSkillProvider(new CloudSkillProvider_1.CloudSkillProvider(process.env.OPENLIFE_CLOUD_SKILLS_FILE || ''), new FileSkillProvider_1.FileSkillProvider(defaultSkillRoots()))) {
         this.provider = provider;
         this.load();
     }

package/dist/orchestrator/SquadRegistry.js

@@ -1,10 +1,56 @@
 "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 });
 exports.SquadRegistry = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const FileSquadProvider_1 = require("./providers/FileSquadProvider");
 const CloudSquadProvider_1 = require("./providers/CloudSquadProvider");
 const CompositeSquadProvider_1 = require("./providers/CompositeSquadProvider");
-const defaultSquadRoot = () => process.env.OPENLIFE_SQUAD_ROOT || process.cwd() + '/.catalog/squads';
+// v1.8.3+: prefer the user's project-local .catalog/squads (override) and
+// fall back to the bundled package .catalog/squads when running from a
+// globally-installed @openlife/cli. FileSquadProvider takes a single string,
+// so we pick the right one upfront rather than refactoring the provider.
+const defaultSquadRoot = () => {
+    if (process.env.OPENLIFE_SQUAD_ROOT)
+        return process.env.OPENLIFE_SQUAD_ROOT;
+    const cwdRoot = path.join(process.cwd(), '.catalog', 'squads');
+    if (fs.existsSync(cwdRoot))
+        return cwdRoot;
+    return path.join(__dirname, '..', '..', '.catalog', 'squads');
+};
 class SquadRegistry {
     provider;
     squads = [];

package/dist/test_flow_run_cli.js

@@ -0,0 +1,183 @@
+"use strict";
+// src/test_flow_run_cli.ts
+// Smoke test for the v1.9.0 `openlife flow` CLI surface and
+// `openlife project-mode` commands. Exercises the runtime path without
+// requiring an LLM or external CI.
+//
+// Covers:
+//  1. listFlows() returns all 12 expected workflows from bundled source
+//  2. findFlow(id) resolves a known workflow
+//  3. dryRunFlow(id) produces a phase plan with > 0 steps
+//  4. ProjectMetadata read/write roundtrip
+//  5. detectMode + recommendWorkflow produce sane defaults
+//  6. project mode persistence file shape is valid JSON
+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 CommandFlowRunner_1 = require("./cli/CommandFlowRunner");
+const ProjectMetadata_1 = require("./orchestrator/ProjectMetadata");
+let passed = 0;
+let failed = 0;
+function check(name, cond, detail) {
+    if (cond) {
+        passed++;
+        console.log(`  ✓ ${name}`);
+    }
+    else {
+        failed++;
+        console.error(`  ✗ ${name}${detail ? ` — ${detail}` : ''}`);
+    }
+}
+const REPO_ROOT = path.resolve(__dirname, '..');
+// ── 1. listFlows ───────────────────────────────────────────────────────
+console.log('\n[1] CommandFlowRunner.listFlows()');
+const flows = (0, CommandFlowRunner_1.listFlows)(REPO_ROOT);
+check('at least 12 workflows surfaced', flows.length >= 12, `got ${flows.length}`);
+const flowIds = new Set(flows.map(f => f.id));
+for (const expected of ['greenfield-fullstack', 'greenfield-service', 'greenfield-ui',
+    'brownfield-discovery', 'brownfield-fullstack', 'brownfield-service',
+    'brownfield-ui', 'story-development-cycle', 'qa-loop',
+    'spec-pipeline', 'epic-orchestration', 'continuous-deployment']) {
+    check(`flow "${expected}" listed`, flowIds.has(expected));
+}
+// Every entry has the right shape
+for (const f of flows.slice(0, 3)) {
+    check(`flow "${f.id}" has type`, !!f.type);
+    check(`flow "${f.id}" has steps > 0`, f.steps > 0, `steps=${f.steps}`);
+}
+// ── 2. findFlow ────────────────────────────────────────────────────────
+console.log('\n[2] CommandFlowRunner.findFlow()');
+const greenfieldFs = (0, CommandFlowRunner_1.findFlow)('greenfield-fullstack', REPO_ROOT);
+check('findFlow("greenfield-fullstack") returns a workflow', greenfieldFs !== null);
+check('found workflow has correct id', greenfieldFs?.workflow.id === 'greenfield-fullstack');
+check('source is bundled when running from repo', greenfieldFs?.source === 'bundled' || greenfieldFs?.source === 'local');
+const notFound = (0, CommandFlowRunner_1.findFlow)('definitely-does-not-exist', REPO_ROOT);
+check('findFlow returns null for unknown id', notFound === null);
+// ── 3. dryRunFlow ──────────────────────────────────────────────────────
+console.log('\n[3] CommandFlowRunner.dryRunFlow()');
+const summary = (0, CommandFlowRunner_1.dryRunFlow)('greenfield-service', REPO_ROOT);
+check('dryRunFlow("greenfield-service") returns summary', summary !== null);
+if (summary) {
+    check('summary has id', summary.id === 'greenfield-service');
+    check('summary has > 5 steps', summary.steps.length > 5, `got ${summary.steps.length}`);
+    check('summary has at least one phase marker', summary.steps.some(s => s.phase !== undefined));
+    check('summary has at least one executable step', summary.steps.some(s => s.id !== undefined));
+    const rendered = (0, CommandFlowRunner_1.renderDryRun)(summary);
+    check('renderDryRun produces > 5 lines', rendered.length > 5);
+}
+// ── 4. ProjectMetadata roundtrip ───────────────────────────────────────
+console.log('\n[4] ProjectMetadata read/write roundtrip');
+const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-method-test-'));
+try {
+    const meta = (0, ProjectMetadata_1.buildMetadata)('greenfield', tmpRoot, 'test-run-note');
+    const fp = (0, ProjectMetadata_1.writeProjectMetadata)(meta, tmpRoot);
+    check('writeProjectMetadata returns path', fp.endsWith('project.json'));
+    check('file was actually written', fs.existsSync(fp));
+    const readBack = (0, ProjectMetadata_1.readProjectMetadata)(tmpRoot);
+    check('readProjectMetadata returns metadata', readBack !== null);
+    check('read mode matches written mode', readBack?.mode === 'greenfield');
+    check('read createdAt is ISO string', /\d{4}-\d{2}-\d{2}T/.test(readBack?.createdAt || ''));
+    check('read recommendedWorkflow is non-empty', !!readBack?.recommendedWorkflow);
+    check('read notes preserved', readBack?.notes === 'test-run-note');
+    // Round-trip with brownfield
+    const meta2 = (0, ProjectMetadata_1.buildMetadata)('brownfield', tmpRoot);
+    (0, ProjectMetadata_1.writeProjectMetadata)(meta2, tmpRoot);
+    const readBack2 = (0, ProjectMetadata_1.readProjectMetadata)(tmpRoot);
+    check('brownfield mode roundtrips', readBack2?.mode === 'brownfield');
+    check('brownfield recommends discovery', readBack2?.recommendedWorkflow === 'brownfield-discovery');
+}
+finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+}
+// ── 5. detectMode + recommendWorkflow ──────────────────────────────────
+console.log('\n[5] Heuristic detection');
+// Empty tmpdir → greenfield
+const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-empty-'));
+try {
+    const mode = (0, ProjectMetadata_1.detectMode)(emptyDir);
+    check('empty dir → greenfield', mode === 'greenfield');
+    const rec = (0, ProjectMetadata_1.recommendWorkflow)(mode, []);
+    check('greenfield + no stack → greenfield-fullstack', rec === 'greenfield-fullstack');
+}
+finally {
+    fs.rmSync(emptyDir, { recursive: true, force: true });
+}
+// Tmp with package.json but no git → still greenfield
+const pkgDir = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-pkg-'));
+try {
+    fs.writeFileSync(path.join(pkgDir, 'package.json'), JSON.stringify({ name: 'x', dependencies: { react: '*' } }));
+    const stack = (0, ProjectMetadata_1.detectStack)(pkgDir);
+    check('detectStack finds node', stack.includes('node'));
+    check('detectStack finds react', stack.includes('react'));
+    const rec = (0, ProjectMetadata_1.recommendWorkflow)('greenfield', stack);
+    check('greenfield + react → greenfield-ui (no server)', rec === 'greenfield-ui');
+}
+finally {
+    fs.rmSync(pkgDir, { recursive: true, force: true });
+}
+// Brownfield always recommends discovery
+const rec3 = (0, ProjectMetadata_1.recommendWorkflow)('brownfield', ['node', 'typescript', 'react']);
+check('brownfield → discovery regardless of stack', rec3 === 'brownfield-discovery');
+// ── 6. JSON file shape ─────────────────────────────────────────────────
+console.log('\n[6] project.json shape');
+const tmpRoot2 = fs.mkdtempSync(path.join(os.tmpdir(), 'openlife-shape-'));
+try {
+    const meta = (0, ProjectMetadata_1.buildMetadata)('greenfield', tmpRoot2);
+    (0, ProjectMetadata_1.writeProjectMetadata)(meta, tmpRoot2);
+    const raw = fs.readFileSync((0, ProjectMetadata_1.projectMetadataPath)(tmpRoot2), 'utf-8');
+    let parsed = {};
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch { /* shape check below catches it */ }
+    check('file is valid JSON', !!parsed.mode);
+    check('has createdAt', typeof parsed.createdAt === 'string');
+    check('has updatedAt', typeof parsed.updatedAt === 'string');
+    check('has detectedStack array', Array.isArray(parsed.detectedStack));
+    check('has recommendedWorkflow string', typeof parsed.recommendedWorkflow === 'string');
+}
+finally {
+    fs.rmSync(tmpRoot2, { recursive: true, force: true });
+}
+// ── Done ───────────────────────────────────────────────────────────────
+console.log('');
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+    console.error('TEST_FLOW_RUN_CLI_FAIL');
+    process.exit(1);
+}
+console.log('TEST_FLOW_RUN_CLI_OK');

package/dist/test_host_uninstaller.js

@@ -99,9 +99,19 @@ function testUninstallRemovesAllInstalledArtifacts() {
         // 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.
+        // Count dynamically from dist-templates/claude-code/. The uninstaller
+        // removes top-level files (agents + top-level commands + MCP snippet),
+        // not files inside nested commands/openlife/{agents,flow}/ subdirs.
+        const distTemplateRoot = path.join(__dirname, '..', 'dist-templates', 'claude-code');
+        const agentCount = fs.existsSync(path.join(distTemplateRoot, 'agents'))
+            ? fs.readdirSync(path.join(distTemplateRoot, 'agents')).filter((f) => f.endsWith('.md')).length
+            : 0;
+        const commandCount = fs.existsSync(path.join(distTemplateRoot, 'commands', 'openlife'))
+            ? fs.readdirSync(path.join(distTemplateRoot, 'commands', 'openlife')).filter((f) => f.endsWith('.md')).length
+            : 0;
+        const expectedRemoved = agentCount + commandCount + 1; // +1 for MCP snippet
         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}: ` +
+        assert(removed === expectedRemoved, `expected ${expectedRemoved} 'removed' actions (${agentCount} agents + ${commandCount} top-level commands + 1 mcp); got ${removed}: ` +
             JSON.stringify(result.files.map((f) => `${path.basename(f.destination)}:${f.action}`)));
     }
     finally {