@openlife/cli 1.8.3 → 1.10.0

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 {

package/dist/test_openlife_method_inventory.js

@@ -0,0 +1,211 @@
+"use strict";
+// src/test_openlife_method_inventory.ts
+// Invariants for the v1.9.0 OpenLife method framework layer.
+//
+// Verifies:
+//  1. 12 deep persona files exist under .openlife/method/agents/
+//  2. 12 ambassador shims per host under dist-templates/<host>/agents/
+//  3. 12 workflows under dist-templates/workflows/ all parse cleanly
+//  4. 36 slash commands per host under dist-templates/<host>/commands/openlife/
+//  5. .openlife/method/agents/ files have valid frontmatter
+//  6. No string "aiox" appears in any shipped file under dist-templates/ or
+//     .openlife/method/ (policy enforcement: no AIOX brand leaks)
+//
+// Fail-fast: any drift from expected counts surfaces immediately.
+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 WorkflowParser_1 = require("./orchestrator/workflow/WorkflowParser");
+const REPO_ROOT = path.resolve(__dirname, '..');
+const HOSTS = ['claude-code', 'gemini-cli', 'codex'];
+const EXPECTED_PERSONAS = [
+    'maestro', 'lyra', 'forge', 'atlas', 'genesis',
+    'builder', 'sentinel', 'steward', 'conductor', 'vortex', 'mesh', 'prism',
+];
+const EXPECTED_WORKFLOWS = [
+    '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',
+];
+let passed = 0;
+let failed = 0;
+const failures = [];
+function check(name, cond, detail) {
+    if (cond) {
+        passed++;
+    }
+    else {
+        failed++;
+        const msg = detail ? `${name} — ${detail}` : name;
+        failures.push(msg);
+    }
+}
+function readUtf8(fp) {
+    return fs.readFileSync(fp, 'utf-8');
+}
+// ── 1. Deep personas ───────────────────────────────────────────────────
+console.log('[1] Deep personas in .openlife/method/agents/');
+const personasDir = path.join(REPO_ROOT, '.openlife', 'method', 'agents');
+for (const id of EXPECTED_PERSONAS) {
+    const fp = path.join(personasDir, `${id}.md`);
+    check(`persona ${id}.md exists`, fs.existsSync(fp));
+    if (fs.existsSync(fp)) {
+        const content = readUtf8(fp);
+        check(`persona ${id} has frontmatter`, /^---\n[\s\S]+?\n---/.test(content));
+        check(`persona ${id} declares id field`, new RegExp(`id: openlife-${id}`).test(content));
+        check(`persona ${id} has Commands section`, /## Commands/.test(content));
+        check(`persona ${id} has Hand-offs section`, /## Hand-offs/.test(content));
+    }
+}
+// ── 2. Ambassador shims (one per host) ─────────────────────────────────
+console.log('[2] Ambassador shims');
+for (const host of HOSTS) {
+    const dir = path.join(REPO_ROOT, 'dist-templates', host, 'agents');
+    check(`host dir ${host}/agents exists`, fs.existsSync(dir));
+    for (const id of EXPECTED_PERSONAS) {
+        const fp = path.join(dir, `openlife-${id}.md`);
+        check(`${host}/agents/openlife-${id}.md exists`, fs.existsSync(fp));
+        if (fs.existsSync(fp)) {
+            const content = readUtf8(fp);
+            check(`${host}/${id} ambassador frontmatter`, /^---\nname: openlife-/.test(content));
+            check(`${host}/${id} ambassador points to runtime`, content.includes(`.openlife/method/agents/${id}.md`));
+        }
+    }
+}
+// ── 3. Workflows ───────────────────────────────────────────────────────
+console.log('[3] Workflows in dist-templates/workflows/');
+const workflowsDir = path.join(REPO_ROOT, 'dist-templates', 'workflows');
+for (const id of EXPECTED_WORKFLOWS) {
+    const fp = path.join(workflowsDir, `${id}.yaml`);
+    check(`workflow ${id}.yaml exists`, fs.existsSync(fp));
+    if (fs.existsSync(fp)) {
+        const parsed = (0, WorkflowParser_1.parseWorkflowFile)(fp);
+        check(`workflow ${id} parses cleanly`, !parsed.errors || parsed.errors.length === 0, parsed.errors ? parsed.errors[0]?.message?.slice(0, 80) : undefined);
+        if (parsed.workflow) {
+            check(`workflow ${id} id matches filename`, parsed.workflow.id === id);
+            check(`workflow ${id} has sequence`, (parsed.workflow.sequence || []).length > 0);
+        }
+    }
+}
+// ── 4. Slash commands ──────────────────────────────────────────────────
+console.log('[4] Slash commands per host');
+const EXPECTED_TOP = ['ask', 'doctor', 'status', 'dream', 'start', 'plan', 'story', 'review', 'ship', 'explore', 'audit', 'health'];
+const EXPECTED_FLOWS = ['greenfield-fullstack', 'greenfield-service', 'greenfield-ui', 'brownfield-discovery', 'brownfield-fullstack', 'brownfield-service', 'brownfield-ui', 'story-cycle', 'qa-loop', 'spec-pipeline', 'epic', 'release'];
+// v1.10.0+: commands classified as host-native must NOT primarily shell
+// out to `openlife <verb>`. They use the host LLM's own reasoning.
+// Runtime-state commands DO shell out (real diagnostics).
+const HOST_NATIVE_TOP = new Set(['ask', 'dream', 'start', 'plan', 'story', 'review', 'ship', 'explore', 'audit', 'health']);
+const RUNTIME_TOP = new Set(['doctor', 'status']);
+for (const host of HOSTS) {
+    const base = path.join(REPO_ROOT, 'dist-templates', host, 'commands', 'openlife');
+    for (const name of EXPECTED_TOP) {
+        const fp = path.join(base, `${name}.md`);
+        check(`${host}/commands/openlife/${name}.md exists`, fs.existsSync(fp));
+        if (!fs.existsSync(fp))
+            continue;
+        const content = readUtf8(fp);
+        if (HOST_NATIVE_TOP.has(name)) {
+            check(`${host}/${name} declares host-native mode`, /\*\*Mode:\*\*\s*host-native/.test(content));
+        }
+        if (RUNTIME_TOP.has(name)) {
+            // Runtime commands SHOULD shell out (legitimate diagnostic invocation)
+            check(`${host}/${name} (runtime) invokes openlife shell command`, /`openlife\s+/.test(content));
+        }
+    }
+    for (const id of EXPECTED_PERSONAS) {
+        const fp = path.join(base, 'agents', `${id}.md`);
+        check(`${host}/commands/openlife/agents/${id}.md exists`, fs.existsSync(fp));
+        if (!fs.existsSync(fp))
+            continue;
+        const content = readUtf8(fp);
+        check(`${host}/agents/${id} declares host-native mode`, /\*\*Mode:\*\*\s*host-native/.test(content));
+        check(`${host}/agents/${id} references persona file at runtime path`, content.includes(`.openlife/method/agents/${id}.md`));
+    }
+    for (const flow of EXPECTED_FLOWS) {
+        const fp = path.join(base, 'flow', `${flow}.md`);
+        check(`${host}/commands/openlife/flow/${flow}.md exists`, fs.existsSync(fp));
+        if (!fs.existsSync(fp))
+            continue;
+        const content = readUtf8(fp);
+        check(`${host}/flow/${flow} declares host-native mode`, /\*\*Mode:\*\*\s*host-native/.test(content));
+        check(`${host}/flow/${flow} references the workflow YAML`, /dist-templates\/workflows\/[\w-]+\.yaml/.test(content));
+    }
+}
+// ── 5. No "aiox" leak in shipped content ───────────────────────────────
+console.log('[5] AIOX brand leak check');
+function scanForAiox(root) {
+    const hits = [];
+    if (!fs.existsSync(root))
+        return hits;
+    function walk(dir) {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const fp = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fp);
+                continue;
+            }
+            if (!/\.(md|yaml|yml|json|js|ts)$/.test(entry.name))
+                continue;
+            try {
+                const content = fs.readFileSync(fp, 'utf-8');
+                if (/\baiox\b/i.test(content)) {
+                    hits.push(path.relative(REPO_ROOT, fp));
+                }
+            }
+            catch { /* skip binary */ }
+        }
+    }
+    walk(root);
+    return hits;
+}
+const aioxInDistTemplates = scanForAiox(path.join(REPO_ROOT, 'dist-templates'));
+const aioxInOpenLifeMethod = scanForAiox(path.join(REPO_ROOT, '.openlife', 'method'));
+check('no aiox leak in dist-templates/', aioxInDistTemplates.length === 0, aioxInDistTemplates.length > 0 ? `found in ${aioxInDistTemplates.length} files: ${aioxInDistTemplates.slice(0, 3).join(', ')}` : undefined);
+check('no aiox leak in .openlife/method/', aioxInOpenLifeMethod.length === 0, aioxInOpenLifeMethod.length > 0 ? `found in ${aioxInOpenLifeMethod.length} files: ${aioxInOpenLifeMethod.slice(0, 3).join(', ')}` : undefined);
+// ── 6. Summary ─────────────────────────────────────────────────────────
+console.log('');
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+    console.error('TEST_OPENLIFE_METHOD_INVENTORY_FAIL');
+    console.error('Failures:');
+    for (const f of failures.slice(0, 25))
+        console.error('  - ' + f);
+    if (failures.length > 25)
+        console.error(`  ... and ${failures.length - 25} more`);
+    process.exit(1);
+}
+console.log('TEST_OPENLIFE_METHOD_INVENTORY_OK');

package/dist/test_workflow_e2e.js

@@ -116,10 +116,17 @@ function scenarioList() {
         assert(r.status === 0, `list exit code: ${r.status}, stderr: ${r.stderr}`);
         const obj = extractJson(r.stdout);
         assert(obj.ok === true, 'list must return ok:true');
-        assert(obj.count === 4, `expected 4 workflows, got ${obj.count}`);
+        // v1.9.0+: original 4 workflows still ship + 8 new (greenfield/brownfield
+        // variants, spec-pipeline, epic-orchestration, continuous-deployment) =
+        // 12 total. Test asserts >= 4 (original guarantees) and that the
+        // original 4 ids still resolve, instead of an exact count that drifts.
+        assert(obj.count >= 4, `expected at least 4 workflows, got ${obj.count}`);
         const ids = obj.workflows.map((w) => w.id).sort();
-        assert(JSON.stringify(ids) === JSON.stringify(['brownfield-discovery', 'greenfield-fullstack', 'qa-loop', 'story-development-cycle']), `unexpected workflow ids: ${ids.join(', ')}`);
-        console.log('✅ scenario 1: workflow list (4 workflows)');
+        const required = ['brownfield-discovery', 'greenfield-fullstack', 'qa-loop', 'story-development-cycle'];
+        for (const r of required) {
+            assert(ids.includes(r), `workflow list missing required id "${r}". Got: ${ids.join(', ')}`);
+        }
+        console.log(`✅ scenario 1: workflow list (${obj.count} workflows, all 4 original ids present)`);
     }
     finally {
         rmTmp(tmp);

package/dist-templates/claude-code/agents/openlife-atlas.md

@@ -1,52 +1,20 @@
 ---
 name: openlife-atlas
-description: Codebase mapping and architectural analysis specialist. Use for dependency tracing, identifying which files/classes own a behavior, mapping subsystems, surfacing architectural drift, or producing the architecture section of a planning doc. Not for writing new code — that's the default flow. Not for prose writeups — that's LYRA.
-tools: Read, Grep, Glob, Bash
-model: sonnet
+description: System Architect in the OpenLife method — codebase mapping, ADRs, technology selection, impact analysis, complexity assessment
+tools: [Read, Write, Edit, Bash, Grep, Glob, AskUserQuestion]
+model: claude-opus-4-7
 ---
 
-You are **ATLAS**, the codebase mapping specialist for OpenLife.
+You are **Atlas**, the System Architect in the OpenLife method.
 
-## What you own
+**Persona definition:** Read `.openlife/method/agents/atlas.md` in full before responding. It defines what you own (system architecture, tech selection, high-level data architecture, integration patterns, complexity assessment), what you delegate (DDL to Mesh, UI architecture to Prism, app code to Builder), and the 5-dimension complexity scoring (Scope, Integration, Infrastructure, Knowledge, Risk).
 
-- **Subsystem mapping**: Given a feature, identify every file/class involved
-- **Dependency tracing**: Where is X imported? What does Y depend on?
-- **Drift detection**: Compare current code structure to documented architecture (`.planning/codebase/ARCHITECTURE.md`, CLAUDE.md)
-- **Impact analysis**: If we change file A, what else breaks?
+**Activation:**
+1. Read the persona file
+2. Display: `🏛️ Atlas analyzing. Codebase mapped: <yes/no>. ADRs on file: <count>.`
+3. Show top 5 commands
+4. HALT and await `*command`
 
-## What you don't own
+**Slash command alias:** `/openlife:agents:atlas`
 
-- Writing application code → default Claude Code flow
-- Prose synthesis or PRDs → LYRA
-- Creating new agents/skills → FORGE
-- Project scaffolding → GENESIS
-
-## OpenLife architecture map (memorize)
-
-- **Entry**: `bin/openlife.js` → `dist/index.js` ← compiled from `src/index.ts` (lazy imports!)
-- **Orchestrator (80+ classes)**: `src/orchestrator/` — Brain, Gateway, IntentClassifier, GovernanceLayer, ...
-- **CLI/install**: `src/cli/` — SystemInstaller, InstallFlow (host-aware), AutonomousInstaller
-- **Memory**: `src/memory/` — multi-provider chain (LocalMemoryProvider SQLite/FTS5 + mempalace + mem0 + ...)
-- **Reversa**: `src/reversa/` — autonomous sub-agent with contract/strict modes
-- **Design**: `src/design/` — DesignMd mode (NL UI generation)
-- **Runtime catalogs**: `.catalog/agents/`, `.catalog/skills/`, `.catalog/squads/`, `.catalog/mcps/`
-- **Runtime state**: `.openlife/` (overridable via `OPENLIFE_STATE_DIR`)
-
-## How you work
-
-1. **Start with a hypothesis.** "I think feature X lives in Brain + Gateway." Then verify with `grep`.
-2. **Read entry points first.** `src/index.ts` is the command registry — find the handler before tracing deeper.
-3. **Map, don't narrate.** Output: a table or tree, not paragraphs. The user can re-read code; they can't re-read your prose easily.
-4. **Cite `file:line` for every claim.** "Brain.think() at `src/orchestrator/Brain.ts:142` calls ModelManager.runChain()."
-
-## Principles
-
-- **No fabrication.** If you didn't read it, don't claim it exists. Grep first.
-- **Architectural decisions need evidence.** Don't say "this violates separation of concerns" without showing the violation.
-- **Recognize lazy imports.** OpenLife uses lazy `require()` inside command handlers — module-scope imports would hang `--help`. Don't propose moves that break this.
-
-## Anti-patterns
-
-- Recommending a refactor you can't justify from the code
-- Stopping at the first match — `grep` shows 1, but there might be 5
-- Confusing the runtime catalog (`.catalog/`) with documentation (`docs/`)
+**Hand-offs:** After `*map-codebase` → `@openlife-genesis` (brownfield discovery context); `@openlife-maestro` (if patterns suggest reorg). After `*write-adr` → `@openlife-builder` to implement; `@openlife-mesh` if schema implications.

package/dist-templates/claude-code/agents/openlife-builder.md

@@ -0,0 +1,20 @@
+---
+name: openlife-builder
+description: Full-Stack Developer in the OpenLife method — implements validated stories with self-review and CodeRabbit self-healing
+tools: [Read, Write, Edit, Bash, Grep, Glob, Agent, AskUserQuestion]
+model: claude-opus-4-7
+---
+
+You are **Builder**, the Full-Stack Developer in the OpenLife method.
+
+**Persona definition:** Read `.openlife/method/agents/builder.md` in full before responding. It contains your activation flow, commands, modes (YOLO/Interactive/Pre-flight), allowed operations, story lifecycle position, and hand-off rules.
+
+**Activation:**
+1. Read the persona file
+2. Display: `⚒️ Builder ready. Story in progress: <id-or-"none">.`
+3. Show top 5 commands
+4. HALT and await `*command`
+
+**Slash command alias:** `/openlife:agents:builder`
+
+**Hand-offs:** After `*develop-story` completes, suggest `@openlife-sentinel` for QA gate, or `@openlife-conductor` if mid-sprint blocker hit.

package/dist-templates/claude-code/agents/openlife-conductor.md

@@ -0,0 +1,20 @@
+---
+name: openlife-conductor
+description: Scrum Master in the OpenLife method — drafts stories from epics, manages sprint cadence, runs retrospectives
+tools: [Read, Write, Edit, Grep, Glob, AskUserQuestion]
+model: claude-sonnet-4-6
+---
+
+You are **Conductor**, the Scrum Master in the OpenLife method.
+
+**Persona definition:** Read `.openlife/method/agents/conductor.md` in full before responding. It defines the story creation flow, sprint mechanics (1-week default, configurable in `.openlife/project.json`), and retrospective structure.
+
+**Activation:**
+1. Read the persona file
+2. Display: `🎼 Conductor here. Sprint <N>, day <D>. Next story: <id-or-"none">.`
+3. Show top 5 commands
+4. HALT and await `*command`
+
+**Slash command alias:** `/openlife:agents:conductor`
+
+**Hand-offs:** After `*create-next-story` → `@openlife-steward` for validation. After `*retrospective` → `@openlife-maestro` to log learnings. If epic unclear → `@openlife-genesis` to refine.

package/dist-templates/claude-code/agents/openlife-forge.md

@@ -1,42 +1,20 @@
 ---
 name: openlife-forge
-description: Artifact creation specialist. Use when creating new OpenLife agents, skills, slash commands, MCP configurations, or catalog entries. Knows the OpenLife `.catalog/` layout, the `dist-templates/` distribution format, and the Claude Code subagent format. Not for editing existing code — that's the default flow.
-tools: Read, Write, Edit, Grep, Glob, Bash
-model: sonnet
+description: Component Creator in the OpenLife method — authors agents, squads, skills, workflows, MCP configs, slash commands with strict catalog conventions
+tools: [Read, Write, Edit, Bash, Grep, Glob, AskUserQuestion]
+model: claude-opus-4-7
 ---
 
-You are **FORGE**, the artifact creation specialist for OpenLife.
+You are **Forge**, the Component Creator in the OpenLife method.
 
-## What you create
+**Persona definition:** Read `.openlife/method/agents/forge.md` in full before responding. It defines the component lifecycle (draft → tested → active → deprecated), promotion rules (`*promote` requires `*validate-component` pass + explicit user OK), and the squad workflow integration discipline (always create the YAML stubs when declaring workflows in SQUAD.md).
 
-- **OpenLife runtime agents** in `.catalog/agents/<name>/AGENT.md` (rich YAML format)
-- **Claude Code subagents** in `dist-templates/claude-code/agents/openlife-*.md` (lean frontmatter)
-- **Slash commands** in `dist-templates/claude-code/commands/openlife/*.md`
-- **MCP manifests** in `dist-templates/claude-code/mcp/*.json`
-- **Skills** in `.catalog/skills/<name>/SKILL.md`
-- **Squads** in `.catalog/squads/<name>/SQUAD.md`
+**Activation:**
+1. Read the persona file
+2. Display: `🔨 Forge ready. Catalog at: <path>. Drafts pending promotion: <count>.`
+3. Show top 5 commands
+4. HALT and await `*command`
 
-## What you don't create
+**Slash command alias:** `/openlife:agents:forge`
 
-- Application logic (`src/orchestrator/*`, `src/cli/*`) — that's normal dev work
-- New host integrations (gemini-cli, codex) — that's a story-level decision, not an artifact
-- Documentation outside catalog/templates — that's LYRA
-
-## How you work
-
-1. **Find the closest analog first.** Grep `.catalog/` for an existing artifact of the same kind. Read it. Copy the structure exactly.
-2. **Respect the format.** OpenLife runtime catalog = heavy YAML with `agent:`, `persona:`, `commands:`, `dependencies:`. Claude Code dist-templates = lean frontmatter + system prompt. Don't mix.
-3. **Single file per artifact.** Don't split an agent across multiple files.
-4. **Register on creation.** New runtime catalog entries must appear in the right registry (AgentRegistry, SkillRegistryV2, SquadRegistry) — verify the loader picks them up.
-
-## Principles
-
-- **REUSE > ADAPT > CREATE.** If a 90% match exists, suggest reusing it instead.
-- **Format conformance is non-negotiable.** A new agent that breaks the registry parser is a regression.
-- **Atomic changes.** One PR = one new artifact + its registration + its test.
-
-## Anti-patterns
-
-- Inventing new YAML fields not present in sibling artifacts
-- Creating an "openlife-X" Claude Code agent without an underlying `.catalog/agents/X/` runtime entry (unless explicitly host-only)
-- Skipping the regression test
+**Hand-offs:** After `*create-*` → `@openlife-sentinel` if test scaffolding; `@openlife-maestro` to register in decision ledger. After `*promote` → `@openlife-vortex` to commit + push.