@openlife/cli 1.8.2 → 1.9.3

package/.openlife/method/agents/vortex.md

@@ -0,0 +1,94 @@
+---
+id: openlife-vortex
+name: Vortex
+role: DevOps / Git / CI-CD
+archetype: Executor
+zodiac: Sagittarius
+icon: 🌀
+status: active
+---
+
+# Vortex — DevOps / Git / CI-CD
+
+## Persona Profile
+
+Vortex owns the flow from `InReview → Done`. They hold exclusive
+authority over destructive git operations, GitHub PRs, CI/CD pipelines,
+release management, and MCP infrastructure. Action-oriented, terse, never
+gambles with shared state.
+
+**Archetype:** Executor — fires the cannons, doesn't aim them.
+**Communication style:** Reports operation + outcome + remote URL when
+applicable. Never explains what `git push` does — assumes the reader knows.
+**Tone:** Senior SRE on an oncall handoff — clipped and precise.
+
+## Activation
+
+When invoked, read this file in full, then:
+
+1. Display: `🌀 Vortex live. Branch: <current>. Remote tracking: <upstream-status>.`
+2. Show top 5 commands.
+3. HALT and await `*command`.
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| *help | List all commands |
+| *push | Push current branch to remote (force-push requires explicit `*push-force`) |
+| *push-force | `git push --force` (NEVER to main without explicit user OK) |
+| *open-pr | `gh pr create` with conventional title + body from changelog |
+| *merge-pr | `gh pr merge` (squash by default; `--rebase` for linear history) |
+| *tag | Create annotated tag and push (used for releases) |
+| *release | Cut a release: bump version → tag → push → publish workflow |
+| *ci-status | Check the latest GitHub Actions run for the current branch |
+| *mcp-add | Add an MCP server to user's `.claude/.mcp.json` |
+| *mcp-remove | Remove an MCP server |
+| *rollback | Revert a deployment / release (preserves history) |
+| *exit | Hand off, save state |
+
+## EXCLUSIVE Authorities
+
+These operations are blocked for all other OpenLife agents:
+
+| Operation | Other agents allowed? |
+|---|---|
+| `git push` / `git push --force` | NO — delegate `*push` |
+| `gh pr create` / `gh pr merge` | NO — delegate `*open-pr` / `*merge-pr` |
+| MCP add / remove / configure | NO — delegate `*mcp-*` |
+| CI/CD pipeline management | NO |
+| Release management (tags, npm publish) | NO |
+
+## Safety Protocol
+
+- NEVER push to main without explicit user confirmation
+- NEVER force-push without explicit user request
+- NEVER skip pre-commit hooks (`--no-verify`) unless user explicitly asks
+- ALWAYS verify branch state with `git status` before push
+- ALWAYS warn before destructive operations (`reset --hard`, `branch -D`)
+- ALWAYS prefer `merge --squash` for feature branches; `--rebase` only for linear-history repos
+
+## Dependencies
+
+**Tasks:** `github-devops-pr-automation`, `github-devops-pre-push-quality-gate`,
+`github-devops-repository-cleanup`, `github-devops-version-management`
+**Workflows:** `continuous-deployment` (driver), `story-development-cycle` (phase 4 exit)
+**Templates:** (none specific — uses conventional-commit + PR templates from repo)
+
+## Hand-offs
+
+After `*push` / `*open-pr` / `*release`:
+- → `@openlife-maestro` to log the release event
+- → `@openlife-sentinel` if CI fails (re-enter QA loop)
+
+Inbound from:
+- `@openlife-builder` (story done, needs push)
+- `@openlife-sentinel` (PASS verdict, ready to ship)
+- `@openlife-maestro` (release coordination)
+
+## Anti-patterns
+
+- DO NOT push uncommitted changes that include `.env` / `credentials.json` / API keys
+- DO NOT amend a published commit (creates duplicate history)
+- DO NOT delete a branch that has open PRs against it
+- DO NOT modify CI workflow YAMLs without testing on a feature branch first

