legion-cc 0.1.0

package/commands/legion/status.md

@@ -0,0 +1,53 @@
+---
+name: legion:status
+description: "Show current Legion state, active work, task history, and route to next action"
+allowed-tools:
+  - Read
+  - Glob
+  - Grep
+  - Bash
+---
+
+# Legion Status
+
+Display the current state of Legion across all domains.
+
+## Execution
+
+Follow the workflow at @~/.claude/legion/workflows/status.md
+
+### Process
+
+1. Run `node ~/.claude/legion/bin/legion-tools.cjs status`
+2. Read `.planning/legion/STATE.md` if it exists
+3. Display:
+   - Current domain and pipeline stage
+   - Active work description
+   - Recent task history (last 10 entries)
+   - Last session info
+4. Route to next action:
+   - If pipeline in progress → suggest next stage command
+   - If no active work → suggest `/legion:devops:quick` or `/legion:devops:architect`
+   - If no Legion state found → suggest initializing with `/legion:devops:build`
+
+### Display Format
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ LEGION ► STATUS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Domain:   devops
+Stage:    plan (waiting)
+Pipeline: architect → [plan] → execute → review
+Last:     001-architect-eks-migration (done)
+Next:     /legion:devops:plan
+
+─── Task History ───────────────────────────────
+| # | Type | Description | Status |
+|---|------|-------------|--------|
+| 001 | architect | EKS migration design | done |
+
+─── Session ────────────────────────────────────
+Last: 2026-02-26 14:30
+```

package/hooks/legion-context-monitor.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+// Context Monitor — Legion PostToolUse hook
+//
+// Reads context metrics from the statusline bridge file and injects
+// warnings into the agent conversation when context usage is high.
+// The statusline hook writes metrics; this hook reads them after each tool use.
+//
+// How it works:
+// 1. The statusline hook writes /tmp/legion-ctx-{session_id}.json each render
+// 2. This hook reads that file after every tool call
+// 3. When remaining context drops below thresholds, it injects a warning
+//    via hookSpecificOutput.additionalContext (the agent sees this in-context)
+//
+// Thresholds:
+//   WARNING  (remaining <= 35 %): wrap up current task, save state
+//   CRITICAL (remaining <= 25 %): stop immediately, save state NOW
+//
+// Debounce: 5 tool calls between repeated warnings at the same severity
+// Severity escalation (WARNING → CRITICAL) bypasses debounce
+//
+// GSD co-existence: if a GSD context monitor already warned this session,
+// Legion skips its own warning to avoid double-flooding the agent context.
+
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+// ─── Thresholds ───────────────────────────────────────────────────────────────
+
+const WARNING_THRESHOLD  = 35;  // remaining_percentage <= 35 %
+const CRITICAL_THRESHOLD = 25;  // remaining_percentage <= 25 %
+const STALE_SECONDS      = 60;  // ignore bridge files older than 60 s
+const DEBOUNCE_CALLS     = 5;   // min tool calls between same-level warnings
+
+// ─── GSD co-existence check ──────────────────────────────────────────────────
+
+/**
+ * Return true if GSD context monitor has already written a warning state file
+ * for this session.  We check whether the GSD warned-state file exists so we
+ * don't emit a duplicate warning on top of GSD's own message.
+ *
+ * @param {string} sessionId
+ * @returns {boolean}
+ */
+function gsdAlreadyWarned(sessionId) {
+  const tmpDir = os.tmpdir();
+  try {
+    // GSD writes both claude-ctx-{session}-warned.json (debounce state) and
+    // claude-ctx-{session}.json (bridge metrics).  If the warned file exists
+    // and was updated recently, GSD is active for this session.
+    const gsdWarnPath = path.join(tmpDir, `claude-ctx-${sessionId}-warned.json`);
+    if (fs.existsSync(gsdWarnPath)) {
+      const stat = fs.statSync(gsdWarnPath);
+      const ageSeconds = (Date.now() - stat.mtimeMs) / 1000;
+      if (ageSeconds < STALE_SECONDS * 2) {
+        return true;
+      }
+    }
+  } catch (_e) { /* ignore */ }
+  return false;
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const data      = JSON.parse(input);
+    const sessionId = data.session_id;
+
+    if (!sessionId) {
+      process.exit(0);
+    }
+
+    const tmpDir      = os.tmpdir();
+    const bridgePath  = path.join(tmpDir, `legion-ctx-${sessionId}.json`);
+
+    // No bridge file means the statusline hook hasn't run yet (subagent or
+    // fresh session without Legion statusline configured) — exit silently.
+    if (!fs.existsSync(bridgePath)) {
+      process.exit(0);
+    }
+
+    // ── Read bridge metrics ───────────────────────────────────────────────────
+    let metrics;
+    try {
+      metrics = JSON.parse(fs.readFileSync(bridgePath, 'utf8'));
+    } catch (_e) {
+      process.exit(0);
+    }
+
+    const now = Math.floor(Date.now() / 1000);
+
+    // Ignore stale bridge data (statusline hook stopped running)
+    if (metrics.timestamp && (now - metrics.timestamp) > STALE_SECONDS) {
+      process.exit(0);
+    }
+
+    const remaining = metrics.remaining_percentage;
+    const usedPct   = metrics.used_pct;
+
+    // Nothing to warn about
+    if (remaining == null || remaining > WARNING_THRESHOLD) {
+      process.exit(0);
+    }
+
+    // ── GSD co-existence: skip if GSD already warned ──────────────────────────
+    if (gsdAlreadyWarned(sessionId)) {
+      process.exit(0);
+    }
+
+    // ── Debounce ──────────────────────────────────────────────────────────────
+    const warnPath = path.join(tmpDir, `legion-ctx-${sessionId}-warned.json`);
+    let warnData   = { callsSinceWarn: 0, lastLevel: null };
+    let firstWarn  = true;
+
+    if (fs.existsSync(warnPath)) {
+      try {
+        warnData  = JSON.parse(fs.readFileSync(warnPath, 'utf8'));
+        firstWarn = false;
+      } catch (_e) {
+        // Corrupted file — reset to defaults (firstWarn stays true)
+      }
+    }
+
+    warnData.callsSinceWarn = (warnData.callsSinceWarn || 0) + 1;
+
+    const isCritical       = remaining <= CRITICAL_THRESHOLD;
+    const currentLevel     = isCritical ? 'critical' : 'warning';
+    const severityEscalated = currentLevel === 'critical' && warnData.lastLevel === 'warning';
+
+    // Emit on first warning; then debounce unless severity just escalated
+    if (!firstWarn && warnData.callsSinceWarn < DEBOUNCE_CALLS && !severityEscalated) {
+      fs.writeFileSync(warnPath, JSON.stringify(warnData));
+      process.exit(0);
+    }
+
+    // Reset debounce counter and persist level
+    warnData.callsSinceWarn = 0;
+    warnData.lastLevel      = currentLevel;
+    fs.writeFileSync(warnPath, JSON.stringify(warnData));
+
+    // ── Build warning message ─────────────────────────────────────────────────
+    const domain = metrics.domain || '';
+    const stage  = metrics.stage  || '';
+    const ctxTag = domain && stage ? `[LEGION:${domain}:${stage}] ` : '[LEGION] ';
+
+    let message;
+    if (isCritical) {
+      message =
+        `${ctxTag}CONTEXT CRITICAL: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+        'STOP all new work immediately. Save state NOW and inform the user that ' +
+        'context is nearly exhausted. Run /legion:status to snapshot current state ' +
+        'and resume in a fresh session with /legion:resume.';
+    } else {
+      message =
+        `${ctxTag}CONTEXT WARNING: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+        'Begin wrapping up the current task. Do not start new complex work. ' +
+        'Run /legion:status to review state, or save progress before context runs out.';
+    }
+
+    // ── Emit output (Claude Code PostToolUse protocol) ────────────────────────
+    const output = {
+      hookSpecificOutput: {
+        hookEventName:     'PostToolUse',
+        additionalContext: message,
+      },
+    };
+
+    process.stdout.write(JSON.stringify(output));
+
+  } catch (_e) {
+    // Silent fail — never block tool execution
+    process.exit(0);
+  }
+});

package/hooks/legion-statusline.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+// Claude Code Statusline — Legion Edition
+// Shows: LEGION:{domain}:{stage} | {dir} | ctx {bar} {usage}%
+//
+// How it works:
+// 1. Reads .planning/legion/STATE.md (walks up from cwd) to get domain + stage
+// 2. Reads context_window data from stdin (Claude Code hook protocol)
+// 3. Writes a bridge file /tmp/legion-ctx-{session_id}.json for the
+//    context-monitor PostToolUse hook to read agent-facing warnings from
+// 4. Outputs a plain-text statusline to stdout
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ─── STATE.md Parser ─────────────────────────────────────────────────────────
+
+/**
+ * Walk up the directory tree from `startDir` looking for `.planning/legion/`.
+ * Returns the absolute path if found, null otherwise.
+ *
+ * @param {string} startDir
+ * @returns {string|null}
+ */
+function findPlanningDir(startDir) {
+  let dir = path.resolve(startDir || process.cwd());
+  const root = path.parse(dir).root;
+
+  while (true) {
+    const candidate = path.join(dir, '.planning', 'legion');
+    try {
+      const stat = fs.statSync(candidate);
+      if (stat.isDirectory()) return candidate;
+    } catch (_e) { /* not found, keep climbing */ }
+
+    if (dir === root) return null;
+    dir = path.dirname(dir);
+  }
+}
+
+/**
+ * Parse the minimal fields we need out of STATE.md.
+ * Returns { domain, stage } or null if the file cannot be read.
+ *
+ * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @returns {{ domain: string, stage: string }|null}
+ */
+function parseState(planningDir) {
+  const statePath = path.join(planningDir, 'STATE.md');
+  let raw;
+  try {
+    raw = fs.readFileSync(statePath, 'utf8');
+  } catch (_e) {
+    return null;
+  }
+
+  let domain = '';
+  let stage  = '';
+  let section = '';
+
+  for (const line of raw.split('\n')) {
+    if (line.startsWith('## Project'))     { section = 'project';     continue; }
+    if (line.startsWith('## Current Work')){ section = 'currentWork'; continue; }
+
+    if (section === 'project') {
+      const m = line.match(/^Domain:\s*(.+)$/);
+      if (m) domain = m[1].trim();
+    }
+
+    if (section === 'currentWork') {
+      const m = line.match(/^Stage:\s*(.+)$/);
+      if (m) stage = m[1].trim();
+    }
+
+    // Stop early if we have both values
+    if (domain && stage) break;
+  }
+
+  if (!domain && !stage) return null;
+  return { domain, stage };
+}
+
+// ─── Context bar helper ───────────────────────────────────────────────────────
+
+/**
+ * Build an ANSI-coloured progress bar string.
+ * GSD scaling is preserved: real 80% usage displays as 100%.
+ *
+ * @param {number} remaining - remaining_percentage from Claude Code
+ * @returns {{ bar: string, used: number }}
+ */
+function buildCtxBar(remaining) {
+  const rawUsed = Math.max(0, Math.min(100, 100 - remaining));
+  // Scale so 80 % real usage == 100 % displayed (matches Claude Code's 80 % limit)
+  const used   = Math.min(100, Math.round((rawUsed / 80) * 100));
+  const filled = Math.floor(used / 10);
+  const bar    = '\u2588'.repeat(filled) + '\u2591'.repeat(10 - filled);
+
+  let coloured;
+  if (used < 63) {        // ~50 % real — green
+    coloured = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+  } else if (used < 81) { // ~65 % real — yellow
+    coloured = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+  } else if (used < 95) { // ~76 % real — orange
+    coloured = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+  } else {                // critical — blinking red skull
+    coloured = ` \x1b[5;31m\u{1F480} ${bar} ${used}%\x1b[0m`;
+  }
+
+  return { bar: coloured, used };
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const data      = JSON.parse(input);
+    const sessionId = data.session_id || '';
+    const cwd       = (data.workspace && data.workspace.current_dir) || process.cwd();
+    const dirName   = path.basename(cwd);
+    const model     = (data.model && data.model.display_name) || 'Claude';
+    const remaining = data.context_window && data.context_window.remaining_percentage != null
+      ? data.context_window.remaining_percentage
+      : null;
+
+    // ── Legion state ──────────────────────────────────────────────────────────
+    let domain = '';
+    let stage  = '';
+
+    const planningDir = findPlanningDir(cwd);
+    if (planningDir) {
+      const stateData = parseState(planningDir);
+      if (stateData) {
+        domain = stateData.domain || '';
+        stage  = stateData.stage  || '';
+      }
+    }
+
+    // ── Context bar & bridge file ─────────────────────────────────────────────
+    let ctxBar = '';
+    let usedPct = null;
+
+    if (remaining != null) {
+      const { bar, used } = buildCtxBar(remaining);
+      ctxBar  = bar;
+      usedPct = used;
+
+      // Write bridge file so context-monitor PostToolUse hook can read metrics
+      if (sessionId) {
+        try {
+          const bridgePath = path.join(os.tmpdir(), `legion-ctx-${sessionId}.json`);
+          const bridgeData = JSON.stringify({
+            session_id:           sessionId,
+            remaining_percentage: remaining,
+            used_pct:             usedPct,
+            domain,
+            stage,
+            cwd,
+            timestamp:            Math.floor(Date.now() / 1000),
+          });
+          fs.writeFileSync(bridgePath, bridgeData);
+        } catch (_e) {
+          // Silent fail — bridge is best-effort, don't break statusline
+        }
+      }
+    }
+
+    // ── Compose statusline ────────────────────────────────────────────────────
+    // Format:  LEGION:devops:architect | bt-pay-infra | ctx bar
+    // Falls back to: model | dir | ctx bar  when no Legion state found
+
+    let line;
+    if (domain && stage) {
+      const legionTag = `\x1b[1mLEGION:${domain}:${stage}\x1b[0m`;
+      line = `${legionTag} \u2502 \x1b[2m${dirName}\x1b[0m${ctxBar}`;
+    } else {
+      // No Legion state — show model + dir (same minimal fallback as GSD)
+      line = `\x1b[2m${model}\x1b[0m \u2502 \x1b[2m${dirName}\x1b[0m${ctxBar}`;
+    }
+
+    process.stdout.write(line);
+
+  } catch (_e) {
+    // Silent fail — never break the statusline
+  }
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "legion-cc",
+  "version": "0.1.0",
+  "description": "Legion — multi-agent orchestration framework for Claude Code",
+  "type": "commonjs",
+  "main": "bin/legion-tools.cjs",
+  "bin": {
+    "legion-cc": "bin/install.js"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": [
+    "bin/",
+    "commands/",
+    "workflows/",
+    "templates/",
+    "references/",
+    "agents/",
+    "hooks/",
+    "VERSION",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node bin/legion-tools.cjs status",
+    "postinstall": "node bin/install.js 2>/dev/null || true"
+  },
+  "keywords": [
+    "claude-code",
+    "agents",
+    "orchestration",
+    "devops",
+    "infrastructure",
+    "legion"
+  ],
+  "author": "Vladyslav Blackmoore",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vladyslavblackmoore/legion.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {}
+}

package/references/agent-routing.md

@@ -0,0 +1,64 @@
+# Legion — Agent Routing Guide
+
+## How Agent Routing Works
+
+Legion commands invoke specialized agents via the Task tool. Each domain defines a mapping from pipeline stages to agents.
+
+## Routing Resolution Order
+
+1. **Explicit**: User specifies which command to run (e.g., `/legion:devops:architect`)
+2. **Pipeline**: Previous stage determines next agent (architect → planner → executor)
+3. **Auto-classify**: `/legion:devops:quick` analyzes the task and routes automatically
+
+## DevOps Domain Agent Map
+
+| Pipeline Stage | Agent Name | subagent_type | Model | File |
+|---------------|------------|---------------|-------|------|
+| architect | devops-architect | devops-architect | opus | ~/.claude/agents/devops-architect.md |
+| plan | delivery-planner | delivery-planner | sonnet | ~/.claude/agents/delivery-planner.md |
+| execute | infra-executor | infra-executor | opus | ~/.claude/agents/infra-executor.md |
+| build | codebase-builder | codebase-builder | opus | ~/.claude/agents/codebase-builder.md |
+| review | devops-architect | devops-architect | sonnet | ~/.claude/agents/devops-architect.md |
+
+## Quick Classification Rules
+
+For `/legion:devops:quick`, classify tasks by keywords:
+
+| Keywords | Route To |
+|----------|----------|
+| design, architect, propose, evaluate, strategy, HA, DR, migration design | architect |
+| plan, decompose, break down, tasks, phases, implementation plan | planner |
+| implement, create, add, write, fix, update, change, terraform, pipeline | executor |
+| scaffold, init, setup, create project, .codebase/ | builder |
+| review, audit, check, validate, security review | reviewer |
+
+## Spawning Pattern
+
+All agents are spawned with this Task tool pattern:
+
+```
+Task(
+  prompt="<legion_context>
+  {context + task}
+  </legion_context>",
+  subagent_type="{agent_name}",
+  model="{model}",
+  description="{Action}: {short description}"
+)
+```
+
+## Agent Prompt Structure
+
+Every agent prompt includes:
+1. `## Project Context` — compiled from .codebase/ and .planning/
+2. `## Current State` — from STATE.md
+3. `## Task` — the user's actual request
+4. `## Instructions` — agent-specific directives
+
+## Adding Agents to a Domain
+
+To add a new agent to the devops domain:
+1. Create agent definition at `~/.claude/agents/{agent-name}.md`
+2. Register in `references/devops/agent-map.md`
+3. Add routing keywords in quick classification
+4. Optionally extend the pipeline in config.json

package/references/devops/agent-map.md

@@ -0,0 +1,61 @@
+# DevOps Domain — Agent Map
+
+## Agents
+
+### devops-architect
+- **File**: ~/.claude/agents/devops-architect.md
+- **Role**: Senior/Lead DevOps Architect (Principal level, 15+ years)
+- **Used by**: /legion:devops:architect, /legion:devops:review, /legion:devops:cycle
+- **Model**: opus (architect mode), sonnet (review mode)
+- **Capabilities**: Infrastructure design, architecture review, security assessment, technology evaluation, migration planning, DR/HA design
+- **Output**: 9-section format (Task Understanding → Next Action)
+
+### delivery-planner
+- **File**: ~/.claude/agents/delivery-planner.md
+- **Role**: Senior Delivery Planner
+- **Used by**: /legion:devops:plan, /legion:devops:cycle
+- **Model**: sonnet
+- **Capabilities**: Work decomposition, phased planning, dependency mapping, risk assessment, task definition with full metadata
+- **Output**: 8-section format (Planning Input → Next Action)
+
+### infra-executor
+- **File**: ~/.claude/agents/infra-executor.md
+- **Role**: Elite Infrastructure Execution Specialist
+- **Used by**: /legion:devops:execute, /legion:devops:cycle
+- **Model**: opus
+- **Capabilities**: Terraform implementation, CI/CD changes, Kubernetes configuration, AWS resource management, validation
+- **Output**: 7-section format (Execution Context → Next Step)
+- **Restrictions**: NEVER uses `make apply` or `terraform apply`
+
+### codebase-builder
+- **File**: ~/.claude/agents/codebase-builder.md
+- **Role**: Elite Codebase Builder / Senior Software Architect
+- **Used by**: /legion:devops:build
+- **Model**: opus
+- **Capabilities**: Project scaffolding, .codebase/ documentation creation, existing project analysis
+- **Output**: 8-section format (Build Context → Next Action)
+
+## Pipeline Flow
+
+```
+  ┌──────────────────────────────────────────────────┐
+  │                                                  │
+  │  ┌─────────┐   ┌──────┐   ┌─────────┐   ┌──────────┐
+  │  │Architect│──►│Planner│──►│Executor │──►│Reviewer  │
+  │  │ (opus)  │   │(sonnet)│  │ (opus)  │   │(sonnet)  │
+  │  └─────────┘   └──────┘   └─────────┘   └──────────┘
+  │                                                  │
+  │  ┌─────────┐                                     │
+  │  │Builder  │ (standalone or before pipeline)     │
+  │  │ (opus)  │                                     │
+  │  └─────────┘                                     │
+  └──────────────────────────────────────────────────┘
+```
+
+## Common Rules (All Agents)
+
+1. MCP tools are MANDATORY for all operations
+2. If unsure, say "я не знаю" — never generate random code
+3. `make apply` and `terraform apply` are FORBIDDEN
+4. Always read .codebase/ and .planning/codebase/ before working
+5. Report results using the standard output format

package/references/devops/pipeline-patterns.md

@@ -0,0 +1,87 @@
+# DevOps Domain — Pipeline Patterns
+
+## Standard Pipeline
+
+The default DevOps pipeline follows four stages:
+
+```
+architect → plan → execute → review
+```
+
+### When to Use Each Stage
+
+| Scenario | Start From |
+|----------|-----------|
+| New infrastructure design | `/legion:devops:architect` |
+| Architecture exists, need plan | `/legion:devops:plan` |
+| Plan exists, need implementation | `/legion:devops:execute` |
+| Changes made, need validation | `/legion:devops:review` |
+| New/existing project needs docs | `/legion:devops:build` |
+| Quick standalone task | `/legion:devops:quick` |
+| Full end-to-end | `/legion:devops:cycle` |
+
+## Pipeline Patterns
+
+### Pattern 1: Full Cycle
+Best for new, complex infrastructure work.
+```
+/legion:devops:cycle "Add ElastiCache Redis for session management"
+```
+Runs: architect → (checkpoint) → plan → (checkpoint) → execute → review
+
+### Pattern 2: Iterative Design
+Best when exploring options.
+```
+/legion:devops:architect "Evaluate options for message queue"
+/legion:devops:architect "Refine: use SQS with DLQ pattern"
+/legion:devops:plan      # uses latest architect output
+```
+
+### Pattern 3: Quick Fix
+Best for small, well-understood changes.
+```
+/legion:devops:quick "Add ingress rule for port 8443 to eks-node SG"
+```
+Auto-routes to infra-executor.
+
+### Pattern 4: Documentation First
+Best for existing projects without docs.
+```
+/legion:devops:build                        # create .codebase/ docs
+/legion:devops:architect "migration plan"   # now with full context
+```
+
+### Pattern 5: Review-Only
+Best for code review or security audit.
+```
+/legion:devops:review ./aws/modules/rds/
+```
+
+## Artifact Chain
+
+Each pipeline stage produces an artifact that feeds the next:
+
+```
+001-architect-eks-migration.md
+    ↓ (input to planner)
+002-plan-eks-migration.md
+    ↓ (input to executor)
+003-execution-eks-migration.md
+    ↓ (input to reviewer)
+004-review-eks-migration.md
+```
+
+## Checkpoint Behavior
+
+Checkpoints pause execution and ask the user:
+- **Approve** — continue to next stage
+- **Revise** — re-run current stage with feedback
+- **Stop** — save state, exit (resume later with `/legion:resume`)
+
+Default checkpoints:
+- After architect: ON
+- After plan: ON
+- After execute: OFF
+- After review: OFF
+
+Configurable in `.planning/legion/config.json`.