gsdd-cli 0.27.0 → 0.28.0

package/bin/lib/health.mjs

@@ -10,15 +10,18 @@ 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';
-import { findUiProofBundleFiles, readUiProofBundleFile, validateUiProofBundle } from './ui-proof.mjs';
 import { resolveWorkspaceContext } from './workspace-root.mjs';
 
+function statePath(stateDirName, relativePath = '') {
+  return relativePath ? `${stateDirName}/${relativePath}` : stateDirName;
+}
+
 /**
  * Build the structured health report without printing or mutating workspace
  * state. ctx should provide: { frameworkVersion, workflows }.
  */
 export function buildHealthReport(ctx, healthArgs = []) {
-    const { planningDir, workspaceRoot, invalid, error } = resolveWorkspaceContext(healthArgs);
+    const { planningDir, workspaceRoot, invalid, error, stateDirName = '.work' } = resolveWorkspaceContext(healthArgs);
     if (invalid) {
       return {
         status: 'broken',
@@ -30,13 +33,13 @@ export function buildHealthReport(ctx, healthArgs = []) {
     }
     const cwd = workspaceRoot;
     const frameworkSourceMode = isFrameworkSourceRepo(cwd);
-    const healthCheckIds = ['E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7', 'E8', 'E9', 'E10', 'W1', 'W2', 'W3', 'W4', 'W5', 'W6', ...TRUTH_CHECK_IDS, 'I1', 'I2', 'I3'];
+    const healthCheckIds = ['E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7', 'E8', 'E9', 'W1', 'W2', 'W3', 'W4', 'W5', 'W6', ...TRUTH_CHECK_IDS, 'I1', 'I2', 'I3'];
 
     // Pre-init guard
     if (!existsSync(join(planningDir, 'config.json'))) {
       return {
         status: 'broken',
-        errors: [{ id: 'E1', severity: 'ERROR', message: '.planning/config.json missing', fix: 'Run `npx -y gsdd-cli init`' }],
+        errors: [{ id: 'E1', severity: 'ERROR', message: `${statePath(stateDirName, 'config.json')} missing`, fix: 'Run `npx -y gsdd-cli init`' }],
         warnings: [],
         info: [],
         humanMessage: 'Not initialized. Run `npx -y gsdd-cli init`. If `gsdd` is installed globally, `gsdd init` is also fine.',
@@ -62,7 +65,7 @@ export function buildHealthReport(ctx, healthArgs = []) {
         errors.push({ id: 'E2', severity: 'ERROR', message: `config.json missing required fields: ${missing.join(', ')}`, fix: 'Run `npx -y gsdd-cli init` to regenerate' });
       }
     } catch {
-      errors.push({ id: 'E1', severity: 'ERROR', message: '.planning/config.json is unparseable', fix: 'Run `npx -y gsdd-cli init`' });
+      errors.push({ id: 'E1', severity: 'ERROR', message: `${statePath(stateDirName, 'config.json')} is unparseable`, fix: 'Run `npx -y gsdd-cli init`' });
     }
 
     // E3: templates/ missing
@@ -77,47 +80,47 @@ export function buildHealthReport(ctx, healthArgs = []) {
     const skipInstalledTemplateChecks = !hasTemplatesDir && frameworkSourceMode;
 
     if (!hasTemplatesDir && !skipInstalledTemplateChecks) {
-      errors.push({ id: 'E3', severity: 'ERROR', message: '.planning/templates/ missing', fix: 'Run `npx -y gsdd-cli update --templates`' });
+      errors.push({ id: 'E3', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/')} missing`, fix: 'Run `npx -y gsdd-cli update --templates`' });
     } else if (hasTemplatesDir) {
       // E4: roles/ missing or empty
       if (!hasRolesDir) {
-        errors.push({ id: 'E4', severity: 'ERROR', message: '.planning/templates/roles/ missing', fix: 'Run `npx -y gsdd-cli update --templates`' });
+        errors.push({ id: 'E4', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/roles/')} missing`, fix: 'Run `npx -y gsdd-cli update --templates`' });
       } else {
         const roleFiles = readdirSync(rolesDir).filter((f) => f.endsWith('.md'));
         if (roleFiles.length === 0) {
-          errors.push({ id: 'E4', severity: 'ERROR', message: '.planning/templates/roles/ has 0 role files', fix: 'Run `npx -y gsdd-cli update --templates`' });
+          errors.push({ id: 'E4', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/roles/')} has 0 role files`, fix: 'Run `npx -y gsdd-cli update --templates`' });
         }
       }
 
       // E5: delegates/ missing or empty
       if (!hasDelegatesDir) {
-        errors.push({ id: 'E5', severity: 'ERROR', message: '.planning/templates/delegates/ missing', fix: 'Run `npx -y gsdd-cli update --templates`' });
+        errors.push({ id: 'E5', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/delegates/')} missing`, fix: 'Run `npx -y gsdd-cli update --templates`' });
       } else {
         const delegateFiles = readdirSync(delegatesDir).filter((f) => f.endsWith('.md'));
         if (delegateFiles.length === 0) {
-          errors.push({ id: 'E5', severity: 'ERROR', message: '.planning/templates/delegates/ has 0 delegate files', fix: 'Run `npx -y gsdd-cli update --templates`' });
+          errors.push({ id: 'E5', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/delegates/')} has 0 delegate files`, fix: 'Run `npx -y gsdd-cli 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 `npx -y gsdd-cli update --templates`' });
+        errors.push({ id: 'E6', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/research/')} missing`, fix: 'Run `npx -y gsdd-cli 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 `npx -y gsdd-cli update --templates`' });
+          errors.push({ id: 'E6', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/research/')} has 0 template files`, fix: 'Run `npx -y gsdd-cli 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 `npx -y gsdd-cli update --templates`' });
+        errors.push({ id: 'E7', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/codebase/')} missing`, fix: 'Run `npx -y gsdd-cli 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 `npx -y gsdd-cli update --templates`' });
+          errors.push({ id: 'E7', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/codebase/')} has 0 template files`, fix: 'Run `npx -y gsdd-cli update --templates`' });
         }
       }
 
@@ -125,37 +128,20 @@ export function buildHealthReport(ctx, healthArgs = []) {
       const requiredRootFiles = ['spec.md', 'roadmap.md', 'auth-matrix.md', 'ui-proof.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 `npx -y gsdd-cli update --templates`' });
+        errors.push({ id: 'E8', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/')} missing critical root files: ${missingRoot.join(', ')}`, fix: 'Run `npx -y gsdd-cli update --templates`' });
       }
 
       const brownfieldChangeDir = join(templatesDir, 'brownfield-change');
       if (!existsSync(brownfieldChangeDir)) {
-        errors.push({ id: 'E9', severity: 'ERROR', message: '.planning/templates/brownfield-change/ missing', fix: 'Run `npx -y gsdd-cli update --templates`' });
+        errors.push({ id: 'E9', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/brownfield-change/')} missing`, fix: 'Run `npx -y gsdd-cli update --templates`' });
       } else {
         const missingBrownfield = ['CHANGE.md', 'HANDOFF.md', 'VERIFICATION.md'].filter((file) => !existsSync(join(brownfieldChangeDir, file)));
         if (missingBrownfield.length > 0) {
-          errors.push({ id: 'E9', severity: 'ERROR', message: `.planning/templates/brownfield-change/ missing critical files: ${missingBrownfield.join(', ')}`, fix: 'Run `npx -y gsdd-cli update --templates`' });
+          errors.push({ id: 'E9', severity: 'ERROR', message: `${statePath(stateDirName, 'templates/brownfield-change/')} missing critical files: ${missingBrownfield.join(', ')}`, fix: 'Run `npx -y gsdd-cli update --templates`' });
         }
       }
     }
 
-    // E10: known UI proof bundles must satisfy deterministic metadata/privacy validation.
-    for (const bundlePath of findUiProofBundleFiles(planningDir)) {
-      const relativePath = relative(cwd, bundlePath).replace(/\\/g, '/');
-      const parsed = readUiProofBundleFile(bundlePath);
-      const validation = parsed.errors.length > 0
-        ? { valid: false, errors: parsed.errors }
-        : validateUiProofBundle(parsed.bundle, { requireLocalArtifactExists: true, workspaceRoot: cwd });
-      if (!validation.valid) {
-        errors.push({
-          id: 'E10',
-          severity: 'ERROR',
-          message: `${relativePath} has invalid UI proof metadata (${validation.errors.map((entry) => entry.code).join(', ')})`,
-          fix: 'Run `gsdd ui-proof validate <path>` and add required privacy metadata, claim limits, fixed evidence kinds, concise tool provenance, failure classification when failed or partial, observation artifact references, existing local artifact paths, and safe-to-publish handling.',
-        });
-      }
-    }
-
     // --- WARNING checks ---
 
     // W1: generation-manifest.json missing
@@ -188,7 +174,7 @@ export function buildHealthReport(ctx, healthArgs = []) {
       }
     }
 
-    // W4: ROADMAP.md references phases not found in .planning/phases/
+    // W4: ROADMAP.md references phases not found in the resolved state phases directory.
     const roadmapPath = join(planningDir, 'ROADMAP.md');
     const phasesDir = join(planningDir, 'phases');
     const roadmap = existsSync(roadmapPath) ? readFileSync(roadmapPath, 'utf-8') : null;
@@ -199,7 +185,7 @@ export function buildHealthReport(ctx, healthArgs = []) {
         warnings.push({
           id: 'W4',
           severity: 'WARN',
-          message: `ROADMAP.md references active Phase ${phase.number} but no files found in .planning/phases/`,
+          message: `ROADMAP.md references active Phase ${phase.number} but no files found in ${statePath(stateDirName, 'phases/')}`,
           fix: 'Create missing phase dirs or update ROADMAP',
         });
       }
@@ -208,7 +194,7 @@ export function buildHealthReport(ctx, healthArgs = []) {
     // W5: Phase dir has PLAN but no SUMMARY (stale in-progress)
     if (lifecycle.incompletePlans.length > 0) {
       for (const plan of lifecycle.incompletePlans) {
-        const expectedSummary = `.planning/phases/${plan.dir}/${plan.baseId}-SUMMARY.md`;
+        const expectedSummary = statePath(stateDirName, `phases/${plan.dir}/${plan.baseId}-SUMMARY.md`);
         warnings.push({
           id: 'W5',
           severity: 'WARN',
@@ -227,7 +213,7 @@ export function buildHealthReport(ctx, healthArgs = []) {
       ? evaluateRuntimeFreshness({ cwd, workflows: ctx.workflows })
       : null;
 
-    warnings.push(...runTruthChecks(planningDir, cwd, healthCheckIds, { runtimeFreshnessReport }).map((warning) => {
+    warnings.push(...runTruthChecks(planningDir, cwd, healthCheckIds, { runtimeFreshnessReport, stateDirName }).map((warning) => {
       if (warning.id !== 'W10') return warning;
       return {
         ...warning,
@@ -235,7 +221,7 @@ export function buildHealthReport(ctx, healthArgs = []) {
           /^ROADMAP\/SPEC requirement status drift/,
           'ROADMAP lifecycle status drift (requirement checkbox and/or overview/detail phase status mismatch)'
         ),
-        fix: 'Reconcile .planning/ROADMAP.md overview/detail phase markers and .planning/SPEC.md requirement checkboxes',
+        fix: `Reconcile ${statePath(stateDirName, 'ROADMAP.md')} overview/detail phase markers and ${statePath(stateDirName, 'SPEC.md')} requirement checkboxes`,
       };
     }));
 

package/bin/lib/init-flow.mjs

@@ -3,7 +3,7 @@ import { dirname, join, isAbsolute } from 'path';
 import { buildPlanningCliHelperEntries, renderSkillContent } from './rendering.mjs';
 import { buildManifest, readManifest, writeManifest } from './manifest.mjs';
 import { parseFlagValue, parseToolsFlag, parseAutoFlag } from './cli-utils.mjs';
-import { buildDefaultConfig, COST_PROFILES, RIGOR_PROFILES } from './models.mjs';
+import { buildDefaultConfig, COST_PROFILES, RIGOR_PROFILES } from './config.mjs';
 import { installProjectTemplates, refreshTemplates } from './templates.mjs';
 import {
   detectPlatforms,
@@ -84,34 +84,36 @@ export function createCmdInit(ctx) {
       parsedTools,
       isAuto,
     });
+    const { planningDir, stateDirName } = ctx;
 
-    const existed = existsSync(ctx.planningDir);
-    mkdirSync(join(ctx.planningDir, 'phases'), { recursive: true });
-    mkdirSync(join(ctx.planningDir, 'research'), { recursive: true });
+    const existed = existsSync(planningDir);
+    mkdirSync(join(planningDir, 'phases'), { recursive: true });
+    mkdirSync(join(planningDir, 'research'), { recursive: true });
     console.log(existed
-      ? '  - .planning/ already exists (ensured subdirectories)'
-      : '  - created .planning/ directory structure');
+      ? `  - ${stateDirName}/ already exists (ensured subdirectories)`
+      : `  - created ${stateDirName}/ directory structure`);
 
     installProjectTemplates(ctx);
     await ensureConfig({
       cwd: ctx.cwd,
-      planningDir: ctx.planningDir,
+      planningDir,
       isAuto,
       promptApi,
       preselectedConfig: interactiveSession.config,
+      stateDirName,
     });
-    ensureGitignoreEntry(ctx.cwd, '.planning/.local/', '  - ensured .planning/.local/ is gitignored');
+    ensureGitignoreEntry(ctx.cwd, `${stateDirName}/.local/`, `  - ensured ${stateDirName}/.local/ is gitignored`);
 
     if (briefSource) {
-      cpSync(briefSource, join(ctx.planningDir, 'PROJECT_BRIEF.md'));
-      console.log('  - copied project brief to .planning/PROJECT_BRIEF.md');
+      cpSync(briefSource, join(planningDir, 'PROJECT_BRIEF.md'));
+      console.log(`  - copied project brief to ${stateDirName}/PROJECT_BRIEF.md`);
     }
 
-    generateOpenStandardSkills(ctx.cwd, ctx.workflows);
+    generateOpenStandardSkills(ctx.cwd, ctx.workflows, { stateDirName });
     console.log('  - generated open-standard skills (.agents/skills/gsdd-*)');
 
     generatePlanningCliHelpers(ctx);
-    console.log('  - generated local workflow helpers (.planning/bin/gsdd*)');
+    console.log(`  - generated local workflow helpers (${stateDirName}/bin/gsdd*)`);
 
     for (const adapter of resolveAdapters(ctx.adapters, interactiveSession.adapterTargets)) {
       adapter.generate();
@@ -119,8 +121,8 @@ export function createCmdInit(ctx) {
       console.log(`  - ${adapter.summary('generated')}`);
     }
 
-    const manifest = buildManifest({ planningDir: ctx.planningDir, frameworkVersion: ctx.frameworkVersion });
-    writeManifest(ctx.planningDir, manifest);
+    const manifest = buildManifest({ planningDir, frameworkVersion: ctx.frameworkVersion });
+    writeManifest(planningDir, manifest);
     console.log('  - wrote generation manifest');
 
     console.log('\n\x1B[1m\x1B[32m✓ GSDD initialized.\x1B[0m');
@@ -135,6 +137,7 @@ export function createCmdUpdate(ctx) {
   return function cmdUpdate(...updateArgs) {
     const isDry = updateArgs.includes('--dry');
     const doTemplates = updateArgs.includes('--templates');
+    const { planningDir, stateDirName } = ctx;
 
     console.log(`gsdd update - regenerating adapter files${isDry ? ' (dry run)' : ''}\n`);
 
@@ -149,22 +152,22 @@ export function createCmdUpdate(ctx) {
       updated = true;
     }
 
-    if (platforms.length > 0 || existsSync(ctx.planningDir) || hasGeneratedOpenStandardSkills(ctx.cwd)) {
+    if (platforms.length > 0 || existsSync(planningDir) || hasGeneratedOpenStandardSkills(ctx.cwd)) {
       if (isDry) {
         console.log('  - would update open-standard skills (.agents/skills/gsdd-*)');
       } else {
-        generateOpenStandardSkills(ctx.cwd, ctx.workflows);
+        generateOpenStandardSkills(ctx.cwd, ctx.workflows, { stateDirName });
         console.log('  - updated open-standard skills (.agents/skills/gsdd-*)');
       }
       updated = true;
     }
 
-    if (existsSync(ctx.planningDir)) {
+    if (existsSync(planningDir)) {
       if (isDry) {
-        console.log('  - would update local workflow helpers (.planning/bin/gsdd*)');
+        console.log(`  - would update local workflow helpers (${stateDirName}/bin/gsdd*)`);
       } else {
         generatePlanningCliHelpers(ctx);
-        console.log('  - updated local workflow helpers (.planning/bin/gsdd*)');
+        console.log(`  - updated local workflow helpers (${stateDirName}/bin/gsdd*)`);
       }
       updated = true;
     }
@@ -185,14 +188,14 @@ export function createCmdUpdate(ctx) {
     } else if (isDry) {
       console.log('\nDry run complete. No files were written.\n');
     } else {
-      if (existsSync(ctx.planningDir)) {
+      if (existsSync(planningDir)) {
         const manifest = buildUpdateManifest({
-          planningDir: ctx.planningDir,
+          planningDir,
           frameworkVersion: ctx.frameworkVersion,
           updateTemplates: doTemplates,
         });
         if (manifest) {
-          writeManifest(ctx.planningDir, manifest);
+          writeManifest(planningDir, manifest);
           console.log('  - updated generation manifest');
         }
       }
@@ -216,20 +219,21 @@ function hasGeneratedOpenStandardSkills(cwd) {
   }
 }
 
-function generateOpenStandardSkills(cwd, workflows) {
+function generateOpenStandardSkills(cwd, workflows, { stateDirName = '.work' } = {}) {
   for (const workflow of workflows) {
     const dir = join(cwd, '.agents', 'skills', workflow.name);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'SKILL.md'), renderSkillContent(workflow));
+    writeFileSync(join(dir, 'SKILL.md'), renderSkillContent(workflow, { stateDirName }));
   }
 }
 
-function generatePlanningCliHelpers(ctx) {
+function generatePlanningCliHelpers({ packageName, packageVersion, planningDir, stateDirName = '.work' }) {
   for (const entry of buildPlanningCliHelperEntries({
-    packageName: ctx.packageName,
-    packageVersion: ctx.packageVersion,
+    packageName,
+    packageVersion,
+    stateDirName,
   })) {
-    const absolutePath = join(ctx.planningDir, entry.relativePath);
+    const absolutePath = join(planningDir, entry.relativePath);
     mkdirSync(dirname(absolutePath), { recursive: true });
     writeFileSync(absolutePath, entry.content);
     if (!absolutePath.endsWith('.cmd')) {
@@ -264,33 +268,35 @@ function stripManifestTimestamp(manifest) {
   return rest;
 }
 
-async function ensureConfig({ cwd, planningDir, isAuto, promptApi, preselectedConfig = null }) {
+async function ensureConfig({ cwd, planningDir, stateDirName = '.work', isAuto, promptApi, preselectedConfig = null }) {
   const configFile = join(planningDir, 'config.json');
+  const ignoreEntry = `${stateDirName}/`;
+  const ignoreMsg = `  - ensured ${stateDirName}/ is gitignored`;
   if (existsSync(configFile)) {
-    console.log('  - .planning/config.json already exists');
+    console.log(`  - ${stateDirName}/config.json already exists`);
     return;
   }
 
   if (preselectedConfig) {
     writeFileSync(configFile, JSON.stringify(preselectedConfig, null, 2));
-    console.log('  - saved .planning/config.json (guided wizard)\n');
-    if (!preselectedConfig.commitDocs) ensureGitignoreEntry(cwd, '.planning/', '  - ensured .planning/ is gitignored');
+    console.log(`  - saved ${stateDirName}/config.json (guided wizard)\n`);
+    if (!preselectedConfig.commitDocs) ensureGitignoreEntry(cwd, ignoreEntry, ignoreMsg);
     return;
   }
 
   if (isAuto) {
     const config = buildDefaultConfig({ autoAdvance: true });
     writeFileSync(configFile, JSON.stringify(config, null, 2));
-    console.log('  - wrote .planning/config.json (auto defaults)\n');
-    if (!config.commitDocs) ensureGitignoreEntry(cwd, '.planning/', '  - ensured .planning/ is gitignored');
+    console.log(`  - wrote ${stateDirName}/config.json (auto defaults)\n`);
+    if (!config.commitDocs) ensureGitignoreEntry(cwd, ignoreEntry, ignoreMsg);
     return;
   }
 
   if (!process.stdin.isTTY) {
     const config = buildDefaultConfig({ autoAdvance: false });
     writeFileSync(configFile, JSON.stringify(config, null, 2));
-    console.log('  - wrote .planning/config.json (non-interactive defaults)\n');
-    if (!config.commitDocs) ensureGitignoreEntry(cwd, '.planning/', '  - ensured .planning/ is gitignored');
+    console.log(`  - wrote ${stateDirName}/config.json (non-interactive defaults)\n`);
+    if (!config.commitDocs) ensureGitignoreEntry(cwd, ignoreEntry, ignoreMsg);
     return;
   }
 
@@ -303,8 +309,8 @@ async function ensureConfig({ cwd, planningDir, isAuto, promptApi, preselectedCo
   }
 
   writeFileSync(configFile, JSON.stringify(selected, null, 2));
-  console.log('  - saved .planning/config.json (guided wizard)\n');
-  if (!selected.commitDocs) ensureGitignoreEntry(cwd, '.planning/', '  - ensured .planning/ is gitignored');
+  console.log(`  - saved ${stateDirName}/config.json (guided wizard)\n`);
+  if (!selected.commitDocs) ensureGitignoreEntry(cwd, ignoreEntry, ignoreMsg);
 }
 
 function ensureGitignoreEntry(cwd, entry, message) {

package/bin/lib/init-prompts.mjs

@@ -1,5 +1,5 @@
 import * as readline from 'readline';
-import { DEFAULT_GIT_PROTOCOL, resolveCost, resolveRigor } from './models.mjs';
+import { DEFAULT_GIT_PROTOCOL, resolveCost, resolveRigor } from './config.mjs';
 import { buildRuntimeChoices, INIT_VERSION, resolveWizardAdapterTargets } from './init-runtime.mjs';
 
 const ANSI = {
@@ -79,8 +79,8 @@ export async function promptForConfig(cwd, { input = process.stdin, output = pro
     output,
     title: 'Planning docs in git',
     choices: [
-      { value: true, label: 'yes', description: 'Track .planning/ in git.' },
-      { value: false, label: 'no', description: 'Keep .planning/ local only.' },
+      { value: true, label: 'yes', description: 'Track .work/ in git.' },
+      { value: false, label: 'no', description: 'Keep .work/ local only.' },
     ],
     defaultIndex: 0,
   });

package/bin/lib/init-runtime.mjs

@@ -2,19 +2,19 @@ const RUNTIME_OPTIONS = [
   {
     id: 'claude',
     label: 'Claude Code',
-    description: 'Directly validated native skills, commands, and agents with local freshness checks',
+    description: 'Recorded proof for native skills, commands, and agents with local freshness checks',
     kind: 'native',
   },
   {
     id: 'opencode',
     label: 'OpenCode',
-    description: 'Directly validated native slash commands and agents with local freshness checks',
+    description: 'Recorded proof for native slash commands and agents with local freshness checks',
     kind: 'native',
   },
   {
     id: 'codex',
     label: 'Codex CLI',
-    description: 'Directly validated portable skills plus native checker agents with local freshness checks',
+    description: 'Recorded proof for portable skills plus native checker agents with local freshness checks',
     kind: 'native',
   },
   {
@@ -163,7 +163,7 @@ export function getPostInitRoutingLines(selectedRuntimes) {
 export function getHelpText() {
   return `
 gsdd - Workspine CLI
-Repo-native delivery spine for long-horizon AI-assisted work across coding runtimes.
+Plan, execute, and verify AI-assisted work from files in your repo — with proof before "done".
 
 Usage: gsdd <command> [args]
 
@@ -171,14 +171,14 @@ 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
+                              --brief <file>: copy project brief to .work/PROJECT_BRIEF.md
   install --global [--auto] [--tools <platform>] [--dry]
                               Install reusable Workspine skills and native runtime surfaces into agent home directories
                               --auto: non-interactive mode that installs detected local agent targets
                               In TTYs, omitting --tools opens an agent picker
   update [--tools <platform>] [--templates] [--dry]
                               Regenerate adapters from latest framework sources
-                              --templates: also refresh .planning/templates/ and roles
+                              --templates: also refresh .work/templates/ and roles
                               --dry: preview changes without writing files
   health [--json]             Check workspace integrity (healthy/degraded/broken)
   next [--json] [--format auto|json|human] [--init]
@@ -192,18 +192,6 @@ Commands:
   phase-status <N> <status>   Update ROADMAP.md phase status ([ ] / [-] / [x])
   lifecycle-preflight <surface> [phase]
                               Inspect deterministic lifecycle gate results for a workflow surface
-  session-fingerprint write [--allow-changed <ROADMAP.md,SPEC.md,config.json>]
-                              Rebaseline planning-state drift after reviewing changed planning files
-  ui-proof validate <path> [--claim <public|publication|tracked|delivery|release>]
-                              Validate UI proof metadata; use --claim for stronger proof uses
-  ui-proof compare <planned-slots-json> [observed-bundle-json ...]
-                              Compare planned UI proof slots against observed bundles
-  control-map [--json] [--with-ignored] [--annotations <path>]
-                              Report computed repo/worktree/planning state and local annotations
-  control-map annotate <set|clear>
-                              Maintain optional local intent annotations under .planning/.local/
-  closeout-report [--json] [--phase <N>]
-                              Replay read-only closeout status from control-map, health, preflight, verify, and UI-proof signals
   help                        Show this summary
 
 Platforms (for --tools):
@@ -226,17 +214,17 @@ Global install targets:
 Notes:
   - use \`npx -y gsdd-cli init\` for repo-local setup; use \`npx -y gsdd-cli install --global --auto\` when you want reusable skills in detected agent homes
   - init always generates open-standard skills at .agents/skills/gsdd-*; this is the shared workflow entry surface
-  - init also generates a local .planning/bin/gsdd* helper surface for workflow-embedded lifecycle helpers; it is internal/advanced, not the normal first-run user entrypoint
-  - install --global never creates .planning/ in the current repo; it writes only selected agent-home surfaces and per-runtime Workspine manifests
+  - init also generates a local .work/bin/gsdd* helper surface for workflow-embedded lifecycle helpers; it is internal/advanced, not the normal first-run user entrypoint
+  - install --global never creates .work/ in the current repo; it writes only selected agent-home surfaces and per-runtime Workspine manifests
   - use \`npx -y gsdd-cli install --global --auto\` for non-interactive global install into detected agent homes; use \`--tools <targets>\` to override detection explicitly
   - repair or refresh a global install by rerunning \`npx -y gsdd-cli install --global --auto\` or \`npx -y gsdd-cli install --global --tools <targets>\`; runtime probes stay in test harnesses
-  - Workspine is the public product name; the retained package, command, workflow, and workspace contracts stay gsdd-cli, gsdd, gsdd-*, and .planning/
+  - Workspine is the public product name; the retained package, command, workflow, and workspace contracts stay gsdd-cli, gsdd, gsdd-*, and .work/ (legacy planning workspaces are still read)
   - running \`npx -y gsdd-cli init\` in a terminal opens the guided runtime-selection wizard; bare \`gsdd init\` is equivalent only when globally installed
   - the wizard lets you pick runtimes first, then separately decide whether repo-wide AGENTS.md governance is worth installing
-  - \`npx -y gsdd-cli health\` is for repo-local .planning/ workspaces; it compares local generated surfaces and points back to \`npx -y gsdd-cli update\` when they drift
+  - \`npx -y gsdd-cli health\` is for repo-local .work/ workspaces; it compares local generated surfaces and points back to \`npx -y gsdd-cli update\` when they drift
   - \`npx -y gsdd-cli next --init\` bootstraps the local .work continuity surface; plain \`next\` is read-only and emits a typed next-action packet
   - \`gsdd next\` defaults to JSON when stdout is captured; use \`--format human\` for the compact supervisor card
-  - directly validated launch surfaces in this repo are Claude Code, OpenCode, and Codex CLI
+  - recorded launch proof in this repo currently covers Claude Code, OpenCode, and Codex CLI paths
   - 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; $gsdd-plan is plan-only until explicit $gsdd-execute)
@@ -266,8 +254,6 @@ Examples:
   npx -y gsdd-cli next --init
   npx -y gsdd-cli find-phase
   npx -y gsdd-cli verify 1
-  npx -y gsdd-cli control-map annotate set --id canonical --write-set src/app.ts
-  npx -y gsdd-cli control-map annotate clear --id canonical
   npx -y gsdd-cli scaffold phase 4 Payments
 
 Workflows (run via skills/adapters generated by init, not direct CLI):
@@ -280,7 +266,6 @@ Workflows (run via skills/adapters generated by init, not direct CLI):
   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
@@ -293,11 +278,7 @@ Starting lanes after init:
 
 Advanced/internal helpers (kept available, but not the primary first-run user story):
   lifecycle-preflight       Inspect deterministic lifecycle gate results for a workflow surface
-  session-fingerprint       Rebaseline the local planning-state fingerprint after review
   phase-status              Update ROADMAP.md phase status through the local helper surface
-  ui-proof                  Validate UI proof metadata and compare planned slots to observed bundles
-  control-map               Report computed repo/worktree/planning state; annotate only records local intent
-  closeout-report           Read-only post-merge closure replay; reports blockers, warnings, and next safe action
   next                      Read-only \`.work\` continuity router for the next coherent agent action
   file-op                   Deterministic workspace-confined file copy/delete/text mutation
 `;