gsdd-cli 0.2.0 → 0.3.1

package/README.md

@@ -48,17 +48,27 @@ This creates:
 
 1. `.planning/` — durable workspace with templates, role contracts, and config
 2. `.agents/skills/gsdd-*` — portable workflow entrypoints
-3. Tool-specific adapters if detected (Claude skills/commands/agents, OpenCode commands/agents, Codex agents)
+3. Tool-specific adapters you choose in the install wizard (Claude skills/commands/agents, OpenCode commands/agents, Codex agents, optional governance)
 
 Then run the new-project workflow to produce `.planning/SPEC.md` and `.planning/ROADMAP.md`.
 
+In a terminal, `gsdd init` now opens a guided install wizard:
+
+- Step 1: select the runtimes/vendors you want to support
+- Step 2: decide separately whether repo-wide `AGENTS.md` governance is worth installing
+- Step 3: configure planning defaults in the same guided flow
+
+Portable `.agents/skills/gsdd-*` skills are always generated. The wizard controls extra native adapters and optional governance, not the portable baseline.
+
 ### Quickstart (after init)
 
 Your tool determines how you invoke workflows:
 
-- **Claude Code / OpenCode:** Use slash commands directly — `/gsdd-new-project`, `/gsdd-plan`, etc.
+- **Claude Code / OpenCode / Cursor / Copilot / Gemini:** Use slash commands directly — `/gsdd-new-project`, `/gsdd-plan`, etc.
 - **Codex CLI:** Use skill references — `$gsdd-new-project`, `$gsdd-plan`, etc.
-- **Cursor / Copilot / Gemini / Others:** Open `.agents/skills/gsdd-<workflow>/SKILL.md` and follow the instructions. The root `AGENTS.md` governance block keeps the agent on track.
+- **Other AI tools:** Open `.agents/skills/gsdd-<workflow>/SKILL.md` and follow the instructions.
+
+If you generate the root `AGENTS.md` block, it adds GSDD behavioral governance. For Cursor, Copilot, and Gemini, that governance is optional discipline on top of native skill discovery — not the mechanism that makes workflows discoverable.
 
 First workflow to run: **new-project** — it asks about your goals, audits the codebase (if brownfield), and produces `.planning/SPEC.md` + `.planning/ROADMAP.md`.
 
@@ -67,11 +77,12 @@ First workflow to run: **new-project** — it asks about your goals, audits the
 GSDD generates adapters for whichever tools you use:
 
 ```bash
-npx gsdd-cli init                    # Auto-detect installed tools
+npx gsdd-cli init                    # Guided install wizard (detected runtimes preselected)
 npx gsdd-cli init --tools claude     # Claude Code: .claude/skills + commands + agents
 npx gsdd-cli init --tools opencode   # OpenCode: .opencode/commands + agents
 npx gsdd-cli init --tools codex      # Codex CLI: portable gsdd-plan skill + .codex/agents checker
 npx gsdd-cli init --tools agents     # Root AGENTS.md fallback
+npx gsdd-cli init --tools cursor     # Backward-compatible AGENTS.md governance alias
 npx gsdd-cli init --tools all        # All of the above
 ```
 
@@ -81,7 +92,8 @@ npx gsdd-cli init --tools all        # All of the above
 | **Claude Code** | Native | `.claude/skills/`, `.claude/commands/`, `.claude/agents/` — slash commands work immediately |
 | **OpenCode** | Native | `.opencode/commands/`, `.opencode/agents/` — slash commands work immediately |
 | **Codex CLI** | Native | `.codex/agents/gsdd-plan-checker.toml` — skill reference `$gsdd-plan` works immediately |
-| **Cursor / Copilot / Gemini** | Governance | Root `AGENTS.md` block — governs agent behavior; invoke workflows by opening `.agents/skills/gsdd-*/SKILL.md` directly |
+| **Cursor / Copilot / Gemini** | Skills-native runtime + optional governance | Native slash-command discovery from `.agents/skills/`; optional root `AGENTS.md` block adds behavioral governance |
+| **Other AI tools** | Open standard fallback | Open `.agents/skills/gsdd-*/SKILL.md` directly |
 
 ### Updating
 
@@ -102,10 +114,13 @@ npx gsdd-cli init --auto --tools claude --brief path/to/PRD.md
 
 `--auto` skips interactive prompts, uses smart defaults (`autoAdvance: true` in config). `--brief` copies a project document to `.planning/PROJECT_BRIEF.md` for `new-project` to consume.
 
