gsdd-cli 0.3.1 → 0.16.1

package/bin/lib/health-truth.mjs

@@ -0,0 +1,188 @@
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+export const TRUTH_CHECK_IDS = ['W7', 'W8', 'W9', 'W10'];
+
+export function runTruthChecks(planningDir, frameworkDir, actualCheckIds) {
+  const warnings = [];
+  const designPath = join(frameworkDir, 'distilled', 'DESIGN.md');
+  const readmePath = join(frameworkDir, 'distilled', 'README.md');
+  const workflowsDir = join(frameworkDir, 'distilled', 'workflows');
+  const gapsPath = join(frameworkDir, '.internal-research', 'gaps.md');
+  const specPath = join(planningDir, 'SPEC.md');
+  const roadmapPath = join(planningDir, 'ROADMAP.md');
+
+  if (existsSync(designPath)) {
+    const documentedIds = extractHealthTableIds(readFileSync(designPath, 'utf-8'));
+    const missingFromDesign = actualCheckIds.filter((id) => !documentedIds.includes(id));
+    const extraInDesign = documentedIds.filter((id) => !actualCheckIds.includes(id));
+    if (missingFromDesign.length > 0 || extraInDesign.length > 0) {
+      const parts = [];
+      if (missingFromDesign.length > 0) parts.push(`missing in DESIGN.md: ${missingFromDesign.join(', ')}`);
+      if (extraInDesign.length > 0) parts.push(`extra in DESIGN.md: ${extraInDesign.join(', ')}`);
+      warnings.push({
+        id: 'W7',
+        severity: 'WARN',
+        message: `DESIGN.md health check table is out of sync (${parts.join('; ')})`,
+        fix: 'Update distilled/DESIGN.md section 20 to match the implemented health checks',
+      });
+    }
+  }
+
+  if (existsSync(readmePath) && existsSync(workflowsDir)) {
+    const readme = readFileSync(readmePath, 'utf-8');
+    const workflowFiles = readdirSync(workflowsDir).filter((entry) => entry.endsWith('.md')).sort();
+    const statusEntries = extractReadmeStatusEntries(readme);
+    const treeEntries = extractReadmeWorkflowTreeEntries(readme);
+    const issues = [];
+    if (statusEntries.length !== workflowFiles.length) {
+      issues.push(`status table ${statusEntries.length} != workflows dir ${workflowFiles.length}`);
+    }
+    if (treeEntries.length !== workflowFiles.length) {
+      issues.push(`framework tree ${treeEntries.length} != workflows dir ${workflowFiles.length}`);
+    }
+    const missingStatus = workflowFiles.filter((name) => !statusEntries.includes(name));
+    const missingTree = workflowFiles.filter((name) => !treeEntries.includes(name));
+    if (missingStatus.length > 0) issues.push(`missing from status table: ${missingStatus.join(', ')}`);
+    if (missingTree.length > 0) issues.push(`missing from framework tree: ${missingTree.join(', ')}`);
+    if (issues.length > 0) {
+      warnings.push({
+        id: 'W8',
+        severity: 'WARN',
+        message: `distilled/README.md workflow inventory is out of sync (${issues.join('; ')})`,
+        fix: 'Update distilled/README.md workflow status table and framework file tree to match distilled/workflows/',
+      });
+    }
+  }
+
+  if (existsSync(gapsPath)) {
+    const gapRefs = extractRepoLocalPaths(readFileSync(gapsPath, 'utf-8'));
+    const missingRefs = gapRefs.filter((ref) => !existsSync(join(frameworkDir, ref)));
+    if (missingRefs.length > 0) {
+      warnings.push({
+        id: 'W9',
+        severity: 'WARN',
+        message: `gaps.md references missing repo-local paths (${missingRefs.join(', ')})`,
+        fix: 'Annotate stale gap references as resolved or update them to current repo truth',
+      });
+    }
+  }
+
+  if (existsSync(specPath) && existsSync(roadmapPath)) {
+    const spec = readFileSync(specPath, 'utf-8');
+    const roadmap = readFileSync(roadmapPath, 'utf-8');
+    const checkedRequirements = extractCheckedRequirements(spec);
+    const roadmapRequirements = extractRoadmapRequirements(roadmap);
+    const mismatches = [];
+    for (const [requirementId, roadmapStatus] of roadmapRequirements.entries()) {
+      const specChecked = checkedRequirements.has(requirementId);
+      if (roadmapStatus && !specChecked) mismatches.push(`${requirementId} phase complete but SPEC unchecked`);
+      if (!roadmapStatus && specChecked) mismatches.push(`${requirementId} SPEC checked but phase incomplete`);
+    }
+    if (mismatches.length > 0) {
+      warnings.push({
+        id: 'W10',
+        severity: 'WARN',
+        message: `ROADMAP/SPEC requirement status drift (${mismatches.join('; ')})`,
+        fix: 'Reconcile .planning/ROADMAP.md phase completion markers with .planning/SPEC.md requirement checkboxes',
+      });
+    }
+  }
+
+  return warnings;
+}
+
+function extractHealthTableIds(content) {
+  const section = extractSection(content, '## 20. Workspace Health Diagnostics', '## 21.');
+  if (!section) return [];
+  return [...normalizeContent(section).matchAll(/^\|\s*([EWI]\d+)\s*\|/gm)].map((result) => result[1]);
+}
+
+function extractReadmeStatusEntries(content) {
+  const section = extractSection(content, '## Current Status', 'Architecture notes:');
+  if (!section) return [];
+  return [...normalizeContent(section).matchAll(/\|\s*`([^`]+\.md)`\s*\|/g)].map((result) => result[1]);
+}
+
+function extractReadmeWorkflowTreeEntries(content) {
+  const section = extractSection(content, '## Files In This Framework', '## ');
+  const match = normalizeContent(section || '').match(/```[\s\S]*?workflows\/\n([\s\S]*?)\n\s*templates\//);
+  if (!match) return [];
+  return match[1]
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.endsWith('.md'));
+}
+
+function extractRepoLocalPaths(content) {
+  const allowedRoots = [
+    'AGENTS.md',
+    'README.md',
+    'CHANGELOG.md',
+    'SPEC.md',
+    'package.json',
+    '.planning/',
+    '.internal-research/',
+    '.agents/',
+    '.claude/',
+    '.opencode/',
+    '.codex/',
+    '.worktrees/',
+    'bin/',
+    'distilled/',
+    'tests/',
+    'fixtures/',
+    'agents/',
+  ];
+  const refs = new Set();
+  for (const result of content.matchAll(/`([^`]+)`/g)) {
+    const value = result[1].trim();
+    if (!looksLikeRepoLocalPath(value, allowedRoots)) continue;
+    refs.add(value.replace(/\\/g, '/').replace(/\/$/, ''));
+  }
+  return [...refs];
+}
+
+function looksLikeRepoLocalPath(value, allowedRoots) {
+  if (value.includes(' ')) return false;
+  if (value.startsWith('/')) return false;
+  if (value.startsWith('$')) return false;
+  if (value.startsWith('..')) return false;
+  if (value.includes('://')) return false;
+  if (value.startsWith('feat/') || value.startsWith('fix/') || value.startsWith('pr') || value.startsWith('origin/')) return false;
+  if (allowedRoots.some((root) => value === root || value.startsWith(root))) return true;
+  return false;
+}
+
+function extractSection(content, startMarker, endMarker) {
+  const normalized = normalizeContent(content);
+  const start = normalized.indexOf(startMarker);
+  if (start === -1) return '';
+  const rest = normalized.slice(start);
+  if (!endMarker) return rest;
+  const end = rest.indexOf(endMarker, startMarker.length);
+  return end === -1 ? rest : rest.slice(0, end);
+}
+
+function normalizeContent(content) {
+  return content.replace(/\r\n/g, '\n');
+}
+
+function extractCheckedRequirements(content) {
+  const checked = new Set();
+  for (const result of content.matchAll(/- \[x\] \*\*\[([A-Z0-9-]+)]\*\*/g)) {
+    checked.add(result[1]);
+  }
+  return checked;
+}
+
+function extractRoadmapRequirements(content) {
+  const mapped = new Map();
+  for (const result of content.matchAll(/- \[([ x-])] \*\*Phase\s+\d+[a-z]?:.*?\*\*\s+—\s+\[([^\]]+)]/g)) {
+    const requirementIds = result[2].split(',').map((id) => id.trim());
+    for (const requirementId of requirementIds) {
+      mapped.set(requirementId, result[1].toLowerCase() === 'x');
+    }
+  }
+  return mapped;
+}

package/bin/lib/health.mjs

@@ -7,6 +7,7 @@ import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { readManifest, detectModifications } from './manifest.mjs';
 import { output } from './cli-utils.mjs';
+import { runTruthChecks, TRUTH_CHECK_IDS } from './health-truth.mjs';
 
 /**
  * Factory function returning the health command.
@@ -17,6 +18,8 @@ export function createCmdHealth(ctx) {
     const jsonMode = healthArgs.includes('--json');
     const cwd = process.cwd();
     const planningDir = join(cwd, '.planning');
+    const frameworkSourceMode = isFrameworkSourceRepo(cwd);
+    const healthCheckIds = ['E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7', 'E8', 'W1', 'W2', 'W3', 'W4', 'W5', 'W6', ...TRUTH_CHECK_IDS, 'I1', 'I2', 'I3'];
 
     // Pre-init guard
     if (!existsSync(join(planningDir, 'config.json'))) {
@@ -56,10 +59,11 @@ export function createCmdHealth(ctx) {
     const delegatesDir = join(templatesDir, 'delegates');
     const hasRolesDir = hasTemplatesDir && existsSync(rolesDir);
     const hasDelegatesDir = hasTemplatesDir && existsSync(delegatesDir);
+    const skipInstalledTemplateChecks = !hasTemplatesDir && frameworkSourceMode;
 
-    if (!hasTemplatesDir) {
+    if (!hasTemplatesDir && !skipInstalledTemplateChecks) {
       errors.push({ id: 'E3', severity: 'ERROR', message: '.planning/templates/ missing', fix: 'Run `gsdd update --templates`' });
-    } else {
+    } else if (hasTemplatesDir) {
       // E4: roles/ missing or empty
       if (!hasRolesDir) {
         errors.push({ id: 'E4', severity: 'ERROR', message: '.planning/templates/roles/ missing', fix: 'Run `gsdd update --templates`' });
@@ -79,13 +83,42 @@ export function createCmdHealth(ctx) {
           errors.push({ id: 'E5', severity: 'ERROR', message: '.planning/templates/delegates/ has 0 delegate files', fix: 'Run `gsdd update --templates`' });
         }
       }
+
+      // E6: research/ missing or empty
+      const researchDir = join(templatesDir, 'research');
+      if (!existsSync(researchDir)) {
+        errors.push({ id: 'E6', severity: 'ERROR', message: '.planning/templates/research/ missing', fix: 'Run `gsdd update --templates`' });
+      } else {
+        const researchFiles = readdirSync(researchDir).filter((f) => f.endsWith('.md'));
+        if (researchFiles.length === 0) {
+          errors.push({ id: 'E6', severity: 'ERROR', message: '.planning/templates/research/ has 0 template files', fix: 'Run `gsdd update --templates`' });
+        }
+      }
+
+      // E7: codebase/ missing or empty
+      const codebaseDir = join(templatesDir, 'codebase');
+      if (!existsSync(codebaseDir)) {
+        errors.push({ id: 'E7', severity: 'ERROR', message: '.planning/templates/codebase/ missing', fix: 'Run `gsdd update --templates`' });
+      } else {
+        const codebaseFiles = readdirSync(codebaseDir).filter((f) => f.endsWith('.md'));
+        if (codebaseFiles.length === 0) {
+          errors.push({ id: 'E7', severity: 'ERROR', message: '.planning/templates/codebase/ has 0 template files', fix: 'Run `gsdd update --templates`' });
+        }
+      }
+
+      // E8: critical root template files missing
+      const requiredRootFiles = ['spec.md', 'roadmap.md', 'auth-matrix.md'];
+      const missingRoot = requiredRootFiles.filter((f) => !existsSync(join(templatesDir, f)));
+      if (missingRoot.length > 0) {
+        errors.push({ id: 'E8', severity: 'ERROR', message: `.planning/templates/ missing critical root files: ${missingRoot.join(', ')}`, fix: 'Run `gsdd update --templates`' });
+      }
     }
 
     // --- WARNING checks ---
 
     // W1: generation-manifest.json missing
-    const manifest = readManifest(planningDir);
-    if (!manifest) {
+    const manifest = skipInstalledTemplateChecks ? null : readManifest(planningDir);
+    if (!manifest && !skipInstalledTemplateChecks) {
       warnings.push({ id: 'W1', severity: 'WARN', message: 'generation-manifest.json missing', fix: 'Run `gsdd update --templates` to create' });
     }
 
@@ -118,16 +151,25 @@ export function createCmdHealth(ctx) {
     const phaseArtifacts = existsSync(phasesDir) ? listPhaseArtifacts(phasesDir) : [];
 
     if (roadmap && existsSync(phasesDir)) {
-      const phaseNums = [];
+      const phaseLabels = [];
+      let inDetails = false;
       for (const line of roadmap.split('\n')) {
-        const match = line.match(/^\s*[-*]\s*\[[ x-]\]\s*\*\*Phase\s+(\d+)/i);
-        if (match) phaseNums.push(parseInt(match[1], 10));
+        if (line.includes('<details>') && !line.includes('</details>')) {
+          inDetails = true;
+          continue;
+        }
+        if (line.includes('</details>')) {
+          inDetails = false;
+          continue;
+        }
+        if (inDetails) continue;
+        const match = line.match(/^\s*[-*]\s*\[([x-])\]\s*\*\*Phase\s+(\d+[a-z]?)/i);
+        if (match) phaseLabels.push(normalizePhaseLabel(match[2]));
       }
-      for (const num of phaseNums) {
-        const padded = String(num).padStart(2, '0');
-        const hasFile = phaseArtifacts.some((artifact) => artifact.phasePrefix === padded || artifact.phasePrefix === String(num));
+      for (const label of phaseLabels) {
+        const hasFile = phaseArtifacts.some((artifact) => normalizePhaseLabel(artifact.phasePrefix) === label);
         if (!hasFile) {
-          warnings.push({ id: 'W4', severity: 'WARN', message: `ROADMAP.md references Phase ${num} but no files found in .planning/phases/`, fix: 'Create missing phase dirs or update ROADMAP' });
+          warnings.push({ id: 'W4', severity: 'WARN', message: `ROADMAP.md references active Phase ${label} but no files found in .planning/phases/`, fix: 'Create missing phase dirs or update ROADMAP' });
         }
       }
     }
@@ -160,6 +202,8 @@ export function createCmdHealth(ctx) {
       warnings.push({ id: 'W6', severity: 'WARN', message: 'No adapter surfaces detected', fix: 'Run `gsdd init --tools <platform>`' });
     }
 
+    warnings.push(...runTruthChecks(planningDir, cwd, healthCheckIds));
+
     // --- INFO checks ---
 
     // I1: generation manifest was produced by a different framework version
@@ -220,6 +264,15 @@ export function createCmdHealth(ctx) {
   };
 }
 
+function isFrameworkSourceRepo(cwd) {
+  return existsSync(join(cwd, 'distilled', 'templates')) && existsSync(join(cwd, 'distilled', 'workflows'));
+}
+
+function normalizePhaseLabel(value) {
+  if (!value) return null;
+  return value.toLowerCase().replace(/^0+(\d)/, '$1');
+}
+
 function listPhaseArtifacts(phasesDir) {
   const artifacts = [];
   for (const entry of readdirSync(phasesDir, { withFileTypes: true })) {
@@ -243,6 +296,6 @@ function createPhaseArtifact(dir, name) {
     dir,
     name,
     displayPath: dir ? `${dir}/${name}` : name,
-    phasePrefix: name.match(/^(\d+(?:\.\d+)?)-/)?.[1] || dir.match(/^(\d+(?:\.\d+)?)-/)?.[1] || null,
+    phasePrefix: name.match(/^(\d+[a-z]?(?:\.\d+)?)-/i)?.[1] || dir.match(/^(\d+[a-z]?(?:\.\d+)?)-/i)?.[1] || null,
   };
 }

package/bin/lib/init-flow.mjs

@@ -3,7 +3,7 @@ import { join, isAbsolute } from 'path';
 import { renderSkillContent } from './rendering.mjs';
 import { buildManifest, writeManifest } from './manifest.mjs';
 import { parseFlagValue, parseToolsFlag, parseAutoFlag } from './cli-utils.mjs';
-import { buildDefaultConfig } from './models.mjs';
+import { buildDefaultConfig, COST_PROFILES, RIGOR_PROFILES } from './models.mjs';
 import { installProjectTemplates, refreshTemplates } from './templates.mjs';
 import {
   detectPlatforms,
@@ -15,9 +15,34 @@ import {
 } from './init-runtime.mjs';
 import { createInitPromptApi } from './init-prompts.mjs';
 
+function validateKindContract(adapter, cwd) {
+  if (!adapter.subagentFiles) return;
+  if (adapter.kind === 'native_capable') {
+    const missing = adapter.subagentFiles
+      .map(f => join(cwd, f))
+      .filter(p => !existsSync(p));
+    if (missing.length > 0) {
+      console.warn(
+        `[WARN] ${adapter.name} adapter (kind=native_capable) missing expected subagent files:\n` +
+        missing.map(p => `  - ${p}`).join('\n')
+      );
+    }
+  } else if (adapter.kind === 'governance_only') {
+    const unexpected = adapter.subagentFiles
+      .map(f => join(cwd, f))
+      .filter(p => existsSync(p));
+    if (unexpected.length > 0) {
+      console.warn(
+        `[WARN] ${adapter.name} adapter (kind=governance_only) unexpectedly generated subagent files:\n` +
+        unexpected.map(p => `  - ${p}`).join('\n')
+      );
+    }
+  }
+}
+
 export function createCmdInit(ctx) {
   return async function cmdInit(...initArgs) {
-    console.log('gsdd init - setting up SDD workflow\n');
+    console.log('gsdd init - setting up GSDD workflow\n');
 
     const isAuto = parseAutoFlag(initArgs);
     const toolsFlag = parseFlagValue(initArgs, '--tools');
@@ -86,6 +111,7 @@ export function createCmdInit(ctx) {
 
     for (const adapter of resolveAdapters(ctx.adapters, interactiveSession.adapterTargets)) {
       adapter.generate();
+      validateKindContract(adapter, ctx.cwd);
       console.log(`  - ${adapter.summary('generated')}`);
     }
 
@@ -93,7 +119,8 @@ export function createCmdInit(ctx) {
     writeManifest(ctx.planningDir, manifest);
     console.log('  - wrote generation manifest');
 
-    console.log('\nSDD initialized.');
+    console.log('\nGSDD initialized.');
+    printInitSummary(interactiveSession.config ?? buildDefaultConfig({ autoAdvance: isAuto }));
     console.log('Next: run the new-project workflow to produce SPEC.md and ROADMAP.md:\n');
     printPostInitRouting(interactiveSession.selectedRuntimes);
   };
@@ -132,6 +159,7 @@ export function createCmdUpdate(ctx) {
         console.log(`  - would update ${adapter.name} adapter`);
       } else {
         adapter.generate();
+        validateKindContract(adapter, ctx.cwd);
         console.log(`  - ${adapter.summary('updated')}`);
       }
       updated = true;
@@ -218,3 +246,22 @@ function printPostInitRouting(selectedRuntimes) {
   }
   console.log('');
 }
+
+function printInitSummary(config) {
+  const rigor = Object.entries(RIGOR_PROFILES).find(([, profile]) => (
+    profile.researchDepth === config.researchDepth
+    && profile.workflow.research === config.workflow?.research
+    && profile.workflow.discuss === config.workflow?.discuss
+    && profile.workflow.planCheck === config.workflow?.planCheck
+    && profile.workflow.verifier === config.workflow?.verifier
+  ))?.[0] ?? 'balanced';
+  const cost = Object.entries(COST_PROFILES).find(([, profile]) => (
+    profile.modelProfile === config.modelProfile
+    && profile.parallelization === config.parallelization
+  ))?.[0] ?? 'balanced';
+
+  console.log(`Rigor: ${rigor}   Cost: ${cost}   Track .planning/ in git: ${config.commitDocs ? 'yes' : 'no'}`);
+  console.log('Workflows: new-project → plan → execute → verify → progress');
+  console.log('Edit .planning/config.json to fine-tune (verifier, gitProtocol, individual workflow flags).');
+  console.log('');
+}

package/bin/lib/init-prompts.mjs

@@ -1,5 +1,5 @@
 import * as readline from 'readline';
-import { DEFAULT_GIT_PROTOCOL, normalizeModelProfile } from './models.mjs';
+import { DEFAULT_GIT_PROTOCOL, resolveCost, resolveRigor } from './models.mjs';
 import { buildRuntimeChoices, INIT_VERSION, resolveWizardAdapterTargets } from './init-runtime.mjs';
 
 const ANSI = {
@@ -51,112 +51,51 @@ export function createInitPromptApi({ input = process.stdin, output = process.st
 export async function promptForConfig(cwd, { input = process.stdin, output = process.stdout } = {}) {
   output.write(`\n${ANSI.bold}Step 3 of 3 - Configure planning defaults${ANSI.reset}\n`);
 
-  const researchDepth = await promptSingleSelect({
+  const rigor = await promptSingleSelect({
     input,
     output,
-    title: 'Research depth',
+    title: 'Rigor',
     choices: [
-      { value: 'balanced', label: 'balanced', description: 'SOTA research per phase (recommended)' },
-      { value: 'fast', label: 'fast', description: 'Skip deeper domain research and plan from current context' },
-      { value: 'deep', label: 'deep', description: 'Exhaustive research sweeps and parallel researchers' },
+      { value: 'quick', label: 'quick', description: 'Faster setup with lighter planning rigor' },
+      { value: 'balanced', label: 'balanced', description: 'Recommended default for most projects' },
+      { value: 'thorough', label: 'thorough', description: 'Maximum research and plan review rigor' },
     ],
-    defaultIndex: 0,
+    defaultIndex: 1,
   });
-  const parallelization = await promptSingleSelect({
+  const cost = await promptSingleSelect({
     input,
     output,
-    title: 'Parallelization',
-    choices: yesNoChoices('Run independent agents in parallel?', true),
-    defaultIndex: 0,
+    title: 'Cost',
+    choices: [
+      { value: 'budget', label: 'budget', description: 'Lower-cost model profile and no parallelization' },
+      { value: 'balanced', label: 'balanced', description: 'Recommended cost/quality tradeoff' },
+      { value: 'quality', label: 'quality', description: 'Maximum quality with parallel work enabled' },
+    ],
+    defaultIndex: 1,
   });
   const commitDocs = await promptSingleSelect({
     input,
     output,
     title: 'Planning docs in git',
-    choices: yesNoChoices('Track .planning/ in git?', true),
-    defaultIndex: 0,
-  });
-  const modelProfile = await promptSingleSelect({
-    input,
-    output,
-    title: 'Model profile',
     choices: [
-      { value: 'balanced', label: 'balanced', description: 'Capable default for most agents (recommended)' },
-      { value: 'quality', label: 'quality', description: 'Most capable model for research and roadmap work' },
-      { value: 'budget', label: 'budget', description: 'Cheapest and fastest model profile' },
+      { value: true, label: 'yes', description: 'Track .planning/ in git.' },
+      { value: false, label: 'no', description: 'Keep .planning/ local only.' },
     ],
     defaultIndex: 0,
   });
-  const workflowResearch = await promptSingleSelect({
-    input,
-    output,
-    title: 'Workflow research',
-    choices: yesNoChoices('Research before planning each phase?', true),
-    defaultIndex: 0,
-  });
-  const workflowDiscuss = await promptSingleSelect({
-    input,
-    output,
-    title: 'Approach discussion',
-    choices: yesNoChoices('Explore approaches with the user before planning?', false),
-    defaultIndex: 0,
-  });
-  const workflowPlanCheck = await promptSingleSelect({
-    input,
-    output,
-    title: 'Plan checking',
-    choices: yesNoChoices('Run the fresh-context plan checker before execution?', true),
-    defaultIndex: 0,
-  });
-  const workflowVerifier = await promptSingleSelect({
-    input,
-    output,
-    title: 'Phase verification',
-    choices: yesNoChoices('Run phase verification after execution?', true),
-    defaultIndex: 0,
-  });
 
-  const gitProtocol = await promptGitProtocol(cwd, { input, output });
+  const rigorConfig = resolveRigor(rigor);
+  const costConfig = resolveCost(cost);
 
   return {
-    researchDepth,
-    parallelization,
+    ...rigorConfig,
+    ...costConfig,
     commitDocs,
-    modelProfile: normalizeModelProfile(modelProfile),
-    workflow: {
-      research: workflowResearch,
-      discuss: workflowDiscuss,
-      planCheck: workflowPlanCheck,
-      verifier: workflowVerifier,
-    },
-    gitProtocol,
+    gitProtocol: { ...DEFAULT_GIT_PROTOCOL },
     initVersion: INIT_VERSION,
   };
 }
 
-export async function promptGitProtocol(cwd, { input = process.stdin, output = process.stdout } = {}) {
-  if (typeof input.resume === 'function') input.resume();
-  output.write(`\n${ANSI.bold}Version control guidance${ANSI.reset}\n`);
-  output.write(`${ANSI.dim}This is advisory only. Repo or user conventions still win.${ANSI.reset}\n`);
-  const rl = readline.createInterface({ input, output });
-  const askQuestion = (query) => new Promise((resolve) => rl.question(query, resolve));
-
-  try {
-    let branch = await askQuestion('  Branching guidance (Enter for default): ');
-    branch = branch.trim() || DEFAULT_GIT_PROTOCOL.branch;
-
-    let commit = await askQuestion('  Commit guidance (Enter for default): ');
-    commit = commit.trim() || DEFAULT_GIT_PROTOCOL.commit;
-
-    let pr = await askQuestion('  PR guidance (Enter for default): ');
-    pr = pr.trim() || DEFAULT_GIT_PROTOCOL.pr;
-
-    return { branch, commit, pr };
-  } finally {
-    rl.close();
-  }
-}
-
 export function yesNoChoices(prompt, defaultYes) {
   return [
     { value: true, label: 'yes', description: `${prompt} Yes.` },

package/bin/lib/init-runtime.mjs

@@ -2,37 +2,37 @@ const RUNTIME_OPTIONS = [
   {
     id: 'claude',
     label: 'Claude Code',
-    description: 'Native skills, commands, and agents',
+    description: 'Directly validated native skills, commands, and agents',
     kind: 'native',
   },
   {
     id: 'opencode',
     label: 'OpenCode',
-    description: 'Native slash commands and agents',
+    description: 'Directly validated native slash commands and agents',
     kind: 'native',
   },
   {
     id: 'codex',
     label: 'Codex CLI',
-    description: 'Portable skills plus native checker agents',
+    description: 'Directly validated portable skills plus native checker agents',
     kind: 'native',
   },
   {
     id: 'cursor',
     label: 'Cursor',
-    description: 'Skills-native slash commands from .agents/skills/',
+    description: 'Qualified support via skills-native slash commands from .agents/skills/',
     kind: 'skills_native',
   },
   {
     id: 'copilot',
     label: 'GitHub Copilot',
-    description: 'Skills-native slash commands from .agents/skills/',
+    description: 'Qualified support via skills-native slash commands from .agents/skills/',
     kind: 'skills_native',
   },
   {
     id: 'gemini',
     label: 'Gemini CLI',
-    description: 'Skills-native slash commands from .agents/skills/',
+    description: 'Qualified support via skills-native slash commands from .agents/skills/',
     kind: 'skills_native',
   },
 ];
@@ -189,12 +189,14 @@ Platforms (for --tools):
   cursor    Generate root AGENTS.md governance block; workflows are already discovered natively from .agents/skills/ (legacy alias kept for backward compatibility)
   copilot   Generate root AGENTS.md governance block; workflows are already discovered natively from .agents/skills/ (legacy alias kept for backward compatibility)
   gemini    Generate root AGENTS.md governance block; workflows are already discovered natively from .agents/skills/ (legacy alias kept for backward compatibility)
-  all       Generate all adapters (Claude, OpenCode, Codex, AGENTS-based surfaces)
+  all       Generate all adapters (Claude, OpenCode, Codex, AGENTS.md, Cursor, Copilot, Gemini)
 
 Notes:
   - init always generates open-standard skills at .agents/skills/gsdd-* (portable workflow entrypoints)
   - running plain \`gsdd init\` in a terminal opens the guided runtime-selection wizard
   - the wizard lets you pick runtimes first, then separately decide whether repo-wide AGENTS.md governance is worth installing
+  - directly validated launch surfaces in this repo are Claude Code, OpenCode, and Codex CLI
+  - Cursor, Copilot, and Gemini are qualified support through the shared .agents/skills/ surface plus optional governance
   - --tools remains the advanced/manual path and preserves legacy runtime aliases for backward compatibility
   - --tools codex generates .codex/agents/gsdd-plan-checker.toml (portable skill is the entry surface)
   - root AGENTS.md is only written on init when explicitly requested via --tools agents, --tools all, or the wizard governance opt-in

package/bin/lib/init.mjs

@@ -5,7 +5,11 @@ import { createInitPromptApi, promptChoiceList } from './init-prompts.mjs';
 import { buildRuntimeChoices, detectPlatforms, getHelpText, normalizeRequestedTools } from './init-runtime.mjs';
 
 function cmdHelp() {
-  console.log(getHelpText());
+  console.log(`${getHelpText().trimEnd()}
+  file-op <copy|delete|regex-sub>
+                              Run deterministic workspace-confined file copy/delete/text mutation
+  phase-status <N> <status>   Update ROADMAP.md phase status ([ ] / [-] / [x])
+`);
 }
 
 export {