legion-cc 0.7.0 → 0.9.0

package/README.md

@@ -65,7 +65,8 @@ npx legion-cc@latest --uninstall  # remove Legion
 | `/legion:devops:architect <task>` | Design infrastructure architecture with the `devops-architect` agent (opus). |
 | `/legion:devops:plan [path]` | Decompose architecture into an implementation plan with `delivery-planner` (sonnet). Uses latest architect artifact if no path given. |
 | `/legion:devops:execute [path]` | Implement the plan with `infra-executor` (opus). Supports `--task T1` to run a single task. |
-| `/legion:devops:init [path]` | Scaffold project structure and create `.legion/codebase/` documentation with `codebase-builder` (opus). |
+| `/legion:codebase:init` | Scan the codebase with 9 parallel mapper agents, create `.legion/codebase/` documentation. |
+| `/legion:codebase:update [ref]` | Incrementally update `.legion/codebase/` docs based on git changes since last run. |
 | `/legion:devops:review [path]` | Review changes against architectural intent with `devops-architect` in review mode (sonnet). |
 | `/legion:devops:cycle <task>` | Run the full pipeline (architect → plan → execute → review) with checkpoints after architect and plan. |
 
@@ -87,7 +88,8 @@ legion/
 │   └── lib/         # Modules: config, core, domain, init, session, state
 ├── commands/        # Claude Code slash commands (.md frontmatter + execution prompt)
 │   └── legion/
-│       ├── devops/  # /legion:devops:* commands
+│       ├── codebase/  # /legion:codebase:* commands (init, update)
+│       ├── devops/    # /legion:devops:* commands
 │       ├── resume.md
 │       └── status.md
 ├── hooks/           # Claude Code hooks (Node.js)
@@ -97,13 +99,16 @@ legion/
 │   ├── agent-routing.md
 │   ├── domain-registry.md
 │   ├── ui-brand.md
+│   ├── codebase/    # agent-map.md, output-specs.md, routing-rules.md
 │   └── devops/
 │       ├── agent-map.md
 │       └── pipeline-patterns.md
 ├── templates/       # State, session, artifact, and config templates
+│   ├── codebase/    # INDEX.md, BRIEF.md, CHANGELOG.md templates
 │   └── devops/      # Artifact templates (architect, plan, execution, review)
 ├── workflows/       # Step-by-step execution logic referenced by commands
 │   ├── core/        # init, context-load, completion (shared across domains)
+│   ├── codebase/    # init.md, update.md
 │   └── devops/      # One workflow per command
 ├── package.json
 └── VERSION
@@ -118,7 +123,7 @@ legion/
 | `devops-architect` | Senior/Lead DevOps Architect — infrastructure design, security assessment, migration planning, HA/DR | opus (architect) / sonnet (review) | `architect`, `review`, `cycle` |
 | `delivery-planner` | Senior Delivery Planner — work decomposition, phased planning, dependency mapping, risk assessment | sonnet | `plan`, `cycle` |
 | `infra-executor` | Elite Infrastructure Execution Specialist — Terraform, CI/CD, Kubernetes, AWS resource management | opus | `execute`, `cycle` |
-| `codebase-builder` | Elite Codebase Builder — project scaffolding, `.legion/codebase/` documentation creation, existing project analysis | opus | `init` |
+| `codebase-builder` | Elite Codebase Builder — project scaffolding, `.legion/codebase/` documentation creation, existing project analysis | opus | `codebase:init` |
 
 The `devops-architect` agent doubles as reviewer: the same agent definition is invoked with a review prompt at sonnet model for the review stage.
 
@@ -179,7 +184,7 @@ Checkpoints default to ON after architect and plan, OFF after execute and review
 
 **Documentation first** — existing project without `.legion/codebase/` docs:
 ```
-/legion:devops:init
+/legion:codebase:init
 /legion:devops:architect "migration plan"
 ```
 

package/VERSION

@@ -1 +1 @@
-0.7.0
+0.9.0

package/agents/legion-orchestrator.md

@@ -24,28 +24,53 @@ Analyze the task and classify into one of these categories:
 
 ### architecture
 **Agent**: devops-architect (opus)
