@bhargavvc/sdd-cc 1.35.0 → 1.42.4

package/sdd/bin/lib/profile-output.cjs

@@ -12,7 +12,9 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { output, error, safeReadFile } = require('./core.cjs');
+const { output, error, loadConfig } = require('./core.cjs');
+const { platformReadSync: safeReadFile, platformWriteSync, platformEnsureDir } = require('./shell-command-projection.cjs');
+const { getGlobalSkillDir } = require('./runtime-homes.cjs');
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
@@ -173,23 +175,23 @@ const CLAUDE_INSTRUCTIONS = {
 };
 
 const CLAUDE_MD_FALLBACKS = {
-  project: 'Project not yet initialized. Run /sdd-new-project to set up.',
+  project: 'Project not yet initialized. Run /sdd:new-project to set up.',
   stack: 'Technology stack not yet documented. Will populate after codebase mapping or first phase.',
   conventions: 'Conventions not yet established. Will populate as patterns emerge during development.',
   architecture: 'Architecture not yet mapped. Follow existing patterns found in the codebase.',
-  skills: 'No project skills found. Add skills to any of: `.claude/skills/`, `.agents/skills/`, `.cursor/skills/`, or `.github/skills/` with a `SKILL.md` index file.',
+  skills: 'No project skills found. Add skills to any of: `.claude/skills/`, `.agents/skills/`, `.cursor/skills/`, `.github/skills/`, or `.codex/skills/` with a `SKILL.md` index file.',
 };
 
 // Directories where project skills may live (checked in order)
-const SKILL_SEARCH_DIRS = ['.claude/skills', '.agents/skills', '.cursor/skills', '.github/skills'];
+const SKILL_SEARCH_DIRS = ['.claude/skills', '.agents/skills', '.cursor/skills', '.github/skills', '.codex/skills'];
 
 const CLAUDE_MD_WORKFLOW_ENFORCEMENT = [
   'Before using Edit, Write, or other file-changing tools, start work through a SDD command so planning artifacts and execution context stay in sync.',
   '',
   'Use these entry points:',
-  '- `/sdd-quick` for small fixes, doc updates, and ad-hoc tasks',
-  '- `/sdd-debug` for investigation and bug fixing',
-  '- `/sdd-execute-phase` for planned phase work',
+  '- `/sdd:quick` for small fixes, doc updates, and ad-hoc tasks',
+  '- `/sdd:debug` for investigation and bug fixing',
+  '- `/sdd:execute-phase` for planned phase work',
   '',
   'Do not make direct repo edits outside a SDD workflow unless the user explicitly asks to bypass it.',
 ].join('\n');
@@ -198,7 +200,7 @@ const CLAUDE_MD_PROFILE_PLACEHOLDER = [
   '<!-- SDD:profile-start -->',
   '## Developer Profile',
   '',
-  '> Profile not yet configured. Run `/sdd-profile-user` to generate your developer profile.',
+  '> Profile not yet configured. Run `/sdd:profile-user` to generate your developer profile.',
   '> This section is managed by `generate-claude-profile` -- do not edit manually.',
   '<!-- SDD:profile-end -->',
 ].join('\n');
