legion-cc 0.1.0 → 0.2.0

package/README.md

@@ -12,10 +12,10 @@ The first domain ships with Legion: **devops** — infrastructure design, planni
 Each domain defines a sequential pipeline of specialized agents. The devops domain runs: `architect → plan → execute → review`. Every stage produces a numbered artifact that feeds the next.
 
 **Fast context-aware execution**
-`/legion:devops:quick` reads `.codebase/` and `.planning/codebase/` before dispatching to classify and route the task to the correct agent automatically.
+`/legion:devops:quick` reads `.legion/codebase/` before dispatching to classify and route the task to the correct agent automatically.
 
 **State tracking across sessions**
-All pipeline state is written to `.planning/legion/STATE.md` — current domain, stage, task history, and artifact chain. State persists between Claude Code sessions.
+All pipeline state is written to `.legion/planning/STATE.md` — current domain, stage, task history, and artifact chain. State persists between Claude Code sessions.
 
 **Context window monitoring**
 A `PostToolUse` hook reads context metrics after each tool call. When remaining context drops below 35%, the agent receives an in-context warning to wrap up. At 25%, it receives a critical stop directive. Warnings are debounced across tool calls and coexist safely with GSD.
@@ -24,7 +24,7 @@ A `PostToolUse` hook reads context metrics after each tool call. When remaining
 `/legion:devops:cycle` pauses after the architect and plan stages to show the output and ask for approval before continuing. The user can approve, request a revision, or stop and save state for later.
 
 **Sequential artifact management**
-Each pipeline stage writes a numbered artifact to `.planning/legion/devops/`:
+Each pipeline stage writes a numbered artifact to `.legion/planning/devops/`:
 ```
 001-architect-eks-migration.md
 002-plan-eks-migration.md
@@ -40,10 +40,7 @@ Each pipeline stage writes a numbered artifact to `.planning/legion/devops/`:
 ## Quick Start
 
 ```bash
-git clone git@github.com:vladyslavblackmoore/legion.git
-cd legion
-chmod +x install.sh
-./install.sh
+npx legion-cc@latest
 ```
 
 The installer copies commands, workflows, templates, references, and hooks into `~/.claude/`, registers the `PostToolUse` context monitor in Claude Code settings, and writes a file manifest for clean uninstalls.
@@ -51,14 +48,9 @@ The installer copies commands, workflows, templates, references, and hooks into
 **Options**
 
 ```bash
-./install.sh --dry-run   # preview what would be installed
-./install.sh --force     # overwrite existing agent files
-```
-
-**Uninstall**
-
-```bash
-./uninstall.sh
+npx legion-cc@latest --force      # overwrite existing agent files
+npx legion-cc@latest --dry-run    # preview what would be installed
+npx legion-cc@latest --uninstall  # remove Legion
 ```
 
 ---
@@ -69,11 +61,11 @@ The installer copies commands, workflows, templates, references, and hooks into
 
 | Command | Description |
 |---------|-------------|
-| `/legion:devops:quick <task>` | Classify the task and dispatch to the right agent. Reads `.codebase/` first. |
+| `/legion:devops:quick <task>` | Classify the task and dispatch to the right agent. Reads `.legion/codebase/` first. |
 | `/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:build [path]` | Scaffold project structure and create `.codebase/` documentation with `codebase-builder` (opus). |
+| `/legion:devops:init [path]` | Scaffold project structure and create `.legion/codebase/` documentation with `codebase-builder` (opus). |
 | `/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. |
 
@@ -113,8 +105,6 @@ legion/
 ├── workflows/       # Step-by-step execution logic referenced by commands
 │   ├── core/        # init, context-load, completion (shared across domains)
 │   └── devops/      # One workflow per command