+If you already know exactly what to generate, `--tools ...` remains the manual path. The wizard is the primary onboarding UX; flags remain the advanced/headless contract.
+
 ### Team Use
 
 - **Shared state:** Set `commitDocs: true` (default) — `.planning/` is tracked in git. Everyone sees the same spec, roadmap, and phase plans.
 - **Onboarding:** After cloning, run `npx gsdd-cli init` to generate tool-specific adapters. `.planning/` is already tracked — no re-initialization needed.
+- **Governance is explicit:** The wizard asks separately whether to install repo-wide `AGENTS.md` rules, and explains why you may care before writing to the repo root.
 - **Session handoff:** Use `gsdd-pause` / `gsdd-resume` to hand off work. The checkpoint (`.planning/.continue-here.md`) captures context for the next person.
 - **Adapter isolation:** Each developer runs `gsdd init --tools <their-tool>`. Adapter files don't conflict across tools.
 
@@ -192,7 +207,8 @@ When all phases are done, run `gsdd-audit-milestone` to verify:
 
 - `Claude Code / OpenCode`: `/gsdd-quick`
 - `Codex CLI`: `$gsdd-quick`
-- `Cursor / Copilot / Gemini / Others`: open `.agents/skills/gsdd-quick/SKILL.md`
+- `Cursor / Copilot / Gemini`: `/gsdd-quick`
+- `Other AI tools`: open `.agents/skills/gsdd-quick/SKILL.md`
 
 For sub-hour tasks that don't need the full phase cycle:
 
@@ -231,7 +247,8 @@ Workflows are agent skills or commands, not plain shell utilities. How you invok
 | Claude Code | `/gsdd-plan` (slash command, works immediately after init) |
 | OpenCode | `/gsdd-plan` (slash command, works immediately after init) |
 | Codex CLI | `$gsdd-plan` (skill reference, works immediately after init) |
-| Cursor / Copilot / Gemini | Open `.agents/skills/gsdd-plan/SKILL.md` and paste or reference its content. The `AGENTS.md` governance block steers agent behavior. |
+| Cursor / Copilot / Gemini | `/gsdd-plan` (skills-native slash command). If the root `AGENTS.md` block is present, it adds governance, not workflow discovery. |
+| Other AI tools | Open `.agents/skills/gsdd-plan/SKILL.md` and paste or reference its content. |
 
 ## CLI Commands
 
@@ -279,14 +296,15 @@ GSDD generates vendor-specific files from vendor-agnostic markdown — it does n
 
 | Adapter | Kind | Strategy |
 |---------|------|----------|
-| **Claude Code** | `native_capable` | Skill-primary plan surface (stays in main context to spawn checker subagent), thin command alias, native `gsdd-plan-checker` agent |
-| **OpenCode** | `native_capable` | Specialized `/gsdd-plan` command (`subtask: false`), hidden `gsdd-plan-checker` subagent (`mode: subagent`) |
-| **Codex CLI** | `native_capable` | Portable skill as entry surface, `.codex/agents/gsdd-plan-checker.toml` (read-only, high reasoning effort) |
-| **Cursor / Copilot / Gemini** | `governance_only` | Root `AGENTS.md` block governs agent behavior; invoke workflows by opening `.agents/skills/gsdd-*/SKILL.md` directly |
+| **Claude Code** | `native_capable` adapter + skills-native runtime | Skill-primary plan surface (stays in main context to spawn checker subagent), thin command alias, native `gsdd-plan-checker` agent |
+| **OpenCode** | `native_capable` adapter + skills-native runtime | Specialized `/gsdd-plan` command (`subtask: false`), hidden `gsdd-plan-checker` subagent (`mode: subagent`) |
+| **Codex CLI** | `native_capable` adapter + skills-native runtime | Portable skill as entry surface, `.codex/agents/gsdd-plan-checker.toml` (read-only, high reasoning effort) |
+| **Cursor / Copilot / Gemini** | skills-native runtime + `governance_only` adapter | Runtime discovers `.agents/skills/` natively; optional root `AGENTS.md` block adds behavioral governance only |
+| **agents** (`--tools agents`) | `governance_only` adapter | Root `AGENTS.md` block for tools that benefit from governance or need open-standard fallback guidance |
 
 All adapters render the plan-checker from a single source (`distilled/templates/delegates/plan-checker.md`). Each adapter shapes the output to its platform's native mechanics, and the portable skill remains the shared workflow source.
 
