@bhargavvc/sdd-cc 1.30.1 → 1.42.3

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 ────────────────────────────────────────────────────────────────
 
@@ -177,8 +179,12 @@ const CLAUDE_MD_FALLBACKS = {
   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/`, `.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', '.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.',
   '',
@@ -281,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);
@@ -302,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) {
@@ -312,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 = [];
@@ -332,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 = [];
@@ -348,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 = [];
@@ -364,17 +372,108 @@ 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,
   };
 }
 
+/**
+ * Discover project skills from standard directories and extract frontmatter
+ * (name + description) for each. Returns a table summary for CLAUDE.md so
+ * agents know which skills are available at session startup (Layer 1 discovery).
+ */
+function generateSkillsSection(cwd) {
+  const discovered = [];
+
+  for (const dir of SKILL_SEARCH_DIRS) {
+    const absDir = path.join(cwd, dir);
+    if (!fs.existsSync(absDir)) continue;
+
+    let entries;
+    try {
+      entries = fs.readdirSync(absDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      // Skip SDD's own installed skills — only surface project-specific skills
+      if (entry.name.startsWith('sdd-')) continue;
+
+      const skillMdPath = path.join(absDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillMdPath)) continue;
+
+      const content = safeReadFile(skillMdPath);
+      if (!content) continue;
+
+      const frontmatter = extractSkillFrontmatter(content);
+      const name = frontmatter.name || entry.name;
+      const description = frontmatter.description || '';
+
+      // Avoid duplicates when same skill dir is symlinked from multiple locations
+      if (discovered.some(s => s.name === name)) continue;
+
+      discovered.push({ name, description, path: `${dir}/${entry.name}` });
+    }
+  }
+
+  if (discovered.length === 0) {
+    return { content: CLAUDE_MD_FALLBACKS.skills, source: 'skills/', hasFallback: true };
+  }
+
+  const lines = ['| Skill | Description | Path |', '|-------|-------------|------|'];
+  for (const skill of discovered) {
+    // Sanitize table cell content (escape pipes)
+    const desc = skill.description.replace(/\|/g, '\\|').replace(/\n/g, ' ').trim();
+    const safeName = skill.name.replace(/\|/g, '\\|');
+    lines.push(`| ${safeName} | ${desc} | \`${skill.path}/SKILL.md\` |`);
+  }
+
+  return { content: lines.join('\n'), source: 'skills/', hasFallback: false };
+}
+
+/**
+ * Extract name and description from YAML-like frontmatter in a SKILL.md file.
+ * Handles multi-line description values (continuation lines indented with spaces).
+ */
+function extractSkillFrontmatter(content) {
+  const result = { name: '', description: '' };
+  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!fmMatch) return result;
+
+  const fmBlock = fmMatch[1];
+  const lines = fmBlock.split('\n');
+
+  let currentKey = '';
+  for (const line of lines) {
+    // Top-level key: value
+    const kvMatch = line.match(/^(\w[\w-]*):\s*(.*)/);
+    if (kvMatch) {
+      currentKey = kvMatch[1];
+      const value = kvMatch[2].trim();
+      if (currentKey === 'name') result.name = value;
+      if (currentKey === 'description') result.description = value;
+      continue;
+    }
+    // Continuation line (indented) for multi-line values
+    if (currentKey === 'description' && /^\s+/.test(line)) {
+      result.description += ' ' + line.trim();
+    } else {
+      currentKey = '';
+    }
+  }
+
+  return result;
+}
+
 // ─── Commands ─────────────────────────────────────────────────────────────────
 
 function cmdWriteProfile(cwd, options, raw) {
@@ -387,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}`);
   }
@@ -533,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,
@@ -618,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}`);
   }
@@ -679,19 +782,38 @@ 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,
-    command_name: '/sdd:dev-preferences',
+    command_name: '/sdd-dev-preferences',
     dimensions_included: dimensionsIncluded,
     source: analysis.data_source || 'session_analysis',
   };
@@ -707,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}`);
   }
@@ -776,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);
@@ -797,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';
   }
 
@@ -815,12 +945,13 @@ function cmdGenerateClaudeProfile(cwd, options, raw) {
 }
 
 function cmdGenerateClaudeMd(cwd, options, raw) {
-  const MANAGED_SECTIONS = ['project', 'stack', 'conventions', 'architecture', 'workflow'];
+  const MANAGED_SECTIONS = ['project', 'stack', 'conventions', 'architecture', 'skills', 'workflow'];
   const generators = {
     project: generateProjectSection,
     stack: generateStackSection,
     conventions: generateConventionsSection,
     architecture: generateArchitectureSection,
+    skills: generateSkillsSection,
     workflow: generateWorkflowSection,
   };
   const sectionHeadings = {
@@ -828,6 +959,7 @@ function cmdGenerateClaudeMd(cwd, options, raw) {
     stack: '## Technology Stack',
     conventions: '## Conventions',
     architecture: '## Architecture',
+    skills: '## Project Skills',
     workflow: '## SDD Workflow Enforcement',
   };
 
@@ -846,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;
 
@@ -861,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;
@@ -877,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);
@@ -905,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);

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,
+};