create-quiver 0.15.3 → 0.16.0

package/src/create-quiver/index.js

@@ -35,6 +35,8 @@ const {
   runSpecsList: runAiSpecsList,
   runTraceReport: runAiTraceReport,
 } = require('./commands/ai');
+const { runChangelog } = require('./commands/changelog');
+const { runConfig } = require('./commands/config');
 const { runDashboard } = require('./commands/dashboard');
 const { runDemo } = require('./commands/demo');
 const { runPrepare } = require('./commands/prepare');
@@ -57,8 +59,27 @@ const { cleanupSlice, refreshActiveSlicesBoard, startSlice } = require('./lib/li
 const { buildSpecStatus, closeSpecWorktree, formatSpecCloseResult, formatSpecStartResult, formatSpecStatus, startSpecWorktree } = require('./lib/spec-worktrees');
 const { getContextPathExclusionReason } = require('./lib/ai/safety');
 const { selectOption } = require('./lib/cli/selectors');
+const {
+  SUPPORTED_AI_COMMANDS,
+  SUPPORTED_COMMAND_MODES,
+  SUPPORTED_CONFIG_LANGUAGE_COMMANDS,
+  SUPPORTED_CONFIG_SECTIONS,
+  SUPPORTED_DEMO_COMMANDS,
+  SUPPORTED_SPEC_COMMANDS,
+} = require('./lib/cli/command-registry');
+const { parseCliArgs } = require('./lib/cli/parser');
 const { createUx } = require('./lib/cli/ux');
 const { validateUxFlags } = require('./lib/cli/ux-flags');
+const {
+  DEFAULT_LANGUAGE,
+  extractCliLanguageFlag,
+  normalizeLanguage,
+  readProjectLanguageConfig,
+  resolveLanguage,
+  writeProjectLanguageConfig,
+} = require('./lib/i18n/language');
+const { createTranslator, getCatalog, translate } = require('./lib/i18n/catalog');
+const { formatWarningPrefix } = require('./lib/i18n/read-only-format');
 const { relativePosixPath, resolveTargetRoot } = require('./lib/paths');
 const {
   CURRENT_SCAN_RELATIVE_PATH,
@@ -78,73 +99,102 @@ const {
 const cliPackageJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../..', 'package.json'), 'utf8'));
 const CLI_VERSION = cliPackageJson.version || '0.0.0';
 
+let currentErrorLanguage = DEFAULT_LANGUAGE;
+
+function setCurrentErrorLanguage(language) {
+  currentErrorLanguage = language || DEFAULT_LANGUAGE;
+}
+
+function localizeParserMessage(message, language = currentErrorLanguage) {
+  const raw = String(message || '');
+  const missingValue = raw.match(/^missing value for (--[a-z0-9-]+)$/i);
+  if (missingValue) {
+    return translate(language, 'error.flag.missing_value', { flag: missingValue[1] });
+  }
+
+  const invalidValue = raw.match(/^invalid value for (--[a-z0-9-]+)$/i);
+  if (invalidValue) {
+    return translate(language, 'error.flag.invalid_value', { flag: invalidValue[1] });
+  }
+
+  const unknownFlag = raw.match(/^unknown flag: (.+)$/);
+  if (unknownFlag) {
+    return translate(language, 'error.flag.unknown', { flag: unknownFlag[1] });
+  }
+
+  return raw;
+}
+
 function formatError(message) {
-  return `create-quiver: ${message}`;
-}
-
-const SUPPORTED_COMMAND_MODES = new Set([
-  'init',
-  'version',
-  'flow',
-  'dashboard',
-  'plan',
-  'graph',
-  'next',
-  'doctor',
-  'prepare',
-  'analyze',
-  'migrate',
-  'start-slice',
-  'check-slice',
-  'check-pr',
-  'check-handoff',
-  'new-handoff',
-  'cleanup-slice',
-  'check-scope',
-  'refresh-active-slices',
-  'spec',
-  'evidence',
-  'demo',
-  'ai',
-]);
+  return `create-quiver: ${localizeParserMessage(message)}`;
+}
 
-const SUPPORTED_AI_COMMANDS = new Set([
-  'active-slice',
-  'agent',
-  'approve',
-  'approval-status',
-  'approvals',
-  'doctor',
-  'execute-plan',
-  'execute-slice',
-  'executor-prompt',
-  'export',
-  'inspect',
-  'onboard',
-  'plan',
-  'prepare-context',
-  'pr',
-  'prompt-slice',
-  'repair-plan',
-  'review-plan',
-  'revise',
-  'resume',
-  'run',
-  'slices',
-  'specs',
-  'status',
-  'trace',
-]);
+function helpCatalog(language = DEFAULT_LANGUAGE) {
+  const catalog = getCatalog(language);
+  return catalog.messages['cli.help'] || getCatalog(DEFAULT_LANGUAGE).messages['cli.help'] || {};
+}
+
+function helpText(help, section, key, fallback) {
+  return help?.[section]?.[key] || fallback;
+}
+
+function optionDescription(help, fallback) {
+  return helpText(help, 'optionDescriptions', fallback, fallback);
+}
 
-const SUPPORTED_SPEC_COMMANDS = new Set(['close', 'create', 'start', 'status', 'validate']);
-const SUPPORTED_DEMO_COMMANDS = new Set(['create']);
+function formatLanguageWarningForCli(warning, language = DEFAULT_LANGUAGE) {
+  if (!warning || warning.code !== 'UNSUPPORTED_LANGUAGE') {
+    return '';
+  }
+
+  return formatError(translate(language, 'warning.language.unsupported_source', {
+    fallback: warning.fallbackLanguage,
+    language: warning.requestedLanguage,
+    source: warning.source,
+    supported: warning.supportedLanguages.join(', '),
+  }));
+}
+
+const SLICE_NAMESPACE_COMMANDS = Object.freeze({
+  start: 'start-slice',
+  check: 'check-slice',
+  pr: 'check-pr',
+  scope: 'check-scope',
+  cleanup: 'cleanup-slice',
+  'refresh-active': 'refresh-active-slices',
+});
+
+const HANDOFF_NAMESPACE_COMMANDS = Object.freeze({
+  check: 'check-handoff',
+  new: 'new-handoff',
+});
+
+const LEGACY_NAMESPACE_ALIASES = Object.freeze({
+  'start-slice': 'slice start',
+  'check-slice': 'slice check',
+  'check-pr': 'slice pr',
+  'check-scope': 'slice scope',
+  'cleanup-slice': 'slice cleanup',
+  'refresh-active-slices': 'slice refresh-active',
+  'check-handoff': 'handoff check',
+  'new-handoff': 'handoff new',
+});
+
+function legacyNamespaceAliasFor(mode) {
+  return LEGACY_NAMESPACE_ALIASES[mode] || '';
+}
+
+function formatLegacyNamespaceWarning(mode, canonicalCommand) {
+  return `create-quiver: ${mode} is a legacy alias; use npx create-quiver ${canonicalCommand}.`;
+}
 
 function unsupportedCommandMessage(commandName) {
+  const translator = createTranslator(currentErrorLanguage);
   return [
-    `unsupported command: ${commandName}`,
-    'Run: npx create-quiver --help',
-    `If you meant to initialize a project, use: npx create-quiver init --name "${commandName}"`,
-    'If this command exists in newer docs, update create-quiver and rerun the command.',
+    translator.t('error.command.unsupported', { commandName }),
+    translator.t('error.command.help'),
+    translator.t('error.command.init_hint', { commandName }),
+    translator.t('error.command.update_hint'),
   ].join('\n');
 }
 
@@ -158,6 +208,8 @@ const COMMAND_HELP_GROUPS = [
       ['flow', 'Show the read-only guided workflow stage, blockers, and next safe command.'],
       ['dashboard', 'Show compact read-only project, spec, slice, run, approval, and agent status.'],
       ['version', 'Show a Quiver-branded version report; use --json for metadata.'],
+      ['changelog', 'Show recent local CHANGELOG.md release entries; use --json for metadata.'],
+      ['config language show|set', 'Inspect or update the effective Quiver language without editing JSON by hand.'],
       ['prepare', 'Run setup diagnostics for providers, GitHub, SSH, and project readiness.'],
       ['migrate', 'Upgrade an already initialized Quiver project to the current contract.'],
     ],
@@ -212,6 +264,8 @@ const COMMAND_HELP_GROUPS = [
       ['spec status', 'Show spec worktree, branch, slice-00 state, and pending slices.'],
       ['spec validate', 'Validate spec docs, slices, briefs, evidence, status, dependencies, and safe paths.'],
       ['spec close', 'Close a merged clean spec worktree and guide local sync.'],
+      ['slice start|check|pr|scope|cleanup|refresh-active', 'Canonical namespace for slice lifecycle, validation, scope, and board commands.'],
+      ['handoff check|new', 'Canonical namespace for validating or scaffolding handoff artifacts.'],
       ['start-slice', 'Start work on one slice and mark it active.'],
       ['check-slice', 'Validate slice structure, dependencies, scope, and readiness.'],
       ['check-pr', 'Validate PR readiness for a slice/spec workflow.'],
@@ -226,6 +280,8 @@ const COMMAND_HELP_GROUPS = [
     title: 'Evidence and demos',
     commands: [
       ['evidence run', 'Run a command and record exit code, duration, redacted output, and Markdown evidence.'],
+      ['evidence list', 'List local evidence records; use --json for automation.'],
+      ['evidence show', 'Show one local evidence record; use --json for automation.'],
       ['demo create spec-viewer', 'Create or preview the optional static Quiver Spec Viewer demo scaffold.'],
     ],
   },
@@ -240,25 +296,30 @@ const COMMAND_HELP_GROUPS = [
   },
 ];
 
-function formatCommandHelpGroups() {
-  const lines = ['Commands:'];
+function formatCommandHelpGroups(language = DEFAULT_LANGUAGE) {
+  const help = helpCatalog(language);
+  const lines = [helpText(help, 'headings', 'commands', 'Commands:')];
   for (const group of COMMAND_HELP_GROUPS) {
-    lines.push('', `${group.title}:`);
+    lines.push('', `${helpText(help, 'groupTitles', group.title, group.title)}:`);
     for (const [command, description] of group.commands) {
-      lines.push(`  ${command.padEnd(24)} ${description}`);
+      lines.push(`  ${command.padEnd(24)} ${helpText(help, 'commandDescriptions', command, description)}`);
     }
   }
   return lines.join('\n');
 }
 
-function printUsage() {
-  console.log(`Usage:
+function printUsage(language = DEFAULT_LANGUAGE) {
+  const help = helpCatalog(language);
+  console.log(`${helpText(help, 'headings', 'usage', 'Usage:')}
   npx create-quiver [options]
   npx create-quiver init [options]
   npx create-quiver analyze [options]
   npx create-quiver flow [options]
   npx create-quiver dashboard [options]
   npx create-quiver version [--json]
+  npx create-quiver changelog [--json]
+  npx create-quiver config language show [--json]
+  npx create-quiver config language set <en|es> [--global]
   npx create-quiver plan [options]
   npx create-quiver ai <task> [options]
   npx create-quiver ai run create --input <requirements.md>
@@ -294,62 +355,66 @@ function printUsage() {
   npx create-quiver spec status <spec-dir>
   npx create-quiver spec validate <spec-dir>
   npx create-quiver spec close <spec-dir>
-  npx create-quiver evidence run [options] -- <command>
+  npx create-quiver slice <start|check|pr|scope|cleanup|refresh-active> [options]
+  npx create-quiver handoff <check|new> [options]
+  npx create-quiver evidence <run|list|show> [options]
   npx create-quiver demo create spec-viewer [options]
 
-${formatCommandHelpGroups()}
-
-Options:
-  -n, --name <project-name>   Project name to generate
-  -d, --dir <target-dir>      Target directory to scaffold into or inspect
-      --spec <slug>           Restrict plan, graph, next, or dashboard output to one spec
-      --format <name>         Graph or AI export output format (tree, mermaid, dot, json, markdown)
-      --show-conflicts        Show shared file paths in graph output
-      --level <n>             Restrict graph output to one level
-      --json                  Emit machine-readable JSON
-      --include-completed     Include completed slices in dashboard, plan, graph, or next history output
-      --details               Show the full human dashboard report
-      --section <name>        Show one human dashboard section
-      --limit <n>             Limit dashboard human lists (1-100)
-      --only-ready            Show only slices with no pending dependencies
-      --all-ready             List every ready slice returned by next
-      --auto-start            Prompt for confirmation and run start-slice on next
-      --local                 For check-slice, run structural validation without remote/base checks
-      --strict                Treat supported validation warnings as failures
-      --unicode               Prefer Unicode output when supported
-      --minimal               Plan or run the minimal init profile
-      --full                  Plan or run the full compatibility init profile
-      --legacy-scripts        Include legacy Bash wrappers in init profile
-      --include-templates     Export packaged templates in init profile
-      --dry-run               Preview init, analyze, migrate, prepare, spec create/start/close, demo, ai agent set, or AI work without executing writes/providers
-      --print-prompt          Print the exact AI prompt and exit without executing provider CLIs
-      --with-planner          Enable planner-assisted behavior on commands that explicitly support it
-      --interactive           Enable prompts on commands that explicitly support interactive choices
-      --review                Open or prepare human review before persistent writes where supported
-      --methodology <name>    Select methodology where supported (currently wdd-sdd)
-      --no-color              Disable ANSI colors in human output
-      --fix                   For doctor, apply safe non-destructive repairs
-      --execute               For ai execute-plan, run the planned slices instead of printing commands
-      --create                For ai pr, create the PR after preflight instead of printing the plan only
-      --commit                For ai execute-slice, commit validated slice changes after provider, scope, and tests pass
-      --allow-dirty           For ai execute-slice, allow pre-existing dirty files and ignore them for scope diff
-      --mode <name>           Execution mode for ai execute-plan (auto, manual, delegated)
-      --provider <name>       Provider CLI to preflight for prepare or AI commands
-      --model <model-id>      Technical model id for AI agent profiles or provider-backed AI commands
-      --version <n>           Draft version to approve for AI planner phases
-      --run <id>              AI lifecycle run id
-      --ssh-host-alias <name> SSH host alias to validate for prepare or AI commands
-      --identity-file <path>  SSH identity file to validate for prepare or AI commands
-      --remote <name>         Git remote name for check-slice or AI PR checks
-      --base <branch>         Base branch for check-slice, check-scope, ai pr, or spec close (default: main)
-      --output <file>         Output file for evidence run
-      --max-output <n>        Maximum stdout/stderr chars per evidence section
-      --title <text>          Override PR title for ai pr create
-  -y, --yes                   Skip prompts and use the provided inputs
-  -V, --version               Show the installed create-quiver version
-  -h, --help                  Show this help message
-
-Examples:
+${formatCommandHelpGroups(language)}
+
+${helpText(help, 'headings', 'options', 'Options:')}
+  -n, --name <project-name>   ${optionDescription(help, 'Project name to generate')}
+  -d, --dir <target-dir>      ${optionDescription(help, 'Target directory to scaffold into or inspect')}
+      --spec <slug>           ${optionDescription(help, 'Restrict plan, graph, next, or dashboard output to one spec')}
+      --format <name>         ${optionDescription(help, 'Graph or AI export output format (tree, mermaid, dot, json, markdown)')}
+      --show-conflicts        ${optionDescription(help, 'Show shared file paths in graph output')}
+      --level <n>             ${optionDescription(help, 'Restrict graph output to one level')}
+      --json                  ${optionDescription(help, 'Emit machine-readable JSON')}
+      --lang <en|es>          ${optionDescription(help, 'Override CLI human output language')}
+      --global                ${optionDescription(help, 'For config language set, write the global user config')}
+      --include-completed     ${optionDescription(help, 'Include completed slices in dashboard, plan, graph, or next history output')}
+      --details               ${optionDescription(help, 'Show the full human dashboard report')}
+      --section <name>        ${optionDescription(help, 'Show one human dashboard section')}
+      --limit <n>             ${optionDescription(help, 'Limit dashboard human lists (1-100)')}
+      --only-ready            ${optionDescription(help, 'Show only slices with no pending dependencies')}
+      --all-ready             ${optionDescription(help, 'List every ready slice returned by next')}
+      --auto-start            ${optionDescription(help, 'Prompt for confirmation and run start-slice on next')}
+      --local                 ${optionDescription(help, 'For check-slice, run structural validation without remote/base checks')}
+      --strict                ${optionDescription(help, 'Treat supported validation warnings as failures')}
+      --unicode               ${optionDescription(help, 'Prefer Unicode output when supported')}
+      --minimal               ${optionDescription(help, 'Plan or run the minimal init profile')}
+      --full                  ${optionDescription(help, 'Plan or run the full compatibility init profile')}
+      --legacy-scripts        ${optionDescription(help, 'Include legacy Bash wrappers in init profile')}
+      --include-templates     ${optionDescription(help, 'Export packaged templates in init profile')}
+      --dry-run               ${optionDescription(help, 'Preview init, analyze, migrate, prepare, spec create/start/close, demo, ai agent set, or AI work without executing writes/providers')}
+      --print-prompt          ${optionDescription(help, 'Print the exact AI prompt and exit without executing provider CLIs')}
+      --with-planner          ${optionDescription(help, 'Enable planner-assisted behavior on commands that explicitly support it')}
+      --interactive           ${optionDescription(help, 'Enable prompts on commands that explicitly support interactive choices')}
+      --review                ${optionDescription(help, 'Open or prepare human review before persistent writes where supported')}
+      --methodology <name>    ${optionDescription(help, 'Select methodology where supported (currently wdd-sdd)')}
+      --no-color              ${optionDescription(help, 'Disable ANSI colors in human output')}
+      --fix                   ${optionDescription(help, 'For doctor, apply safe non-destructive repairs')}
+      --execute               ${optionDescription(help, 'For ai execute-plan, run the planned slices instead of printing commands')}
+      --create                ${optionDescription(help, 'For ai pr, create the PR after preflight instead of printing the plan only')}
+      --commit                ${optionDescription(help, 'For ai execute-slice, commit validated slice changes after provider, scope, and tests pass')}
+      --allow-dirty           ${optionDescription(help, 'For ai execute-slice, allow pre-existing dirty files and ignore them for scope diff')}
+      --mode <name>           ${optionDescription(help, 'Execution mode for ai execute-plan (auto, manual, delegated)')}
+      --provider <name>       ${optionDescription(help, 'Provider CLI to preflight for prepare or AI commands')}
+      --model <model-id>      ${optionDescription(help, 'Technical model id for AI agent profiles or provider-backed AI commands')}
+      --version <n>           ${optionDescription(help, 'Draft version to approve for AI planner phases')}
+      --run <id>              ${optionDescription(help, 'AI lifecycle run id')}
+      --ssh-host-alias <name> ${optionDescription(help, 'SSH host alias to validate for prepare or AI commands')}
+      --identity-file <path>  ${optionDescription(help, 'SSH identity file to validate for prepare or AI commands')}
+      --remote <name>         ${optionDescription(help, 'Git remote name for check-slice or AI PR checks')}
+      --base <branch>         ${optionDescription(help, 'Base branch override for check-slice, check-scope, check-pr, ai pr, spec start, or spec close')}
+      --output <file>         ${optionDescription(help, 'Output file for evidence run')}
+      --max-output <n>        ${optionDescription(help, 'Maximum stdout/stderr chars per evidence section')}
+      --title <text>          ${optionDescription(help, 'Override PR title for ai pr create')}
+  -y, --yes                   ${optionDescription(help, 'Skip prompts and confirm write prompts such as migrate')}
+  -V, --version               ${optionDescription(help, 'Show the installed create-quiver version')}
+  -h, --help                  ${optionDescription(help, 'Show this help message')}
+
+${helpText(help, 'headings', 'examples', 'Examples:')}
   npx create-quiver init --name "My Project"
   npx create-quiver init --interactive
   npx create-quiver init --name "My Project" --dry-run
@@ -361,6 +426,11 @@ Examples:
   cd ./my-project && npx create-quiver dashboard --json
   cd ./my-project && npx create-quiver version
   cd ./my-project && npx create-quiver version --json
+  cd ./my-project && npx create-quiver changelog
+  cd ./my-project && npx create-quiver changelog --json
+  cd ./my-project && npx create-quiver config language show
+  cd ./my-project && npx create-quiver config language set es
+  npx create-quiver config language set en --global
   cd ./my-project && npx create-quiver analyze
   cd ./my-project && npx create-quiver plan --json
   cd ./my-project && npx create-quiver ai onboard --dry-run
@@ -422,13 +492,15 @@ Examples:
   cd ./my-project && npx create-quiver spec status specs/my-project
   cd ./my-project && npx create-quiver spec validate specs/my-project
   cd ./my-project && npx create-quiver spec close specs/my-project --dry-run
+  cd ./my-project && npx create-quiver slice check --local specs/my-project/slices/slice-01/slice.json
+  cd ./my-project && npx create-quiver handoff check specs/my-project/slices/slice-01/EXECUTION_BRIEF.md
   cd ./my-project && npx create-quiver evidence run -- npm test
   cd ./my-project && npx create-quiver demo create spec-viewer --dry-run
   node bin/create-quiver.js doctor --dir ./my-project
 `);
 }
 
-function parseArgs(argv) {
+function parseArgs(argv, options = {}) {
   const result = {
     help: false,
     force: false,
@@ -448,8 +520,14 @@ function parseArgs(argv) {
     strict: false,
     strictOverlap: false,
     json: false,
+    language: options.language || '',
+    languageResolution: null,
     noColor: false,
     withPlanner: false,
+    configGlobal: false,
+    configSection: '',
+    configCommand: '',
+    configValue: '',
     interactive: false,
     review: false,
     includeCompleted: false,
@@ -501,22 +579,33 @@ function parseArgs(argv) {
     initLegacyScripts: false,
     initMinimal: false,
     specCommand: '',
+    sliceCommand: '',
+    handoffCommand: '',
+    legacyAliasCommand: '',
     demoCommand: '',
     demoName: '',
     evidenceCommand: '',
     evidenceArgs: [],
     evidenceOutput: '',
     evidenceMaxOutput: null,
+    evidenceTarget: '',
   };
 
   const args = [...argv];
   if (SUPPORTED_COMMAND_MODES.has(args[0])) {
     result.mode = args[0];
+    result.legacyAliasCommand = legacyNamespaceAliasFor(result.mode);
     result.explicitInit = args[0] === 'init';
     args.shift();
     if (result.mode === 'spec') {
       result.specCommand = args.shift() || '';
     }
+    if (result.mode === 'slice') {
+      result.sliceCommand = args.shift() || '';
+    }
+    if (result.mode === 'handoff') {
+      result.handoffCommand = args.shift() || '';
+    }
     if (result.mode === 'evidence') {
       result.evidenceCommand = args.shift() || '';
     }
@@ -535,9 +624,11 @@ function parseArgs(argv) {
     args.shift();
   } else if (args[0] === '--check-handoff') {
     result.mode = 'check-handoff';
+    result.legacyAliasCommand = legacyNamespaceAliasFor(result.mode);
     args.shift();
   } else if (args[0] === '--new-handoff') {
     result.mode = 'new-handoff';
+    result.legacyAliasCommand = legacyNamespaceAliasFor(result.mode);
     args.shift();
   } else if (args[0] && !args[0].startsWith('-')) {
     throw new Error(formatError(unsupportedCommandMessage(args[0])));
@@ -588,11 +679,13 @@ function parseArgs(argv) {
 
     if (arg === '--check-handoff') {
       result.mode = 'check-handoff';
+      result.legacyAliasCommand = legacyNamespaceAliasFor(result.mode);
       continue;
     }
 
     if (arg === '--new-handoff') {
       result.mode = 'new-handoff';
+      result.legacyAliasCommand = legacyNamespaceAliasFor(result.mode);
       continue;
     }
 
@@ -700,6 +793,11 @@ function parseArgs(argv) {
       continue;
     }
 
+    if (arg === '--global') {
+      result.configGlobal = true;
+      continue;
+    }
+
     if (arg === '--with-planner') {
       result.withPlanner = true;
       continue;
@@ -1104,6 +1202,32 @@ function parseArgs(argv) {
     if (positional.length > 0) {
       throw new Error(formatError('dashboard does not accept positional arguments; use --spec <slug>'));
     }
+  } else if (result.mode === 'config') {
+    if (!result.configSection && positional.length > 0) {
+      result.configSection = positional.shift();
+    }
+    if (!SUPPORTED_CONFIG_SECTIONS.has(result.configSection)) {
+      throw new Error(formatError(translate(currentErrorLanguage, 'config.error.unsupported_section', {
+        section: result.configSection || '(missing)',
+      })));
+    }
+    if (!result.configCommand && positional.length > 0) {
+      result.configCommand = positional.shift();
+    }
+    if (!SUPPORTED_CONFIG_LANGUAGE_COMMANDS.has(result.configCommand)) {
+      throw new Error(formatError(translate(currentErrorLanguage, 'config.error.unsupported_language_command', {
+        command: result.configCommand || '(missing)',
+      })));
+    }
+    if (result.configCommand === 'set') {
+      if (positional.length === 0) {
+        throw new Error(formatError('missing language for config language set. Use: npx create-quiver config language set <en|es>'));
+      }
+      result.configValue = positional.shift();
+    }
+    if (result.configCommand === 'show' && positional.length > 0) {
+      throw new Error(formatError('config language show does not accept a language value'));
+    }
   } else if (result.mode === 'ai') {
     if (!result.aiCommand && positional.length > 0) {
       result.aiCommand = positional.shift();
@@ -1142,6 +1266,38 @@ function parseArgs(argv) {
     if (positional.length > 0) {
       throw new Error(formatError('refresh-active-slices does not accept positional arguments'));
     }
+  } else if (result.mode === 'slice') {
+    if (!result.sliceCommand && positional.length > 0) {
+      result.sliceCommand = positional.shift();
+    }
+    const mappedMode = SLICE_NAMESPACE_COMMANDS[result.sliceCommand];
+    if (!mappedMode) {
+      throw new Error(formatError(`unsupported slice subcommand: ${result.sliceCommand || '(missing)'}. Supported tasks: start, check, pr, scope, cleanup, refresh-active`));
+    }
+    result.mode = mappedMode;
+    if (mappedMode === 'refresh-active-slices') {
+      if (positional.length > 0) {
+        throw new Error(formatError('slice refresh-active does not accept positional arguments'));
+      }
+    } else {
+      result.targetDir = positional.shift() || '';
+      if (!result.targetDir) {
+        throw new Error(formatError(`slice ${result.sliceCommand} requires a slice.json path`));
+      }
+    }
+  } else if (result.mode === 'handoff') {
+    if (!result.handoffCommand && positional.length > 0) {
+      result.handoffCommand = positional.shift();
+    }
+    const mappedMode = HANDOFF_NAMESPACE_COMMANDS[result.handoffCommand];
+    if (!mappedMode) {
+      throw new Error(formatError(`unsupported handoff subcommand: ${result.handoffCommand || '(missing)'}. Supported tasks: check, new`));
+    }
+    result.mode = mappedMode;
+    result.targetDir = positional.shift() || '';
+    if (!result.targetDir) {
+      throw new Error(formatError(`handoff ${result.handoffCommand} requires ${result.handoffCommand === 'new' ? 'a spec slug' : 'a handoff or brief path'}`));
+    }
   } else if (result.mode === 'spec') {
     if (!result.specCommand && positional.length > 0) {
       result.specCommand = positional.shift();
@@ -1160,14 +1316,26 @@ function parseArgs(argv) {
       result.evidenceCommand = positional.shift();
     }
     if (!result.evidenceCommand) {
-      throw new Error(formatError('missing evidence subcommand. Use: npx create-quiver evidence run -- <command>'));
+      throw new Error(formatError('missing evidence subcommand. Use: npx create-quiver evidence <run|list|show>'));
     }
-    if (result.evidenceCommand !== 'run') {
-      throw new Error(formatError(`unsupported evidence subcommand: ${result.evidenceCommand}. Supported tasks: run`));
+    if (!['run', 'list', 'show'].includes(result.evidenceCommand)) {
+      throw new Error(formatError(`unsupported evidence subcommand: ${result.evidenceCommand}. Supported tasks: run, list, show`));
     }
-    if (positional.length > 0) {
+    if (result.evidenceCommand === 'run' && positional.length > 0) {
       throw new Error(formatError('evidence run does not accept positional arguments before --'));
     }
+    if (result.evidenceCommand === 'list' && positional.length > 0) {
+      throw new Error(formatError('evidence list does not accept positional arguments'));
+    }
+    if (result.evidenceCommand === 'show') {
+      result.evidenceTarget = positional.shift() || '';
+      if (!result.evidenceTarget) {
+        throw new Error(formatError('evidence show requires an evidence file path'));
+      }
+      if (positional.length > 0) {
+        throw new Error(formatError('evidence show accepts exactly one evidence file path'));
+      }
+    }
   } else if (result.mode === 'demo') {
     if (!result.demoCommand && positional.length > 0) {
       result.demoCommand = positional.shift();
@@ -1205,6 +1373,14 @@ function parseArgs(argv) {
     throw new Error(formatError(`${requestedDashboardFlags.join(', ')} ${requestedDashboardFlags.length === 1 ? 'is' : 'are'} only supported by dashboard. Use: npx create-quiver dashboard ${requestedDashboardFlags[0]}${requestedDashboardFlags[0] === '--section' ? ' <name>' : requestedDashboardFlags[0] === '--limit' ? ' <n>' : ''}`));
   }
 
+  if (result.mode !== 'config' && result.configGlobal) {
+    throw new Error(formatError('--global is only supported by config language set. Use: npx create-quiver config language set <en|es> --global'));
+  }
+
+  if (result.mode === 'config' && result.configGlobal && result.configCommand !== 'set') {
+    throw new Error(formatError('--global is only supported by config language set. Use: npx create-quiver config language set <en|es> --global'));
+  }
+
   return result;
 }
 
@@ -1349,6 +1525,7 @@ function runInitDocs(repoRoot, projectName, options = {}) {
     migrateMode: false,
     profile: options.profile || 'default',
     templateRoot: templateRoot.path,
+    language: options.language || '',
   });
 }
 
@@ -2202,24 +2379,56 @@ function writeProjectScanArtifacts(projectRoot, scan) {
   return { jsonPath, mdPath: scanPaths.projectMapPath };
 }
 
-function runAnalyze(targetDir, options = {}) {
+function createCommandProgressUx(options = {}) {
+  return createUx({
+    env: options.env || process.env,
+    error: options.error,
+    input: options.input,
+    interactive: false,
+    json: options.json,
+    noColor: options.noColor,
+    output: options.output,
+    prompts: options.prompts,
+    spinner: options.noColor === true ? false : options.spinner,
+    stderrIsTTY: options.stderrIsTTY,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    write: options.write,
+  });
+}
+
+async function runProgress(ux, message, task, successMessage = message) {
+  return ux.withSpinner(message, task, {
+    echo: false,
+    successMessage,
+  });
+}
+
+async function runAnalyze(targetDir, options = {}) {
   const projectRoot = resolveTargetRoot(process.cwd(), targetDir);
+  const translator = createTranslator(options.language);
+  const progress = createCommandProgressUx(options);
 
   if (!fs.existsSync(projectRoot)) {
     throw new Error(formatError(`target directory does not exist: ${projectRoot}`));
   }
 
-  const scan = buildProjectScan(projectRoot);
+  const scan = await runProgress(
+    progress,
+    translator.t('analyze.progress.scanning'),
+    () => buildProjectScan(projectRoot),
+    translator.t('analyze.progress.scanned'),
+  );
 
   if (options.dryRun) {
-    console.log(`Project analysis dry-run for ${projectRoot}`);
-    console.log('Writes: none');
-    console.log(`Would write ${CURRENT_SCAN_RELATIVE_PATH}`);
-    console.log(`Would write ${PROJECT_MAP_RELATIVE_PATH}`);
-    console.log('Would refresh docs/AI_CONTEXT.md');
-    console.log(`Detected primary stack: ${scan.stack.primary}`);
-    console.log(`Detected frameworks: ${scan.stack.frameworks.length > 0 ? scan.stack.frameworks.join(', ') : 'none detected'}`);
-    console.log(`Detected package manager: ${scan.project.package_manager}`);
+    console.log(translator.t('analyze.dry_run_for', { path: projectRoot }));
+    console.log(translator.t('analyze.writes_none'));
+    console.log(translator.t('analyze.would_write', { path: CURRENT_SCAN_RELATIVE_PATH }));
+    console.log(translator.t('analyze.would_write', { path: PROJECT_MAP_RELATIVE_PATH }));
+    console.log(translator.t('analyze.would_refresh', { path: 'docs/AI_CONTEXT.md' }));
+    console.log(translator.t('analyze.detected_primary_stack', { stack: scan.stack.primary }));
+    console.log(translator.t('analyze.detected_frameworks', { frameworks: scan.stack.frameworks.length > 0 ? scan.stack.frameworks.join(', ') : translator.t('common.none_detected') }));
+    console.log(translator.t('analyze.detected_package_manager', { manager: scan.project.package_manager }));
     return {
       artifacts: {
         jsonPath: path.join(projectRoot, CURRENT_SCAN_RELATIVE_PATH),
@@ -2230,16 +2439,31 @@ function runAnalyze(targetDir, options = {}) {
     };
   }
 
-  const artifacts = writeProjectScanArtifacts(projectRoot, scan);
-  const aiContextPath = refreshAiContextDoc(projectRoot, scan);
-  updateStateForAnalyze(projectRoot, CLI_VERSION);
+  const artifacts = await runProgress(
+    progress,
+    translator.t('analyze.progress.writing_artifacts'),
+    () => writeProjectScanArtifacts(projectRoot, scan),
+    translator.t('analyze.progress.artifacts_written'),
+  );
+  const aiContextPath = await runProgress(
+    progress,
+    translator.t('analyze.progress.refreshing_context'),
+    () => refreshAiContextDoc(projectRoot, scan),
+    translator.t('analyze.progress.context_refreshed'),
+  );
+  await runProgress(
+    progress,
+    translator.t('analyze.progress.updating_state'),
+    () => updateStateForAnalyze(projectRoot, CLI_VERSION),
+    translator.t('analyze.progress.state_updated'),
+  );
 
-  console.log(`Project analysis completed for ${projectRoot}`);
-  console.log(`Wrote ${relativePosixPath(projectRoot, artifacts.jsonPath)}`);
-  console.log(`Wrote ${relativePosixPath(projectRoot, artifacts.mdPath)}`);
-  console.log(`Wrote ${relativePosixPath(projectRoot, aiContextPath)}`);
-  console.log(`Detected primary stack: ${scan.stack.primary}`);
-  console.log(`Detected package manager: ${scan.project.package_manager}`);
+  console.log(translator.t('analyze.completed_for', { path: projectRoot }));
+  console.log(translator.t('analyze.wrote', { path: relativePosixPath(projectRoot, artifacts.jsonPath) }));
+  console.log(translator.t('analyze.wrote', { path: relativePosixPath(projectRoot, artifacts.mdPath) }));
+  console.log(translator.t('analyze.wrote', { path: relativePosixPath(projectRoot, aiContextPath) }));
+  console.log(translator.t('analyze.detected_primary_stack', { stack: scan.stack.primary }));
+  console.log(translator.t('analyze.detected_package_manager', { manager: scan.project.package_manager }));
 
   return {
     artifacts,
@@ -2249,8 +2473,41 @@ function runAnalyze(targetDir, options = {}) {
   };
 }
 
-function runMigrate(targetDir, options = {}) {
+async function confirmMigrateWrite(projectRoot, options, translator) {
+  if (options.force === true) {
+    return;
+  }
+
+  const ux = createUx({
+    env: options.env,
+    error: options.error,
+    input: options.input,
+    interactive: true,
+    json: options.json,
+    noColor: options.noColor,
+    output: options.output,
+    promptConfirm: options.promptConfirm,
+    stderrIsTTY: options.stderrIsTTY,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    write: options.write,
+  });
+
+  if (!ux.mode.usePrompts) {
+    throw new Error(formatError(translator.t('migrate.confirm.required')));
+  }
+
+  const confirmed = await ux.promptConfirm(translator.t('migrate.confirm.prompt', { path: projectRoot }), {
+    initialValue: false,
+  });
+  if (!confirmed) {
+    throw new Error(formatError(translator.t('migrate.confirm.declined')));
+  }
+}
+
+async function runMigrate(targetDir, options = {}) {
   const projectRoot = resolveTargetRoot(process.cwd(), targetDir);
+  const translator = createTranslator(options.language);
 
   if (!fs.existsSync(projectRoot)) {
     throw new Error(formatError(`target directory does not exist: ${projectRoot}`));
@@ -2273,22 +2530,24 @@ function runMigrate(targetDir, options = {}) {
       projectName,
       skipInstall: options.skipInstall === true,
     });
-    console.log('Quiver migration dry-run');
-    console.log(`- Project: ${projectName}`);
-    console.log(`- Target: ${projectRoot}`);
-    console.log('- Writes: none');
-    console.log(`- Planned create: ${migrationPlan.summary.create}`);
-    console.log(`- Planned update: ${migrationPlan.summary.update}`);
-    console.log(`- Planned preserve: ${migrationPlan.summary.preserve}`);
+    console.log(translator.t('migrate.dry_run_title'));
+    console.log(`- ${translator.t('migrate.project', { project: projectName })}`);
+    console.log(`- ${translator.t('migrate.target', { path: projectRoot })}`);
+    console.log(`- ${translator.t('migrate.writes_none')}`);
+    console.log(`- ${translator.t('migrate.planned_create', { count: migrationPlan.summary.create })}`);
+    console.log(`- ${translator.t('migrate.planned_update', { count: migrationPlan.summary.update })}`);
+    console.log(`- ${translator.t('migrate.planned_preserve', { count: migrationPlan.summary.preserve })}`);
     if (legacyLayout.hasLegacyLayout) {
-      console.log(`- Legacy layout detected and preserved: ${legacyLayout.legacyPaths.join(', ')}`);
+      console.log(`- ${translator.t('migrate.legacy_preserved', { paths: legacyLayout.legacyPaths.join(', ') })}`);
     }
-    console.log('- Next command: npx create-quiver migrate --skip-install');
+    console.log(`- ${translator.t('migrate.next_command', { command: 'npx create-quiver migrate --skip-install' })}`);
     console.log('');
     console.log(formatInitLayoutPlan(migrationPlan));
     return;
   }
 
+  await confirmMigrateWrite(projectRoot, options, translator);
+
   const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'quiver-migrate-'));
 
   try {
@@ -2314,10 +2573,10 @@ function runMigrate(targetDir, options = {}) {
       }
     }
 
-    console.log(`Quiver migration completed for ${projectRoot}`);
-    console.log('Missing workflow files were restored without overwriting existing project files.');
+    console.log(translator.t('migrate.completed_for', { path: projectRoot }));
+    console.log(translator.t('migrate.restored_missing'));
     if (legacyLayout.hasLegacyLayout) {
-      console.log(`Legacy layout detected and preserved: ${legacyLayout.legacyPaths.join(', ')}`);
+      console.log(translator.t('migrate.legacy_preserved', { paths: legacyLayout.legacyPaths.join(', ') }));
     }
   } finally {
     fs.rmSync(tempRoot, { recursive: true, force: true });
@@ -2558,6 +2817,7 @@ function buildDoctorCommandReport(projectRoot) {
 }
 
 function formatDoctorHumanReport(report, options = {}) {
+  const translator = createTranslator(options.language);
   const lines = [];
   const ux = createUx({
     ...options,
@@ -2574,19 +2834,39 @@ function formatDoctorHumanReport(report, options = {}) {
     if (status === 'error') return 'error';
     return 'warning';
   };
+  const localizeDoctorText = (message) => {
+    const text = String(message || '');
+    let match = text.match(/^Quiver doctor passed for (.+)$/);
+    if (match) return translator.t('doctor.check.passed_for', { path: match[1] });
+    match = text.match(/^Layout: (.+)$/);
+    if (match) return translator.t('doctor.check.layout', { layout: match[1] });
+    if (text === 'Specs: none yet') return translator.t('doctor.check.specs_none');
+    match = text.match(/^Specs: (.+)$/);
+    if (match) return translator.t('doctor.check.specs_found', { specs: match[1] });
+    if (text === 'Required files found') return translator.t('doctor.check.required_files_found');
+    if (text === 'Workflow scripts available') return translator.t('doctor.check.workflow_scripts_available');
+    if (text === 'Quiver state metadata found') return translator.t('doctor.check.state_found');
+    if (text === 'Project analysis artifacts found') return translator.t('doctor.check.project_analysis_found');
+    if (text === 'No specs yet. That is valid after the AI-first init flow.') return translator.t('doctor.fix.no_specs_yet');
+    if (text === 'Run `npx create-quiver analyze` to generate docs/PROJECT_MAP.md when you want the visible project map.') return translator.t('doctor.fix.generate_project_map');
+    if (text === 'Analyze the project first: npx create-quiver analyze') return translator.t('doctor.fix.analyze_first');
+    if (text === 'Check the next ready slice: npx create-quiver next') return translator.t('doctor.fix.check_next');
+    if (text === 'Create real specs and slices only after acceptance criteria are approved and the technical plan is reviewed and approved.') return translator.t('doctor.fix.create_specs_after_approval');
+    return formatWarningPrefix(text, translator);
+  };
 
-  ux.section('Quiver Doctor');
+  ux.section(translator.t('doctor.title'));
   ux.line('');
-  ux.line('Checks');
+  ux.line(translator.t('doctor.checks'));
   for (const check of report.checks) {
-    const line = `  ${symbolForStatus(check.status)} ${check.message}`;
+    const line = `  ${symbolForStatus(check.status)} ${localizeDoctorText(check.message)}`;
     ux.line(ux.mode.decoration ? ux.theme.status(colorForStatus(check.status), line) : line);
   }
 
   ux.line('');
-  ux.line('Suggested fixes');
+  ux.line(translator.t('doctor.suggested_fixes'));
   for (const fix of report.suggested_fixes) {
-    const line = `  ${ux.theme.symbols.bullet} ${fix}`;
+    const line = `  ${ux.theme.symbols.bullet} ${localizeDoctorText(fix)}`;
     ux.line(ux.mode.decoration ? ux.theme.status('command', line) : line);
   }
 
@@ -2640,6 +2920,74 @@ const INIT_PROFILE_OPTIONS = Object.freeze([
   },
 ]);
 
+function initModeOptions(translator) {
+  return [
+    {
+      label: translator.t('init.mode.existing.label'),
+      value: 'existing',
+      hint: translator.t('init.mode.existing.hint'),
+      default: true,
+    },
+    {
+      label: translator.t('init.mode.new.label'),
+      value: 'new',
+      hint: translator.t('init.mode.new.hint'),
+    },
+    {
+      label: translator.t('init.mode.validate.label'),
+      value: 'validate',
+      hint: translator.t('init.mode.validate.hint'),
+    },
+  ];
+}
+
+function methodologyOptions(translator) {
+  return [
+    {
+      label: translator.t('init.methodology.wdd_sdd.label'),
+      value: 'wdd-sdd',
+      hint: translator.t('init.methodology.wdd_sdd.hint'),
+      default: true,
+    },
+  ];
+}
+
+function initProfileOptions(translator) {
+  return [
+    {
+      label: 'Default',
+      value: 'default',
+      hint: translator.t('init.profile.default.hint'),
+      default: true,
+    },
+    {
+      label: 'Minimal',
+      value: 'minimal',
+      hint: translator.t('init.profile.minimal.hint'),
+    },
+    {
+      label: 'Full compatibility',
+      value: 'full',
+      hint: translator.t('init.profile.full.hint'),
+    },
+  ];
+}
+
+function initLanguageOptions() {
+  return [
+    {
+      label: 'English',
+      value: 'en',
+      hint: 'en',
+    },
+    {
+      label: 'Español',
+      value: 'es',
+      hint: 'es',
+    },
+  ];
+}
+
 function hasDirectoryContent(dirPath) {
   return fs.existsSync(dirPath)
     && fs.statSync(dirPath).isDirectory()
@@ -2657,8 +3005,16 @@ function assertSupportedMethodology(value) {
   return normalized;
 }
 
+function resolveExistingProjectLanguage(targetDir) {
+  const config = readProjectLanguageConfig(targetDir);
+  return normalizeLanguage(config.language);
+}
+
 async function resolveInteractiveInitOptions(args, targetDir, projectName, options = {}) {
   const explicitMethodology = assertSupportedMethodology(args.methodology);
+  const language = normalizeLanguage(options.language || args.language) || DEFAULT_LANGUAGE;
+  const translator = createTranslator(language);
+  const existingProjectLanguage = resolveExistingProjectLanguage(targetDir);
 
   if (args.interactive !== true) {
     return {
@@ -2669,6 +3025,7 @@ async function resolveInteractiveInitOptions(args, targetDir, projectName, optio
       methodology: explicitMethodology,
       minimal: args.initMinimal,
       projectName,
+      language: '',
     };
   }
 
@@ -2702,58 +3059,66 @@ async function resolveInteractiveInitOptions(args, targetDir, projectName, optio
     stdoutIsTTY: options.stdoutIsTTY,
   };
 
-  ux.heading('Bienvenido a Quiver');
-  const selectedMode = await selectOption('¿Qué querés configurar?', INIT_MODE_OPTIONS, {
+  ux.heading(translator.t('init.heading'));
+  const selectedMode = await selectOption(translator.t('init.prompt.mode'), initModeOptions(translator), {
     ...selectorOptions,
     defaultValue: hasDirectoryContent(targetDir) ? 'existing' : 'new',
     flag: 'init|doctor',
     name: 'init mode',
   });
-  const selectedMethodology = await selectOption('¿Qué metodología vas a usar?', METHODOLOGY_OPTIONS, {
+  const selectedMethodology = await selectOption(translator.t('init.prompt.methodology'), methodologyOptions(translator), {
     ...selectorOptions,
     defaultValue: explicitMethodology,
     flag: '--methodology',
     name: 'methodology',
     value: args.methodology || '',
   });
+  const selectedLanguage = await selectOption(translator.t('init.prompt.language'), initLanguageOptions(), {
+    ...selectorOptions,
+    defaultValue: existingProjectLanguage || language,
+    flag: '--lang|config language set',
+    name: 'project language',
+  });
 
   assertSupportedMethodology(selectedMethodology.value);
 
   if (selectedMode.value === 'validate') {
     ux.summary([
-      { label: 'Modo', value: 'Solo validar estructura' },
-      { label: 'Metodologia', value: selectedMethodology.label },
-      { label: 'Comando equivalente', value: 'npx create-quiver doctor' },
-    ], { title: 'Configuracion elegida' });
+      { label: translator.t('init.summary.mode'), value: selectedMode.label },
+      { label: translator.t('init.summary.methodology'), value: selectedMethodology.label },
+      { label: translator.t('init.summary.language'), value: selectedLanguage.value },
+      { label: translator.t('init.summary.equivalent_command'), value: 'npx create-quiver doctor' },
+    ], { title: translator.t('init.summary.title') });
     if (!args.force && !args.dryRun) {
-      const confirmed = await ux.promptConfirm('Ejecutar Doctor ahora?', { initialValue: true });
+      const confirmed = await ux.promptConfirm(translator.t('init.confirm.doctor'), { initialValue: true });
       if (!confirmed) {
         throw new Error(formatError('init interactive validation declined. No files were written.'));
       }
     }
     return {
       action: 'doctor',
+      language: selectedLanguage.value,
       methodology: selectedMethodology.value,
       projectName,
     };
   }
 
   const defaultProfile = args.initFull ? 'full' : args.initMinimal ? 'minimal' : 'default';
-  const selectedProfile = await selectOption('¿Qué contrato inicial querés crear?', INIT_PROFILE_OPTIONS, {
+  const selectedProfile = await selectOption(translator.t('init.prompt.profile'), initProfileOptions(translator), {
     ...selectorOptions,
     defaultValue: defaultProfile,
     flag: '--minimal|--full',
     name: 'init profile',
   });
-  const agentGuidance = await selectOption('¿Querés ver el próximo paso para perfiles de agentes?', [
+  const agentGuidance = await selectOption(translator.t('init.prompt.agent_guidance'), [
     {
-      label: 'Mostrar comandos sugeridos',
+      label: translator.t('init.agent_guidance.show.label'),
       value: 'show',
-      hint: 'No guarda credenciales ni ejecuta proveedores',
+      hint: translator.t('init.agent_guidance.show.hint'),
       default: true,
     },
     {
-      label: 'Omitir por ahora',
+      label: translator.t('init.agent_guidance.skip.label'),
       value: 'skip',
     },
   ], {
@@ -2766,28 +3131,30 @@ async function resolveInteractiveInitOptions(args, targetDir, projectName, optio
     full: selectedProfile.value === 'full',
     includeTemplates: args.initIncludeTemplates || selectedProfile.value === 'full',
     legacyScripts: args.initLegacyScripts,
+    language: selectedLanguage.value,
     methodology: selectedMethodology.value,
     minimal: selectedProfile.value === 'minimal',
     projectName,
   };
 
   ux.summary([
-    { label: 'Proyecto', value: projectName },
-    { label: 'Modo', value: selectedMode.label },
-    { label: 'Metodologia', value: selectedMethodology.label },
-    { label: 'Perfil', value: selectedProfile.label },
-    { label: 'Perfiles de agentes', value: agentGuidance.value === 'show' ? 'mostrar proximo paso' : 'omitir' },
-  ], { title: 'Configuracion elegida' });
+    { label: translator.t('init.summary.project'), value: projectName },
+    { label: translator.t('init.summary.mode'), value: selectedMode.label },
+    { label: translator.t('init.summary.methodology'), value: selectedMethodology.label },
+    { label: translator.t('init.summary.language'), value: selectedLanguage.value },
+    { label: translator.t('init.summary.profile'), value: selectedProfile.label },
+    { label: translator.t('init.summary.agent_profiles'), value: agentGuidance.value === 'show' ? translator.t('init.agent_guidance.show.summary') : translator.t('init.agent_guidance.skip.summary') },
+  ], { title: translator.t('init.summary.title') });
 
   if (agentGuidance.value === 'show') {
     ux.nextSteps([
       'npx create-quiver ai agent set planner --provider codex --model gpt-5.5 --dry-run',
       'npx create-quiver ai agent set executor --provider claude --model claude-sonnet-4-6 --dry-run',
-    ], { title: 'Despues de inicializar' });
+    ], { title: translator.t('init.next_steps.after_init') });
   }
 
   if (!args.force && !args.dryRun) {
-    const confirmed = await ux.promptConfirm(`Inicializar Quiver en ${targetDir}?`, { initialValue: true });
+    const confirmed = await ux.promptConfirm(translator.t('init.confirm.initialize', { path: targetDir }), { initialValue: true });
     if (!confirmed) {
       throw new Error(formatError('init interactive approval declined. No files were written.'));
     }
@@ -2799,6 +3166,46 @@ async function resolveInteractiveInitOptions(args, targetDir, projectName, optio
   };
 }
 
+function persistInitLanguage(targetDir, initOptions = {}) {
+  if (!initOptions.language) {
+    return null;
+  }
+  writeProjectLanguageConfig(targetDir, initOptions.language);
+  return {
+    language: initOptions.language,
+    path: path.join(targetDir, '.quiver', 'config.json'),
+  };
+}
+
+function resolveInitGeneratedLanguage(args, targetDir, initOptions = {}) {
+  if (initOptions.language) {
+    return {
+      configLanguage: initOptions.language,
+      docsLanguage: initOptions.language,
+    };
+  }
+
+  if (args.languageResolution?.source === '--lang') {
+    return {
+      configLanguage: args.language,
+      docsLanguage: args.language,
+    };
+  }
+
+  const existingProjectLanguage = resolveExistingProjectLanguage(targetDir);
+  if (existingProjectLanguage) {
+    return {
+      configLanguage: existingProjectLanguage,
+      docsLanguage: existingProjectLanguage,
+    };
+  }
+
+  return {
+    configLanguage: '',
+    docsLanguage: args.language || DEFAULT_LANGUAGE,
+  };
+}
+
 function runDoctor(targetDir, options = {}) {
   const projectRoot = resolveTargetRoot(process.cwd(), targetDir);
 
@@ -2837,6 +3244,7 @@ function runDoctor(targetDir, options = {}) {
     console.log(JSON.stringify(commandReport, null, 2));
   } else {
     process.stdout.write(formatDoctorHumanReport(commandReport, {
+      language: options.language,
       noColor: options.noColor,
       unicode: options.unicode,
     }));
@@ -2847,38 +3255,84 @@ function runDoctor(targetDir, options = {}) {
   }
 }
 
-function printInitNextSteps(targetDir, projectName) {
+function printInitNextSteps(targetDir, projectName, options = {}) {
+  const translator = createTranslator(options.language);
   console.log('');
-  console.log('Next steps:');
-  console.log(`- Review AGENTS.md, then ${path.join(targetDir, 'docs', 'AI_ONBOARDING_PROMPT.md')}`);
-  console.log(`- Review ${path.join(targetDir, 'docs', 'WORKFLOW.md')}`);
-  console.log('- Analyze the project with npx create-quiver analyze');
-  console.log('- Create real specs and slices after acceptance criteria are approved and the technical plan is reviewed and approved.');
+  console.log(translator.t('init.next_steps.title'));
+  console.log(`- ${translator.t('init.next_steps.review_agents', { path: path.join(targetDir, 'docs', 'AI_ONBOARDING_PROMPT.md') })}`);
+  console.log(`- ${translator.t('init.next_steps.review_workflow', { path: path.join(targetDir, 'docs', 'WORKFLOW.md') })}`);
+  console.log(`- ${translator.t('init.next_steps.analyze')}`);
+  console.log(`- ${translator.t('init.next_steps.create_specs')}`);
 }
 
 async function run(argv) {
-  if (argv.length === 1 && argv[0] === 'help') {
-    printUsage();
+  let languageArgs;
+  try {
+    languageArgs = extractCliLanguageFlag(argv);
+  } catch (error) {
+    const languageResolution = resolveLanguage({
+      env: process.env,
+      projectRoot: process.cwd(),
+    });
+    setCurrentErrorLanguage(languageResolution.language);
+    throw new Error(formatError(error.message));
+  }
+
+  const normalizedArgv = languageArgs.argv;
+  const languageResolution = resolveLanguage({
+    cliLanguage: languageArgs.language,
+    env: process.env,
+    projectRoot: process.cwd(),
+  });
+  setCurrentErrorLanguage(languageResolution.language);
+
+  if (normalizedArgv.length === 1 && normalizedArgv[0] === 'help') {
+    printUsage(languageResolution.language);
     return;
   }
 
-  if (argv.length === 1 && (argv[0] === '-V' || argv[0] === '--version')) {
+  if (normalizedArgv.length === 1 && (normalizedArgv[0] === '-V' || normalizedArgv[0] === '--version')) {
     console.log(CLI_VERSION);
     return;
   }
 
-  const args = parseArgs(argv);
+  const args = parseCliArgs(normalizedArgv, {
+    language: languageArgs.language,
+    legacyParseArgs: parseArgs,
+  });
+  args.languageResolution = languageResolution;
+  args.language = args.languageResolution.language;
 
   if (args.help) {
-    printUsage();
+    if (!args.json) {
+      for (const warning of args.languageResolution.warnings || []) {
+        process.stderr.write(`${formatLanguageWarningForCli(warning, args.language)}\n`);
+      }
+    }
+    printUsage(args.language);
     return;
   }
 
   validateUxFlags(args);
 
+  if (!args.json) {
+    for (const warning of args.languageResolution.warnings || []) {
+      process.stderr.write(`${formatLanguageWarningForCli(warning, args.language)}\n`);
+    }
+    if (args.legacyAliasCommand) {
+      process.stderr.write(`${formatLegacyNamespaceWarning(args.mode, args.legacyAliasCommand)}\n`);
+    }
+  }
+
   if (args.mode === 'analyze') {
-    runAnalyze(args.targetDir, {
+    await runAnalyze(args.targetDir, {
       dryRun: args.dryRun,
+      json: args.json,
+      language: args.language,
+      noColor: args.noColor,
+      stderrIsTTY: Boolean(process.stderr.isTTY),
+      stdinIsTTY: Boolean(process.stdin.isTTY),
+      stdoutIsTTY: Boolean(process.stdout.isTTY),
     });
     return;
   }
@@ -2886,6 +3340,7 @@ async function run(argv) {
   if (args.mode === 'flow') {
     await runFlow(process.cwd(), {
       json: args.json,
+      language: args.language,
     });
     return;
   }
@@ -2895,6 +3350,7 @@ async function run(argv) {
       details: args.dashboardDetails,
       includeCompleted: args.includeCompleted,
       json: args.json,
+      language: args.language,
       limit: args.dashboardLimit,
       noColor: args.noColor,
       optionErrors: args.dashboardOptionErrors,
@@ -2914,6 +3370,7 @@ async function run(argv) {
     } else {
       process.stdout.write(formatHumanVersionReport(report, {
         env: process.env,
+        language: args.language,
         noColor: args.noColor,
         stdoutIsTTY: Boolean(process.stdout.isTTY),
       }));
@@ -2921,10 +3378,29 @@ async function run(argv) {
     return;
   }
 
+  if (args.mode === 'changelog') {
+    runChangelog({ json: args.json });
+    return;
+  }
+
+  if (args.mode === 'config') {
+    runConfig(process.cwd(), {
+      command: args.configCommand,
+      global: args.configGlobal,
+      json: args.json,
+      language: args.language,
+      languageResolution: args.languageResolution,
+      section: args.configSection,
+      value: args.configValue,
+    });
+    return;
+  }
+
   if (args.mode === 'plan') {
     runPlan(process.cwd(), {
       includeCompleted: args.includeCompleted,
       json: args.json,
+      language: args.language,
       onlyReady: args.onlyReady,
       specSlug: args.specSlug,
       unicode: args.unicode,
@@ -2951,6 +3427,7 @@ async function run(argv) {
       runAiLifecycleRun(process.cwd(), {
         command: args.aiRunCommand,
         input: args.aiInput || undefined,
+        language: args.language,
         runId: args.aiRunId || undefined,
         specSlug: args.specSlug || undefined,
       });
@@ -2961,12 +3438,14 @@ async function run(argv) {
       runAiActiveSlice(process.cwd(), {
         command: args.aiSecondaryCommand || 'status',
         dryRun: args.dryRun,
+        language: args.language,
       });
       return;
     }
 
     if (args.aiCommand === 'status') {
       runAiLifecycleStatus(process.cwd(), {
+        language: args.language,
         runId: args.aiRunId || undefined,
       });
       return;
@@ -2974,6 +3453,7 @@ async function run(argv) {
 
     if (args.aiCommand === 'resume') {
       runAiLifecycleResume(process.cwd(), {
+        language: args.language,
         runId: args.aiRunId || undefined,
       });
       return;
@@ -2982,6 +3462,7 @@ async function run(argv) {
     if (args.aiCommand === 'inspect') {
       runAiInspect(process.cwd(), {
         includeCompleted: args.includeCompleted,
+        language: args.language,
       });
       return;
     }
@@ -2990,6 +3471,7 @@ async function run(argv) {
       runAiExport(process.cwd(), {
         format: args.formatExplicit ? args.format : 'json',
         includeCompleted: args.includeCompleted,
+        language: args.language,
       });
       return;
     }
@@ -2998,6 +3480,7 @@ async function run(argv) {
       runAiSpecsList(process.cwd(), {
         includeCompleted: args.includeCompleted,
         json: args.json,
+        language: args.language,
       });
       return;
     }
@@ -3006,6 +3489,7 @@ async function run(argv) {
       runAiSlicesList(process.cwd(), {
         includeCompleted: args.includeCompleted,
         json: args.json,
+        language: args.language,
       });
       return;
     }
@@ -3013,6 +3497,7 @@ async function run(argv) {
     if (args.aiCommand === 'trace') {
       runAiTraceReport(process.cwd(), {
         includeCompleted: args.includeCompleted,
+        language: args.language,
       });
       return;
     }
@@ -3020,6 +3505,7 @@ async function run(argv) {
     if (args.aiCommand === 'models') {
       runAiModelsList({
         json: args.json,
+        language: args.language,
         provider: args.aiProviderExplicit ? args.aiProvider : undefined,
       });
       return;
@@ -3034,6 +3520,7 @@ async function run(argv) {
         id: args.aiProfileId || undefined,
         interactive: args.interactive,
         json: args.json,
+        language: args.language,
         label: args.aiLabel || undefined,
         model: args.aiModel || undefined,
         provider: args.aiProviderExplicit ? args.aiProvider : undefined,
@@ -3052,6 +3539,7 @@ async function run(argv) {
         provider: args.aiProvider,
         providerExplicit: args.aiProviderExplicit,
         model: args.aiModel || undefined,
+        language: args.language,
         plannerProfile: args.aiPlannerProfile || undefined,
         role: args.aiRole,
         timeout: args.aiTimeout,
@@ -3064,6 +3552,7 @@ async function run(argv) {
         context: args.aiContext || undefined,
         dryRun: args.dryRun,
         interactive: args.interactive,
+        language: args.language,
         printPrompt: args.aiPrintPrompt,
         provider: args.aiProvider,
         providerExplicit: args.aiProviderExplicit,
@@ -3084,6 +3573,7 @@ async function run(argv) {
         dryRun: args.dryRun,
         input: args.aiInput || undefined,
         phase: args.aiPhase,
+        language: args.language,
         printPrompt: args.aiPrintPrompt,
         provider: args.aiProvider,
         providerExplicit: args.aiProviderExplicit,
@@ -3105,6 +3595,7 @@ async function run(argv) {
         context: args.aiContext || undefined,
         dryRun: args.dryRun,
         input: args.aiInput || undefined,
+        language: args.language,
         printPrompt: args.aiPrintPrompt,
         provider: args.aiProvider,
         providerExplicit: args.aiProviderExplicit,
@@ -3120,6 +3611,7 @@ async function run(argv) {
         context: args.aiContext || undefined,
         dryRun: args.dryRun,
         input: args.aiInput || undefined,
+        language: args.language,
         printPrompt: args.aiPrintPrompt,
         provider: args.aiProvider,
         providerExplicit: args.aiProviderExplicit,
@@ -3138,6 +3630,7 @@ async function run(argv) {
         dryRun: args.dryRun,
         input: args.aiInput || undefined,
         phase: args.aiPhase,
+        language: args.language,
         printPrompt: args.aiPrintPrompt,
         provider: args.aiProvider,
         providerExplicit: args.aiProviderExplicit,
@@ -3154,6 +3647,7 @@ async function run(argv) {
       await runAiApprove(process.cwd(), {
         dryRun: args.dryRun,
         input: args.aiInput || undefined,
+        language: args.language,
         phase: args.aiPhase,
         runId: args.aiRunId || undefined,
         version: args.aiVersion || undefined,
@@ -3162,7 +3656,9 @@ async function run(argv) {
     }
 
     if (args.aiCommand === 'approvals' || args.aiCommand === 'approval-status') {
-      await runAiApprovalStatus(process.cwd());
+      await runAiApprovalStatus(process.cwd(), {
+        language: args.language,
+      });
       return;
     }
 
@@ -3174,6 +3670,7 @@ async function run(argv) {
         dryRun: args.dryRun,
         executorProfile: args.aiExecutorProfile || undefined,
         interactive: args.interactive,
+        language: args.language,
         model: args.aiModel || undefined,
         provider: args.aiProvider,
         providerExplicit: args.aiProviderExplicit,
@@ -3186,6 +3683,7 @@ async function run(argv) {
 
     if (args.aiCommand === 'prompt-slice' || args.aiCommand === 'executor-prompt') {
       runAiPromptSlice(process.cwd(), {
+        language: args.language,
         slice: args.aiSlice || undefined,
       });
       return;
@@ -3201,6 +3699,7 @@ async function run(argv) {
         executorProfile: args.aiExecutorProfile || undefined,
         interactive: args.interactive,
         json: args.json,
+        language: args.language,
         model: args.aiModel || undefined,
         mode: args.aiExecutionMode,
         provider: args.aiProvider,
@@ -3224,11 +3723,12 @@ async function run(argv) {
 
     if (args.aiCommand === 'pr') {
       await runAiPr(process.cwd(), {
-        baseBranch: args.aiBaseBranch,
+        baseBranch: args.baseBranchExplicit ? args.aiBaseBranch : '',
         create: args.aiCreate,
         dryRun: args.dryRun,
         input: args.aiInput || undefined,
         interactive: args.interactive,
+        language: args.language,
         remote: args.aiRemote || undefined,
         review: args.review,
         sshHostAlias: args.aiSshHostAlias || undefined,
@@ -3246,6 +3746,7 @@ async function run(argv) {
       format: args.format,
       includeCompleted: args.includeCompleted,
       json: args.json,
+      language: args.language,
       level: args.level,
       showConflicts: args.showConflicts,
       specSlug: args.specSlug,
@@ -3260,6 +3761,7 @@ async function run(argv) {
       autoStart: args.autoStart,
       includeCompleted: args.includeCompleted,
       json: args.json,
+      language: args.language,
       specSlug: args.specSlug,
     });
     return;
@@ -3268,9 +3770,12 @@ async function run(argv) {
   if (args.mode === 'evidence') {
     const result = runEvidence(process.cwd(), {
       command: args.evidenceArgs,
+      language: args.language,
       maxOutput: args.evidenceMaxOutput || undefined,
       output: args.evidenceOutput || undefined,
+      json: args.json,
       subcommand: args.evidenceCommand,
+      target: args.evidenceTarget,
     });
     process.exitCode = result.exitCode;
     return;
@@ -3282,15 +3787,23 @@ async function run(argv) {
       command: args.demoCommand,
       demo: args.demoName,
       dryRun: args.dryRun,
+      language: args.language,
       targetRoot: demoTarget,
     });
     return;
   }
 
   if (args.mode === 'migrate') {
-    runMigrate(args.targetDir, {
+    await runMigrate(args.targetDir, {
       dryRun: args.dryRun,
+      force: args.force,
+      json: args.json,
+      language: args.language,
+      noColor: args.noColor,
       skipInstall: args.skipInstall,
+      stderrIsTTY: Boolean(process.stderr.isTTY),
+      stdinIsTTY: Boolean(process.stdin.isTTY),
+      stdoutIsTTY: Boolean(process.stdout.isTTY),
     });
     return;
   }
@@ -3300,6 +3813,7 @@ async function run(argv) {
       dryRun: args.dryRun,
       fix: args.doctorFix,
       json: args.json,
+      language: args.language,
       noColor: args.noColor,
       unicode: args.unicode,
     });
@@ -3307,7 +3821,10 @@ async function run(argv) {
   }
 
   if (args.mode === 'start-slice') {
-    startSlice(args.targetDir, { allowDraft: args.allowDraft });
+    startSlice(args.targetDir, {
+      allowDraft: args.allowDraft,
+      language: args.language,
+    });
     return;
   }
 
@@ -3315,6 +3832,7 @@ async function run(argv) {
     checkSliceReadiness(args.targetDir, {
       baseBranch: args.baseBranchExplicit ? args.aiBaseBranch : '',
       gate: args.gate,
+      language: args.language,
       local: args.checkSliceLocal,
       remote: args.aiRemote,
       strictOverlap: args.strictOverlap,
@@ -3323,7 +3841,11 @@ async function run(argv) {
   }
 
   if (args.mode === 'check-pr') {
-    checkPrReadiness(args.targetDir);
+    checkPrReadiness(args.targetDir, {
+      baseBranch: args.baseBranchExplicit ? args.aiBaseBranch : '',
+      language: args.language,
+      remote: args.aiRemote,
+    });
     return;
   }
 
@@ -3333,16 +3855,21 @@ async function run(argv) {
     if (!handoffInput || handoffInput === '.') {
       throw new Error(formatError('missing handoff or brief path. Use: npx create-quiver check-handoff specs/<spec-slug>/HANDOFF.md or specs/<spec-slug>/slices/<slice-id>/EXECUTION_BRIEF.md'));
     }
-    const resolved = checkHandoff(handoffInput, repoRoot);
-    console.log(`PASS: ${resolved.label} validated at ${resolved.relativePath}`);
+    const translator = createTranslator(args.language);
+    const resolved = checkHandoff(handoffInput, repoRoot, { language: args.language });
+    console.log(translator.t('handoff.validated', {
+      path: resolved.relativePath,
+      subject: translator.t(`handoff.label.${resolved.kind}`),
+    }));
     return;
   }
 
   if (args.mode === 'new-handoff') {
     const repoRoot = process.cwd();
     const handoffSlug = args.targetDir;
+    const translator = createTranslator(args.language);
     const resolved = scaffoldHandoff(handoffSlug, repoRoot);
-    console.log(`PASS: Handoff scaffolded at ${resolved.relativePath}`);
+    console.log(translator.t('handoff.scaffolded', { path: resolved.relativePath }));
     return;
   }
 
@@ -3352,6 +3879,7 @@ async function run(argv) {
       discard: args.discard,
       dryRun: args.dryRun,
       force: args.force,
+      language: args.language,
     });
     return;
   }
@@ -3359,6 +3887,7 @@ async function run(argv) {
   if (args.mode === 'check-scope') {
     checkScope(args.targetDir, {
       baseBranch: args.baseBranchExplicit ? args.aiBaseBranch : '',
+      language: args.language,
       remote: args.aiRemote,
       strict: args.strict,
     });
@@ -3377,6 +3906,7 @@ async function run(argv) {
         dryRun: args.dryRun,
         input: args.aiInput || undefined,
         interactive: args.interactive,
+        language: args.language,
         methodology: args.methodology || undefined,
         review: args.review,
         specSlug: args.specSlug || undefined,
@@ -3386,25 +3916,27 @@ async function run(argv) {
     }
 
     if (!args.targetDir || args.targetDir === '.') {
-      throw new Error(formatError('missing spec directory. Use: npx create-quiver spec <start|status|validate|close> <spec-dir>'));
+      throw new Error(formatError(createTranslator(args.language).t('spec.error.missing_directory_command')));
     }
 
     if (args.specCommand === 'start') {
       const report = startSpecWorktree(process.cwd(), args.targetDir, {
+        baseBranch: args.baseBranchExplicit ? args.aiBaseBranch : '',
         dryRun: args.dryRun,
       });
-      process.stdout.write(formatSpecStartResult(report));
+      process.stdout.write(formatSpecStartResult(report, { language: args.language }));
       return;
     }
 
     if (args.specCommand === 'status') {
       const report = buildSpecStatus(process.cwd(), args.targetDir);
-      process.stdout.write(formatSpecStatus(report));
+      process.stdout.write(formatSpecStatus(report, { language: args.language }));
       return;
     }
 
     if (args.specCommand === 'validate') {
       runValidateSpec(process.cwd(), args.targetDir, {
+        language: args.language,
         strict: args.strict,
       });
       return;
@@ -3412,13 +3944,13 @@ async function run(argv) {
 
     if (args.specCommand === 'close') {
       const report = closeSpecWorktree(process.cwd(), args.targetDir, {
-        baseBranch: args.aiBaseBranch,
+        baseBranch: args.baseBranchExplicit ? args.aiBaseBranch : '',
         discard: args.discard,
         dryRun: args.dryRun,
         force: args.force,
         remote: args.aiRemote,
       });
-      process.stdout.write(formatSpecCloseResult(report));
+      process.stdout.write(formatSpecCloseResult(report, { language: args.language }));
       return;
     }
 
@@ -3439,11 +3971,13 @@ async function run(argv) {
     });
     return;
   }
+  const initLanguage = resolveInitGeneratedLanguage(args, targetDir, initOptions);
   const initLayout = buildInitLayout(targetDir, {
     compatibilityAlias: !args.explicitInit,
     dryRun: args.dryRun,
     full: initOptions.full,
     includeTemplates: initOptions.includeTemplates,
+    language: initLanguage.configLanguage,
     legacyScripts: initOptions.legacyScripts,
     minimal: initOptions.minimal,
     projectName: initOptions.projectName,
@@ -3456,23 +3990,60 @@ async function run(argv) {
   }
 
   const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'quiver-create-'));
+  const translator = createTranslator(args.language);
+  const progress = createCommandProgressUx({
+    json: args.json,
+    noColor: args.noColor,
+    stderrIsTTY: Boolean(process.stderr.isTTY),
+    stdinIsTTY: Boolean(process.stdin.isTTY),
+    stdoutIsTTY: Boolean(process.stdout.isTTY),
+  });
 
   try {
-    ensureDir(targetDir);
-
-    const templateRoot = packTemplate(packageRoot, tempRoot);
+    let templateRoot = '';
+    await runProgress(
+      progress,
+      translator.t('init.progress.preparing_templates'),
+      () => {
+        ensureDir(targetDir);
+        templateRoot = packTemplate(packageRoot, tempRoot);
+        return templateRoot;
+      },
+      translator.t('init.progress.templates_ready'),
+    );
     if (initLayout.profile === 'full') {
-      exportTemplatesToLegacyRoot(templateRoot, targetDir);
-    }
-    runInitDocs(targetDir, initOptions.projectName, {
-      includeTemplates: initOptions.includeTemplates,
-      legacyScripts: initOptions.legacyScripts,
-      profile: initLayout.profile,
-      templateRoot,
-    });
+      await runProgress(
+        progress,
+        translator.t('init.progress.exporting_templates'),
+        () => exportTemplatesToLegacyRoot(templateRoot, targetDir),
+        translator.t('init.progress.templates_exported'),
+      );
+    }
+    let languageWrite = null;
+    await runProgress(
+      progress,
+      translator.t('init.progress.writing_docs'),
+      () => {
+        runInitDocs(targetDir, initOptions.projectName, {
+          includeTemplates: initOptions.includeTemplates,
+          language: initLanguage.docsLanguage,
+          legacyScripts: initOptions.legacyScripts,
+          profile: initLayout.profile,
+          templateRoot,
+        });
+        languageWrite = persistInitLanguage(targetDir, { language: initLanguage.configLanguage });
+        return languageWrite;
+      },
+      translator.t('init.progress.docs_written'),
+    );
 
     if (!args.skipInstall) {
-      const installResult = installSelfAsDevDep(targetDir, CLI_VERSION);
+      const installResult = await runProgress(
+        progress,
+        translator.t('init.progress.installing_package'),
+        () => installSelfAsDevDep(targetDir, CLI_VERSION),
+        translator.t('init.progress.install_checked'),
+      );
       if (installResult === 'installed') {
         console.log(`Added create-quiver@${CLI_VERSION} as dev dependency`);
       } else if (installResult === 'failed') {
@@ -3480,14 +4051,18 @@ async function run(argv) {
       }
     }
 
-    console.log(`Installed Quiver into ${targetDir}`);
-    printInitNextSteps(targetDir, initOptions.projectName);
+    console.log(translator.t('init.installed', { path: targetDir }));
+    if (languageWrite) {
+      console.log(translator.t('init.language.saved', { language: languageWrite.language }));
+    }
+    printInitNextSteps(targetDir, initOptions.projectName, { language: args.language });
   } finally {
     fs.rmSync(tempRoot, { recursive: true, force: true });
   }
 }
 
 module.exports = {
+  persistInitLanguage,
   resolveInteractiveInitOptions,
   runAnalyze,
   runDashboard,