gsdd-cli 0.3.1 → 0.18.0

package/bin/lib/health.mjs

@@ -7,16 +7,21 @@ 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';
+import { evaluateLifecycleState } from './lifecycle-state.mjs';
+import { evaluateRuntimeFreshness } from './runtime-freshness.mjs';
 
 /**
  * Factory function returning the health command.
- * ctx must provide: { frameworkVersion }
+ * ctx should provide: { frameworkVersion, workflows }
  */
 export function createCmdHealth(ctx) {
   return async function cmdHealth(...healthArgs) {
     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'))) {
@@ -38,8 +43,10 @@ export function createCmdHealth(ctx) {
     // E1: config.json missing (already handled by pre-init guard, but keep for completeness)
     // E2: config.json missing required fields
     let config = null;
+    let configOk = false;
     try {
       config = JSON.parse(readFileSync(join(planningDir, 'config.json'), 'utf-8'));
+      configOk = true;
       const requiredFields = ['researchDepth', 'modelProfile', 'initVersion'];
       const missing = requiredFields.filter((f) => !(f in config));
       if (missing.length > 0) {
@@ -56,10 +63,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 +87,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' });
     }
 
@@ -115,36 +152,28 @@ export function createCmdHealth(ctx) {
     const roadmapPath = join(planningDir, 'ROADMAP.md');
     const phasesDir = join(planningDir, 'phases');
     const roadmap = existsSync(roadmapPath) ? readFileSync(roadmapPath, 'utf-8') : null;
-    const phaseArtifacts = existsSync(phasesDir) ? listPhaseArtifacts(phasesDir) : [];
+    const lifecycle = evaluateLifecycleState({ planningDir });
 
     if (roadmap && existsSync(phasesDir)) {
-      const phaseNums = [];
-      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));
-      }
-      for (const num of phaseNums) {
-        const padded = String(num).padStart(2, '0');
-        const hasFile = phaseArtifacts.some((artifact) => artifact.phasePrefix === padded || artifact.phasePrefix === String(num));
-        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' });
-        }
+      for (const phase of lifecycle.phases.filter((entry) => entry.status !== 'not_started' && !entry.hasArtifacts)) {
+        warnings.push({
+          id: 'W4',
+          severity: 'WARN',
+          message: `ROADMAP.md references active Phase ${phase.number} but no files found in .planning/phases/`,
+          fix: 'Create missing phase dirs or update ROADMAP',
+        });
       }
     }
 
     // W5: Phase dir has PLAN but no SUMMARY (stale in-progress)
-    if (phaseArtifacts.length > 0) {
-      const plans = phaseArtifacts.filter((artifact) => artifact.name.includes('PLAN'));
-      for (const plan of plans) {
-        const prefix = plan.name.split('-PLAN')[0];
-        const hasSummary = phaseArtifacts.some((artifact) =>
-          artifact.dir === plan.dir &&
-          artifact.name.startsWith(prefix) &&
-          artifact.name.includes('SUMMARY')
-        );
-        if (!hasSummary) {
-          warnings.push({ id: 'W5', severity: 'WARN', message: `${plan.displayPath} exists but no matching SUMMARY found (stale in-progress?)`, fix: 'Resume or complete the phase' });
-        }
+    if (lifecycle.incompletePlans.length > 0) {
+      for (const plan of lifecycle.incompletePlans) {
+        warnings.push({
+          id: 'W5',
+          severity: 'WARN',
+          message: `${plan.displayPath} exists but no matching SUMMARY found (stale in-progress?)`,
+          fix: 'Resume or complete the phase',
+        });
       }
     }
 
@@ -160,6 +189,12 @@ export function createCmdHealth(ctx) {
       warnings.push({ id: 'W6', severity: 'WARN', message: 'No adapter surfaces detected', fix: 'Run `gsdd init --tools <platform>`' });
     }
 
+    const runtimeFreshnessReport = configOk && Array.isArray(ctx.workflows)
+      ? evaluateRuntimeFreshness({ cwd, workflows: ctx.workflows })
+      : null;
+
+    warnings.push(...runTruthChecks(planningDir, cwd, healthCheckIds, { runtimeFreshnessReport }));
+
     // --- INFO checks ---
 
     // I1: generation manifest was produced by a different framework version
@@ -168,20 +203,12 @@ export function createCmdHealth(ctx) {
     }
 
     // I2: Phase completion count
-    if (roadmap) {
-      const lines = roadmap.split('\n');
-      let total = 0;
-      let done = 0;
-      for (const line of lines) {
-        const match = line.match(/^\s*[-*]\s*\[([x ]|-)\]\s*\*\*Phase\s+\d+/i);
-        if (match) {
-          total++;
-          if (match[1] === 'x') done++;
-        }
-      }
-      if (total > 0) {
-        info.push({ id: 'I2', severity: 'INFO', message: `Phases: ${done}/${total} completed` });
-      }
+    if (lifecycle.counts.total > 0) {
+      info.push({
+        id: 'I2',
+        severity: 'INFO',
+        message: `Phases: ${lifecycle.counts.completed}/${lifecycle.counts.total} completed`,
+      });
     }
 
     // I3: Which adapters are installed
@@ -220,29 +247,7 @@ export function createCmdHealth(ctx) {
   };
 }
 
-function listPhaseArtifacts(phasesDir) {
-  const artifacts = [];
-  for (const entry of readdirSync(phasesDir, { withFileTypes: true })) {
-    const entryPath = join(phasesDir, entry.name);
-    if (entry.isFile()) {
-      artifacts.push(createPhaseArtifact('', entry.name));
-      continue;
-    }
-    if (!entry.isDirectory()) continue;
-    for (const child of readdirSync(entryPath, { withFileTypes: true })) {
-      if (child.isFile()) {
-        artifacts.push(createPhaseArtifact(entry.name, child.name));
-      }
-    }
-  }
-  return artifacts;
+function isFrameworkSourceRepo(cwd) {
+  return existsSync(join(cwd, 'distilled', 'templates')) && existsSync(join(cwd, 'distilled', 'workflows'));
 }
 
-function createPhaseArtifact(dir, name) {
-  return {
-    dir,
-    name,
-    displayPath: dir ? `${dir}/${name}` : name,
-    phasePrefix: name.match(/^(\d+(?:\.\d+)?)-/)?.[1] || dir.match(/^(\d+(?:\.\d+)?)-/)?.[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 with local freshness checks',
     kind: 'native',
   },
   {
     id: 'opencode',
     label: 'OpenCode',
-    description: 'Native slash commands and agents',
+    description: 'Directly validated native slash commands and agents with local freshness checks',
     kind: 'native',
   },
   {
     id: 'codex',
     label: 'Codex CLI',
-    description: 'Portable skills plus native checker agents',
+    description: 'Directly validated portable skills plus native checker agents with local freshness checks',
     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/ with the same local freshness checks',
     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/ with the same local freshness checks',
     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/ with the same local freshness checks',
     kind: 'skills_native',
   },
 ];
@@ -161,25 +161,31 @@ export function getPostInitRoutingLines(selectedRuntimes) {
 
 export function getHelpText() {
   return `
-gsdd - GSD Distilled CLI
-Spec-Driven Development for AI coding agents.
+gsdd - Workspine CLI
+Portable multi-runtime software delivery framework for AI coding agents.
 
 Usage: gsdd <command> [args]
 
-Commands:
-  init [--tools <platform>] [--auto] [--brief <file>]
-                              Launch guided install wizard in TTYs, or use --tools for manual/headless setup
-                              --auto: non-interactive mode with smart defaults (requires --tools)
-                              --brief <file>: copy project brief to .planning/PROJECT_BRIEF.md
+Commands:
+  init [--tools <platform>] [--auto] [--brief <file>]
+                              Launch guided install wizard in TTYs, or use --tools for manual/headless setup
+                              --auto: non-interactive mode with smart defaults (requires --tools)
+                              --brief <file>: copy project brief to .planning/PROJECT_BRIEF.md
   update [--tools <platform>] [--templates] [--dry]
                               Regenerate adapters from latest framework sources
                               --templates: also refresh .planning/templates/ and roles
                               --dry: preview changes without writing files
-  health [--json]             Check workspace integrity (healthy/degraded/broken)
-  models [subcommand]         Inspect or update model profile / runtime overrides
-  find-phase [N]              Show phase info as JSON (for agent consumption)
-  verify <N>                  Run artifact checks for phase N
-  scaffold phase <N> [name]   Create a new phase plan file
+  health [--json]             Check workspace integrity (healthy/degraded/broken)
+  models [subcommand]         Inspect or update model profile / runtime overrides
+  find-phase [N]              Show phase info as JSON (for agent consumption)
+  verify <N>                  Run artifact checks for phase N
+  scaffold phase <N> [name]   Create a new phase plan file
+  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])
+  lifecycle-preflight <surface> [phase]
+                              Inspect deterministic lifecycle gate results for a workflow surface
+  help                        Show this summary
 
 Platforms (for --tools):
   claude    Generate Claude Code skills (.claude/skills/gsdd-*), commands (.claude/commands/gsdd-*.md), and native agents (.claude/agents/gsdd-*.md)
@@ -189,14 +195,18 @@ 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)
+  - Workspine is the public product name; the retained package, command, workflow, and workspace contracts stay gsdd-cli, gsdd, gsdd-*, and .planning/
   - 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
+  - \`gsdd health\` compares any installed generated runtime surfaces against current render output and points back to \`gsdd update\` when they drift
+  - 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)
+  - --tools codex generates .codex/agents/gsdd-plan-checker.toml (portable skill is the entry surface; $gsdd-plan is plan-only until explicit $gsdd-execute)
   - root AGENTS.md is only written on init when explicitly requested via --tools agents, --tools all, or the wizard governance opt-in
 
 Examples:
@@ -217,8 +227,20 @@ Examples:
   npx gsdd-cli verify 1
   npx gsdd-cli scaffold phase 4 Payments
 
-Workflows (run via skills/adapters generated by init, not direct CLI):
-  map-codebase      Map or refresh codebase (.agents/skills/gsdd-map-codebase/)
-  audit-milestone   Audit a completed milestone (.agents/skills/gsdd-audit-milestone/)
-`;
-}
+Workflows (run via skills/adapters generated by init, not direct CLI):
+  gsdd-new-project          Full initializer: questioning, brownfield audit, research, spec, roadmap
+  gsdd-map-codebase         Map or refresh brownfield codebase context
+  gsdd-plan                 Research, plan, and fresh-context plan check for a phase
+  gsdd-execute              Execute a phase plan and write phase summaries
+  gsdd-verify               Verify a completed phase with 3-level checks
+  gsdd-verify-work          Conversational UAT validation for user-facing behavior
+  gsdd-audit-milestone      Cross-phase integration, requirements coverage, and E2E audit
+  gsdd-complete-milestone   Archive a shipped milestone and collapse roadmap state
+  gsdd-new-milestone        Start the next milestone with goals, requirements, and phases
+  gsdd-plan-milestone-gaps  Turn milestone-audit gaps into closure phases
+  gsdd-quick                Bounded brownfield lane for sub-hour work
+  gsdd-pause                Save session context to checkpoint
+  gsdd-resume               Restore context and route to the next action
+  gsdd-progress             Read-only status and routing surface
+`;
+}

package/bin/lib/init.mjs

@@ -4,9 +4,9 @@ import { createCmdInit, createCmdUpdate } from './init-flow.mjs';
 import { createInitPromptApi, promptChoiceList } from './init-prompts.mjs';
 import { buildRuntimeChoices, detectPlatforms, getHelpText, normalizeRequestedTools } from './init-runtime.mjs';
 
-function cmdHelp() {
-  console.log(getHelpText());
-}
+function cmdHelp() {
+  console.log(getHelpText().trimEnd());
+}
 
 export {
   buildRuntimeChoices,