legion-cc 0.1.0

package/references/domain-registry.md

@@ -0,0 +1,63 @@
+# Legion — Domain Registry
+
+## Installed Domains
+
+### devops (v0.1.0)
+
+**Description**: Infrastructure design, planning, execution, and review.
+
+**Pipeline**: architect → plan → execute → review
+
+**Agents**:
+| Role | Agent | Model |
+|------|-------|-------|
+| architect | devops-architect | opus |
+| planner | delivery-planner | sonnet |
+| executor | infra-executor | opus |
+| builder | codebase-builder | opus |
+| reviewer | devops-architect | sonnet |
+
+**Commands**:
+- `/legion:devops:quick` — Fast context-aware execution
+- `/legion:devops:architect` — Architecture design
+- `/legion:devops:plan` — Delivery planning
+- `/legion:devops:execute` — Infrastructure execution
+- `/legion:devops:build` — Codebase scaffolding
+- `/legion:devops:review` — Architecture review
+- `/legion:devops:cycle` — Full pipeline
+
+## Adding a New Domain
+
+To register a new domain (e.g., `backend`):
+
+1. Create commands at `commands/legion/{domain}/`
+2. Create workflows at `workflows/{domain}/`
+3. Create templates at `templates/{domain}/`
+4. Create references at `references/{domain}/`
+5. Map agents in `references/{domain}/agent-map.md`
+6. Add domain entry to this registry
+7. Run `install.sh` to deploy
+
+### Domain Structure Template
+
+```
+commands/legion/{domain}/
+├── quick.md
+├── {stage1}.md
+├── {stage2}.md
+├── ...
+└── cycle.md
+
+workflows/{domain}/
+├── quick.md
+├── {stage1}.md
+├── {stage2}.md
+├── ...
+└── cycle.md
+```
+
+Each domain must define:
+- **Pipeline stages** (ordered sequence)
+- **Agent mapping** (which agent handles which stage)
+- **Model assignment** (which Claude model for each agent)
+- **Classification rules** (for `/quick` auto-routing)

package/references/ui-brand.md