@@ -285,7 +287,7 @@ function generateProjectSection(cwd) {
   const projectPath = path.join(cwd, '.planning', 'PROJECT.md');
   const content = safeReadFile(projectPath);
   if (!content) {
-    return { content: CLAUDE_MD_FALLBACKS.project, source: 'PROJECT.md', hasFallback: true };
+    return { content: CLAUDE_MD_FALLBACKS.project, source: 'PROJECT.md', linkPath: null, hasFallback: true };
   }
   const parts = [];
   const h1Match = content.match(/^# (.+)$/m);
@@ -306,9 +308,9 @@ function generateProjectSection(cwd) {
     if (body) parts.push(`### Constraints\n\n${body}`);
   }
   if (parts.length === 0) {
-    return { content: CLAUDE_MD_FALLBACKS.project, source: 'PROJECT.md', hasFallback: true };
+    return { content: CLAUDE_MD_FALLBACKS.project, source: 'PROJECT.md', linkPath: null, hasFallback: true };
   }
-  return { content: parts.join('\n\n'), source: 'PROJECT.md', hasFallback: false };
+  return { content: parts.join('\n\n'), source: 'PROJECT.md', linkPath: '.planning/PROJECT.md', hasFallback: false };
 }
 
 function generateStackSection(cwd) {
@@ -316,12 +318,14 @@ function generateStackSection(cwd) {
   const researchPath = path.join(cwd, '.planning', 'research', 'STACK.md');
   let content = safeReadFile(codebasePath);
   let source = 'codebase/STACK.md';
+  let linkPath = '.planning/codebase/STACK.md';
   if (!content) {
     content = safeReadFile(researchPath);
     source = 'research/STACK.md';
+    linkPath = '.planning/research/STACK.md';
   }
   if (!content) {
-    return { content: CLAUDE_MD_FALLBACKS.stack, source: 'STACK.md', hasFallback: true };
+    return { content: CLAUDE_MD_FALLBACKS.stack, source: 'STACK.md', linkPath: null, hasFallback: true };
   }
   const lines = content.split('\n');
   const summaryLines = [];
@@ -336,14 +340,14 @@ function generateStackSection(cwd) {
     if (line.startsWith('- ') || line.startsWith('* ')) summaryLines.push(line);
   }
   const summary = summaryLines.length > 0 ? summaryLines.join('\n') : content.trim();
-  return { content: summary, source, hasFallback: false };
+  return { content: summary, source, linkPath, hasFallback: false };
 }
 
 function generateConventionsSection(cwd) {
   const conventionsPath = path.join(cwd, '.planning', 'codebase', 'CONVENTIONS.md');
   const content = safeReadFile(conventionsPath);
   if (!content) {
-    return { content: CLAUDE_MD_FALLBACKS.conventions, source: 'CONVENTIONS.md', hasFallback: true };
+    return { content: CLAUDE_MD_FALLBACKS.conventions, source: 'CONVENTIONS.md', linkPath: null, hasFallback: true };
   }
   const lines = content.split('\n');
   const summaryLines = [];
@@ -352,14 +356,14 @@ function generateConventionsSection(cwd) {
     if (line.startsWith('- ') || line.startsWith('* ') || line.startsWith('|')) summaryLines.push(line);
   }
   const summary = summaryLines.length > 0 ? summaryLines.join('\n') : content.trim();
-  return { content: summary, source: 'CONVENTIONS.md', hasFallback: false };
+  return { content: summary, source: 'CONVENTIONS.md', linkPath: '.planning/codebase/CONVENTIONS.md', hasFallback: false };
 }
 
 function generateArchitectureSection(cwd) {
   const architecturePath = path.join(cwd, '.planning', 'codebase', 'ARCHITECTURE.md');
   const content = safeReadFile(architecturePath);
   if (!content) {
-    return { content: CLAUDE_MD_FALLBACKS.architecture, source: 'ARCHITECTURE.md', hasFallback: true };
+    return { content: CLAUDE_MD_FALLBACKS.architecture, source: 'ARCHITECTURE.md', linkPath: null, hasFallback: true };
   }
   const lines = content.split('\n');
   const summaryLines = [];
@@ -368,13 +372,14 @@ function generateArchitectureSection(cwd) {
     if (line.startsWith('- ') || line.startsWith('* ') || line.startsWith('|') || line.startsWith('```')) summaryLines.push(line);
   }
   const summary = summaryLines.length > 0 ? summaryLines.join('\n') : content.trim();
-  return { content: summary, source: 'ARCHITECTURE.md', hasFallback: false };
+  return { content: summary, source: 'ARCHITECTURE.md', linkPath: '.planning/codebase/ARCHITECTURE.md', hasFallback: false };
 }
 
 function generateWorkflowSection() {
   return {
     content: CLAUDE_MD_WORKFLOW_ENFORCEMENT,
     source: 'SDD defaults',
+    linkPath: null,
     hasFallback: false,
   };
 }
@@ -481,8 +486,10 @@ function cmdWriteProfile(cwd, options, raw) {
   if (!fs.existsSync(analysisPath)) error(`Analysis file not found: ${analysisPath}`);
 
   let analysis;
+  const analysisRaw = safeReadFile(analysisPath);
   try {
-    analysis = JSON.parse(fs.readFileSync(analysisPath, 'utf-8'));
+    if (analysisRaw === null) throw new Error(`analysis file not found: ${analysisPath}`);
+    analysis = JSON.parse(analysisRaw);
   } catch (err) {
     error(`Failed to parse analysis JSON: ${err.message}`);
   }
@@ -627,8 +634,8 @@ function cmdWriteProfile(cwd, options, raw) {
     outputPath = path.join(cwd, outputPath);
   }
 
-  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-  fs.writeFileSync(outputPath, template, 'utf-8');
+  platformEnsureDir(path.dirname(outputPath));
+  platformWriteSync(outputPath, template);
 
   const result = {
     profile_path: outputPath,
@@ -712,8 +719,10 @@ function cmdGenerateDevPreferences(cwd, options, raw) {
   if (!fs.existsSync(analysisPath)) error(`Analysis file not found: ${analysisPath}`);
 
   let analysis;
+  const analysisRaw = safeReadFile(analysisPath);
   try {
-    analysis = JSON.parse(fs.readFileSync(analysisPath, 'utf-8'));
+    if (analysisRaw === null) throw new Error(`analysis file not found: ${analysisPath}`);
+    analysis = JSON.parse(analysisRaw);
   } catch (err) {
     error(`Failed to parse analysis JSON: ${err.message}`);
   }
@@ -765,7 +774,7 @@ function cmdGenerateDevPreferences(cwd, options, raw) {
 
   let stackBlock;
   if (analysis.data_source === 'questionnaire') {
-    stackBlock = 'Stack preferences not available (questionnaire-only profile). Run `/sdd-profile-user --refresh` with session data to populate.';
+    stackBlock = 'Stack preferences not available (questionnaire-only profile). Run `/sdd:profile-user --refresh` with session data to populate.';
   } else if (options.stack) {
     stackBlock = options.stack;
   } else {
@@ -773,15 +782,34 @@ function cmdGenerateDevPreferences(cwd, options, raw) {
   }
   template = template.replace(/\{\{stack_preferences\}\}/g, stackBlock);
 
+  // #2973: v1.39.0's skills-only migration removed the legacy
+  // commands/sdd subdirectory in favor of skills/<skill>/SKILL.md under
+  // the runtime config dir. This writer was missed in the migration
+  // (PR #1540 targeted SDD-shipped command files; dev-preferences is a
+  // runtime-generated user artifact). Default now points at the skills/
+  // location so /sdd:profile-user --refresh stops re-creating the legacy
+  // directory. The path is constructed via path.join (not a literal
+  // string) so the cline-install leaked-path lint does not flag it.
   let outputPath = options.output;
   if (!outputPath) {
-    outputPath = path.join(os.homedir(), '.claude', 'commands', 'sdd', 'dev-preferences.md');
+    let effectiveRuntime = 'claude';
+    try {
+      const config = loadConfig(cwd);
+      effectiveRuntime = process.env.SDD_RUNTIME || config.runtime || 'claude';
+    } catch {
+      effectiveRuntime = process.env.SDD_RUNTIME || 'claude';
+    }
+    const skillDir = getGlobalSkillDir(effectiveRuntime, 'sdd-dev-preferences');
+    if (!skillDir) {
+      error(`Runtime "${effectiveRuntime}" does not use a skills directory; pass --output to choose a path explicitly.`);
+    }
+    outputPath = path.join(skillDir, 'SKILL.md');
   } else if (!path.isAbsolute(outputPath)) {
     outputPath = path.join(cwd, outputPath);
   }
 
-  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-  fs.writeFileSync(outputPath, template, 'utf-8');
+  platformEnsureDir(path.dirname(outputPath));
+  platformWriteSync(outputPath, template);
 
   const result = {
     command_path: outputPath,
@@ -801,8 +829,10 @@ function cmdGenerateClaudeProfile(cwd, options, raw) {
   if (!fs.existsSync(analysisPath)) error(`Analysis file not found: ${analysisPath}`);
 
   let analysis;
+  const analysisRaw = safeReadFile(analysisPath);
   try {
-    analysis = JSON.parse(fs.readFileSync(analysisPath, 'utf-8'));
+    if (analysisRaw === null) throw new Error(`analysis file not found: ${analysisPath}`);
+    analysis = JSON.parse(analysisRaw);
   } catch (err) {
     error(`Failed to parse analysis JSON: ${err.message}`);
   }
@@ -851,7 +881,7 @@ function cmdGenerateClaudeProfile(cwd, options, raw) {
     '<!-- SDD:profile-start -->',
     '## Developer Profile',
     '',
-    `> Generated by SDD from ${dataSource}. Run \`/sdd-profile-user --refresh\` to update.`,
+    `> Generated by SDD from ${dataSource}. Run \`/sdd:profile-user --refresh\` to update.`,
     '',
     '| Dimension | Rating | Confidence |',
     '|-----------|--------|------------|',
@@ -870,13 +900,19 @@ function cmdGenerateClaudeProfile(cwd, options, raw) {
   } else if (options.output) {
     targetPath = path.isAbsolute(options.output) ? options.output : path.join(cwd, options.output);
   } else {
-    targetPath = path.join(cwd, 'CLAUDE.md');
+    // Read claude_md_path from config, default to ./CLAUDE.md
+    let configClaudeMdPath = './CLAUDE.md';
+    try {
+      const config = loadConfig(cwd);
+      if (config.claude_md_path) configClaudeMdPath = config.claude_md_path;
+    } catch { /* use default */ }
+    targetPath = path.isAbsolute(configClaudeMdPath) ? configClaudeMdPath : path.join(cwd, configClaudeMdPath);
   }
 
   let action;
 
-  if (fs.existsSync(targetPath)) {
-    let existingContent = fs.readFileSync(targetPath, 'utf-8');
+  let existingContent = safeReadFile(targetPath);
+  if (existingContent !== null) {
     const startMarker = '<!-- SDD:profile-start -->';
     const endMarker = '<!-- SDD:profile-end -->';
     const startIdx = existingContent.indexOf(startMarker);
@@ -891,10 +927,10 @@ function cmdGenerateClaudeProfile(cwd, options, raw) {
       existingContent = existingContent.trimEnd() + '\n\n' + sectionContent + '\n';
       action = 'appended';
     }
-    fs.writeFileSync(targetPath, existingContent, 'utf-8');
+    platformWriteSync(targetPath, existingContent);
   } else {
-    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-    fs.writeFileSync(targetPath, sectionContent + '\n', 'utf-8');
+    platformEnsureDir(path.dirname(targetPath));
+    platformWriteSync(targetPath, sectionContent + '\n');
     action = 'created';
   }
 
@@ -942,13 +978,42 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
     }
   }
 
+  let assemblyConfig = {};
+  let configClaudeMdPath = './CLAUDE.md';
+  try {
+    const config = loadConfig(cwd);
+    if (config.claude_md_path) configClaudeMdPath = config.claude_md_path;
+    if (config.claude_md_assembly) assemblyConfig = config.claude_md_assembly;
+    // #3163: When runtime is codex, override the output target to AGENTS.md
+    // regardless of claude_md_path, so Codex projects never write to CLAUDE.md.
+    // SDD_RUNTIME env var takes precedence over config.runtime, mirroring detectRuntime().
+    const effectiveRuntime = process.env.SDD_RUNTIME || config.runtime || null;
+    if (!options.output && effectiveRuntime === 'codex') {
+      configClaudeMdPath = './AGENTS.md';
+    }
+  } catch { /* use default */ }
+
   let outputPath = options.output;
   if (!outputPath) {
-    outputPath = path.join(cwd, 'CLAUDE.md');
+    outputPath = path.isAbsolute(configClaudeMdPath) ? configClaudeMdPath : path.join(cwd, configClaudeMdPath);
   } else if (!path.isAbsolute(outputPath)) {
     outputPath = path.join(cwd, outputPath);
   }
 
+  const globalAssemblyMode = assemblyConfig.mode || 'embed';
+  const blockModes = assemblyConfig.blocks || {};
+
+  // Return the assembled content for a section, respecting link vs embed mode.
+  // "link" mode writes `@<linkPath>` when the generator has a real source file.
+  // Falls back to "embed" for sections without a linkable source (workflow, fallbacks).
+  function buildSectionContent(name, gen, heading) {
+    const effectiveMode = blockModes[name] || globalAssemblyMode;
+    if (effectiveMode === 'link' && gen.linkPath && !gen.hasFallback) {
+      return buildSection(name, gen.source, `${heading}\n\n@${gen.linkPath}`);
+    }
+    return buildSection(name, gen.source, `${heading}\n\n${gen.content}`);
+  }
+
   let existingContent = safeReadFile(outputPath);
   let action;
 
@@ -957,15 +1022,14 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
     for (const name of MANAGED_SECTIONS) {
       const gen = generated[name];
       const heading = sectionHeadings[name];
-      const body = `${heading}\n\n${gen.content}`;
-      sections.push(buildSection(name, gen.source, body));
+      sections.push(buildSectionContent(name, gen, heading));
     }
     sections.push('');
     sections.push(CLAUDE_MD_PROFILE_PLACEHOLDER);
     existingContent = sections.join('\n\n') + '\n';
     action = 'created';
-    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-    fs.writeFileSync(outputPath, existingContent, 'utf-8');
+    platformEnsureDir(path.dirname(outputPath));
+    platformWriteSync(outputPath, existingContent);
   } else {
     action = 'updated';
     let fileContent = existingContent;
@@ -973,13 +1037,15 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
     for (const name of MANAGED_SECTIONS) {
       const gen = generated[name];
       const heading = sectionHeadings[name];
-      const body = `${heading}\n\n${gen.content}`;
-      const fullSection = buildSection(name, gen.source, body);
+      const fullSection = buildSectionContent(name, gen, heading);
       const hasMarkers = fileContent.indexOf(`<!-- SDD:${name}-start`) !== -1;
 
       if (hasMarkers) {
         if (options.auto) {
-          const expectedBody = `${heading}\n\n${gen.content}`;
+          const effectiveMode = blockModes[name] || globalAssemblyMode;
+          const expectedBody = (effectiveMode === 'link' && gen.linkPath && !gen.hasFallback)
+            ? `${heading}\n\n@${gen.linkPath}`
+            : `${heading}\n\n${gen.content}`;
           if (detectManualEdit(fileContent, name, expectedBody)) {
             sectionsSkipped.push(name);
             const genIdx = sectionsGenerated.indexOf(name);
@@ -1001,7 +1067,7 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
       fileContent = fileContent.trimEnd() + '\n\n' + CLAUDE_MD_PROFILE_PLACEHOLDER + '\n';
     }
 
-    fs.writeFileSync(outputPath, fileContent, 'utf-8');
+    platformWriteSync(outputPath, fileContent);
   }
 
   const finalContent = safeReadFile(outputPath);
@@ -1021,7 +1087,7 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
   let message = `Generated ${genCount}/${totalManaged} sections.`;
   if (sectionsFallback.length > 0) message += ` Fallback: ${sectionsFallback.join(', ')}.`;
   if (sectionsSkipped.length > 0) message += ` Skipped (manually edited): ${sectionsSkipped.join(', ')}.`;
-  if (profileStatus === 'placeholder_added') message += ' Run /sdd-profile-user to unlock Developer Profile.';
+  if (profileStatus === 'placeholder_added') message += ' Run /sdd:profile-user to unlock Developer Profile.';
 
   const result = {
     claude_md_path: outputPath,

package/sdd/bin/lib/profile-pipeline.cjs

@@ -12,7 +12,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const readline = require('readline');
-const { output, error, safeReadFile, reapStaleTempFiles } = require('./core.cjs');
+const { output, error, reapStaleTempFiles } = require('./core.cjs');
 
 // ─── Session I/O Helpers ──────────────────────────────────────────────────────
 

package/sdd/bin/lib/review-reviewer-selection.cjs

@@ -0,0 +1,125 @@
+'use strict';
+
+/**
+ * Review Reviewer Selection Module
+ *
+ * Owns reviewer-selection policy projection for /sdd:review:
+ * explicit flags > --all > review.default_reviewers > all detected.
+ */
+
+const KNOWN_REVIEWER_SLUGS = [
+  'gemini',
+  'claude',
+  'codex',
+  'coderabbit',
+  'opencode',
+  'qwen',
+  'cursor',
+  'ollama',
+  'lm_studio',
+  'llama_cpp',
+];
+
+function normalizeConfiguredDefaultReviewers(rawValue) {
+  if (rawValue === undefined || rawValue === null) {
+    return { absent: true, values: [], errors: [] };
+  }
+  if (!Array.isArray(rawValue)) {
+    return {
+      absent: false,
+      values: [],
+      errors: ['review.default_reviewers must be a JSON array of reviewer slugs'],
+    };
+  }
+  if (rawValue.length === 0) {
+    return {
+      absent: false,
+      values: [],
+      errors: ['review.default_reviewers cannot be empty'],
+    };
+  }
+
+  const seen = new Set();
+  const normalized = [];
+  const errors = [];
+  for (const item of rawValue) {
+    if (typeof item !== 'string') {
+      errors.push('review.default_reviewers must contain only string slugs');
+      continue;
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(item)) {
+      errors.push(`invalid reviewer slug in review.default_reviewers: ${item}`);
+      continue;
+    }
+    const slug = item.toLowerCase();
+    if (!seen.has(slug)) {
+      seen.add(slug);
+      normalized.push(slug);
+    }
+  }
+
+  return { absent: false, values: normalized, errors };
+}
+
+function resolveReviewerSelection(input) {
+  const detected = new Set((input.detected || []).map((v) => String(v).toLowerCase()));
+  const explicitFlags = new Set((input.explicitFlags || []).map((v) => String(v).toLowerCase()));
+  const allFlag = !!input.allFlag;
+  const normalizedDefaults = normalizeConfiguredDefaultReviewers(input.configuredDefaultReviewers);
+
+  const warnings = [];
+  const infos = [];
+  const errors = [...normalizedDefaults.errors];
+
+  let source = 'no_config_all_detected';
+  let selected = [];
+
+  if (explicitFlags.size > 0) {
+    source = 'explicit_flags';
+    selected = [...explicitFlags].filter((slug) => detected.has(slug));
+    const missing = [...explicitFlags].filter((slug) => !detected.has(slug));
+    if (missing.length > 0) {
+      infos.push(`explicit reviewers missing on host: ${missing.join(', ')}`);
+    }
+    if (selected.length === 0 && errors.length === 0) {
+      errors.push('no selected reviewers are available for explicit flags');
+    }
+  } else if (allFlag) {
+    source = 'all_flag';
+    selected = [...detected];
+  } else if (!normalizedDefaults.absent) {
+    source = 'config_default';
+    const knownDefaults = [];
+    for (const slug of normalizedDefaults.values) {
+      if (!KNOWN_REVIEWER_SLUGS.includes(slug)) {
+        warnings.push(`unknown reviewer slug in review.default_reviewers: ${slug}`);
+      } else {
+        knownDefaults.push(slug);
+      }
+    }
+    const undetected = knownDefaults.filter((slug) => !detected.has(slug));
+    if (undetected.length > 0) {
+      infos.push(`configured reviewers not detected on this host: ${undetected.join(', ')}`);
+    }
+    selected = knownDefaults.filter((slug) => detected.has(slug));
+    if (selected.length === 0 && errors.length === 0) {
+      errors.push('all configured default reviewers are unavailable on this host');
+    }
+  } else {
+    selected = [...detected];
+  }
+
+  return {
+    source,
+    selected: selected.sort(),
+    warnings,
+    infos,
+    errors,
+  };
+}
+
+module.exports = {
+  KNOWN_REVIEWER_SLUGS,
+  normalizeConfiguredDefaultReviewers,
+  resolveReviewerSelection,
+};

package/sdd/bin/lib/roadmap-command-router.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+const { ROADMAP_SUBCOMMANDS } = require('./command-aliases.generated.cjs');
+
+function routeRoadmapCommand({ roadmap, args, cwd, raw, error }) {
+  const subcommand = args[1];
+
+  if (subcommand === 'get-phase') {
+    roadmap.cmdRoadmapGetPhase(cwd, args[2], raw);
+  } else if (subcommand === 'analyze') {
+    roadmap.cmdRoadmapAnalyze(cwd, raw);
+  } else if (subcommand === 'update-plan-progress') {
+    roadmap.cmdRoadmapUpdatePlanProgress(cwd, args[2], raw);
+  } else if (subcommand === 'annotate-dependencies') {
+    roadmap.cmdRoadmapAnnotateDependencies(cwd, args[2], raw);
+  } else {
+    error(`Unknown roadmap subcommand. Available: ${ROADMAP_SUBCOMMANDS.join(', ')}`);
+  }
+}
+
+module.exports = {
+  routeRoadmapCommand,
+};