agile-context-engineering 0.1.0 → 0.2.1

package/bin/install.js

@@ -30,30 +30,18 @@ const RUNTIMES = {
     supportsLocal: true,
   },
   opencode: {
-    name: 'OpenCode',
-    description: 'OpenCode AI coding assistant',
+    name: 'Crush',
+    description: 'Crush AI coding assistant (formerly OpenCode)',
     globalDir: '.opencode',
     commandsDir: 'commands',
     agentsDir: 'agents',
     supportsLocal: true,
   },
-  gemini: {
-    name: 'Gemini CLI',
-    description: "Google's Gemini CLI",
-    globalDir: '.gemini',
-    commandsDir: 'commands',
-    agentsDir: 'agents',
-    supportsLocal: true,
-  },
-  codex: {
-    name: 'Codex CLI',
-    description: "OpenAI's Codex CLI",
-    globalDir: '.codex',
-    skillsDir: 'skills',
-    supportsLocal: false, // Codex only supports global installation
-  },
 };
 
+// The folder name installed inside the config directory (e.g. ~/.claude/agile-context-engineering/)
+const ACE_DIR_NAME = 'agile-context-engineering';
+
 function log(message, color = '') {
   console.log(`${color}${message}${colors.reset}`);
 }
@@ -76,8 +64,6 @@ function parseArgs() {
   const flags = {
     claude: args.includes('--claude'),
     opencode: args.includes('--opencode'),
-    gemini: args.includes('--gemini'),
-    codex: args.includes('--codex'),
     all: args.includes('--all'),
     global: args.includes('--global'),
     local: args.includes('--local'),
@@ -93,20 +79,18 @@ Usage: npx agile-context-engineering [options]
 
 Options:
   --claude      Install for Claude Code only
-  --opencode    Install for OpenCode only
-  --gemini      Install for Gemini CLI only
-  --codex       Install for Codex CLI only (global only)
+  --opencode    Install for Crush (formerly OpenCode)
   --all         Install for all supported runtimes
-  --global      Install globally (~/.claude, ~/.gemini, etc.)
-  --local       Install locally (.claude, .opencode, etc.)
+  --global      Install globally (~/.claude, ~/.opencode)
+  --local       Install locally (.claude, .opencode)
   -h, --help    Show this help message
   -v, --version Show version number
 
 Examples:
   npx agile-context-engineering                    # Interactive installation
   npx agile-context-engineering --claude --local   # Claude Code, local install
+  npx agile-context-engineering --opencode --global # Crush (formerly OpenCode), global install
   npx agile-context-engineering --all --global     # All runtimes, global install
-  npx agile-context-engineering --codex            # Codex CLI (always global)
 `);
 }
 
@@ -148,7 +132,7 @@ async function askMultiple(rl, question, options) {
         log(`     ${opt.description}`, colors.dim);
       }
     });
-    log(`\n  Enter numbers separated by commas (e.g., 1,2,3) or 'all'`, colors.dim);
+    log(`\n  Enter numbers separated by commas (e.g., 1,2) or 'all'`, colors.dim);
     rl.question(`\n${colors.yellow}Your choice: ${colors.reset}`, (answer) => {
       if (answer.toLowerCase() === 'all') {
         resolve(options.map(o => o.value));
@@ -174,18 +158,24 @@ function getBasePath(runtime, scope) {
   const cwd = process.cwd();
   const config = RUNTIMES[runtime];
 
-  if (scope === 'local' && !config.supportsLocal) {
-    // Fallback to global for runtimes that don't support local
-    return path.join(home, config.globalDir);
-  }
-
   return scope === 'global'
     ? path.join(home, config.globalDir)
     : path.join(cwd, config.globalDir);
 }
 
-// Copy directory recursively
-function copyDir(src, dest) {
+// File extensions that contain path references needing runtime transformation
+const TRANSFORMABLE_EXTENSIONS = new Set(['.md', '.xml']);
+
+// Transform file content for a target runtime (replaces .claude/ paths with target runtime paths)
+function transformForRuntime(content, runtime) {
+  if (runtime === 'claude') return content; // Source files already use .claude paths
+  const targetDir = RUNTIMES[runtime].globalDir; // e.g. '.opencode'
+  // Replace path references: ~/.claude/ → ~/.opencode/, .claude/settings → .opencode/settings, etc.
+  return content.replace(/\.claude\//g, `${targetDir}/`);
+}
+
+// Copy directory recursively, optionally transforming text file content for the target runtime
+function copyDir(src, dest, runtime) {
   if (!fs.existsSync(dest)) {
     fs.mkdirSync(dest, { recursive: true });
   }
@@ -197,148 +187,100 @@ function copyDir(src, dest) {
     const destPath = path.join(dest, entry.name);
 
     if (entry.isDirectory()) {
-      copyDir(srcPath, destPath);
+      copyDir(srcPath, destPath, runtime);
     } else {
-      fs.copyFileSync(srcPath, destPath);
+      const ext = path.extname(entry.name).toLowerCase();
+      if (runtime !== 'claude' && TRANSFORMABLE_EXTENSIONS.has(ext)) {
+        // Transform path references for non-Claude runtimes
+        const content = fs.readFileSync(srcPath, 'utf-8');
+        fs.writeFileSync(destPath, transformForRuntime(content, runtime), 'utf-8');
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
     }
   }
 }
 
-// Install for Claude Code, OpenCode, or Gemini (similar structure)
-function installStandard(runtime, scope, packageDir) {
+// Install ACE for a runtime (Claude Code or Crush)
+function installForRuntime(runtime, scope, packageDir) {
   const config = RUNTIMES[runtime];
   const basePath = getBasePath(runtime, scope);
   const commandsPath = path.join(basePath, config.commandsDir);
   const agentsPath = path.join(basePath, config.agentsDir);
+  const acePath = path.join(basePath, ACE_DIR_NAME);
 
   // Source directories
   const srcCommands = path.join(packageDir, 'commands');
   const srcAgents = path.join(packageDir, 'agents');
+  const srcTemplates = path.join(packageDir, 'agile-context-engineering', 'templates');
+  const srcUtils = path.join(packageDir, 'agile-context-engineering', 'utils');
+  const srcWorkflows = path.join(packageDir, 'agile-context-engineering', 'workflows');
+  const srcTools = path.join(packageDir, 'agile-context-engineering', 'src');
 
   log(`\nInstalling ACE for ${config.name}...`, colors.cyan);
   log(`  Target: ${basePath}`, colors.dim);
 
+  // Clean previous ACE installation to remove stale files from renamed/deleted commands
+  const aceCommandsPath = path.join(commandsPath, 'ace');
+  if (fs.existsSync(aceCommandsPath)) {
+    fs.rmSync(aceCommandsPath, { recursive: true });
+  }
+  if (fs.existsSync(agentsPath)) {
+    // Only remove ace-* agent files, preserve non-ACE agents
+    for (const f of fs.readdirSync(agentsPath)) {
+      if (f.startsWith('ace-')) {
+        fs.rmSync(path.join(agentsPath, f), { recursive: true });
+      }
+    }
+  }
+  if (fs.existsSync(acePath)) {
+    fs.rmSync(acePath, { recursive: true });
+  }
+
   // Create directories
   fs.mkdirSync(commandsPath, { recursive: true });
   fs.mkdirSync(agentsPath, { recursive: true });
+  fs.mkdirSync(acePath, { recursive: true });
 
-  // Copy commands
+  // Copy commands (transform paths for target runtime)
   if (fs.existsSync(srcCommands)) {
-    copyDir(srcCommands, commandsPath);
+    copyDir(srcCommands, commandsPath, runtime);
     log(`  ✓ Commands installed`, colors.green);
   }
 
-  // Copy agents
+  // Copy agents (transform paths for target runtime)
   if (fs.existsSync(srcAgents)) {
-    copyDir(srcAgents, agentsPath);
+    copyDir(srcAgents, agentsPath, runtime);
     log(`  ✓ Agents installed`, colors.green);
   }
 
-  return basePath;
-}
-
-// Install for Codex CLI (different structure - uses skills with SKILL.md)
-function installCodex(packageDir) {
-  const config = RUNTIMES.codex;
-  const home = os.homedir();
-  const basePath = path.join(home, config.globalDir);
-  const skillsPath = path.join(basePath, config.skillsDir, 'ace');
-
-  // Source directories
-  const srcCommands = path.join(packageDir, 'commands');
-  const srcAgents = path.join(packageDir, 'agents');
-
-  log(`\nInstalling ACE for ${config.name}...`, colors.cyan);
-  log(`  Target: ${skillsPath}`, colors.dim);
-
-  // Create ace skill directory
-  fs.mkdirSync(skillsPath, { recursive: true });
+  // Copy templates into agile-context-engineering/
+  if (fs.existsSync(srcTemplates)) {
+    copyDir(srcTemplates, path.join(acePath, 'templates'), runtime);
+    log(`  ✓ Templates installed`, colors.green);
+  }
 
-  // For Codex, we need to create a combined SKILL.md file
-  // or individual skill directories for each command
+  // Copy utils into agile-context-engineering/
+  if (fs.existsSync(srcUtils)) {
+    copyDir(srcUtils, path.join(acePath, 'utils'), runtime);
+    log(`  ✓ Utils installed`, colors.green);
+  }
 
-  // Create main ACE skill file
-  const skillContent = generateCodexSkill(srcCommands, srcAgents);
-  fs.writeFileSync(path.join(skillsPath, 'SKILL.md'), skillContent);
-  log(`  ✓ Main skill installed`, colors.green);
+  // Copy workflows into agile-context-engineering/
+  if (fs.existsSync(srcWorkflows)) {
+    copyDir(srcWorkflows, path.join(acePath, 'workflows'), runtime);
+    log(`  ✓ Workflows installed`, colors.green);
+  }
 
-  // Create individual command skills
-  if (fs.existsSync(srcCommands)) {
-    const commands = fs.readdirSync(srcCommands).filter(f => f.endsWith('.md'));
-    for (const cmd of commands) {
-      const cmdName = cmd.replace('.md', '').replace('ace-', '');
-      const cmdSkillPath = path.join(basePath, config.skillsDir, `ace-${cmdName}`);
-      fs.mkdirSync(cmdSkillPath, { recursive: true });
-      fs.copyFileSync(
-        path.join(srcCommands, cmd),
-        path.join(cmdSkillPath, 'SKILL.md')
-      );
-    }
-    log(`  ✓ Command skills installed`, colors.green);
+  // Copy src (ace-tools) into agile-context-engineering/
+  if (fs.existsSync(srcTools)) {
+    copyDir(srcTools, path.join(acePath, 'src'), runtime);
+    log(`  ✓ Tools installed`, colors.green);
   }
 
   return basePath;
 }
 
-// Generate a combined skill file for Codex
-function generateCodexSkill(srcCommands, srcAgents) {
-  let content = `# ACE - Agile Context Engineering
-
-A spec-driven development system with Agile workflows.
-
-## Description
-
-ACE (Agile Context Engineering) helps you plan and execute projects using Agile methodology with epics, features, stories, and tasks.
-
-## Commands
-
-The following ACE commands are available:
-
-- \`/ace:init\` - Initialize ACE in your project
-- \`/ace:plan-project\` - Plan your project with epics and features
-- \`/ace:plan-epic\` - Break an epic into features
-- \`/ace:plan-feature\` - Break a feature into stories
-- \`/ace:plan-story\` - Create a new user story
-- \`/ace:refine-story\` - Prepare a story for execution
-- \`/ace:execute-story\` - Execute a story with atomic commits
-- \`/ace:verify-story\` - Verify a completed story
-
-## Workflow
-
-\`\`\`
-Epic → Feature → Story → Tasks
-  ↓       ↓        ↓       ↓
-Plan → Refine → Execute → Verify
-\`\`\`
-
-## Agile Hierarchy
-
-- **Epic**: Large body of work (1-3 months)
-- **Feature**: Deliverable functionality (1-2 sprints)
-- **Story**: User-facing work item (1-3 days)
-- **Task**: Atomic implementation step (30 min - 2 hours)
-
-## Getting Started
-
-1. Run \`/ace:init\` to initialize ACE in your project
-2. Run \`/ace:plan-project\` to start planning
-3. Break down work: epic → feature → story
-4. Execute and verify stories
-
-Each command has its own skill file with detailed instructions.
-`;
-
-  return content;
-}
-
-// Install commands and agents for a specific runtime
-function installForRuntime(runtime, scope, packageDir) {
-  if (runtime === 'codex') {
-    return installCodex(packageDir);
-  }
-  return installStandard(runtime, scope, packageDir);
-}
-
 // Main installation logic
 async function main() {
   const flags = parseArgs();
@@ -363,7 +305,7 @@ async function main() {
   let scope = null;
 
   // Check if non-interactive mode
-  const hasRuntimeFlag = flags.claude || flags.opencode || flags.gemini || flags.codex || flags.all;
+  const hasRuntimeFlag = flags.claude || flags.opencode || flags.all;
   const hasScopeFlag = flags.global || flags.local;
   const isInteractive = !hasRuntimeFlag && !hasScopeFlag;
 
@@ -373,44 +315,27 @@ async function main() {
     // Ask for runtime selection (multiple choice)
     runtimes = await askMultiple(rl, '\nWhich runtime(s) do you want to install ACE for?', [
       { label: 'Claude Code', value: 'claude', description: "Anthropic's Claude Code CLI" },
-      { label: 'OpenCode', value: 'opencode', description: 'OpenCode AI coding assistant' },
-      { label: 'Gemini CLI', value: 'gemini', description: "Google's Gemini CLI" },
-      { label: 'Codex CLI', value: 'codex', description: "OpenAI's Codex CLI (global only)" },
+      { label: 'Crush', value: 'opencode', description: 'Crush AI coding assistant (formerly OpenCode)' },
     ]);
 
-    // Check if any selected runtime doesn't support local
-    const hasGlobalOnly = runtimes.some(r => !RUNTIMES[r].supportsLocal);
-
-    if (hasGlobalOnly && runtimes.length === 1 && runtimes[0] === 'codex') {
-      // Only Codex selected, skip scope question
-      scope = 'global';
-      log(`\nNote: Codex CLI only supports global installation.`, colors.yellow);
-    } else {
-      // Ask for scope
-      scope = await ask(rl, '\nWhere should ACE be installed?', [
-        { label: 'Global', value: 'global', description: 'Install in home directory (~/.claude, ~/.gemini, etc.)' },
-        { label: 'Local', value: 'local', description: 'Install in current project (.claude, .opencode, etc.)' },
-      ]);
-
-      if (scope === 'local' && hasGlobalOnly) {
-        log(`\nNote: Codex CLI will be installed globally (doesn't support local).`, colors.yellow);
-      }
-    }
+    // Ask for scope
+    scope = await ask(rl, '\nWhere should ACE be installed?', [
+      { label: 'Global', value: 'global', description: 'Install in home directory (~/.claude, ~/.opencode)' },
+      { label: 'Local', value: 'local', description: 'Install in current project (.claude, .opencode)' },
+    ]);
 
     rl.close();
   } else {
     // Non-interactive mode
     if (flags.all) {
-      runtimes = ['claude', 'opencode', 'gemini', 'codex'];
+      runtimes = ['claude', 'opencode'];
     } else {
       if (flags.claude) runtimes.push('claude');
       if (flags.opencode) runtimes.push('opencode');
-      if (flags.gemini) runtimes.push('gemini');
-      if (flags.codex) runtimes.push('codex');
     }
 
     if (runtimes.length === 0) {
-      log('Error: No runtime specified. Use --claude, --opencode, --gemini, --codex, or --all', colors.red);
+      log('Error: No runtime specified. Use --claude, --opencode (Crush), or --all', colors.red);
       process.exit(1);
     }
 
@@ -440,8 +365,19 @@ async function main() {
     log(`  ${name}: ${p}`, colors.dim);
   }
 
+  log(`\nInstalled structure:`, colors.cyan);
+  for (const { name, path: p } of installedPaths) {
+    log(`  ${p}/`, colors.dim);
+    log(`    commands/ace/       Slash commands`, colors.dim);
+    log(`    agents/             Agent definitions`, colors.dim);
+    log(`    ${ACE_DIR_NAME}/`, colors.dim);
+    log(`      templates/        Project & artifact templates`, colors.dim);
+    log(`      utils/            Formatting & utility guides`, colors.dim);
+    log(`      workflows/        Workflow definitions`, colors.dim);
+  }
+
   log(`\nAvailable commands:`, colors.cyan);
-  log(`  /ace:init          Initialize ACE in your project`, colors.dim);
+  log(`  /ace:help          Check project status and next steps`, colors.dim);
   log(`  /ace:plan-project  Plan your project with epics and features`, colors.dim);
   log(`  /ace:plan-epic     Plan an epic with features and stories`, colors.dim);
   log(`  /ace:plan-feature  Plan a feature with stories`, colors.dim);
@@ -452,7 +388,7 @@ async function main() {
 
   log(`\nGet started:`, colors.cyan);
   log(`  1. Navigate to your project directory`, colors.dim);
-  log(`  2. Run /ace:init to initialize ACE`, colors.dim);
+  log(`  2. Run /ace:help to initialize ACE`, colors.dim);
   log(`  3. Run /ace:plan-project to start planning\n`, colors.dim);
 }
 

package/commands/ace/execute-story.md

@@ -0,0 +1,137 @@
+---
+name: ace:execute-story
+description: Execute a fully-planned story — loads AC + Technical Solution, creates execution plan via Plan Mode, implements (solo or agent teams), runs code review, updates state, and triggers wiki mapping
+argument-hint: "story=<file-path|github-url> [--agent-teams-off]"
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - Edit
+  - AskUserQuestion
+  - Glob
+  - Grep
+  - Agent
+  - EnterPlanMode
+  - ExitPlanMode
+---
+
+```xml
+<command>
+
+    <execution-time>
+        <runs-after>
+            <trigger>After /ace:plan-story — once a story has AC + Technical Solution</trigger>
+            <trigger>Anytime — to execute a fully-planned story specification</trigger>
+        </runs-after>
+        <use-when>
+            <condition>A story has both Acceptance Criteria AND Technical Solution sections</condition>
+            <condition>Story status is "Refined" (ready for implementation)</condition>
+        </use-when>
+    </execution-time>
+
+    <input>
+        <flags>
+            <flag name="--agent-teams-off">
+                Force solo execution mode regardless of agent_teams setting.
+                Overrides the agent_teams flag in settings.json.
+                Use when you want single-context execution even if teams are enabled.
+            </flag>
+        </flags>
+
+        <parameters>
+            <required>
+                <param name="story" type="file | github-url">
+                    Story source — can be either:
+                    - **File path**: Path to a fully-planned story markdown file
+                      (must have AC + Technical Solution sections)
+                    - **GitHub URL or issue number**: GitHub story reference
+                    Must be a valid, accessible file or GitHub issue.
+                    The story MUST have been through /ace:plan-story (has AC + Technical Solution).
+                </param>
+            </required>
+        </parameters>
+    </input>
+
+    <execution-context>
+        <execute-story-workflow>@~/.claude/agile-context-engineering/workflows/execute-story.xml</execute-story-workflow>
+        <story-template>@~/.claude/agile-context-engineering/templates/product/story.xml</story-template>
+        <questioning>@~/.claude/agile-context-engineering/utils/questioning.xml</questioning>
+        <ui-formatting>@~/.claude/agile-context-engineering/utils/ui-formatting.md</ui-formatting>
+    </execution-context>
+
+    <output>
+        <objective>
+            Take a fully-planned story (with AC + Technical Solution) and:
+            1. Create an execution plan via Claude Code Plan Mode
+            2. Execute the plan — solo or with Agent Teams
+            3. Run code review (3-level verification, anti-pattern detection, coding standards)
+            4. Present results to user for verification/approval
+            5. Commit implementation (single commit after approval)
+            6. Update state: story file, feature file, product backlog, GitHub
+            7. Trigger wiki mapping (background) with tech debt integration
+
+            Two execution modes:
+            - **Solo Mode** (default or --agent-teams-off): Single context, plan mode → execute
+            - **Agent Teams Mode** (when enabled + plan recommends): Lead + teammates for parallel work
+        </objective>
+
+        <artifacts>
+            Story file updated with Summary &amp; State section and Wiki Updates section.
+            Feature file updated with story status.
+            Product backlog updated with story (and possibly feature) status.
+            Wiki documents updated/created based on implementation changes.
+        </artifacts>
+    </output>
+
+    <process>
+        **STRICT WORKFLOW EXECUTION — Follow the execute-story workflow STEP BY STEP.
+        Do NOT skip steps. Do NOT improvise. Do NOT start reading code or planning
+        until step 1 (init &amp; validate) is fully complete with the init command output parsed.**
+
+        Execute the execute-story workflow from
+        `@~/.claude/agile-context-engineering/workflows/execute-story.xml` end-to-end.
+
+        **MANDATORY FIRST ACTION: Run the init command (step 1.2) BEFORE doing anything else.
+        Do NOT read the story file manually. Do NOT explore the codebase. Do NOT start planning.
+        The init command validates the story and provides all paths and context needed.**
+
+        **CRITICAL REQUIREMENTS:**
+        - Story MUST have Acceptance Criteria — STOP if missing
+        - Story MUST have Technical Solution — STOP if missing
+        - NO intermediary commits during implementation
+        - ONE single commit per story after user approval (code + state + docs)
+        - Code review is MANDATORY — blockers must be fixed before approval
+        - Coding standards violations are BLOCKERS, not warnings
+        - Dead code and backwards-compatible shims must be DELETED
+    </process>
+
+    <example-usage>
+        ```
+        # Execute a story from a file path
+        /ace:execute-story \
+          story=.ace/artifacts/product/e1-auth/f3-oauth/s1-buttons/s1-buttons.md
+
+        # Execute from a GitHub issue
+        /ace:execute-story \
+          story=https://github.com/owner/repo/issues/95
+
+        # Force solo mode (no agent teams)
+        /ace:execute-story \
+          story=.ace/artifacts/product/e1-auth/f3-oauth/s1-buttons/s1-buttons.md \
+          --agent-teams-off
+
+        # With just an issue number
+        /ace:execute-story story=#95
+        ```
+    </example-usage>
+
+    <next-steps>
+        **After this command:**
+        - `/ace:execute-story story=...` — Execute the next story in the feature
+        - `/ace:review-story story=...` — Re-run code review (standalone)
+        - `/ace:plan-story story=...` — Plan the next story
+        - `/ace:help` — Check project status
+    </next-steps>
+
+</command>
+```

package/commands/ace/help.md

@@ -0,0 +1,93 @@
+---
+name: ace:help
+description: Check project initialization status and suggest next steps
+argument-hint: ""
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - AskUserQuestion
+---
+
+```xml
+<command>
+
+    <execution-time>
+        <runs-after>
+            <trigger>At any time — to check which ACE documents exist and what to do next</trigger>
+            <trigger>At the start of a new project — to see the initialization checklist</trigger>
+        </runs-after>
+        <use-when>
+            <condition>Starting a new project and want to see what needs to be set up</condition>
+            <condition>Returning to a project and want to check initialization status</condition>
+            <condition>Unsure which ACE command to run next</condition>
+        </use-when>
+    </execution-time>
+
+    <input>
+        <flags>
+        </flags>
+
+        <parameters>
+            <required>
+            </required>
+
+            <optional>
+            </optional>
+        </parameters>
+    </input>
+
+    <execution-context>
+        <help-workflow>@~/.claude/agile-context-engineering/workflows/help.xml</help-workflow>
+        <questioning>@~/.claude/agile-context-engineering/utils/questioning.xml</questioning>
+        <ui-formatting>@~/.claude/agile-context-engineering/utils/ui-formatting.md</ui-formatting>
+    </execution-context>
+
+    <output>
+        <objective>
+            Detect which ACE documents exist (product vision, system architecture, system structure,
+            coding standards, testing framework). Display a status dashboard showing what's done
+            and what's missing. Suggest the next command to run based on gaps.
+        </objective>
+
+        <artifacts>
+            - .ace/settings.json (created on first run if missing)
+        </artifacts>
+    </output>
+
+    <process>
+        Execute the help workflow from
+        `@~/.claude/agile-context-engineering/workflows/help.xml` end-to-end.
+        This is a lightweight state-check and routing workflow.
+
+        CRITICAL MANDATORY STEP — DO NOT SKIP:
+        Before displaying the status dashboard, you MUST run:
+        ```bash
+        node ~/.claude/agile-context-engineering/src/ace-tools.js sync-agent-teams --raw
+        ```
+        Then you MUST use `AskUserQuestion` to ask the user whether they want to
+        enable or disable Claude Code Agent Teams (experimental feature).
+        This step is NOT optional. You MUST present this question every time.
+
+        When the user chooses to enable or disable Agent Teams, you MUST run the
+        bash command — NEVER directly edit .ace/settings.json or .claude/settings.json:
+        ```bash
+        node ~/.claude/agile-context-engineering/src/ace-tools.js write-agent-teams true
+        ```
+        or
+        ```bash
+        node ~/.claude/agile-context-engineering/src/ace-tools.js write-agent-teams false
+        ```
+        The write-agent-teams command updates BOTH .ace/settings.json AND .claude/settings.json.
+        Direct file edits will cause the two files to go out of sync.
+    </process>
+
+    <next-steps>
+        **Specialized commands for each document:**
+        - `/ace:plan-product-vision` — Create or update the product vision
+        - `/ace:map-system` — Map codebase structure, architecture, and testing framework
+        - `/ace:init-coding-standards` — Generate tailored coding standards
+    </next-steps>
+
+</command>
+```