@@ -0,0 +1,102 @@
+# Legion — UI & Branding Guide
+
+## Banner Format
+
+All workflows display a banner at start:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► {DOMAIN} ► {ACTION}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+For cross-domain commands:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► {ACTION}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Status Symbols
+
+| Symbol | Meaning |
+|--------|---------|
+| ✓ | Complete / Passed / Loaded |
+| ✗ | Failed / Not found / Error |
+| ◆ | In Progress / Active |
+| ○ | Pending / Not started |
+| ⚠ | Warning / Attention needed |
+| ► | Next action / Suggestion |
+
+## Context Report Format
+
+```
+◆ Loading context...
+
+✓ .codebase/architecture.md (loaded)
+✓ .codebase/project-structure.md (loaded)
+✗ .codebase/stack.md (not found)
+✓ STATE.md (loaded — stage: plan)
+```
+
+## Completion Block
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ✓ COMPLETE — {TYPE}: {description}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Artifact: .planning/legion/{domain}/{artifact}
+Status: {status}
+```
+
+## Next Action Block
+
+```
+───────────────────────────────────────────────
+ ► Next: /legion:{domain}:{action}
+   {description}
+
+   Also available:
+   - /legion:{domain}:{alt1} — {description}
+   - /legion:{domain}:{alt2} — {description}
+───────────────────────────────────────────────
+```
+
+## Warning Block
+
+```
+⚠ {Warning title}
+
+{Warning description}
+
+To resolve:
+  /legion:{command} {args}
+```
+
+## Pipeline Visualization
+
+```
+architect → [plan] → execute → review
+             ^^^^
+          current stage
+```
+
+Or with status:
+```
+✓ architect → ◆ plan → ○ execute → ○ review
+```
+
+## Color Scheme (for statusline)
+
+| Context Remaining | Color | Symbol |
+|-------------------|-------|--------|
+| > 50% | Green | ████████░░ |
+| 35-50% | Yellow | █████░░░░░ |
+| 25-35% | Orange | ███░░░░░░░ |
+| < 25% | Red | ██░░░░░░░░ |
+
+## Naming Convention
+
+- Commands: `/legion:{domain}:{action}` (lowercase, hyphens for multi-word)
+- Artifacts: `{NNN}-{type}-{slug}.md` (zero-padded number, lowercase, hyphens)
+- Directories: lowercase, hyphens

package/templates/config.json

@@ -0,0 +1,25 @@
+{
+  "version": "0.1.0",
+  "domain": "devops",
+  "agents": {
+    "architect": "devops-architect",
+    "planner": "delivery-planner",
+    "executor": "infra-executor",
+    "builder": "codebase-builder",
+    "reviewer": "devops-architect"
+  },
+  "models": {
+    "architect": "opus",
+    "planner": "sonnet",
+    "executor": "opus",
+    "builder": "opus",
+    "reviewer": "sonnet"
+  },
+  "pipeline": ["architect", "plan", "execute", "review"],
+  "checkpoints": {
+    "after_architect": true,
+    "after_plan": true,
+    "after_execute": false,
+    "after_review": false
+  }
+}

package/templates/devops/architect-output.md

@@ -0,0 +1,28 @@
+# Architecture — {{title}}
+
+## 1. Task Understanding
+{{understanding of what was requested}}
+
+## 2. Architecture-Aware Implementation Plan
+{{how this fits into existing architecture}}
+
+## 3. Proposed Architecture/Solution
+{{detailed architecture proposal}}
+
+## 4. Trade-offs/Alternatives
+{{options considered and why this was chosen}}
+
+## 5. Implementation Steps (Phased)
+{{phased implementation approach}}
+
+## 6. Example Implementations
+{{concrete code/config examples}}
+
+## 7. Validation and Operations
+{{how to validate and operate}}
+
+## 8. Common Mistakes/Anti-Patterns
+{{what to avoid}}
+
+## 9. Next Action
+{{recommended next step}}

package/templates/devops/execution-report.md

@@ -0,0 +1,23 @@
+# Execution Report — {{title}}
+
+## 1. Execution Context
+{{what was executed and why}}
+
+## 2. Pre-Execution Verification
+{{state before changes}}
+
+## 3. Execution Actions Performed
+{{what was done, step by step}}
+
+## 4. Validation Results
+{{terraform fmt/validate/plan results, tests, etc.}}
+
+## 5. Task Status
+Status: {{DONE|PARTIAL|BLOCKED}}
+Tasks completed: {{N/M}}
+
+## 6. Risks/Notes
+{{anything to be aware of}}
+
+## 7. Next Execution Step
+{{what comes next}}

package/templates/devops/plan-output.md

@@ -0,0 +1,33 @@
+# Implementation Plan — {{title}}
+
+## 1. Planning Input Summary
+{{what was received from architect}}
+
+## 2. Decomposition Strategy
+{{approach to breaking down the work}}
+
+## 3. Full Phase-by-Phase Implementation Plan
+
+### Phase 0: Discovery/Validation
+{{tasks}}
+
+### Phase 1: Foundation
+{{tasks}}
+
+### Phase N: ...
+{{tasks}}
+
+## 4. Dependency Map
+{{task dependencies}}
+
+## 5. Execution Handoffs
+{{who does what}}
+
+## 6. Critical Path
+{{sequence that determines timeline}}
+
+## 7. Final Readiness Checklist
+{{pre-execution checks}}
+
+## 8. Next Action
+{{recommended next step}}

package/templates/devops/review-checklist.md

@@ -0,0 +1,35 @@
+# Review Checklist — {{title}}
+
+## Architecture Alignment
+- [ ] Changes match original architecture intent
+- [ ] No unauthorized scope expansion
+- [ ] Design patterns followed correctly
+
+## Security
+- [ ] No secrets in code/config
+- [ ] Least privilege IAM policies
+- [ ] Security groups properly scoped
+- [ ] SOPS encryption for sensitive values
+- [ ] No public exposure of internal services
+
+## Terraform Best Practices
+- [ ] terraform fmt passes
+- [ ] terraform validate passes
+- [ ] terraform plan shows expected changes only
+- [ ] No hardcoded values — uses variables
+- [ ] Proper resource naming (snake_case)
+- [ ] Tags include local.tags.general
+- [ ] State management correct
+- [ ] Remote state references valid
+
+## Operational Readiness
+- [ ] Monitoring/alerting configured
+- [ ] Logging enabled
+- [ ] Backup strategy defined
+- [ ] Rollback plan documented
+- [ ] Runbook updated
+
+## Findings
+
+| # | Severity | Finding | Location | Recommendation |
+|---|----------|---------|----------|----------------|

package/templates/session.md

@@ -0,0 +1,17 @@
+# Legion Session — {{date}}
+
+## Context
+Domain: {{domain}}
+Stage: {{stage}}
+Started: {{timestamp}}
+
+## Work Performed
+{{summary}}
+
+## Artifacts Created
+{{artifacts}}
+
+## State at End
+Stage: {{end_stage}}
+Last completed: {{last_completed}}
+Next: {{next_action}}

package/templates/state.md

@@ -0,0 +1,17 @@
+# Legion State
+
+## Project
+Domain: {{domain}}
+Last activity: {{date}} — Initialized
+
+## Current Work
+Pipeline: architect -> plan -> execute -> review
+Stage: idle
+Input: —
+Last completed: —
+Next: /legion:{{domain}}:quick or /legion:{{domain}}:architect
+
+## Task History
+
+| # | Type | Description | Date | Status | Artifact |
+|---|------|-------------|------|--------|----------|

package/templates/task-record.md

@@ -0,0 +1,19 @@
+# Task Record — {{NNN}}-{{type}}-{{slug}}
+
+## Metadata
+- Number: {{NNN}}
+- Type: {{type}}
+- Description: {{description}}
+- Date: {{date}}
+- Status: {{status}}
+- Agent: {{agent}}
+- Model: {{model}}
+
+## Input
+{{input_summary}}
+
+## Output
+{{output_summary}}
+
+## Artifact
+Path: .planning/legion/{{domain}}/{{NNN}}-{{type}}-{{slug}}.md

package/workflows/core/completion.md

@@ -0,0 +1,70 @@
+# Legion Core — Workflow Completion
+
+Every workflow ends with this completion sequence.
+
+## Step 1: Save Artifact
+
+Save the agent's output to:
+```
+.planning/legion/{domain}/{NNN}-{type}-{slug}.md
+```
+
+Where:
+- `{NNN}` — next task number from init context
+- `{type}` — architect, plan, execution, review, build, quick
+- `{slug}` — generated from task description
+
+Use `node ~/.claude/legion/bin/legion-tools.cjs generate-slug "<description>"` for the slug.
+
+## Step 2: Update STATE.md
+
+Run:
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs task-record <type> "<description>" <status>
+```
+
+Where status is: `done`, `partial`, `blocked`, `failed`.
+
+Update current work stage:
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs state update currentWork.stage <next-stage>
+node ~/.claude/legion/bin/legion-tools.cjs state update currentWork.lastCompleted "<type> ({NNN})"
+```
+
+## Step 3: Create Session Record
+
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs session-record "<summary>"
+```
+
+## Step 4: Display Completion
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ✓ COMPLETE — {TYPE}: {description}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Artifact: .planning/legion/{domain}/{artifact}
+Status: {status}
+```
+
+## Step 5: Route to Next Action
+
+Based on the pipeline position, suggest the next command:
+
+| Completed | Next Command | Description |
+|-----------|-------------|-------------|
+| architect | `/legion:devops:plan` | Decompose into executable tasks |
+| plan | `/legion:devops:execute` | Implement the plan |
+| execute | `/legion:devops:review` | Review what was built |
+| review | — | Pipeline complete |
+| quick | — | Standalone task complete |
+| build | `/legion:devops:architect` | Design architecture |
+
+Display:
+```
+───────────────────────────────────────────────
+ ► Next: /legion:devops:{next}
+   {next description}
+───────────────────────────────────────────────
+```

package/workflows/core/context-load.md

@@ -0,0 +1,57 @@
+# Legion Core — Context Loading
+
+This workflow loads all available project context before spawning agents.
+
+## Priority 1: .codebase/ (Project Documentation)
+
+If `.codebase/` exists, read these files in order:
+1. `.codebase/architecture.md` — High-level architecture
+2. `.codebase/project-structure.md` — Directory tree
+3. `.codebase/code-style.md` — Coding conventions
+4. `.codebase/stack.md` — Technology stack
+5. `.codebase/dependencies.md` — Dependencies
+6. `.codebase/configuration.md` — Config and env vars
+7. `.codebase/run-and-dev.md` — How to run/build/test
+8. `.codebase/decisions.md` — Key decisions
+
+Read files in parallel using Read tool. Skip files that don't exist.
+
+## Priority 2: .planning/codebase/ (Codebase Analysis)
+
+If `.planning/codebase/` exists, also read:
+1. `.planning/codebase/ARCHITECTURE.md`
+2. `.planning/codebase/STRUCTURE.md`
+3. `.planning/codebase/CONVENTIONS.md`
+4. `.planning/codebase/STACK.md`
+5. `.planning/codebase/INTEGRATIONS.md`
+6. `.planning/codebase/CONCERNS.md`
+
+## Priority 3: Legion State
+
+Read `.planning/legion/STATE.md` if it exists.
+
+## Priority 4: Latest Artifacts
+
+If STATE.md references a current pipeline, read the latest artifact from `.planning/legion/devops/`.
+
+## Context Summary
+
+After loading, compile a brief context summary (max 500 words) that includes:
+- Project type and stack
+- Architecture overview
+- Current conventions
+- Any active work from STATE.md
+
+This summary will be passed to agents alongside the full task description.
+
+## If Nothing Found
+
+If no .codebase/ or .planning/ exists:
+```
+⚠ No project context found.
+
+To create project documentation, run:
+  /legion:devops:build
+
+To proceed without context, describe your task and the agent will inspect the codebase directly.
+```

package/workflows/core/init.md

@@ -0,0 +1,52 @@
+# Legion Core — Workflow Initialization
+
+Every Legion workflow begins with this initialization sequence.
+
+## Step 1: Run legion-tools init
+
+Execute:
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs init <workflow-type> $ARGUMENTS
+```
+
+Where `<workflow-type>` is one of: `devops-quick`, `devops-architect`, `devops-plan`, `devops-execute`, `devops-build`, `devops-review`, `devops-cycle`, `status`, `resume`.
+
+Parse the JSON output. It contains:
+- `domain` — active domain (e.g., "devops")
+- `stateExists` — whether STATE.md was found
+- `codebaseExists` — whether .codebase/ was found
+- `planningCodebaseExists` — whether .planning/codebase/ was found
+- `config` — Legion config for this project
+- `state` — current state object
+- `nextTaskNum` — next artifact number (e.g., "002")
+- `timestamp` — current date
+- `latestArtifact` — path to most recent artifact
+
+## Step 2: Print Banner
+
+Display the Legion banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► {DOMAIN} ► {ACTION}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Step 3: Report Context Status
+
+Display what was found:
+```
+◆ Initializing...
+
+{✓|✗} .codebase/ — {found N docs | not found}
+{✓|✗} .planning/codebase/ — {found N docs | not found}
+{✓|✗} STATE.md — {loaded, stage: {stage} | created new}
+{✓|✗} config.json — {loaded | created default}
+```
+
+## Step 4: Load Context
+
+Follow the context-load workflow from @~/.claude/legion/workflows/core/context-load.md
+
+## Step 5: Return Context
+
+Make the loaded context available to the calling workflow for agent spawning.

