@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/bin/lib/init.cjs

@@ -0,0 +1,1114 @@
+/**
+ * Init — Compound init commands for workflow bootstrapping
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { loadConfig, resolveModelInternal, findPhaseInternal, getRoadmapPhaseInternal, pathExistsInternal, generateSlugInternal, getMilestoneInfo, normalizePhaseName, toPosixPath, output, error, resolveProjectPath, getProjectRoot, isV2Install, getProjectFolders, getV2Hint } = require('./core.cjs');
+const { requireGitIdentity, formatAuthorString } = require('./identity.cjs');
+const { getPlanningRoot, PROJECTS_DIR } = require('./paths.cjs');
+const { parseReposMd, validateReposMdEager } = require('./repos.cjs');
+
+/**
+ * Safely resolve the current git author string.
+ * Returns null on failure instead of throwing, since init commands
+ * should not hard-fail on identity resolution.
+ */
+function resolveAuthorSafe(cwd) {
+  try {
+    const identity = requireGitIdentity(cwd);
+    return formatAuthorString(identity);
+  } catch {
+    return null;
+  }
+}
+
+// ─── v2 Project Context Resolution ──────────────────────────────────────────
+
+/**
+ * Resolve the project root, handling the NO_CURRENT_PROJECT_V2 guard.
+ * Returns { root, dgs_mode, current_project, guard, v2_hint } where:
+ * - root: the resolved project root path (null if guard triggered)
+ * - dgs_mode: 'v1' or 'v2'
+ * - current_project: string or null
+ * - guard: null (ok) | { action, message, projects? } (needs user action)
+ * - v2_hint: string or null (one-time v2 availability hint for v1 users)
+ */
+function resolveProjectContext(cwd) {
+  const config = loadConfig(cwd);
+  const v2 = isV2Install(cwd);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  try {
+    const root = getProjectRoot(cwd);
+    return {
+      root,
+      dgs_mode: v2 ? 'v2' : 'v1',
+      current_project: config.current_project || null,
+      guard: null,
+      v2_hint: !v2 ? getV2Hint(cwd, config) : null,
+    };
+  } catch (err) {
+    if (err.message === 'NO_CURRENT_PROJECT_V2') {
+      const folders = getProjectFolders(cwd);
+      if (folders.length === 0) {
+        return {
+          root: null,
+          dgs_mode: 'v2',
+          current_project: null,
+          guard: {
+            action: 'create',
+            message: 'No projects found. Run /dgs:new-project to create one.',
+          },
+          v2_hint: null,
+        };
+      }
+      if (folders.length === 1) {
+        const project = folders[0];
+        return {
+          root: path.join(planRootRel, PROJECTS_DIR, project),
+          dgs_mode: 'v2',
+          current_project: project,
+          guard: {
+            action: 'auto_selected',
+            project,
+            message: `Auto-selected project '${project}'`,
+          },
+          v2_hint: null,
+        };
+      }
+      const numbered = folders.map((f, i) => `${i + 1}) ${f}`).join('  ');
+      return {
+        root: null,
+        dgs_mode: 'v2',
+        current_project: null,
+        guard: {
+          action: 'prompt',
+          projects: folders,
+          message: `Multiple projects found. Select one:\n${numbered}`,
+        },
+        v2_hint: null,
+      };
+    }
+    if (err.message.startsWith('PROJECT_NOT_FOUND:')) {
+      const projectName = err.message.split(': ')[1];
+      return {
+        root: null,
+        dgs_mode: 'v2',
+        current_project: projectName,
+        guard: {
+          action: 'project_missing',
+          message: `Project '${projectName}' not found on disk. Run /dgs:switch-project to select a valid project.`,
+        },
+        v2_hint: null,
+      };
+    }
+    if (err.message.startsWith('PROJECT_COMPLETED:')) {
+      const projectName = err.message.split(': ')[1];
+      return {
+        root: null,
+        dgs_mode: 'v2',
+        current_project: projectName,
+        guard: {
+          action: 'project_completed',
+          message: `Project '${projectName}' is completed. Run /dgs:switch-project to select an active project.`,
+        },
+        v2_hint: null,
+      };
+    }
+    throw err;
+  }
+}
+
+function cmdInitExecutePhase(cwd, phase, raw) {
+  if (!phase) {
+    error('phase required for init execute-phase');
+  }
+
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const phaseInfo = findPhaseInternal(cwd, phase);
+  const milestone = getMilestoneInfo(cwd);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  const roadmapPhase = getRoadmapPhaseInternal(cwd, phase);
+  const reqMatch = roadmapPhase?.section?.match(/^\*\*Requirements\*\*:[^\S\n]*([^\n]*)$/m);
+  const reqExtracted = reqMatch
+    ? reqMatch[1].replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(Boolean).join(', ')
+    : null;
+  const phase_req_ids = (reqExtracted && reqExtracted !== 'TBD') ? reqExtracted : null;
+
+  // Resolve {project} in a branch template — errors if template uses {project} but current_project is not set
+  function resolveProjectInTemplate(template, currentProject) {
+    if (template.includes('{project}')) {
+      if (!currentProject) {
+        return { error: 'current_project not set. Run /dgs:settings to configure.' };
+      }
+      return { value: template.replace('{project}', currentProject) };
+    }
+    return { value: template };
+  }
+
+  const result = {
+    // Models
+    executor_model: resolveModelInternal(cwd, 'dgs-executor'),
+    verifier_model: resolveModelInternal(cwd, 'dgs-verifier'),
+
+    // Config flags
+    commit_docs: config.commit_docs,
+    parallelization: config.parallelization,
+    branching_strategy: config.branching_strategy,
+    phase_branch_template: config.phase_branch_template,
+    milestone_branch_template: config.milestone_branch_template,
+    verifier_enabled: config.verifier,
+    base_branch: config.base_branch,
+
+    // Phase info
+    phase_found: !!phaseInfo,
+    phase_dir: phaseInfo?.directory || null,
+    phase_number: phaseInfo?.phase_number || null,
+    phase_name: phaseInfo?.phase_name || null,
+    phase_slug: phaseInfo?.phase_slug || null,
+    phase_req_ids,
+
+    // Plan inventory
+    plans: phaseInfo?.plans || [],
+    summaries: phaseInfo?.summaries || [],
+    incomplete_plans: phaseInfo?.incomplete_plans || [],
+    plan_count: phaseInfo?.plans?.length || 0,
+    incomplete_count: phaseInfo?.incomplete_plans?.length || 0,
+
+    // Branch name (pre-computed with {project} resolution)
+    branch_name: (() => {
+      let template, resolved;
+      if (config.branching_strategy === 'phase' && phaseInfo) {
+        template = config.phase_branch_template;
+        resolved = resolveProjectInTemplate(template, ctx.current_project);
+        if (resolved.error) return resolved.error;
+        return resolved.value
+          .replace('{phase}', phaseInfo.phase_number)
+          .replace('{slug}', phaseInfo.phase_slug || 'phase');
+      } else if (config.branching_strategy === 'milestone') {
+        template = config.milestone_branch_template;
+        resolved = resolveProjectInTemplate(template, ctx.current_project);
+        if (resolved.error) return resolved.error;
+        return resolved.value
+          .replace('{milestone}', milestone.version)
+          .replace('{slug}', generateSlugInternal(milestone.name) || 'milestone');
+      }
+      return null;
+    })(),
+
+    // Milestone info
+    milestone_version: milestone.version,
+    milestone_name: milestone.name,
+    milestone_slug: generateSlugInternal(milestone.name),
+
+    // File existence
+    state_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'STATE.md')) : false,
+    roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : false,
+    config_exists: pathExistsInternal(cwd, path.join(planRootRel, 'dgs.config.json')),
+    // File paths (project-qualified)
+    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+    roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
+    config_path: path.join(planRootRel, 'dgs.config.json'),
+    project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
+    debug_dir: ctx.root ? path.join(ctx.root, 'debug') : path.join(planRootRel, 'debug'),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitPlanPhase(cwd, phase, raw) {
+  if (!phase) {
+    error('phase required for init plan-phase');
+  }
+
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const phaseInfo = findPhaseInternal(cwd, phase);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  const roadmapPhase = getRoadmapPhaseInternal(cwd, phase);
+  const reqMatch = roadmapPhase?.section?.match(/^\*\*Requirements\*\*:[^\S\n]*([^\n]*)$/m);
+  const reqExtracted = reqMatch
+    ? reqMatch[1].replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(Boolean).join(', ')
+    : null;
+  const phase_req_ids = (reqExtracted && reqExtracted !== 'TBD') ? reqExtracted : null;
+
+  const result = {
+    // Models
+    researcher_model: resolveModelInternal(cwd, 'dgs-phase-researcher'),
+    planner_model: resolveModelInternal(cwd, 'dgs-planner'),
+    checker_model: resolveModelInternal(cwd, 'dgs-plan-checker'),
+
+    // Workflow flags
+    research_enabled: config.research,
+    plan_checker_enabled: config.plan_checker,
+    nyquist_validation_enabled: config.nyquist_validation,
+    commit_docs: config.commit_docs,
+
+    // Phase info
+    phase_found: !!phaseInfo,
+    phase_dir: phaseInfo?.directory || null,
+    phase_number: phaseInfo?.phase_number || null,
+    phase_name: phaseInfo?.phase_name || null,
+    phase_slug: phaseInfo?.phase_slug || null,
+    padded_phase: phaseInfo?.phase_number?.padStart(2, '0') || null,
+    phase_req_ids,
+
+    // Existing artifacts
+    has_research: phaseInfo?.has_research || false,
+    has_context: phaseInfo?.has_context || false,
+    has_plans: (phaseInfo?.plans?.length || 0) > 0,
+    plan_count: phaseInfo?.plans?.length || 0,
+
+    // Environment
+    planning_exists: pathExistsInternal(cwd, planRootRel),
+    roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'ROADMAP.md')),
+
+    // File paths (project-qualified)
+    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+    roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
+    requirements_path: ctx.root ? path.join(ctx.root, 'REQUIREMENTS.md') : path.join(planRootRel, 'REQUIREMENTS.md'),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  if (phaseInfo?.directory) {
+    // Find *-CONTEXT.md in phase directory
+    const phaseDirFull = path.join(cwd, phaseInfo.directory);
+    try {
+      const files = fs.readdirSync(phaseDirFull);
+      const contextFile = files.find(f => f.endsWith('-CONTEXT.md') || f === 'CONTEXT.md');
+      if (contextFile) {
+        result.context_path = toPosixPath(path.join(phaseInfo.directory, contextFile));
+      }
+      const researchFile = files.find(f => f.endsWith('-RESEARCH.md') || f === 'RESEARCH.md');
+      if (researchFile) {
+        result.research_path = toPosixPath(path.join(phaseInfo.directory, researchFile));
+      }
+      const verificationFile = files.find(f => f.endsWith('-VERIFICATION.md') || f === 'VERIFICATION.md');
+      if (verificationFile) {
+        result.verification_path = toPosixPath(path.join(phaseInfo.directory, verificationFile));
+      }
+      const uatFile = files.find(f => f.endsWith('-UAT.md') || f === 'UAT.md');
+      if (uatFile) {
+        result.uat_path = toPosixPath(path.join(phaseInfo.directory, uatFile));
+      }
+    } catch {}
+  }
+
+  output(result, raw);
+}
+
+function cmdInitNewProject(cwd, raw) {
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  // Detect Brave Search API key availability
+  const homedir = require('os').homedir();
+  const braveKeyFile = path.join(homedir, '.dgs', 'brave_api_key');
+  const hasBraveSearch = !!(process.env.BRAVE_API_KEY || fs.existsSync(braveKeyFile));
+
+  // Detect existing code
+  let hasCode = false;
+  let hasPackageFile = false;
+  try {
+    const files = execSync('find . -maxdepth 3 \\( -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" -o -name "*.java" \\) 2>/dev/null | grep -v node_modules | grep -v .git | head -5', {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    hasCode = files.trim().length > 0;
+  } catch {}
+
+  hasPackageFile = pathExistsInternal(cwd, 'package.json') ||
+                   pathExistsInternal(cwd, 'requirements.txt') ||
+                   pathExistsInternal(cwd, 'Cargo.toml') ||
+                   pathExistsInternal(cwd, 'go.mod') ||
+                   pathExistsInternal(cwd, 'Package.swift');
+
+  const result = {
+    // Models
+    researcher_model: resolveModelInternal(cwd, 'dgs-project-researcher'),
+    synthesizer_model: resolveModelInternal(cwd, 'dgs-research-synthesizer'),
+    roadmapper_model: resolveModelInternal(cwd, 'dgs-roadmapper'),
+
+    // Config
+    commit_docs: config.commit_docs,
+
+    // Existing state (project-qualified)
+    project_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'PROJECT.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'PROJECT.md')),
+    has_codebase_map: pathExistsInternal(cwd, path.join(planRootRel, 'codebase')),
+    planning_exists: pathExistsInternal(cwd, planRootRel),
+
+    // Brownfield detection
+    has_existing_code: hasCode,
+    has_package_file: hasPackageFile,
+    is_brownfield: hasCode || hasPackageFile,
+    needs_codebase_map: (hasCode || hasPackageFile) && !pathExistsInternal(cwd, path.join(planRootRel, 'codebase')),
+
+    // Git state
+    has_git: pathExistsInternal(cwd, '.git'),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // Enhanced search
+    brave_search_available: hasBraveSearch,
+
+    // File paths (project-qualified)
+    project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
+    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+    roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
+    requirements_path: ctx.root ? path.join(ctx.root, 'REQUIREMENTS.md') : path.join(planRootRel, 'REQUIREMENTS.md'),
+    research_dir: ctx.root ? path.join(ctx.root, 'research') : path.join(planRootRel, 'research'),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitNewMilestone(cwd, raw) {
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const milestone = getMilestoneInfo(cwd);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  const result = {
+    // Models
+    researcher_model: resolveModelInternal(cwd, 'dgs-project-researcher'),
+    synthesizer_model: resolveModelInternal(cwd, 'dgs-research-synthesizer'),
+    roadmapper_model: resolveModelInternal(cwd, 'dgs-roadmapper'),
+
+    // Config
+    commit_docs: config.commit_docs,
+    research_enabled: config.research,
+
+    // Current milestone
+    current_milestone: milestone.version,
+    current_milestone_name: milestone.name,
+
+    // File existence (project-qualified)
+    project_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'PROJECT.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'PROJECT.md')),
+    roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'ROADMAP.md')),
+    state_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'STATE.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'STATE.md')),
+
+    // File paths (project-qualified)
+    project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
+    roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
+    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitQuick(cwd, description, raw) {
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const now = new Date();
+  const slug = description ? generateSlugInternal(description)?.substring(0, 40) : null;
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  // Generate collision-resistant quick task ID: YYMMDD-xxx
+  // xxx = 2-second precision blocks since midnight, encoded as 3-char Base36 (lowercase)
+  // Range: 000 (00:00:00) to xbz (23:59:58), guaranteed 3 chars for any time of day.
+  // Provides ~2s uniqueness window per user — practically collision-free across a team.
+  const quickBase = ctx.root ? path.join(ctx.root, 'quick') : path.join(planRootRel, 'quick');
+  const yy = String(now.getFullYear()).slice(-2);
+  const mm = String(now.getMonth() + 1).padStart(2, '0');
+  const dd = String(now.getDate()).padStart(2, '0');
+  const dateStr = yy + mm + dd;
+  const secondsSinceMidnight = now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds();
+  const timeBlocks = Math.floor(secondsSinceMidnight / 2);
+  const timeEncoded = timeBlocks.toString(36).padStart(3, '0');
+  const quickId = dateStr + '-' + timeEncoded;
+
+  const result = {
+    // Models
+    planner_model: resolveModelInternal(cwd, 'dgs-planner'),
+    executor_model: resolveModelInternal(cwd, 'dgs-executor'),
+    checker_model: resolveModelInternal(cwd, 'dgs-plan-checker'),
+    verifier_model: resolveModelInternal(cwd, 'dgs-verifier'),
+
+    // Config
+    commit_docs: config.commit_docs,
+
+    // Quick task info
+    quick_id: quickId,
+    slug: slug,
+    description: description || null,
+
+    // Timestamps
+    date: now.toISOString().split('T')[0],
+    timestamp: now.toISOString(),
+
+    // Paths (project-qualified)
+    quick_dir: quickBase,
+    task_dir: slug ? path.join(quickBase, `${quickId}-${slug}`) : null,
+    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+
+    // File existence
+    roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'ROADMAP.md')),
+    planning_exists: pathExistsInternal(cwd, planRootRel),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitResume(cwd, raw) {
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  // Check for interrupted agent
+  let interruptedAgentId = null;
+  try {
+    interruptedAgentId = fs.readFileSync(path.join(getPlanningRoot(cwd), 'current-agent-id.txt'), 'utf-8').trim();
+  } catch {}
+
+  const result = {
+    // File existence (project-qualified)
+    state_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'STATE.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'STATE.md')),
+    roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'ROADMAP.md')),
+    project_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'PROJECT.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'PROJECT.md')),
+    planning_exists: pathExistsInternal(cwd, planRootRel),
+
+    // File paths (project-qualified)
+    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+    roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
+    project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // Agent state
+    has_interrupted_agent: !!interruptedAgentId,
+    interrupted_agent_id: interruptedAgentId,
+
+    // Config
+    commit_docs: config.commit_docs,
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitVerifyWork(cwd, phase, raw) {
+  if (!phase) {
+    error('phase required for init verify-work');
+  }
+
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const phaseInfo = findPhaseInternal(cwd, phase);
+
+  const result = {
+    // Models
+    planner_model: resolveModelInternal(cwd, 'dgs-planner'),
+    checker_model: resolveModelInternal(cwd, 'dgs-plan-checker'),
+
+    // Config
+    commit_docs: config.commit_docs,
+
+    // Phase info
+    phase_found: !!phaseInfo,
+    phase_dir: phaseInfo?.directory || null,
+    phase_number: phaseInfo?.phase_number || null,
+    phase_name: phaseInfo?.phase_name || null,
+
+    // Existing artifacts
+    has_verification: phaseInfo?.has_verification || false,
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitAuditPhase(cwd, phase, raw) {
+  if (!phase) {
+    error('phase required for init audit-phase');
+  }
+
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const phaseInfo = findPhaseInternal(cwd, phase);
+
+  const result = {
+    // Models
+    planner_model: resolveModelInternal(cwd, 'dgs-planner'),
+    checker_model: resolveModelInternal(cwd, 'dgs-plan-checker'),
+
+    // Config
+    commit_docs: config.commit_docs,
+
+    // Phase info
+    phase_found: !!phaseInfo,
+    phase_dir: phaseInfo?.directory || null,
+    phase_number: phaseInfo?.phase_number || null,
+    phase_name: phaseInfo?.phase_name || null,
+
+    // Existing artifacts
+    has_verification: phaseInfo?.has_verification || false,
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitPhaseOp(cwd, phase, raw) {
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+  let phaseInfo = findPhaseInternal(cwd, phase);
+
+  // Fallback to ROADMAP.md if no directory exists (e.g., Plans: TBD)
+  if (!phaseInfo) {
+    const roadmapPhase = getRoadmapPhaseInternal(cwd, phase);
+    if (roadmapPhase?.found) {
+      const phaseName = roadmapPhase.phase_name;
+      phaseInfo = {
+        found: true,
+        directory: null,
+        phase_number: roadmapPhase.phase_number,
+        phase_name: phaseName,
+        phase_slug: phaseName ? phaseName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') : null,
+        plans: [],
+        summaries: [],
+        incomplete_plans: [],
+        has_research: false,
+        has_context: false,
+        has_verification: false,
+      };
+    }
+  }
+
+  const result = {
+    // Config
+    commit_docs: config.commit_docs,
+    brave_search: config.brave_search,
+
+    // Phase info
+    phase_found: !!phaseInfo,
+    phase_dir: phaseInfo?.directory || null,
+    phase_number: phaseInfo?.phase_number || null,
+    phase_name: phaseInfo?.phase_name || null,
+    phase_slug: phaseInfo?.phase_slug || null,
+    padded_phase: phaseInfo?.phase_number?.padStart(2, '0') || null,
+
+    // Existing artifacts
+    has_research: phaseInfo?.has_research || false,
+    has_context: phaseInfo?.has_context || false,
+    has_plans: (phaseInfo?.plans?.length || 0) > 0,
+    has_verification: phaseInfo?.has_verification || false,
+    plan_count: phaseInfo?.plans?.length || 0,
+
+    // File existence (project-qualified)
+    roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'ROADMAP.md')),
+    planning_exists: pathExistsInternal(cwd, planRootRel),
+
+    // File paths (project-qualified)
+    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+    roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
+    requirements_path: ctx.root ? path.join(ctx.root, 'REQUIREMENTS.md') : path.join(planRootRel, 'REQUIREMENTS.md'),
+    project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
+    phases_dir: ctx.root ? path.join(ctx.root, 'phases') : path.join(planRootRel, 'phases'),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  if (phaseInfo?.directory) {
+    const phaseDirFull = path.join(cwd, phaseInfo.directory);
+    try {
+      const files = fs.readdirSync(phaseDirFull);
+      const contextFile = files.find(f => f.endsWith('-CONTEXT.md') || f === 'CONTEXT.md');
+      if (contextFile) {
+        result.context_path = toPosixPath(path.join(phaseInfo.directory, contextFile));
+      }
+      const researchFile = files.find(f => f.endsWith('-RESEARCH.md') || f === 'RESEARCH.md');
+      if (researchFile) {
+        result.research_path = toPosixPath(path.join(phaseInfo.directory, researchFile));
+      }
+      const verificationFile = files.find(f => f.endsWith('-VERIFICATION.md') || f === 'VERIFICATION.md');
+      if (verificationFile) {
+        result.verification_path = toPosixPath(path.join(phaseInfo.directory, verificationFile));
+      }
+      const uatFile = files.find(f => f.endsWith('-UAT.md') || f === 'UAT.md');
+      if (uatFile) {
+        result.uat_path = toPosixPath(path.join(phaseInfo.directory, uatFile));
+      }
+    } catch {}
+  }
+
+  output(result, raw);
+}
+
+function cmdInitTodos(cwd, area, raw) {
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const now = new Date();
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  // List todos (reuse existing logic) — project-qualified
+  const pendingBase = path.join(planRootRel, 'todos', 'pending');
+  const pendingDir = path.join(cwd, pendingBase);
+  let count = 0;
+  const todos = [];
+
+  try {
+    const files = fs.readdirSync(pendingDir).filter(f => f.endsWith('.md'));
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(pendingDir, file), 'utf-8');
+        const createdMatch = content.match(/^created:\s*(.+)$/m);
+        const titleMatch = content.match(/^title:\s*(.+)$/m);
+        const areaMatch = content.match(/^area:\s*(.+)$/m);
+        const todoArea = areaMatch ? areaMatch[1].trim() : 'general';
+
+        if (area && todoArea !== area) continue;
+
+        count++;
+        todos.push({
+          file,
+          created: createdMatch ? createdMatch[1].trim() : 'unknown',
+          title: titleMatch ? titleMatch[1].trim() : 'Untitled',
+          area: todoArea,
+          path: pendingBase + '/' + file,
+        });
+      } catch {}
+    }
+  } catch {}
+
+  const completedBase = path.join(planRootRel, 'todos', 'completed');
+  const todosBase = path.join(planRootRel, 'todos');
+
+  const result = {
+    // Config
+    commit_docs: config.commit_docs,
+
+    // Timestamps
+    date: now.toISOString().split('T')[0],
+    timestamp: now.toISOString(),
+
+    // Todo inventory
+    todo_count: count,
+    todos,
+    area_filter: area || null,
+
+    // Paths (project-qualified)
+    pending_dir: pendingBase,
+    completed_dir: completedBase,
+
+    // File existence
+    planning_exists: pathExistsInternal(cwd, planRootRel),
+    todos_dir_exists: pathExistsInternal(cwd, todosBase),
+    pending_dir_exists: pathExistsInternal(cwd, pendingBase),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitMilestoneOp(cwd, raw) {
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const milestone = getMilestoneInfo(cwd);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  // Count phases (project-qualified)
+  let phaseCount = 0;
+  let completedPhases = 0;
+  const phasesBase = ctx.root ? path.join(ctx.root, 'phases') : path.join(planRootRel, 'phases');
+  const phasesDir = path.join(cwd, phasesBase);
+  try {
+    const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+    phaseCount = dirs.length;
+
+    // Count phases with summaries (completed)
+    for (const dir of dirs) {
+      try {
+        const phaseFiles = fs.readdirSync(path.join(phasesDir, dir));
+        const hasSummary = phaseFiles.some(f => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md');
+        if (hasSummary) completedPhases++;
+      } catch {}
+    }
+  } catch {}
+
+  // Check archive (project-qualified)
+  const archiveBase = ctx.root ? path.join(ctx.root, 'archive') : path.join(planRootRel, 'archive');
+  const archiveDir = path.join(cwd, archiveBase);
+  let archivedMilestones = [];
+  try {
+    archivedMilestones = fs.readdirSync(archiveDir, { withFileTypes: true })
+      .filter(e => e.isDirectory())
+      .map(e => e.name);
+  } catch {}
+
+  const result = {
+    // Config
+    commit_docs: config.commit_docs,
+    base_branch: config.base_branch,
+    branching_strategy: config.branching_strategy,
+    phase_branch_template: config.phase_branch_template,
+    milestone_branch_template: config.milestone_branch_template,
+
+    // Current milestone
+    milestone_version: milestone.version,
+    milestone_name: milestone.name,
+    milestone_slug: generateSlugInternal(milestone.name),
+
+    // Phase counts
+    phase_count: phaseCount,
+    completed_phases: completedPhases,
+    all_phases_complete: phaseCount > 0 && phaseCount === completedPhases,
+
+    // Archive
+    archived_milestones: archivedMilestones,
+    archive_count: archivedMilestones.length,
+
+    // File existence (project-qualified)
+    project_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'PROJECT.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'PROJECT.md')),
+    roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'ROADMAP.md')),
+    state_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'STATE.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'STATE.md')),
+    archive_exists: pathExistsInternal(cwd, archiveBase),
+    phases_dir_exists: pathExistsInternal(cwd, phasesBase),
+
+    // File paths (project-qualified)
+    project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
+    roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
+    state_path: ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md'),
+    requirements_path: ctx.root ? path.join(ctx.root, 'REQUIREMENTS.md') : path.join(planRootRel, 'REQUIREMENTS.md'),
+    phases_dir: phasesBase,
+    archive_dir: archiveBase,
+    jobs_root: path.join(planRootRel, 'jobs'),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitMapCodebase(cwd, onlyRepo, raw) {
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  // Check for existing codebase maps — codebase is product-level (shared), NOT project-qualified
+  const codebaseDir = path.join(getPlanningRoot(cwd), 'codebase');
+  let existingMaps = [];
+  try {
+    existingMaps = fs.readdirSync(codebaseDir).filter(f => f.endsWith('.md'));
+  } catch {}
+
+  // ── Multi-repo: read and validate REPOS.md ──
+  const parsed = parseReposMd(cwd);
+  const validated = validateReposMdEager(cwd);
+
+  // Filter out planning repo (cwd itself) from valid repos
+  const resolvedCwd = path.resolve(cwd);
+  const allValidRepos = (validated.repos || []).filter(repo => {
+    const resolvedRepoPath = path.resolve(cwd, repo.path);
+    return resolvedRepoPath !== resolvedCwd;
+  });
+
+  const repoErrors = validated.errors || [];
+
+  // ── --only flag: validate and filter ──
+  let validRepos = allValidRepos;
+  let mode = 'refresh';
+  let only_repo = null;
+
+  if (onlyRepo) {
+    const matched = allValidRepos.find(r => r.name === onlyRepo);
+    if (!matched) {
+      error(`'${onlyRepo}' not found in REPOS.md. Available repos: ${allValidRepos.map(r => r.name).join(', ')}`);
+    }
+    validRepos = [matched];
+    mode = 'update';
+    only_repo = onlyRepo;
+  }
+
+  // Detect existing per-repo maps in codebase/<repo-name>/ subdirectories
+  const existingRepoMaps = {};
+  for (const repo of validRepos) {
+    const repoCodebaseDir = path.join(codebaseDir, repo.name);
+    try {
+      const maps = fs.readdirSync(repoCodebaseDir).filter(f => f.endsWith('.md'));
+      if (maps.length > 0) {
+        existingRepoMaps[repo.name] = maps;
+      }
+    } catch {}
+  }
+
+  const result = {
+    // Models
+    mapper_model: resolveModelInternal(cwd, 'dgs-codebase-mapper'),
+
+    // Config
+    commit_docs: config.commit_docs,
+    search_gitignored: config.search_gitignored,
+    parallelization: config.parallelization,
+
+    // Paths — codebase stays product-level
+    codebase_dir: path.join(planRootRel, 'codebase'),
+
+    // Existing maps (backward compat: flat top-level maps)
+    existing_maps: existingMaps,
+    has_maps: existingMaps.length > 0,
+
+    // File existence
+    planning_exists: pathExistsInternal(cwd, planRootRel),
+    codebase_dir_exists: pathExistsInternal(cwd, path.join(planRootRel, 'codebase')),
+
+    // ── Multi-repo fields ──
+    repos: validRepos.map(r => ({
+      name: r.name,
+      path: path.resolve(cwd, r.path),
+      url: r.url || '',
+      description: r.description || '',
+    })),
+    multi_repo: validRepos.length > 0,
+    valid_repos: validRepos.map(r => r.name),
+    repo_errors: repoErrors,
+    existing_repo_maps: existingRepoMaps,
+
+    // ── Mode fields ──
+    mode: mode,
+    only_repo: only_repo,
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  output(result, raw);
+}
+
+function cmdInitProgress(cwd, raw) {
+  const config = loadConfig(cwd);
+  const ctx = resolveProjectContext(cwd);
+  const milestone = getMilestoneInfo(cwd);
+  const planRootRel = path.relative(cwd, getPlanningRoot(cwd)) || '.';
+
+  // Analyze phases (project-qualified)
+  const phasesBase = ctx.root ? path.join(ctx.root, 'phases') : path.join(planRootRel, 'phases');
+  const phasesDir = path.join(cwd, phasesBase);
+  const phases = [];
+  let currentPhase = null;
+  let nextPhase = null;
+
+  try {
+    const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).sort();
+
+    for (const dir of dirs) {
+      const match = dir.match(/^(\d+(?:\.\d+)*)-?(.*)/);
+      const phaseNumber = match ? match[1] : dir;
+      const phaseName = match && match[2] ? match[2] : null;
+
+      const phasePath = path.join(phasesDir, dir);
+      const phaseFiles = fs.readdirSync(phasePath);
+
+      const plans = phaseFiles.filter(f => f.endsWith('-PLAN.md') || f === 'PLAN.md');
+      const summaries = phaseFiles.filter(f => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md');
+      const hasResearch = phaseFiles.some(f => f.endsWith('-RESEARCH.md') || f === 'RESEARCH.md');
+
+      const status = summaries.length >= plans.length && plans.length > 0 ? 'complete' :
+                     plans.length > 0 ? 'in_progress' :
+                     hasResearch ? 'researched' : 'pending';
+
+      const phaseInfo = {
+        number: phaseNumber,
+        name: phaseName,
+        directory: phasesBase + '/' + dir,
+        status,
+        plan_count: plans.length,
+        summary_count: summaries.length,
+        has_research: hasResearch,
+      };
+
+      phases.push(phaseInfo);
+
+      // Find current (first incomplete with plans) and next (first pending)
+      if (!currentPhase && (status === 'in_progress' || status === 'researched')) {
+        currentPhase = phaseInfo;
+      }
+      if (!nextPhase && status === 'pending') {
+        nextPhase = phaseInfo;
+      }
+    }
+  } catch {}
+
+  // Check for paused work (project-qualified)
+  let pausedAt = null;
+  const statePath = ctx.root ? path.join(ctx.root, 'STATE.md') : path.join(planRootRel, 'STATE.md');
+  try {
+    const state = fs.readFileSync(path.join(cwd, statePath), 'utf-8');
+    const pauseMatch = state.match(/\*\*Paused At:\*\*\s*(.+)/);
+    if (pauseMatch) pausedAt = pauseMatch[1].trim();
+  } catch {}
+
+  const result = {
+    // Models
+    executor_model: resolveModelInternal(cwd, 'dgs-executor'),
+    planner_model: resolveModelInternal(cwd, 'dgs-planner'),
+
+    // Config
+    commit_docs: config.commit_docs,
+
+    // Milestone
+    milestone_version: milestone.version,
+    milestone_name: milestone.name,
+
+    // Phase overview
+    phases,
+    phase_count: phases.length,
+    completed_count: phases.filter(p => p.status === 'complete').length,
+    in_progress_count: phases.filter(p => p.status === 'in_progress').length,
+
+    // Current state
+    current_phase: currentPhase,
+    next_phase: nextPhase,
+    paused_at: pausedAt,
+    has_work_in_progress: !!currentPhase,
+
+    // File existence (project-qualified)
+    project_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'PROJECT.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'PROJECT.md')),
+    roadmap_exists: ctx.root ? pathExistsInternal(cwd, path.join(ctx.root, 'ROADMAP.md')) : pathExistsInternal(cwd, path.join(planRootRel, 'ROADMAP.md')),
+    state_exists: pathExistsInternal(cwd, statePath),
+    // File paths (project-qualified; config stays product-level)
+    state_path: statePath,
+    roadmap_path: ctx.root ? path.join(ctx.root, 'ROADMAP.md') : path.join(planRootRel, 'ROADMAP.md'),
+    project_path: ctx.root ? path.join(ctx.root, 'PROJECT.md') : path.join(planRootRel, 'PROJECT.md'),
+    config_path: path.join(planRootRel, 'dgs.config.json'),
+
+    // Author
+    author: resolveAuthorSafe(cwd),
+
+    // v2 context
+    dgs_mode: ctx.dgs_mode,
+    current_project: ctx.current_project,
+    project_root: ctx.root,
+    guard: ctx.guard,
+    v2_hint: ctx.v2_hint || null,
+  };
+
+  output(result, raw);
+}
+
+module.exports = {
+  cmdInitExecutePhase,
+  cmdInitPlanPhase,
+  cmdInitNewProject,
+  cmdInitNewMilestone,
+  cmdInitQuick,
+  cmdInitResume,
+  cmdInitVerifyWork,
+  cmdInitAuditPhase,
+  cmdInitPhaseOp,
+  cmdInitTodos,
+  cmdInitMilestoneOp,
+  cmdInitMapCodebase,
+  cmdInitProgress,
+};