-├── install.sh
-├── uninstall.sh
 ├── package.json
 └── VERSION
 ```
@@ -128,7 +118,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, `.codebase/` documentation creation, existing project analysis | opus | `build` |
+| `codebase-builder` | Elite Codebase Builder — project scaffolding, `.legion/codebase/` documentation creation, existing project analysis | opus | `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.
 
@@ -166,7 +156,7 @@ The `devops-architect` agent doubles as reviewer: the same agent definition is i
   done
 ```
 
-Checkpoints default to ON after architect and plan, OFF after execute and review. This is configurable per project in `.planning/legion/config.json`.
+Checkpoints default to ON after architect and plan, OFF after execute and review. This is configurable per project in `.legion/planning/config.json`.
 
 ---
 
@@ -187,9 +177,9 @@ Checkpoints default to ON after architect and plan, OFF after execute and review
 /legion:devops:quick "Add ingress rule for port 8443 to eks-node SG"
 ```
 
-**Documentation first** — existing project without `.codebase/` docs:
+**Documentation first** — existing project without `.legion/codebase/` docs:
 ```
-/legion:devops:build
+/legion:devops:init
 /legion:devops:architect "migration plan"
 ```
 
@@ -210,7 +200,7 @@ Legion is designed to host multiple domains. To add a new domain (e.g., `backend
 4. Create references at `references/{domain}/` — `agent-map.md` and `pipeline-patterns.md`
 5. Define agents in `agents/` and register them in `references/{domain}/agent-map.md`
 6. Add the domain entry to `references/domain-registry.md`
-7. Run `./install.sh` to deploy
+7. Run `npx legion-cc --force` to deploy
 
 Each domain must define: pipeline stages (ordered), agent mapping (stage to agent), model assignment, and classification rules for its `/quick` command.
 
@@ -247,8 +237,9 @@ Per-project state is written alongside your code:
 
 ```
 {project}/
-└── .planning/
-    └── legion/
+└── .legion/
+    ├── codebase/            # Project documentation
+    └── planning/
         ├── STATE.md
         ├── config.json
         ├── sessions/

package/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

package/agents/legion-orchestrator.md

@@ -14,7 +14,7 @@ You are the Legion Orchestrator — a lightweight routing agent that analyzes in
 
 You do NOT execute tasks yourself. You:
 1. Analyze the task description
-2. Load project context (.codebase/, .planning/)
+2. Load project context (.legion/)
 3. Classify the task type
 4. Recommend the appropriate agent and provide context for spawning
 
@@ -37,10 +37,10 @@ Analyze the task and classify into one of these categories:
 **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
 
-### build
+### init
 **Agent**: codebase-builder (opus)
-**Triggers**: New project setup, scaffolding, creating .codebase/ documentation, initializing project structure
-**Keywords**: scaffold, init, setup, create project, new project, .codebase/, document structure, bootstrap
+**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
 
 ### review
 **Agent**: devops-architect (sonnet, review mode)

package/bin/install.js

@@ -784,7 +784,7 @@ function doUninstall() {
     console.log(`  ${c(yellow, 'Failed:')}  ${failedCount} files`);
   }
   console.log('');
-  console.log(`  ${c(dim, 'Note: Agent files (agents/) and project data (.planning/legion/) were NOT removed.')}`);
+  console.log(`  ${c(dim, 'Note: Agent files (agents/) and project data (.legion/) were NOT removed.')}`);
   console.log('');
 }
 

package/bin/legion-tools.cjs