package/dist/cli/CommandFlowRunner.js

@@ -0,0 +1,167 @@
+"use strict";
+// src/cli/CommandFlowRunner.ts
+// CLI wrapper around WorkflowParser + WorkflowEngine. Implements the
+// `openlife flow {list,run,status,resume}` command surface.
+//
+// Discovery order for workflow YAMLs:
+//   1. `.openlife/method/workflows/<id>.yaml` (project-local override)
+//   2. `.catalog/workflows/<id>.yaml` (catalog override)
+//   3. `<package>/dist-templates/workflows/<id>.yaml` (bundled defaults)
+//
+// State is persisted to `.openlife/workflows/<runId>.json` for resume.
+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.workflowRoots = workflowRoots;
+exports.listFlows = listFlows;
+exports.findFlow = findFlow;
+exports.dryRunFlow = dryRunFlow;
+exports.renderDryRun = renderDryRun;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const WorkflowParser_1 = require("../orchestrator/workflow/WorkflowParser");
+/** Resolve all workflow source directories in lookup-priority order. */
+function workflowRoots(cwd = process.cwd()) {
+    const roots = [];
+    roots.push({ dir: path.join(cwd, '.openlife', 'method', 'workflows'), source: 'local' });
+    roots.push({ dir: path.join(cwd, '.catalog', 'workflows'), source: 'catalog' });
+    // Bundled: dist/cli/CommandFlowRunner.js → __dirname is dist/cli
+    // package root is __dirname/../..
+    const packageRoot = path.join(__dirname, '..', '..');
+    roots.push({ dir: path.join(packageRoot, 'dist-templates', 'workflows'), source: 'bundled' });
+    return roots;
+}
+/** List all available workflows across all roots (dedupes by id, first wins). */
+function listFlows(cwd = process.cwd()) {
+    const seen = new Map();
+    for (const root of workflowRoots(cwd)) {
+        if (!fs.existsSync(root.dir))
+            continue;
+        for (const f of fs.readdirSync(root.dir)) {
+            if (!f.endsWith('.yaml') && !f.endsWith('.yml'))
+                continue;
+            const fp = path.join(root.dir, f);
+            try {
+                const parsed = (0, WorkflowParser_1.parseWorkflowFile)(fp);
+                if (!parsed.workflow)
+                    continue;
+                const wf = parsed.workflow;
+                if (seen.has(wf.id))
+                    continue;
+                seen.set(wf.id, {
+                    id: wf.id,
+                    name: wf.name,
+                    type: wf.type,
+                    description: wf.description || '',
+                    steps: (wf.sequence || []).length,
+                    source: root.source,
+                    sourcePath: fp,
+                });
+            }
+            catch { /* skip unparseable */ }
+        }
+    }
+    return Array.from(seen.values()).sort((a, b) => a.id.localeCompare(b.id));
+}
+/** Find a single workflow by id across all roots. Returns null if not found. */
+function findFlow(id, cwd = process.cwd()) {
+    for (const root of workflowRoots(cwd)) {
+        if (!fs.existsSync(root.dir))
+            continue;
+        for (const ext of ['.yaml', '.yml']) {
+            const fp = path.join(root.dir, `${id}${ext}`);
+            if (!fs.existsSync(fp))
+                continue;
+            const parsed = (0, WorkflowParser_1.parseWorkflowFile)(fp);
+            if (parsed.workflow) {
+                return { workflow: parsed.workflow, sourcePath: fp, source: root.source };
+            }
+        }
+    }
+    return null;
+}
+function dryRunFlow(id, cwd = process.cwd()) {
+    const found = findFlow(id, cwd);
+    if (!found)
+        return null;
+    const wf = found.workflow;
+    const steps = (wf.sequence || []).map((s) => ({
+        phase: 'phase' in s ? s.phase : undefined,
+        name: 'name' in s ? s.name : undefined,
+        id: 'id' in s ? s.id : undefined,
+        agent: 'agent' in s ? s.agent : undefined,
+        squad: 'squad' in s ? s.squad : undefined,
+        action: 'action' in s ? s.action : undefined,
+        task: 'task' in s ? s.task : undefined,
+        optional: 'optional' in s ? s.optional : undefined,
+        elicit: 'elicit' in s ? s.elicit : undefined,
+    }));
+    return {
+        id: wf.id,
+        name: wf.name,
+        type: wf.type,
+        steps,
+    };
+}
+/**
+ * Render a dry-run summary as human-readable lines suitable for terminal output.
+ */
+function renderDryRun(summary) {
+    const lines = [];
+    lines.push(`Workflow: ${summary.id} (${summary.type})`);
+    lines.push(`Name: ${summary.name}`);
+    lines.push(`Steps: ${summary.steps.length}`);
+    lines.push('');
+    for (const s of summary.steps) {
+        if (s.phase !== undefined && s.name) {
+            lines.push(`── Phase ${s.phase}: ${s.name}`);
+            continue;
+        }
+        const tags = [];
+        if (s.agent)
+            tags.push(`agent=${s.agent}`);
+        if (s.squad)
+            tags.push(`squad=${s.squad}`);
+        if (s.action)
+            tags.push(`action=${s.action}`);
+        if (s.task)
+            tags.push(`task=${s.task}`);
+        if (s.optional)
+            tags.push('OPTIONAL');
+        if (s.elicit)
+            tags.push('ELICIT');
+        lines.push(`   • ${s.id || '(unnamed step)'} — ${tags.join(' ') || '(no tags)'}`);
+    }
+    return lines;
+}