-Cursor, Copilot, and Gemini CLI generate the same root `AGENTS.md` governance block as `--tools agents`. They do not have native adapter surfaces — invoke workflows by opening `.agents/skills/gsdd-*/SKILL.md` directly.
+Cursor, Copilot, and Gemini CLI generate the same root `AGENTS.md` governance block as `--tools agents`, but that file is governance only. Those runtimes already discover `.agents/skills/` natively and surface the workflows as slash commands.
 
 Model IDs pass through a two-layer injection guard: a regex whitelist (`/^[a-zA-Z0-9._\/:@-]+$/`) at the CLI boundary, plus format-specific escaping (TOML string escaping, triple-quote break prevention) at the adapter layer.
 
@@ -410,7 +428,7 @@ For detailed troubleshooting and recovery procedures, see the [User Guide](docs/
 
 ## Design Decisions
 
-GSDD makes 29 documented design decisions relative to GSD, each with evidence from source files and external research. See [`distilled/DESIGN.md`](distilled/DESIGN.md) for the full rationale.
+GSDD makes 36 documented design decisions relative to GSD, each with evidence from source files and external research. See [`distilled/DESIGN.md`](distilled/DESIGN.md) for the full rationale.
 
 Key choices:
 - **4-file codebase standard** — drop state that rots (STRUCTURE, INTEGRATIONS, TESTING), keep rules that don't

package/bin/adapters/claude.mjs

@@ -75,7 +75,7 @@ Execution flow:
      "summary": "One sentence overall assessment",
      "issues": [
        {
-         "dimension": "requirement_coverage | task_completeness | dependency_correctness | key_link_completeness | scope_sanity | must_have_quality | context_compliance | approach_alignment",
+         "dimension": "requirement_coverage | task_completeness | dependency_correctness | key_link_completeness | scope_sanity | must_have_quality | context_compliance | goal_achievement | approach_alignment",
          "severity": "blocker | warning",
          "description": "What is wrong",
          "plan": "01-PLAN",

package/bin/adapters/opencode.mjs

@@ -183,7 +183,7 @@ Execution flow:
      "summary": "One sentence overall assessment",
      "issues": [
        {
-         "dimension": "requirement_coverage | task_completeness | dependency_correctness | key_link_completeness | scope_sanity | must_have_quality | context_compliance | approach_alignment",
+         "dimension": "requirement_coverage | task_completeness | dependency_correctness | key_link_completeness | scope_sanity | must_have_quality | context_compliance | goal_achievement | approach_alignment",
          "severity": "blocker | warning",
          "description": "What is wrong",
          "plan": "01-PLAN",

package/bin/gsdd.mjs

@@ -24,51 +24,61 @@ const __dirname = dirname(__filename);
 const DISTILLED_DIR = join(__dirname, '..', 'distilled');
 const AGENTS_DIR = join(__dirname, '..', 'agents');
 const CWD = process.cwd();
-const PLANNING_DIR = join(CWD, '.planning');
 const IS_MAIN = process.argv[1]
   ? realpathSync(process.argv[1]) === realpathSync(__filename)
   : false;
 
 const [,, command, ...args] = process.argv;
 
+function defineWorkflow({ mutatesArtifacts = true, ...workflow }) {
+  return {
+    ...workflow,
+    mutatesArtifacts,
+    agent: mutatesArtifacts ? 'Code' : 'Plan',
+    opencodeType: mutatesArtifacts ? 'edit' : 'plan',
+  };
+}
+
 const WORKFLOWS = [
-  { name: 'gsdd-new-project', workflow: 'new-project.md', description: 'New project - questioning, codebase audit, research, spec, roadmap', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-map-codebase', workflow: 'map-codebase.md', description: 'Map or refresh codebase - 4 parallel mappers, staleness check, secrets scan', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-plan', workflow: 'plan.md', description: 'Plan a phase - research check, backward planning, task creation', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-execute', workflow: 'execute.md', description: 'Execute a phase plan - implement tasks, verify changes, follow repo git conventions', agent: 'Code', opencodeType: 'edit' },
-  { name: 'gsdd-verify', workflow: 'verify.md', description: 'Verify a completed phase - 3-level checks, anti-pattern scan', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-audit-milestone', workflow: 'audit-milestone.md', description: 'Audit a completed milestone - cross-phase integration, requirements coverage, E2E flows', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-quick', workflow: 'quick.md', description: 'Quick task - plan and execute a sub-hour task outside the phase cycle', agent: 'Code', opencodeType: 'edit' },
-  { name: 'gsdd-pause', workflow: 'pause.md', description: 'Pause work - save session context for seamless resumption', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-resume', workflow: 'resume.md', description: 'Resume work - restore context and route to next action', agent: 'Plan', opencodeType: 'plan' },
-  { name: 'gsdd-progress', workflow: 'progress.md', description: 'Check progress - show project status and route to next action', agent: 'Plan', opencodeType: 'plan' },
+  defineWorkflow({ name: 'gsdd-new-project', workflow: 'new-project.md', description: 'New project - questioning, codebase audit, research, spec, roadmap' }),
+  defineWorkflow({ name: 'gsdd-map-codebase', workflow: 'map-codebase.md', description: 'Map or refresh codebase - 4 parallel mappers, staleness check, secrets scan' }),
+  defineWorkflow({ name: 'gsdd-plan', workflow: 'plan.md', description: 'Plan a phase - research check, backward planning, task creation' }),
+  defineWorkflow({ name: 'gsdd-execute', workflow: 'execute.md', description: 'Execute a phase plan - implement tasks, verify changes, follow repo git conventions' }),
+  defineWorkflow({ name: 'gsdd-verify', workflow: 'verify.md', description: 'Verify a completed phase - 3-level checks, anti-pattern scan' }),
+  defineWorkflow({ name: 'gsdd-audit-milestone', workflow: 'audit-milestone.md', description: 'Audit a completed milestone - cross-phase integration, requirements coverage, E2E flows' }),
+  defineWorkflow({ name: 'gsdd-quick', workflow: 'quick.md', description: 'Quick task - plan and execute a sub-hour task outside the phase cycle' }),
+  defineWorkflow({ name: 'gsdd-pause', workflow: 'pause.md', description: 'Pause work - save session context for seamless resumption' }),
+  defineWorkflow({ name: 'gsdd-resume', workflow: 'resume.md', description: 'Resume work - restore context and route to next action' }),
+  defineWorkflow({ name: 'gsdd-progress', workflow: 'progress.md', description: 'Check progress - show project status and route to next action', mutatesArtifacts: false }),
 ];
 
 const FRAMEWORK_VERSION = 'v1.2';
 
-const ADAPTERS = createAdapterRegistry({
-  cwd: CWD,
-  workflows: WORKFLOWS,
-  renderAgentsBoundedBlock,
-  renderAgentsFileContent,
-  renderOpenCodeCommandContent,
-  renderSkillContent,
-  upsertBoundedBlock,
-  getDelegateContent,
-  loadProjectModelConfig,
-  getRuntimeModelOverride,
-  resolveRuntimeAgentModel,
-});
+function createCliContext(cwd = process.cwd()) {
+  return {
+    cwd,
+    planningDir: join(cwd, '.planning'),
+    distilledDir: DISTILLED_DIR,
+    agentsDir: AGENTS_DIR,
+    workflows: WORKFLOWS,
+    frameworkVersion: FRAMEWORK_VERSION,
+    adapters: createAdapterRegistry({
+      cwd,
+      workflows: WORKFLOWS,
+      renderAgentsBoundedBlock,
+      renderAgentsFileContent,
+      renderOpenCodeCommandContent,
+      renderSkillContent,
+      upsertBoundedBlock,
+      getDelegateContent,
+      loadProjectModelConfig,
+      getRuntimeModelOverride,
+      resolveRuntimeAgentModel,
+    }),
+  };
+}
 
-const INIT_CONTEXT = {
-  cwd: CWD,
-  planningDir: PLANNING_DIR,
-  distilledDir: DISTILLED_DIR,
-  agentsDir: AGENTS_DIR,
-  workflows: WORKFLOWS,
-  frameworkVersion: FRAMEWORK_VERSION,
-  adapters: ADAPTERS,
-};
+const INIT_CONTEXT = createCliContext(CWD);
 
 const cmdInit = createCmdInit(INIT_CONTEXT);
 const cmdUpdate = createCmdUpdate(INIT_CONTEXT);
@@ -99,4 +109,4 @@ if (IS_MAIN) {
   await runCli();
 }
 
-export { cmdHelp, cmdInit, cmdUpdate, cmdModels, cmdHealth, cmdFindPhase, cmdVerify, cmdScaffold, runCli, FRAMEWORK_VERSION };
+export { cmdHelp, cmdInit, cmdUpdate, cmdModels, cmdHealth, cmdFindPhase, cmdVerify, cmdScaffold, runCli, FRAMEWORK_VERSION, createCliContext };

package/bin/lib/init-flow.mjs

@@ -0,0 +1,220 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync } from 'fs';
+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 { installProjectTemplates, refreshTemplates } from './templates.mjs';
+import {
+  detectPlatforms,
+  getAdaptersToUpdate,
+  getPostInitRoutingLines,
+  normalizeRequestedTools,
+  resolveAdapters,
+  resolveInteractiveInitSession,
+} from './init-runtime.mjs';
+import { createInitPromptApi } from './init-prompts.mjs';
+
+export function createCmdInit(ctx) {
+  return async function cmdInit(...initArgs) {
+    console.log('gsdd init - setting up SDD workflow\n');
+
+    const isAuto = parseAutoFlag(initArgs);
+    const toolsFlag = parseFlagValue(initArgs, '--tools');
+    const briefFlag = parseFlagValue(initArgs, '--brief');
+    let briefSource = null;
+
+    if (toolsFlag.invalid) {
+      console.error('ERROR: --tools requires a value. Example: gsdd init --tools claude');
+      process.exitCode = 1;
+      return;
+    }
+
+    if (briefFlag.invalid) {
+      console.error('ERROR: --brief requires a file path. Example: gsdd init --brief project-idea.md');
+      process.exitCode = 1;
+      return;
+    }
+
+    if (briefFlag.value) {
+      briefSource = isAbsolute(briefFlag.value) ? briefFlag.value : join(ctx.cwd, briefFlag.value);
+      if (!existsSync(briefSource)) {
+        console.error(`ERROR: Brief file not found: ${briefFlag.value}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+
+    const parsedTools = parseToolsFlag(initArgs);
+    if (isAuto && parsedTools.length === 0) {
+      console.error('ERROR: --auto requires --tools <platform>. Example: gsdd init --auto --tools claude');
+      process.exitCode = 1;
+      return;
+    }
+
+    const promptApi = ctx.initPromptApi || createInitPromptApi();
+    const interactiveSession = await resolveInteractiveInitSession({
+      ctx,
+      promptApi,
+      parsedTools,
+      isAuto,
+    });
+
+    const existed = existsSync(ctx.planningDir);
+    mkdirSync(join(ctx.planningDir, 'phases'), { recursive: true });
+    mkdirSync(join(ctx.planningDir, 'research'), { recursive: true });
+    console.log(existed
+      ? '  - .planning/ already exists (ensured subdirectories)'
+      : '  - created .planning/ directory structure');
+
+    installProjectTemplates(ctx);
+    await ensureConfig({
+      cwd: ctx.cwd,
+      planningDir: ctx.planningDir,
+      isAuto,
+      promptApi,
+      preselectedConfig: interactiveSession.config,
+    });
+
+    if (briefSource) {
+      cpSync(briefSource, join(ctx.planningDir, 'PROJECT_BRIEF.md'));
+      console.log('  - copied project brief to .planning/PROJECT_BRIEF.md');
+    }
+
+    generateOpenStandardSkills(ctx.cwd, ctx.workflows);
+    console.log('  - generated open-standard skills (.agents/skills/gsdd-*)');
+
+    for (const adapter of resolveAdapters(ctx.adapters, interactiveSession.adapterTargets)) {
+      adapter.generate();
+      console.log(`  - ${adapter.summary('generated')}`);
+    }
+
+    const manifest = buildManifest({ planningDir: ctx.planningDir, frameworkVersion: ctx.frameworkVersion });
+    writeManifest(ctx.planningDir, manifest);
+    console.log('  - wrote generation manifest');
+
+    console.log('\nSDD initialized.');
+    console.log('Next: run the new-project workflow to produce SPEC.md and ROADMAP.md:\n');
+    printPostInitRouting(interactiveSession.selectedRuntimes);
+  };
+}
+
+export function createCmdUpdate(ctx) {
+  return function cmdUpdate(...updateArgs) {
+    const isDry = updateArgs.includes('--dry');
+    const doTemplates = updateArgs.includes('--templates');
+
+    console.log(`gsdd update - regenerating adapter files${isDry ? ' (dry run)' : ''}\n`);
+
+    const parsedTools = parseToolsFlag(updateArgs);
+    const requested = normalizeRequestedTools(parsedTools);
+    const platforms = parsedTools.length > 0 ? requested.adapterTargets : detectPlatforms(ctx.adapters);
+
+    let updated = false;
+
+    if (doTemplates) {
+      refreshTemplates({ ...ctx, isDry });
+      updated = true;
+    }
+
+    if (platforms.length > 0 || existsSync(join(ctx.cwd, '.agents', 'skills'))) {
+      if (isDry) {
+        console.log('  - would update open-standard skills (.agents/skills/gsdd-*)');
+      } else {
+        generateOpenStandardSkills(ctx.cwd, ctx.workflows);
+        console.log('  - updated open-standard skills (.agents/skills/gsdd-*)');
+      }
+      updated = true;
+    }
+
+    for (const adapter of getAdaptersToUpdate(ctx.adapters, platforms)) {
+      if (isDry) {
+        console.log(`  - would update ${adapter.name} adapter`);
+      } else {
+        adapter.generate();
+        console.log(`  - ${adapter.summary('updated')}`);
+      }
+      updated = true;
+    }
+
+    if (!updated) {
+      console.log('  - no adapters found to update (run `gsdd init` first)');
+    } else if (isDry) {
+      console.log('\nDry run complete. No files were written.\n');
+    } else {
+      if (doTemplates && existsSync(ctx.planningDir)) {
+        const manifest = buildManifest({ planningDir: ctx.planningDir, frameworkVersion: ctx.frameworkVersion });
+        writeManifest(ctx.planningDir, manifest);
+        console.log('  - updated generation manifest');
+      }
+      console.log('\nAdapters updated.\n');
+    }
+  };
+}
+
+function generateOpenStandardSkills(cwd, workflows) {
+  for (const workflow of workflows) {
+    const dir = join(cwd, '.agents', 'skills', workflow.name);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'SKILL.md'), renderSkillContent(workflow));
+  }
+}
+
+async function ensureConfig({ cwd, planningDir, isAuto, promptApi, preselectedConfig = null }) {
+  const configFile = join(planningDir, 'config.json');
+  if (existsSync(configFile)) {
+    console.log('  - .planning/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);
+    return;
+  }
+
+  if (isAuto) {
+    console.log('  - auto mode: writing config.json with defaults');
+    writeFileSync(configFile, JSON.stringify(buildDefaultConfig({ autoAdvance: true }), null, 2));
+    console.log('  - saved .planning/config.json (auto mode - autoAdvance enabled)\n');
+    return;
+  }
+
+  if (!process.stdin.isTTY) {
+    console.log('  - non-interactive mode detected: writing config.json with defaults');
+    writeFileSync(configFile, JSON.stringify(buildDefaultConfig(), null, 2));
+    console.log('  - saved .planning/config.json (defaults - re-run gsdd init in a terminal to customize)\n');
+    return;
+  }
+
+  const config = await promptApi.promptForConfig(cwd);
+  writeFileSync(configFile, JSON.stringify(config, null, 2));
+  console.log('  - saved .planning/config.json (guided wizard)\n');
+
+  if (!config.commitDocs) ensureGitignoreEntry(cwd);
+}
+
+function ensureGitignoreEntry(cwd) {
+  const gitignorePath = join(cwd, '.gitignore');
+  const ignoreEntry = '\n# GSDD planning docs (local only)\n.planning/\n';
+
+  if (existsSync(gitignorePath)) {
+    const existing = readFileSync(gitignorePath, 'utf-8');
+    if (!existing.includes('.planning/')) {
+      writeFileSync(gitignorePath, existing + ignoreEntry);
+      console.log('  - added .planning/ to .gitignore');
+    }
+    return;
+  }
+
+  writeFileSync(gitignorePath, ignoreEntry.trimStart());
+  console.log('  - created .gitignore with .planning/ entry');
+}
+
+function printPostInitRouting(selectedRuntimes) {
+  for (const line of getPostInitRoutingLines(selectedRuntimes)) {
+    console.log(line);
+  }
+  console.log('');
+}