legion-cc 0.1.0

package/workflows/devops/build.md

@@ -0,0 +1,92 @@
+# Legion DevOps — Build Workflow
+
+Invoke the codebase-builder agent to scaffold project structure and create .codebase/ documentation.
+
+## Prerequisites
+- None required — can work standalone by inspecting existing codebase
+- Optionally accepts architect/planner output for guided scaffolding
+
+## Workflow
+
+### Step 1: Initialize
+
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs init devops-build $ARGUMENTS
+```
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► DEVOPS ► BUILD
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Step 2: Load Context
+
+Follow @~/.claude/legion/workflows/core/context-load.md
+
+Note: .codebase/ may not exist yet — that's often WHY this command is being run.
+
+### Step 3: Find Optional Input
+
+Check for optional architecture/plan input:
+1. **From $ARGUMENTS**: If a file path is provided, read it
+2. **From STATE.md**: Find latest architect or plan artifacts
+3. **No input**: Proceed without — builder will inspect existing codebase
+
+### Step 4: Spawn Builder Agent
+
+```
+Task(
+  prompt="<legion_context>
+You are being invoked by Legion DevOps Build workflow.
+
+## Project Context
+{existing context if any — may be empty for new projects}
+
+## Architecture/Plan Input
+{content of architect/plan output if available, or 'None — inspect the existing codebase and create .codebase/ documentation'}
+
+## Build Task
+{$ARGUMENTS if provided, or 'Inspect the existing project, scaffold any missing structure, and create comprehensive .codebase/ documentation'}
+
+## Instructions
+- Read and follow your full agent instructions from ~/.claude/agents/codebase-builder.md
+- Use MCP tools for ALL operations (mandatory)
+- Inspect the existing project THOROUGHLY before creating anything
+- Create the full .codebase/ documentation suite
+- If this is an existing project, do NOT recreate existing structure — document and extend
+- If unsure about anything, say 'я не знаю'
+- Report results using your standard 8-section output format
+</legion_context>",
+  subagent_type="codebase-builder",
+  model="opus",
+  description="Build: {project name or task}"
+)
+```
+
+### Step 5: Process Results
+
+Capture what was created/documented.
+
+### Step 6: Complete
+
+Follow @~/.claude/legion/workflows/core/completion.md
+
+- Save artifact as `{NNN}-build-{slug}.md`
+- Update STATE.md
+- Display completion:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ✓ COMPLETE — BUILD: {description}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Artifact: .planning/legion/devops/{NNN}-build-{slug}.md
+Created: {list of files/dirs created}
+
+───────────────────────────────────────────────
+ ► Next: /legion:devops:architect
+   Design the architecture for this project
+───────────────────────────────────────────────
+```

package/workflows/devops/cycle.md