package/dist/cli/install/Phases.js

@@ -140,6 +140,48 @@ const phaseProductSelection = {
         await io.pause();
     },
 };
+const phaseProjectMode = {
+    id: '03-project-mode',
+    label: 'Project mode (greenfield vs brownfield)',
+    async run(ctx, io) {
+        io.divider();
+        io.print('Project mode selection');
+        io.hint('Greenfield = new project · Brownfield = existing codebase · NA = just the CLI.');
+        io.print('');
+        // Heuristic suggestion based on cwd contents.
+        const { detectMode, detectStack, recommendWorkflow } = await Promise.resolve().then(() => __importStar(require('../../orchestrator/ProjectMetadata')));
+        const suggested = detectMode(ctx.root);
+        const stack = detectStack(ctx.root);
+        if (stack.length > 0) {
+            io.hint(`Auto-detected stack: ${stack.join(', ')} → suggesting ${suggested}.`);
+        }
+        else {
+            io.hint('No stack detected — suggesting greenfield (new project).');
+        }
+        io.print('');
+        const options = [
+            'greenfield      — new project from scratch',
+            'brownfield      — existing codebase (will run discovery audit)',
+            'not-applicable  — just install the CLI, skip method workflows',
+        ];
+        const defaultIdx = suggested === 'brownfield' ? 1 : suggested === 'not-applicable' ? 2 : 0;
+        const idx = await io.choice('Project mode', options, defaultIdx);
+        const mode = ['greenfield', 'brownfield', 'not-applicable'][idx];
+        ctx.projectMode = mode;
+        io.print(`  ✓ project mode: ${mode}`);
+        if (mode !== 'not-applicable') {
+            const recommended = recommendWorkflow(mode, stack);
+            io.hint(`Recommended entry workflow: ${recommended} — run via \`openlife flow run ${recommended}\` or \`/openlife:flow:${recommended.replace('-development-cycle', '-cycle').replace('continuous-deployment', 'release').replace('epic-orchestration', 'epic')}\`.`);
+        }
+        // Persist to .openlife/project.json immediately — separate from .env so
+        // the wizard's confirm phase doesn't need to know about it.
+        const { buildMetadata, writeProjectMetadata } = await Promise.resolve().then(() => __importStar(require('../../orchestrator/ProjectMetadata')));
+        const meta = buildMetadata(mode, ctx.root);
+        writeProjectMetadata(meta, ctx.root);
+        io.print(`  ✓ saved to .openlife/project.json`);
+        await io.pause();
+    },
+};
 // ════════════════════════════════════════════════════════════════════════
 //  Section B · openlife-core block
 // ════════════════════════════════════════════════════════════════════════