+**What it does**: Analyzes existing infrastructure, designs target-state architecture, evaluates technology trade-offs, produces architecture decision records
 **Triggers**: Design decisions, technology evaluation, migration strategy, HA/DR planning, security architecture, infrastructure design, capacity planning, comparing options
 **Keywords**: design, architect, propose, evaluate, strategy, migration, HA, DR, compare options, should we use, how to design
+**Example tasks**:
+- "Design a multi-AZ RDS setup with read replicas"
+- "Evaluate options for migrating from self-managed Redis to ElastiCache"
+- "Should we use ECS Fargate or EKS for our microservices?"
 
 ### planning
 **Agent**: delivery-planner (sonnet)
+**What it does**: Decomposes architecture into phased task cards with dependencies, risk levels, rollback procedures, and validation gates
 **Triggers**: Breaking down work, creating implementation plans, task decomposition, phased rollout planning, dependency analysis
 **Keywords**: plan, decompose, break down, create tasks, implementation plan, phases, rollout, what steps, how to implement
+**Example tasks**:
+- "Break down the EKS migration into implementation tasks"
+- "Create a rollout plan for the new monitoring stack"
+- "What steps are needed to enable IRSA across all services?"
 
 ### execution
 **Agent**: infra-executor (opus)
+**What it does**: Writes Terraform modules, modifies CI/CD pipelines, updates Kubernetes manifests, validates with `terraform fmt/validate/plan`, reports evidence
 **Triggers**: Writing Terraform code, modifying infrastructure, fixing configs, updating pipelines, creating AWS resources, changing security groups
 **Keywords**: implement, create, add, write, fix, update, change, terraform, pipeline, module, resource, deploy, configure
+**Example tasks**:
+- "Add ingress rule for port 8443 to eks-node security group"
+- "Create a Terraform module for SQS with DLQ"
+- "Fix the GitHub Actions workflow for staging deployments"
 
 ### init
 **Agent**: codebase-builder (opus)
+**What it does**: Scans project structure, dispatches mapper agents, generates `.legion/codebase/` documentation with architecture, dependencies, and concerns
 **Triggers**: New project setup, scaffolding, creating .legion/codebase/ documentation, initializing project structure
 **Keywords**: scaffold, init, setup, create project, new project, .legion/codebase/, document structure, bootstrap
+**Example tasks**:
+- "Scan this project and create documentation"
+- "Initialize .legion/codebase/ for the backend service"
+- "Scaffold a new Terraform project for our AWS infrastructure"
 
 ### review
 **Agent**: devops-architect (sonnet, review mode)
+**What it does**: Validates code against architecture design, checks for security issues, drift, and regressions, reports findings with severity levels
 **Triggers**: Code review, security audit, architecture validation, compliance check, best practices review
 **Keywords**: review, audit, check, validate, security review, compliance, best practices
+**Example tasks**:
+- "Review the RDS module for security best practices"
+- "Audit IAM policies in ./aws/modules/iam/"
+- "Check if the EKS changes match the original architecture design"
 
 ## Classification Process
 

package/bin/lib/config.cjs

@@ -97,6 +97,62 @@ const DOMAIN_DEFAULTS = {
       discovery: true,
     },
   },
+  dev: {
+    version: '0.1.0',
+    domain: 'dev',
+    agents: {
+      architect: 'general-purpose',
+      codeAnalyst: 'general-purpose',
+      taskDesigner: 'general-purpose',
+      planner: 'delivery-planner',
+      implementer: 'general-purpose',
+      verifier: 'general-purpose',
+      reviewer: 'general-purpose',
+      postAnalyze: 'general-purpose',
+      briefWriter: 'general-purpose'
+    },
+    models: {
+      architect: 'haiku',
+      codeAnalyst: 'sonnet',
+      taskDesigner: 'opus',
+      planner: 'sonnet',
+      implementer: 'opus',
+      verifier: 'sonnet',
+      reviewer: 'sonnet',
+      postAnalyze: 'sonnet',
+      briefWriter: 'haiku'
+    },
+    pipeline: ['architect', 'code-analyst', 'task-designer', 'plan', 'implement', 'verify', 'review', 'post-analyze', 'brief'],
+    checkpoints: {
+      after_task_designer: true,
+      after_planner: true,
+      after_verifier: false,
+      after_post_analyze: false,
+      after_brief_writer: false
+    },
+    parallelism: { minAgents: 5, maxAgents: 12 },
+    mcp: {
+      enforce: true,
+      discovery: true
+    }
+  },
+  codebase: {
+    version: '0.1.0',
+    domain: 'codebase',
+    agents: {
+      builder: 'codebase-builder',
+    },
+    models: {
+      builder: 'sonnet',
+    },
+    pipeline: ['init'],
+    checkpoints: {},
+    parallelism: { minAgents: 9, maxAgents: 12 },
+    mcp: {
+      enforce: true,
+      discovery: true,
+    },
+  },
 };
 
 // ─── Config Functions ────────────────────────────────────────────────────────