@@ -0,0 +1,237 @@
+# Legion DevOps — Full Cycle Workflow
+
+Run the complete DevOps pipeline: architect → plan → execute → review.
+Includes approval checkpoints between stages.
+
+## Prerequisites
+- Task description provided via $ARGUMENTS
+
+## Workflow
+
+### Step 1: Initialize
+
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs init devops-cycle $ARGUMENTS
+```
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► DEVOPS ► FULL CYCLE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Pipeline: [architect] → [plan] → [execute] → [review]
+```
+
+### Step 2: Load Context
+
+Follow @~/.claude/legion/workflows/core/context-load.md
+
+### Step 3: Phase 1 — ARCHITECT
+
+Display:
+```
+◆ Phase 1/4 — ARCHITECT
+```
+
+Spawn devops-architect agent via Task tool:
+```
+Task(
+  prompt="<legion_context>
+You are being invoked by Legion DevOps Cycle workflow — Phase 1: Architecture.
+
+## Project Context
+{compiled context from .codebase/ and .planning/}
+
+## Architecture Task
+{$ARGUMENTS}
+
+## Instructions
+- Follow your full agent instructions from ~/.claude/agents/devops-architect.md
+- Use MCP tools for ALL operations
+- Produce a complete, actionable architecture document
+- If unsure, say 'я не знаю'
+- Report using your standard 9-section format
+</legion_context>",
+  subagent_type="devops-architect",
+  model="opus",
+  description="Cycle/Architect: {task}"
+)
+```
+
+Save output to `{NNN}-architect-{slug}.md`
+
+#### Checkpoint 1
+
+Display architecture summary to the user:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ✓ Phase 1/4 — ARCHITECT complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+{Brief architecture summary — key decisions, proposed changes}
+
+Artifact: .planning/legion/devops/{NNN}-architect-{slug}.md
+```
+
+Ask the user:
+- **Approve** → continue to Phase 2
+- **Revise** → re-run architect with feedback
+- **Stop** → save state and exit (resume with /legion:resume)
+
+### Step 4: Phase 2 — PLAN
+
+Display:
+```
+◆ Phase 2/4 — PLAN
+```
+
+Spawn delivery-planner agent via Task tool:
+```
+Task(
+  prompt="<legion_context>
+You are being invoked by Legion DevOps Cycle workflow — Phase 2: Planning.
+
+## Project Context
+{compiled context}
+
+## Architecture Input
+{FULL architect output from Phase 1}
+
+## Planning Task
+Decompose the architecture into a phased, executable implementation plan.
+
+## Instructions
+- Follow your full agent instructions from ~/.claude/agents/delivery-planner.md
+- Use MCP tools for ALL operations
+- Each task needs: ID, name, purpose, scope, inputs, actions, outputs, owner, dependencies, risks, validation, rollback, completion criteria
+- If unsure, say 'я не знаю'
+</legion_context>",
+  subagent_type="delivery-planner",
+  model="sonnet",
+  description="Cycle/Plan: {task}"
+)
+```
+
+Save output to `{NNN+1}-plan-{slug}.md`
+
+#### Checkpoint 2
+
+Display plan summary:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ✓ Phase 2/4 — PLAN complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+{Brief plan summary — N phases, M tasks, key milestones}
+
+Artifact: .planning/legion/devops/{NNN+1}-plan-{slug}.md
+```
+
+Ask the user: Approve / Revise / Stop
+
+### Step 5: Phase 3 — EXECUTE
+
+Display:
+```
+◆ Phase 3/4 — EXECUTE
+```
+
+Spawn infra-executor agent via Task tool:
+```
+Task(
+  prompt="<legion_context>
+You are being invoked by Legion DevOps Cycle workflow — Phase 3: Execution.
+
+## Project Context
+{compiled context}
+
+## Architecture Reference
+{Summary of architect output}
+
+## Implementation Plan
+{FULL plan output from Phase 2}
+
+## Execution Task
+Execute the plan following the defined phases and task order.
+
+## Instructions
+- Follow your full agent instructions from ~/.claude/agents/infra-executor.md
+- Use MCP tools for ALL operations
+- Follow the plan precisely
+- Validate after every step
+- NEVER use `make apply` or `terraform apply`
+- If unsure, say 'я не знаю'
+</legion_context>",
+  subagent_type="infra-executor",
+  model="opus",
+  description="Cycle/Execute: {task}"
+)
+```
+
+Save output to `{NNN+2}-execution-{slug}.md`
+
+### Step 6: Phase 4 — REVIEW
+
+Display:
+```
+◆ Phase 4/4 — REVIEW
+```
+
+Spawn devops-architect in review mode:
+```
+Task(
+  prompt="<legion_context>
+You are being invoked by Legion DevOps Cycle workflow — Phase 4: Review.
+REVIEW MODE — validate what was built.
+
+## Project Context
+{compiled context}
+
+## Original Architecture
+{Architect output from Phase 1}
+
+## Execution Report
+{Executor output from Phase 3}
+
+## Review Task
+Review the executed changes against the original architecture. Check alignment, security, best practices, naming conventions, tags, secrets handling.
+
+## Instructions
+- Follow your full agent instructions from ~/.claude/agents/devops-architect.md
+- This is a REVIEW — produce a review report
+- Classify findings: CRITICAL / WARNING / INFO / OK
+- If unsure, say 'я не знаю'
+</legion_context>",
+  subagent_type="devops-architect",
+  model="sonnet",
+  description="Cycle/Review: {task}"
+)
+```
+
+Save output to `{NNN+3}-review-{slug}.md`
+
+### Step 7: Complete Cycle
+
+Update STATE.md with all 4 task records.
+
+Display final summary:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ✓ FULL CYCLE COMPLETE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+✓ Phase 1 — Architect: {description}
+✓ Phase 2 — Plan: {N phases, M tasks}
+✓ Phase 3 — Execute: {status}
+✓ Phase 4 — Review: {N findings}
+
+Artifacts:
+  .planning/legion/devops/{NNN}-architect-{slug}.md
+  .planning/legion/devops/{NNN+1}-plan-{slug}.md
+  .planning/legion/devops/{NNN+2}-execution-{slug}.md
+  .planning/legion/devops/{NNN+3}-review-{slug}.md
+
+Ready for new tasks:
+  /legion:devops:quick <next task>
+```

package/workflows/devops/execute.md

@@ -0,0 +1,118 @@
+# Legion DevOps — Execute Workflow
+
+Invoke the infra-executor agent to implement tasks from a delivery plan.
+
+## Prerequisites
+- Plan output must exist (from /legion:devops:plan or provided via $ARGUMENTS)
+
+## Workflow
+
+### Step 1: Initialize
+
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs init devops-execute $ARGUMENTS
+```
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► DEVOPS ► EXECUTE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Step 2: Load Context
+
+Follow @~/.claude/legion/workflows/core/context-load.md
+
+### Step 3: Find Plan
+
+Resolve the plan input:
+
+1. **From $ARGUMENTS**: If a file path is provided, use it
+2. **--task T1**: If task flag provided, extract task ID for targeted execution
+3. **From STATE.md**: Find latest `*-plan-*.md` artifact
+4. **From glob**: Search `.planning/legion/devops/*-plan-*.md`
+
+If no plan found:
+```
+⚠ No plan found.
+
+To create a plan first, run:
+  /legion:devops:plan
+
+Or provide a path:
+  /legion:devops:execute /path/to/plan.md
+```
+STOP — do not proceed without input.
+
+Read the plan fully. Also find and read the corresponding architect output (referenced in the plan or the previous artifact).
+
+### Step 4: Spawn Executor Agent
+
+```
+Task(
+  prompt="<legion_context>
+You are being invoked by Legion DevOps Execute workflow.
+
+## Project Context
+{compiled context summary from .codebase/ and .planning/}
+
+## Architecture Reference
+{Summary or path to architect output that this plan implements}
+
+## Implementation Plan
+{FULL content of the plan document}
+
+## Execution Scope
+{If --task T1 specified: 'Execute ONLY task T1: {task description}'}
+{If no specific task: 'Execute the plan from the beginning, following the defined phases and task order'}
+
+## Current State
+{STATE.md summary}
+
+## Instructions
+- Read and follow your full agent instructions from ~/.claude/agents/infra-executor.md
+- Use MCP tools for ALL operations (mandatory)
+- Read .planning/codebase/ documentation BEFORE making changes
+- Follow the plan precisely — do not improvise
+- Validate after every meaningful step
+- If unsure about anything, say 'я не знаю'
+- Report results using your standard 7-section output format
+- NEVER use `make apply` or `terraform apply`
+</legion_context>",
+  subagent_type="infra-executor",
+  model="opus",
+  description="Execute: {task or plan description}"
+)
+```
+
+### Step 5: Process Results
+
+Capture the executor's output. Check the reported status:
+- **DONE** — all tasks completed successfully
+- **PARTIAL** — some tasks completed, record which ones
+- **BLOCKED** — execution blocked, record reason
+
+### Step 6: Complete
+
+Follow @~/.claude/legion/workflows/core/completion.md
+
+- Save artifact as `{NNN}-execution-{slug}.md`
+- Update STATE.md: stage → "review", next → "/legion:devops:review"
+- If PARTIAL: keep stage as "execute", note remaining tasks
+- Display completion:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ✓ COMPLETE — EXECUTE: {description}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Artifact: .planning/legion/devops/{NNN}-execution-{slug}.md
+Status: {DONE|PARTIAL|BLOCKED}
+Tasks: {N completed / M total}
+
+───────────────────────────────────────────────
+ ► Next: /legion:devops:review
+   Review the executed changes
+───────────────────────────────────────────────
+```

package/workflows/devops/plan.md

@@ -0,0 +1,108 @@
+# Legion DevOps — Plan Workflow
+
+Invoke the delivery-planner agent to decompose architecture into an executable implementation plan.
+
+## Prerequisites
+- Architect output must exist (from /legion:devops:architect or provided via $ARGUMENTS)
+
+## Workflow
+
+### Step 1: Initialize
+
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs init devops-plan $ARGUMENTS
+```
+
+Display banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► DEVOPS ► PLAN
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Step 2: Load Context
+
+Follow @~/.claude/legion/workflows/core/context-load.md
+
+### Step 3: Find Architect Output
+
+Resolve the input for planning:
+
+1. **From $ARGUMENTS**: If a file path is provided, use it directly
+2. **From STATE.md**: Find the latest `*-architect-*.md` artifact in `.planning/legion/devops/`
+3. **From glob**: Search `.planning/legion/devops/*-architect-*.md` and use the most recent
+
+If no architect output found:
+```
+⚠ No architect output found.
+
+To create architecture first, run:
+  /legion:devops:architect <task description>
+
+Or provide a path to an existing architecture document:
+  /legion:devops:plan /path/to/architecture.md
+```
+STOP here — do not proceed without input.
+
+Read the architect output fully. It will be passed to the planner.
+
+### Step 4: Spawn Planner Agent
+
+```
+Task(
+  prompt="<legion_context>
+You are being invoked by Legion DevOps Plan workflow.
+
+## Project Context
+{compiled context summary from .codebase/ and .planning/}
+
+## Architecture Input
+{FULL content of the architect output document}
+
+## Current State
+{STATE.md summary}
+
+## Planning Task
+Decompose the architecture above into a phased, executable implementation plan.
+{Additional instructions from $ARGUMENTS if any}
+
+## Instructions
+- Read and follow your full agent instructions from ~/.claude/agents/delivery-planner.md
+- Use MCP tools for ALL operations (mandatory)
+- Inspect the actual codebase BEFORE finalizing the plan
+- Read .planning/codebase/ documentation if available
+- If unsure about anything, say 'я не знаю'
+- Report results using your standard 8-section output format
+- Each task must have: ID, name, purpose, scope, inputs, actions, outputs, owner, dependencies, risks, validation, rollback, completion criteria
+</legion_context>",
+  subagent_type="delivery-planner",
+  model="sonnet",
+  description="Plan: {short description from architect output}"
+)
+```
+
+### Step 5: Process Results
+
+Capture the planner's output.
+
+### Step 6: Complete
+
+Follow @~/.claude/legion/workflows/core/completion.md
+
+- Save artifact as `{NNN}-plan-{slug}.md`
+- Update STATE.md: stage → "execute", next → "/legion:devops:execute"
+- Display completion:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ ✓ COMPLETE — PLAN: {description}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Artifact: .planning/legion/devops/{NNN}-plan-{slug}.md
+Tasks: {N tasks across M phases}
+
+───────────────────────────────────────────────
+ ► Next: /legion:devops:execute
+   Execute the implementation plan
+───────────────────────────────────────────────
+```

package/workflows/devops/quick.md

@@ -0,0 +1,107 @@
+# Legion DevOps — Quick Execution Workflow
+
+Fast, context-aware task execution. Reads project documentation, classifies the task, and dispatches to the appropriate DevOps agent.
+
+## Prerequisites
+- Task description provided via $ARGUMENTS
+
+## Workflow
+
+### Step 1: Initialize
+
+```bash
+node ~/.claude/legion/bin/legion-tools.cjs init devops-quick $ARGUMENTS
+```
+
+Parse the JSON output. Display the Legion banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► DEVOPS ► QUICK
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Step 2: Load Context
+
+Follow @~/.claude/legion/workflows/core/context-load.md
+
+Read ALL available .codebase/ and .planning/codebase/ files. This step is MANDATORY — the whole point of /quick is context-aware execution.
+
+Report what was loaded:
+```
+◆ Loading context...
+
+✓ .codebase/architecture.md (loaded)
+✓ .codebase/project-structure.md (loaded)
+✓ .codebase/code-style.md (loaded)
+✓ .codebase/stack.md (loaded)
+✓ .planning/codebase/ARCHITECTURE.md (loaded)
+✓ STATE.md (loaded — stage: plan)
+```
+
+### Step 3: Classify Task
+
+Analyze the task description from $ARGUMENTS and classify it:
+
+| Pattern | Classification | Agent |
+|---------|---------------|-------|
+| Design, architect, propose, evaluate options, migration strategy, DR plan, HA design | **architecture** | devops-architect |
+| Plan, decompose, break down, create tasks, implementation plan, phased rollout | **planning** | delivery-planner |
+| Implement, create resource, add module, write terraform, fix config, update pipeline, change infra | **execution** | infra-executor |
+| Scaffold, create project, init codebase, setup structure, create .codebase/ docs | **build** | codebase-builder |
+| Review, audit, check, validate architecture, security review | **review** | devops-architect (review mode) |
+
+If the task doesn't clearly match:
+- Look for keywords and context clues
+- If still unclear, ASK the user: "This task could be handled by [agent1] or [agent2]. Which approach do you prefer?"
+- NEVER guess — routing to the wrong agent wastes context
+
+### Step 4: Spawn Agent
+
+Based on classification, spawn the appropriate agent via Task tool:
+
+```
+Task(
+  prompt="<legion_context>
+You are being invoked by Legion DevOps Quick workflow.
+
+## Project Context
+{compiled context summary from .codebase/ and .planning/}
+
+## Current State
+{STATE.md summary — current pipeline position, last completed task}
+
+## Task
+{$ARGUMENTS — the user's task description}
+
+## Instructions
+- Read and follow your full agent instructions
+- Use MCP tools for all operations (mandatory)
+- If unsure about anything, say 'я не знаю'
+- Report results using your standard output format
+</legion_context>",
+  subagent_type="{agent_name}",
+  model="{model}",
+  description="Quick: {short task description}"
+)
+```
+
+Agent routing table:
+| Classification | subagent_type | model |
+|---------------|---------------|-------|
+| architecture | devops-architect | opus |
+| planning | delivery-planner | sonnet |
+| execution | infra-executor | opus |
+| build | codebase-builder | opus |
+| review | devops-architect | sonnet |
+
+### Step 5: Process Results
+
+Capture the agent's output.
+
+### Step 6: Complete
+
+Follow @~/.claude/legion/workflows/core/completion.md
+
+- Save artifact as `{NNN}-quick-{slug}.md`
+- Update STATE.md
+- Display completion with next action suggestion