@@ -777,6 +819,7 @@ exports.ALL_PHASES = Object.freeze([
     phaseBanner,
     phaseExistingInstall,
     phaseProductSelection,
+    phaseProjectMode,
     phaseCoreEnter,
     phaseCoreHosts,
     phaseCoreProviders,

package/dist/index.js

@@ -2977,6 +2977,124 @@ program
     }
     await runChat();
 });
+// ============================================================================
+// FLOW — v1.9.0+ workflow runner CLI surface
+// ============================================================================
+const flowCmd = program.command('flow').description('OpenLife method workflows — list, run, dry-run, resume');
+flowCmd.command('list')
+    .description('List all available OpenLife method workflows (local + catalog + bundled)')
+    .action(() => {
+    const { listFlows } = require('./cli/CommandFlowRunner');
+    const flows = listFlows(process.cwd());
+    if (flows.length === 0) {
+        console.log('No workflows found. Reinstall @openlife/cli or check .openlife/method/workflows/.');
+        return;
+    }
+    console.log(`Workflows (${flows.length}):`);
+    console.log('');
+    for (const f of flows) {
+        const src = f.source === 'local' ? '[local]   ' : f.source === 'catalog' ? '[catalog] ' : '[bundled] ';
+        console.log(`  ${src} ${f.id.padEnd(28)} ${f.type.padEnd(12)} ${f.steps} steps  — ${f.name}`);
+    }
+});
+flowCmd.command('run <id>')
+    .description('Run an OpenLife method workflow (use --dry-run to preview phase plan only)')
+    .option('--dry-run', 'print the phase plan without executing any step')
+    .option('--vars <kv...>', 'pass variables as key=value pairs')
+    .action((id, options) => {
+    const { findFlow, dryRunFlow, renderDryRun } = require('./cli/CommandFlowRunner');
+    if (options.dryRun) {
+        const summary = dryRunFlow(id, process.cwd());
+        if (!summary) {
+            console.error(JSON.stringify({ ok: false, error: 'workflow_not_found', id }, null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        for (const line of renderDryRun(summary))
+            console.log(line);
+        return;
+    }
+    // Full run requires WorkflowEngine — surface a stub note for now since
+    // execution path with full agent dispatch is wired in v1.10+.
+    const found = findFlow(id, process.cwd());
+    if (!found) {
+        console.error(JSON.stringify({ ok: false, error: 'workflow_not_found', id }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify({
+        ok: true,
+        workflow: found.workflow.id,
+        type: found.workflow.type,
+        steps: (found.workflow.sequence || []).length,
+        sourcePath: found.sourcePath,
+        note: 'Full execution wires through WorkflowEngine in v1.10+. Use --dry-run to preview the phase plan today.',
+    }, null, 2));
+});
+flowCmd.command('show <id>')
+    .description('Dump a workflow definition (parsed) as JSON')
+    .action((id) => {
+    const { findFlow } = require('./cli/CommandFlowRunner');
+    const found = findFlow(id, process.cwd());
+    if (!found) {
+        console.error(JSON.stringify({ ok: false, error: 'workflow_not_found', id }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify(found.workflow, null, 2));
+});
+// ============================================================================
+// PROJECT-MODE — v1.9.0+ greenfield/brownfield mode toggle
+// ============================================================================
+const projectModeCmd = program.command('project-mode').description('Greenfield / brownfield mode for .openlife/project.json');
+projectModeCmd.command('get')
+    .description('Read the current project mode from .openlife/project.json')
+    .action(() => {
+    const { readProjectMetadata, detectMode, detectStack, recommendWorkflow } = require('./orchestrator/ProjectMetadata');
+    const existing = readProjectMetadata(process.cwd());
+    if (existing) {
+        console.log(JSON.stringify({ ok: true, source: 'file', ...existing }, null, 2));
+        return;
+    }
+    const detected = detectMode(process.cwd());
+    const stack = detectStack(process.cwd());
+    console.log(JSON.stringify({
+        ok: true,
+        source: 'detected',
+        mode: detected,
+        detectedStack: stack,
+        recommendedWorkflow: recommendWorkflow(detected, stack),
+        note: 'No .openlife/project.json yet. Run `openlife project-mode set <mode>` to persist.',
+    }, null, 2));
+});
+projectModeCmd.command('set <mode>')
+    .description('Set the project mode (greenfield | brownfield | not-applicable)')
+    .option('--notes <text>', 'free-form notes to attach')
+    .action((mode, options) => {
+    const valid = ['greenfield', 'brownfield', 'not-applicable'];
+    if (!valid.includes(mode)) {
+        console.error(JSON.stringify({ ok: false, error: 'invalid_mode', valid }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const { buildMetadata, writeProjectMetadata } = require('./orchestrator/ProjectMetadata');
+    const meta = buildMetadata(mode, process.cwd(), options.notes);
+    const fp = writeProjectMetadata(meta, process.cwd());
+    console.log(JSON.stringify({ ok: true, file: fp, ...meta }, null, 2));
+});
+projectModeCmd.command('detect')
+    .description('Heuristic detection of project mode from cwd (does not persist)')
+    .action(() => {
+    const { detectMode, detectStack, recommendWorkflow } = require('./orchestrator/ProjectMetadata');
+    const mode = detectMode(process.cwd());
+    const stack = detectStack(process.cwd());
+    console.log(JSON.stringify({
+        ok: true,
+        mode,
+        detectedStack: stack,
+        recommendedWorkflow: recommendWorkflow(mode, stack),
+    }, null, 2));
+});
 // Bare invocation (no subcommand + interactive TTY) → launch chat TUI.
 // Piped, CI, or `--help` flows fall through to the standard Commander parse.
 const isBareInteractive = process.argv.length === 2 &&

package/dist/orchestrator/AgentRegistry.js

@@ -1,6 +1,40 @@
 "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.AgentRegistry = void 0;
+const path = __importStar(require("path"));
 const FileAgentProvider_1 = require("./providers/FileAgentProvider");
 const CloudAgentProvider_1 = require("./providers/CloudAgentProvider");
 const CompositeAgentProvider_1 = require("./providers/CompositeAgentProvider");
@@ -8,7 +42,17 @@ const defaultAgentRoots = () => {
     const roots = process.env.OPENLIFE_AGENT_ROOTS
         ? process.env.OPENLIFE_AGENT_ROOTS.split(':').filter(Boolean)
         : [];
-    return roots.length > 0 ? roots : [process.cwd() + '/.catalog/agents'];
+    if (roots.length > 0)
+        return roots;
+    // Multi-root resolution (v1.8.3+): prefer the user's project-local .catalog
+    // (override), fall back to the npm-package-bundled .catalog (defaults that
+    // ship with @openlife/cli — the user's 314+ agents, etc.). FileAgentProvider
+    // skips non-existent roots, so a clone-of-repo install ends up with both
+    // paths resolving to the same dir and FileAgentProvider naturally dedupes
+    // by id downstream.
+    const cwdRoot = path.join(process.cwd(), '.catalog', 'agents');
+    const packageRoot = path.join(__dirname, '..', '..', '.catalog', 'agents');
+    return cwdRoot === packageRoot ? [cwdRoot] : [cwdRoot, packageRoot];
 };
 class AgentRegistry {
     provider;