package/bin/lib/state.cjs

@@ -22,6 +22,7 @@ function loadState(planningDir) {
     project: {
       domain: '',
       lastActivity: '',
+      lastCodebaseUpdate: '',
     },
     currentWork: {
       pipeline: '',
@@ -65,6 +66,9 @@ function loadState(planningDir) {
 
       const activityMatch = line.match(/^Last activity:\s*(.+)$/);
       if (activityMatch) state.project.lastActivity = activityMatch[1].trim();
+
+      const codebaseUpdateMatch = line.match(/^Last codebase update:\s*(.+)$/);
+      if (codebaseUpdateMatch) state.project.lastCodebaseUpdate = codebaseUpdateMatch[1].trim();
     }
 
     if (section === 'currentWork') {
@@ -136,6 +140,7 @@ function saveState(planningDir, stateObj) {
   lines.push('## Project');
   lines.push(`Domain: ${stateObj.project.domain}`);
   lines.push(`Last activity: ${stateObj.project.lastActivity}`);
+  lines.push(`Last codebase update: ${stateObj.project.lastCodebaseUpdate}`);
   lines.push('');
   lines.push('## Current Work');
   lines.push(`Pipeline: ${stateObj.currentWork.pipeline}`);
@@ -300,6 +305,7 @@ function initState(planningDir, domain) {
     project: {
       domain: domain || 'devops',
       lastActivity: `${currentTimestamp('date')} \u2014 initialized`,
+      lastCodebaseUpdate: '',
     },
     currentWork: {
       pipeline: 'init -> cycle -> quick',

package/commands/legion/codebase/init.md

@@ -0,0 +1,67 @@
+---
+name: legion:codebase:init
+description: "Create comprehensive project documentation in .legion/codebase/ using 9 parallel mapper agents"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - WebSearch
+  - WebFetch
+  - ToolSearch
+---
+
+# Legion Codebase Init
+
+Create a living knowledge base about the project. Scans the codebase with 9 parallel mapper agents, then synthesizes INDEX.md and BRIEF.md.
+
+## Execution
+
+Follow the workflow at @~/.claude/legion/workflows/codebase/init.md
+
+### Quick Reference
+
+**Initialization**: @~/.claude/legion/workflows/core/init.md
+**Context Loading**: @~/.claude/legion/workflows/core/context-load.md
+**Completion**: @~/.claude/legion/workflows/core/completion.md
+**Agent Map**: @~/.claude/legion/references/codebase/agent-map.md
+**Output Specs**: @~/.claude/legion/references/codebase/output-specs.md
+**Routing Rules**: @~/.claude/legion/references/codebase/routing-rules.md
+
+### What It Creates
+
+Up to 12 documentation files in `.legion/codebase/`:
+
+**Always generated (7)**:
+- STACK.md — Technology stack
+- ARCHITECTURE.md — System architecture
+- CONVENTIONS.md — Code conventions
+- DEPENDENCIES.md — Dependency graph
+- CONCERNS.md — Tech debt & risks
+- INDEX.md — Document map
+- BRIEF.md — 30-second overview
+
+**Conditionally generated (4)** — only if relevant code found:
+- INFRASTRUCTURE.md — Cloud/infra (if terraform/helm/k8s files detected)
+- CI_CD.md — Pipelines (if CI configs detected)
+- SECURITY.md — Security posture (if security configs detected)
+- OPERATIONS.md — Monitoring & ops (if ops configs detected)
+
+### Pipeline Position
+
+Standalone command — replaces `/legion:devops:init` for documentation:
+```
+[codebase:init] → codebase:update (for keeping docs fresh)
+                → devops:cycle (for infrastructure work)
+                → devops:quick (for single tasks)
+```
+
+### Key Rules
+- Fingerprints the project first to determine which mappers to run
+- Only dispatches mappers for which relevant files exist
+- All mappers use `subagent_type="codebase-builder"`
+- arch-mapper uses opus model, all others use sonnet
+- MCP tools mandatory (ToolSearch before file operations)

package/commands/legion/codebase/update.md

@@ -0,0 +1,58 @@
+---
+name: legion:codebase:update
+description: "Incrementally update .legion/codebase/ documentation based on git changes"
+argument-hint: "[since-ref]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - WebSearch
+  - WebFetch
+  - ToolSearch
+---
+
+# Legion Codebase Update
+
+Incrementally update project documentation based on git changes. Uses routing rules to dispatch only the mapper agents affected by recent changes.
+
+## Execution
+
+Follow the workflow at @~/.claude/legion/workflows/codebase/update.md
+
+### Quick Reference
+
+**Initialization**: @~/.claude/legion/workflows/core/init.md
+**Context Loading**: @~/.claude/legion/workflows/core/context-load.md
+**Completion**: @~/.claude/legion/workflows/core/completion.md
+**Agent Map**: @~/.claude/legion/references/codebase/agent-map.md
+**Routing Rules**: @~/.claude/legion/references/codebase/routing-rules.md
+
+### How It Works
+
+1. Analyzes `git diff` since last update (or provided ref)
+2. Routes changed files to appropriate mappers using routing rules
+3. Only dispatches affected mappers (not all 9)
+4. Re-runs synthesizers (INDEX, BRIEF, CHANGELOG)
+5. Appends entry to CHANGELOG.md
+
+### Input
+
+Optional: `$ARGUMENTS` can specify a git ref to diff against (commit hash, tag, or branch). If not provided, uses the last update timestamp from STATE.md.
+
+### Pipeline Position
+
+Maintenance command — run after making changes:
+```
+[codebase:init] → [codebase:update] → [codebase:update] → ...
+```
+
+### Key Rules
+- `.legion/codebase/` must exist first (run `/legion:codebase:init`)
+- concerns-mapper always runs on every update
+- Mappers do FULL rewrites (not patches) of their files
+- CHANGELOG.md is only generated in update mode
+- Conditional mappers only dispatch if their output file already exists

package/commands/legion/dev/analyze.md

@@ -0,0 +1,61 @@
+---
+name: legion:dev:analyze
+description: "Code optimization scan — 6 parallel agents analyze performance, reliability, architecture, and cost"
+argument-hint: "[scope: path or concern]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - WebSearch
+  - WebFetch
+  - ToolSearch
+---
+
+# Legion Dev Analyze
+
+Standalone code optimization scan. Dispatches 6 parallel agents to find bottlenecks, reliability issues, architecture smells, and cost optimization opportunities. Analysis only — no implementation.
+
+## Execution
+
+Follow the workflow at @~/.claude/legion/workflows/dev/analyze.md
+
+### Quick Reference
+
+**Initialization**: @~/.claude/legion/workflows/core/init.md
+**Context Loading**: @~/.claude/legion/workflows/core/context-load.md
+**Completion**: @~/.claude/legion/workflows/core/completion.md
+**Agent Map**: @~/.claude/legion/references/dev/agent-map.md
+
+### Scope Parameter
+
+| Usage | What it scans |
+|-------|--------------|
+| `/legion:dev:analyze` | Entire project |
+| `/legion:dev:analyze src/api/` | Specific directory |
+| `/legion:dev:analyze "database performance"` | Specific concern across codebase |
+
+### Parallel Agents
+
+| Agent | Focus | Model |
+|-------|-------|-------|
+| opt-perf-hotpaths | CPU/memory bottlenecks, hot code paths | sonnet |
+| opt-db-queries | N+1 queries, missing indexes, ORM anti-patterns | sonnet |
+| opt-io-network | Timeouts, retry logic, batching, compression | haiku |
+| opt-memory-gc | Memory leaks, allocations, cache sizing | haiku |
+| opt-arch-smells | Circular deps, layer violations, duplication | haiku |
+| opt-infra-cost | Over-provisioning, autoscaling, log/storage costs | haiku |
+
+### Output
+
+- `OPTIMIZATION_REPORT.md` — Full analysis with top-10 findings, categorized issues, recommendations
+- `SUMMARY.md` — Quick overview with key findings and quick wins
+
+### Follow-Up
+
+To implement findings:
+- `/legion:dev:cycle "Implement optimization: {finding}"` — for complex changes
+- `/legion:dev:quick "Fix: {quick win}"` — for simple improvements

package/commands/legion/dev/cycle.md

@@ -0,0 +1,60 @@
+---
+name: legion:dev:cycle
+description: "Full Dev pipeline — 9-stage cycle: architect → code-analyst → task-designer → plan → implement → verify → review → post-analyze → brief"
+argument-hint: "<task description>"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - WebSearch
+  - WebFetch
+  - ToolSearch
+---
+
+# Legion Dev Cycle
+
+Run the complete Dev pipeline in one command with approval checkpoints.
+
+## Execution
+
+Follow the workflow at @~/.claude/legion/workflows/dev/cycle.md
+
+### Quick Reference
+
+**Initialization**: @~/.claude/legion/workflows/core/init.md
+**Context Loading**: @~/.claude/legion/workflows/core/context-load.md
+**Completion**: @~/.claude/legion/workflows/core/completion.md
+**Agent Map**: @~/.claude/legion/references/dev/agent-map.md
+
+### Pipeline Stages
+
+| Stage | Role | Model | What it does | Checkpoint |
+|-------|------|-------|-------------|------------|
+| 1. Architect | general-purpose | haiku | Maps repo structure, boundaries, conventions, infra touchpoints | — |
+| 2. Code Analyst | general-purpose | sonnet | Traces call graphs, data flows, external deps, test coverage | — |
+| 3. Task Designer | general-purpose | opus | Designs solution options, contracts, migrations, security | ✓ User approval |
+| 4. Planner | delivery-planner | sonnet | Decomposes design into ordered tasks with deps and rollback | ✓ User approval |
+| 5. Implementer | general-purpose | opus | Writes code, configs, infra changes per plan | — |
+| 6. Verifier | general-purpose | sonnet | Runs tests, lint, IaC validation | — |
+| 7. Reviewer | general-purpose | sonnet | Reviews arch fit, code quality, security, ops, API compat | — |
+| 8. Post-Analyze | general-purpose | sonnet | Finds perf bottlenecks, DB issues, arch smells, cost optimizations | — |
+| 9. Brief Writer | general-purpose | haiku | Produces SUMMARY.md, updates codebase docs | — |
+
+### Checkpoints
+
+After stages 3 (task-designer) and 4 (planner), the workflow pauses and asks the user to confirm. Options:
+- **Approve** — continue to next stage
+- **Revise** — re-run the stage with feedback
+- **Stop** — save progress and exit (resume with `/legion:resume`)
+
+### Pipeline Flow
+
+```
+[architect] → [code-analyst] → [task-designer] ──checkpoint──►
+[planner] ──checkpoint──► [implementer] → [verifier] →
+[reviewer] → [post-analyze] → [brief-writer]
+```

package/commands/legion/dev/quick.md

@@ -0,0 +1,59 @@
+---
+name: legion:dev:quick
+description: "Fast context-aware Dev task execution — reads .legion/codebase/, analyzes impact, implements with auto-escalation to cycle for complex tasks"
+argument-hint: "<task description>"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - WebSearch
+  - WebFetch
+  - ToolSearch
+---
+
+# Legion Dev Quick
+
+Fast context-aware execution for development tasks. Reads project context, analyzes impact, implements, and verifies — with auto-escalation to full cycle when complexity is detected.
+
+## Execution
+
+Follow the workflow at @~/.claude/legion/workflows/dev/quick.md
+
+### Quick Reference
+
+**Initialization**: @~/.claude/legion/workflows/core/init.md
+**Context Loading**: @~/.claude/legion/workflows/core/context-load.md
+**Completion**: @~/.claude/legion/workflows/core/completion.md
+**Agent Map**: @~/.claude/legion/references/dev/agent-map.md
+
+### Pipeline (Shortened)
+
+| Step | Agent | Model | What it does |
+|------|-------|-------|-------------|
+| 1. Quick Analysis | 4 parallel agents | haiku/sonnet | Context, locations, impact, verify plan |
+| 2. Escalation Check | orchestrator | — | Detects complex scope, asks user |
+| 3. Planner-Lite | delivery-planner | sonnet | 3-7 step compact plan |
+| 4. Implement | general-purpose | opus | Execute plan step by step |
+| 5. Verify-Lite | general-purpose | sonnet | Run tests + lint on changed files |
+| 6. Brief | general-purpose | haiku | SUMMARY.md + codebase update |
+
+### Auto-Escalation Triggers
+
+If the impact analysis detects any of these, the workflow suggests switching to `/legion:dev:cycle`:
+- Auth/security/permissions changes
+- Database migrations
+- Infrastructure/CI/CD changes
+- Public API contract changes
+- Wide cascading impact (>5 files across >2 modules)
+
+The user always decides — no automatic escalation.
+
+### Key Rules
+- ALWAYS read .legion/codebase/ before starting
+- If task is unclear, ASK the user
+- Pass full context summary to spawned agents
+- Update STATE.md after completion

package/commands/legion/devops/cycle.md

@@ -32,12 +32,12 @@ Follow the workflow at @~/.claude/legion/workflows/devops/cycle.md
 
 ### Pipeline Stages
 
-| Stage | Agent | Model | Checkpoint |
-|-------|-------|-------|------------|
-| 1. Architect | devops-architect | opus | ✓ User approval required |
-| 2. Plan | delivery-planner | sonnet | ✓ User approval required |
-| 3. Execute | infra-executor | opus | — |
-| 4. Review | devops-architect | sonnet | — |
+| Stage | Agent | Model | What it does | Checkpoint |
+|-------|-------|-------|-------------|------------|
+| 1. Architect | devops-architect | opus | Analyzes current state, designs target architecture, evaluates options | ✓ User approval required |
+| 2. Plan | delivery-planner | sonnet | Decomposes architecture into ordered tasks with dependencies and rollback points | ✓ User approval required |
+| 3. Execute | infra-executor | opus | Implements planned changes file-by-file, validates with terraform fmt/validate/plan | — |
+| 4. Review | devops-architect | sonnet | Validates execution against original design, checks for drift and regressions | — |
 
 ### Checkpoints
 

package/commands/legion/devops/quick.md

@@ -32,13 +32,13 @@ Follow the workflow at @~/.claude/legion/workflows/devops/quick.md
 
 ### Agent Routing
 
-| Task Type | Agent | subagent_type | Model |
-|-----------|-------|---------------|-------|
-| Architecture/design | devops-architect | devops-architect | opus |
-| Planning/decomposition | delivery-planner | delivery-planner | sonnet |
-| Infrastructure execution | infra-executor | infra-executor | opus |
-| Review/validation | devops-architect | devops-architect | sonnet |
-| Codebase scaffolding | codebase-builder | codebase-builder | opus |
+| Task Type | Agent | subagent_type | Model | What the agent does |
+|-----------|-------|---------------|-------|-------------------|
+| Architecture/design | devops-architect | devops-architect | opus | Designs infrastructure, evaluates technology options, produces architecture decisions |
+| Planning/decomposition | delivery-planner | delivery-planner | sonnet | Breaks work into phased tasks with dependencies, risks, and validation gates |
+| Infrastructure execution | infra-executor | infra-executor | opus | Writes Terraform/CI/CD/K8s code, validates changes, reports evidence |
+| Review/validation | devops-architect | devops-architect | sonnet | Reviews code for security, best practices, drift from architecture |
+| Codebase scaffolding | codebase-builder | codebase-builder | opus | Scans project, generates `.legion/codebase/` docs or scaffolds new projects |
 
 ### Key Rules
 - ALWAYS read .legion/codebase/ before starting work

package/commands/legion/status.md

@@ -29,7 +29,7 @@ Follow the workflow at @~/.claude/legion/workflows/status.md
 4. Route to next action:
    - If pipeline in progress → suggest `/legion:devops:cycle` to continue
    - If no active work → suggest `/legion:devops:quick` or `/legion:devops:cycle`
-   - If no Legion state found → suggest initializing with `/legion:devops:init`
+   - If no Legion state found → suggest initializing with `/legion:codebase:init`
 
 ### Display Format
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "legion-cc",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Legion — multi-agent orchestration framework for Claude Code",
   "type": "commonjs",
   "main": "bin/legion-tools.cjs",