package/workflows/devops/architect.md

@@ -0,0 +1,91 @@
+# Legion DevOps — Architect Workflow
+
+Invoke the devops-architect agent to design infrastructure architecture.
+
+## Prerequisites
+- Task description provided via $ARGUMENTS
+
+## Workflow
+
+### Step 1: Initialize
+
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs init devops-architect $ARGUMENTS
+```
+
+Parse JSON output. Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► DEVOPS ► ARCHITECT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Step 2: Load Context
+
+Follow @~/.claude/legion/workflows/core/context-load.md
+
+### Step 3: Check Existing Architecture
+
+If STATE.md shows previous architect outputs:
+- Read the latest architect artifact
+- Note what was already designed to avoid duplication
+- Pass existing architecture as reference to the agent
+
+### Step 4: Spawn Architect Agent
+
+```
+Task(
+  prompt="<legion_context>
+You are being invoked by Legion DevOps Architect workflow.
+
+## Project Context
+{compiled context summary from .codebase/ and .planning/}
+
+## Existing Architecture
+{content of latest architect artifact, if any — or 'None — this is the first architecture task'}
+
+## Current State
+{STATE.md summary}
+
+## Architecture Task
+{$ARGUMENTS — the user's architecture task description}
+
+## Instructions
+- Read and follow your full agent instructions from ~/.claude/agents/devops-architect.md
+- Use MCP tools for ALL operations (mandatory)
+- Inspect the actual codebase BEFORE making any design decisions
+- Read .planning/codebase/ documentation if available
+- If unsure about anything, say 'я не знаю'
+- Report results using your standard 9-section output format
+- Focus on actionable architecture, not theory
+</legion_context>",
+  subagent_type="devops-architect",
+  model="opus",
+  description="Architect: {short task description}"
+)
+```
+
+### Step 5: Process Results
+
+Capture the architect's output.
+
+### Step 6: Complete
+
+Follow @~/.claude/legion/workflows/core/completion.md
+
+- Save artifact as `{NNN}-architect-{slug}.md`
+- Update STATE.md: stage → "plan", next → "/legion:devops:plan"
+- Display completion:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ✓ COMPLETE — ARCHITECT: {description}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Artifact: .planning/legion/devops/{NNN}-architect-{slug}.md
+
+───────────────────────────────────────────────
+ ► Next: /legion:devops:plan
+   Decompose this architecture into executable tasks
+───────────────────────────────────────────────
+```