@@ -26,8 +26,9 @@ function usage() {
     '  generate-slug <text>               Generate a URL-safe slug from text',
     '  current-timestamp [format]         Print current timestamp (iso|date|datetime)',
     '  task-record <type> <desc> <status> Add a task record to STATE.md',
-    '  context-load [path]                Load context from .codebase/ and .planning/',
+    '  context-load [path]                Load context from .legion/codebase/ and .legion/planning/',
     '  domain list|info [name]            Domain registry operations',
+  '  update-check                       Check for newer version on npm',
     '',
     'Examples:',
     '  legion-tools init devops',
@@ -67,7 +68,7 @@ function die(msg, code) {
 function requirePlanningDir() {
   const planningDir = core.resolvePlanningDir();
   if (!planningDir) {
-    die('No .planning/legion/ directory found. Run "legion-tools init <domain>" first.');
+    die('No .legion/planning/ directory found. Run "legion-tools init <domain>" first.');
   }
   return planningDir;
 }
@@ -376,6 +377,34 @@ function cmdDomain(args) {
   }
 }
 
+// ─── Command: update-check ───────────────────────────────────────────────
+
+function cmdUpdateCheck() {
+  const vc = require('./lib/version-check.cjs');
+  const current = vc.getInstalledVersion();
+
+  console.log(`  Installed: v${current}`);
+  console.log('  Checking npm registry...');
+
+  const result = vc.checkForUpdate();
+
+  if (!result) {
+    console.log(`  ${core.UI.warn} Could not reach npm registry.`);
+    return;
+  }
+
+  if (result.available) {
+    console.log(`  ${core.UI.diamond} Update available: v${result.current} \u2192 v${result.latest}`);
+    console.log('');
+    console.log('  Run: npx legion-cc@latest');
+  } else {
+    console.log(`  ${core.UI.check} Already on latest version (v${result.current})`);
+  }
+  console.log('');
+
+  out(result);
+}
+
 // ─── Main Router ─────────────────────────────────────────────────────────────
 
 function main() {
@@ -413,6 +442,9 @@ function main() {
     case 'domain':
       cmdDomain(commandArgs);
       break;
+    case 'update-check':
+      cmdUpdateCheck();
+      break;
     default:
       die(`Unknown command: ${command}. Run "legion-tools --help" for usage.`);
   }

package/bin/lib/config.cjs

@@ -88,7 +88,7 @@ const DOMAIN_DEFAULTS = {
 /**
  * Load config.json from the given planning directory.
  *
- * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @param {string} planningDir - Absolute path to `.legion/planning/`
  * @returns {object|null} Parsed config or null if missing/invalid
  */
 function loadConfig(planningDir) {
@@ -111,9 +111,9 @@ function defaultConfig(domain) {
 }
 
 /**
- * Save a config object to `.planning/legion/config.json`.
+ * Save a config object to `.legion/planning/config.json`.
  *
- * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @param {string} planningDir - Absolute path to `.legion/planning/`
  * @param {object} config - Config object to persist
  */
 function saveConfig(planningDir, config) {

package/bin/lib/core.cjs

@@ -70,7 +70,7 @@ function currentTimestamp(format) {
  * Walk up from `startDir` looking for a directory that matches `target`.
  * Returns the absolute path to the found directory, or null.
  *
- * @param {string} target - Relative directory name to locate (e.g. '.planning/legion')
+ * @param {string} target - Relative directory name to locate (e.g. '.legion/planning')
  * @param {string} [startDir=process.cwd()] - Where to start searching
  * @returns {string|null}
  */
@@ -89,21 +89,30 @@ function _walkUp(target, startDir) {
 }
 
 /**
- * Find `.planning/legion/` by walking up from cwd.
+ * Find `.legion/planning/` by walking up from cwd.
  * @param {string} [startDir]
  * @returns {string|null}
  */
 function resolvePlanningDir(startDir) {
-  return _walkUp(path.join('.planning', 'legion'), startDir);
+  return _walkUp(path.join('.legion', 'planning'), startDir);
 }
 
 /**
- * Find `.codebase/` by walking up from cwd.
+ * Find `.legion/codebase/` by walking up from cwd.
  * @param {string} [startDir]
  * @returns {string|null}
  */
 function resolveCodebaseDir(startDir) {
-  return _walkUp('.codebase', startDir);
+  return _walkUp(path.join('.legion', 'codebase'), startDir);
+}
+
+/**
+ * Find `.legion/` root by walking up from cwd.
+ * @param {string} [startDir]
+ * @returns {string|null}
+ */
+function resolveLegionDir(startDir) {
+  return _walkUp('.legion', startDir);
 }
 
 // ─── Task Numbering ──────────────────────────────────────────────────────────
@@ -112,7 +121,7 @@ function resolveCodebaseDir(startDir) {
  * Scan existing artifact files in `planningDir/artifacts/` and return the next
  * zero-padded three-digit number (e.g. "002").
  *
- * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @param {string} planningDir - Absolute path to `.legion/planning/`
  * @returns {string} Next task number, zero-padded to 3 digits
  */
 function nextTaskNum(planningDir) {
@@ -209,6 +218,7 @@ module.exports = {
   currentTimestamp,
   resolvePlanningDir,
   resolveCodebaseDir,
+  resolveLegionDir,
   nextTaskNum,
   readJsonSafe,
   writeJsonSafe,

package/bin/lib/init.cjs

@@ -5,9 +5,9 @@ const path = require('path');
 const {
   resolvePlanningDir,
   resolveCodebaseDir,
+  resolveLegionDir,
   currentTimestamp,
   nextTaskNum,
-  banner,
 } = require('./core.cjs');
 const { loadConfig, defaultConfig, saveConfig } = require('./config.cjs');
 const { loadState, initState } = require('./state.cjs');
@@ -59,9 +59,8 @@ function _scanDir(dir, base, depth, results) {
 /**
  * Initialize a workflow and return a full context JSON blob.
  *
- * - Detects `.codebase/` and its contents
- * - Detects `.planning/codebase/`
- * - Ensures `.planning/legion/` exists
+ * - Detects `.legion/codebase/` and its contents
+ * - Ensures `.legion/planning/` exists
  * - Loads or creates STATE.md
  * - Loads or creates config.json
  *
@@ -73,7 +72,20 @@ function initWorkflow(type, args) {
   const domain = (type || 'devops').toLowerCase();
   const cwd = process.cwd();
 
-  // ── Detect .codebase/ ──────────────────────────────────────────────────
+  // ── Detect project root (parent of .legion/) ───────────────────────────
+  let projectRoot = cwd;
+  const legionDir = resolveLegionDir(cwd);
+  if (legionDir) {
+    projectRoot = path.dirname(legionDir);
+  }
+
+  // ── Ensure .legion/ structure ──────────────────────────────────────────
+  const legionRoot = legionDir || path.join(projectRoot, '.legion');
+  if (!fs.existsSync(legionRoot)) {
+    fs.mkdirSync(legionRoot, { recursive: true });
+  }
+
+  // ── Detect .legion/codebase/ ───────────────────────────────────────────
   const codebaseDir = resolveCodebaseDir(cwd);
   const codebaseExists = codebaseDir !== null;
   let codebaseFiles = [];
@@ -81,27 +93,12 @@ function initWorkflow(type, args) {
     codebaseFiles = _scanDir(codebaseDir, codebaseDir);
   }
 
-  // ── Detect project root (the parent of .codebase or .planning) ─────────
-  let projectRoot = cwd;
-  if (codebaseDir) {
-    projectRoot = path.dirname(codebaseDir);
-  }
-
-  // ── Detect .planning/codebase/ ─────────────────────────────────────────
-  const planningCodebaseDir = path.join(projectRoot, '.planning', 'codebase');
-  const planningCodebaseExists = fs.existsSync(planningCodebaseDir) &&
-    fs.statSync(planningCodebaseDir).isDirectory();
-  let planningCodebaseFiles = [];
-  if (planningCodebaseExists) {
-    planningCodebaseFiles = _scanDir(planningCodebaseDir, planningCodebaseDir);
-  }
-
-  // ── Ensure .planning/legion/ ───────────────────────────────────────────
+  // ── Ensure .legion/planning/ ───────────────────────────────────────────
   let planningDir = resolvePlanningDir(cwd);
   const planningDirExisted = planningDir !== null;
 
   if (!planningDir) {
-    planningDir = path.join(projectRoot, '.planning', 'legion');
+    planningDir = path.join(legionRoot, 'planning');
     fs.mkdirSync(planningDir, { recursive: true });
   }
 
@@ -147,11 +144,7 @@ function initWorkflow(type, args) {
       files: codebaseFiles,
     },
 
-    planningCodebase: {
-      exists: planningCodebaseExists,
-      path: planningCodebaseExists ? planningCodebaseDir : null,
-      files: planningCodebaseFiles,
-    },
+    legionRoot: legionRoot,
 
     planning: {
       path: planningDir,

package/bin/lib/session.cjs

@@ -7,12 +7,12 @@ const { currentTimestamp } = require('./core.cjs');
 // ─── Session Management ─────────────────────────────────────────────────────
 
 /**
- * Create a new session record in `.planning/legion/sessions/`.
+ * Create a new session record in `.legion/planning/sessions/`.
  *
  * Session file: `{YYYY-MM-DD}-{NNN}.md`
  * NNN is a zero-padded counter within the same day.
  *
- * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @param {string} planningDir - Absolute path to `.legion/planning/`
  * @param {object} data - Session data
  * @param {string} [data.domain] - Domain name
  * @param {string} [data.stage] - Pipeline stage
@@ -93,9 +93,9 @@ function createSession(planningDir, data) {
 }
 
 /**
- * Get the most recent session file from `.planning/legion/sessions/`.
+ * Get the most recent session file from `.legion/planning/sessions/`.
  *
- * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @param {string} planningDir - Absolute path to `.legion/planning/`
  * @returns {object|null} Session info: { path, name, content } or null
  */
 function getLatestSession(planningDir) {

package/bin/lib/state.cjs

@@ -9,7 +9,7 @@ const { currentTimestamp } = require('./core.cjs');
 /**
  * Parse STATE.md into a structured object.
  *
- * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @param {string} planningDir - Absolute path to `.legion/planning/`
  * @returns {object|null} Parsed state, or null if STATE.md doesn't exist
  */
 function loadState(planningDir) {
@@ -101,7 +101,7 @@ function loadState(planningDir) {
 /**
  * Write a structured state object back to STATE.md.
  *
- * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @param {string} planningDir - Absolute path to `.legion/planning/`
  * @param {object} stateObj - State object (same shape as loadState output)
  */
 function saveState(planningDir, stateObj) {

package/bin/lib/version-check.cjs

@@ -0,0 +1,183 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const PACKAGE_NAME = 'legion-cc';
+const CACHE_TTL_SECONDS = 3600; // 1 hour
+
+// ─── Version Utilities ──────────────────────────────────────────────────────
+
+/**
+ * Read installed version from ~/.claude/legion/VERSION.
+ * Falls back to package.json, then '0.0.0'.
+ *
+ * @param {string} [legionHome] - Path to ~/.claude/legion/
+ * @returns {string}
+ */
+function getInstalledVersion(legionHome) {
+  const home = legionHome || path.join(os.homedir(), '.claude', 'legion');
+
+  // Try VERSION file
+  const versionFile = path.join(home, 'VERSION');
+  try {
+    const v = fs.readFileSync(versionFile, 'utf8').trim();
+    if (v) return v;
+  } catch (_e) { /* fallthrough */ }
+
+  // Try package.json
+  const pkgFile = path.join(home, 'package.json');
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgFile, 'utf8'));
+    if (pkg.version) return pkg.version;
+  } catch (_e) { /* fallthrough */ }
+
+  return '0.0.0';
+}
+
+/**
+ * Compare two semver strings. Returns true if `latest` is newer than `current`.
+ *
+ * @param {string} current
+ * @param {string} latest
+ * @returns {boolean}
+ */
+function isNewer(current, latest) {
+  const curr = current.split('.').map(Number);
+  const next = latest.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const c = curr[i] || 0;
+    const n = next[i] || 0;
+    if (n > c) return true;
+    if (n < c) return false;
+  }
+  return false;
+}
+
+// ─── npm Registry Query ─────────────────────────────────────────────────────
+
+/**
+ * Query npm registry for the latest version of legion-cc.
+ * Uses `npm view` with a 5-second timeout.
+ *
+ * @returns {string|null} Latest version string, or null on failure
+ */
+function queryLatestVersion() {
+  try {
+    const result = spawnSync('npm', ['view', `${PACKAGE_NAME}@latest`, 'version'], {
+      timeout: 5000,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim();
+    }
+  } catch (_e) { /* silent */ }
+
+  return null;
+}
+
+// ─── Cache ──────────────────────────────────────────────────────────────────
+
+/**
+ * Get the cache file path.
+ *
+ * @param {string} [legionHome]
+ * @returns {string}
+ */
+function cachePath(legionHome) {
+  const home = legionHome || path.join(os.homedir(), '.claude', 'legion');
+  return path.join(home, '.update-cache.json');
+}
+
+/**
+ * Read cached update check result. Returns null if stale or missing.
+ *
+ * @param {string} [legionHome]
+ * @returns {object|null} { current, latest, available, checked_at }
+ */
+function readCache(legionHome) {
+  try {
+    const raw = fs.readFileSync(cachePath(legionHome), 'utf8');
+    const data = JSON.parse(raw);
+
+    const now = Math.floor(Date.now() / 1000);
+    if (data.checked_at && (now - data.checked_at) < CACHE_TTL_SECONDS) {
+      return data;
+    }
+  } catch (_e) { /* miss */ }
+
+  return null;
+}
+
+/**
+ * Write update check result to cache.
+ *
+ * @param {object} data
+ * @param {string} [legionHome]
+ */
+function writeCache(data, legionHome) {
+  try {
+    const p = cachePath(legionHome);
+    const dir = path.dirname(p);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(p, JSON.stringify(data, null, 2) + '\n', 'utf8');
+  } catch (_e) { /* silent */ }
+}
+
+// ─── Main Check ─────────────────────────────────────────────────────────────
+
+/**
+ * Check if an update is available. Uses cache to avoid frequent npm queries.
+ *
+ * @param {string} [legionHome] - Path to ~/.claude/legion/
+ * @returns {{ available: boolean, current: string, latest: string }|null}
+ */
+function checkForUpdate(legionHome) {
+  // Check cache first
+  const cached = readCache(legionHome);
+  if (cached) {
+    return {
+      available: cached.available,
+      current: cached.current,
+      latest: cached.latest,
+    };
+  }
+
+  // Query npm
+  const current = getInstalledVersion(legionHome);
+  const latest = queryLatestVersion();
+
+  if (!latest) return null;
+
+  const available = isNewer(current, latest);
+
+  const result = {
+    available,
+    current,
+    latest,
+    checked_at: Math.floor(Date.now() / 1000),
+  };
+
+  writeCache(result, legionHome);
+
+  return { available, current, latest };
+}
+
+// ─── Exports ────────────────────────────────────────────────────────────────
+
+module.exports = {
+  getInstalledVersion,
+  isNewer,
+  queryLatestVersion,
+  checkForUpdate,
+  readCache,
+  writeCache,
+  CACHE_TTL_SECONDS,
+};

package/commands/legion/devops/architect.md

@@ -1,6 +1,6 @@
 ---
 name: legion:devops:architect
-description: "Design infrastructure architecture with devops-architect agent — creates architecture documents in .planning/legion/devops/"
+description: "Design infrastructure architecture with devops-architect agent — creates architecture documents in .legion/planning/devops/"
 argument-hint: "<architecture task description>"
 allowed-tools:
   - Read