create-quiver 0.15.4 → 0.16.0

package/src/create-quiver/lib/ai/github.js

@@ -3,7 +3,7 @@ const os = require('node:os');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 
-const { currentBranch, hasRemote, isCleanWorktree } = require('../git');
+const { currentBranch, hasRemote, isCleanWorktree, resolveBaseBranchName } = require('../git');
 const { createTranslator } = require('../i18n/catalog');
 const { parseJsonWithComments } = require('../json');
 const { formatActionableError } = require('../actionable-error');
@@ -510,7 +510,10 @@ function buildPrCreateArgs(plan) {
 function buildPrCreatePlan(repoRoot, preflightReport, options = {}) {
   const prBody = readPrBody(repoRoot, options.prBodyPath || options.input);
   ensureNoOpenSlicesForPrBody(repoRoot, prBody.path);
-  const baseBranch = String(options.baseBranch || 'main').trim() || 'main';
+  const baseBranch = resolveBaseBranchName(repoRoot, {
+    explicitBaseBranch: options.baseBranch,
+    remote: preflightReport.remote || DEFAULT_REMOTE,
+  });
   const title = String(options.title || '').trim() || extractPrTitle(prBody.body, preflightReport.branchName);
   const plan = {
     baseBranch,

package/src/create-quiver/lib/ai/spec-templates.js

@@ -289,6 +289,25 @@ function buildPrMarkdown(manifest) {
     '',
     'Generate the spec foundation, slice-00, implementation slices, execution plan, and PR body from the approved planning input.',
     '',
+    '## PR Policy',
+    '',
+    '- [ ] One slice only.',
+    '- [ ] Grouped PR exception: at most 2-3 slices, all docs-only, research-only, or low-risk mechanical cleanup.',
+    '- [ ] No behavior changes in a grouped PR.',
+    '- [ ] No mixed docs with UI, backend, refactor, or performance work.',
+    '- [ ] Separate evidence for each included slice.',
+    '- [ ] Whole PR is revertible without leaving partial state.',
+    '',
+    'Individual PR required when the slice includes functional code, UI/UX, Supabase, Edge Functions, auth, storage, preview, performance/code-splitting, refactors, or tests/CI changes that affect gates.',
+    '',
+    '### Merge Policy',
+    '',
+    '- [ ] Human merge expected.',
+    '- [ ] Assisted auto-merge explicitly authorized for this PR or documented category.',
+    '- [ ] Assisted auto-merge conditions met: docs-only or chore-only, low risk, no runtime changes, no production configuration changes, green checks, and no pending comments.',
+    '',
+    'Assisted auto-merge is prohibited for UI, Supabase, Edge Functions, auth, storage, preview, performance, refactors, and changes with doubtful rollback.',
+    '',
     '## Scope',
     '',
     '- `SPEC.md`',

package/src/create-quiver/lib/cli/command-registry.js

@@ -0,0 +1,71 @@
+const SUPPORTED_COMMAND_MODES = new Set([
+  'init',
+  'version',
+  'changelog',
+  'flow',
+  'dashboard',
+  'plan',
+  'graph',
+  'next',
+  'doctor',
+  'prepare',
+  'analyze',
+  'migrate',
+  'slice',
+  'handoff',
+  'start-slice',
+  'check-slice',
+  'check-pr',
+  'check-handoff',
+  'new-handoff',
+  'cleanup-slice',
+  'check-scope',
+  'config',
+  'refresh-active-slices',
+  'spec',
+  'evidence',
+  'demo',
+  'ai',
+]);
+
+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',
+]);
+
+const SUPPORTED_SPEC_COMMANDS = new Set(['close', 'create', 'start', 'status', 'validate']);
+const SUPPORTED_DEMO_COMMANDS = new Set(['create']);
+const SUPPORTED_CONFIG_SECTIONS = new Set(['language']);
+const SUPPORTED_CONFIG_LANGUAGE_COMMANDS = new Set(['show', 'set']);
+
+module.exports = {
+  SUPPORTED_AI_COMMANDS,
+  SUPPORTED_COMMAND_MODES,
+  SUPPORTED_CONFIG_LANGUAGE_COMMANDS,
+  SUPPORTED_CONFIG_SECTIONS,
+  SUPPORTED_DEMO_COMMANDS,
+  SUPPORTED_SPEC_COMMANDS,
+};

package/src/create-quiver/lib/cli/parser.js

@@ -0,0 +1,14 @@
+function parseCliArgs(argv, options = {}) {
+  const legacyParseArgs = options.legacyParseArgs;
+  if (typeof legacyParseArgs !== 'function') {
+    throw new TypeError('parseCliArgs requires a legacyParseArgs adapter');
+  }
+
+  return legacyParseArgs(argv, {
+    language: options.language,
+  });
+}
+
+module.exports = {
+  parseCliArgs,
+};

package/src/create-quiver/lib/evidence.js

@@ -3,6 +3,23 @@ const path = require('path');
 const { spawnSync } = require('node:child_process');
 
 const DEFAULT_OUTPUT_LIMIT = 4000;
+const SIGNAL_NUMBERS = {
+  SIGHUP: 1,
+  SIGINT: 2,
+  SIGQUIT: 3,
+  SIGILL: 4,
+  SIGTRAP: 5,
+  SIGABRT: 6,
+  SIGBUS: 7,
+  SIGFPE: 8,
+  SIGKILL: 9,
+  SIGUSR1: 10,
+  SIGSEGV: 11,
+  SIGUSR2: 12,
+  SIGPIPE: 13,
+  SIGALRM: 14,
+  SIGTERM: 15,
+};
 
 function redactSecrets(text) {
   return String(text || '')
@@ -40,6 +57,83 @@ function defaultEvidencePath(repoRoot, startedAt = new Date()) {
   return path.join(repoRoot, '.quiver', 'evidence', `evidence-${stamp}.md`);
 }
 
+function isPathInside(parentPath, childPath) {
+  const relative = path.relative(parentPath, childPath);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function realpathExistingAncestor(targetPath) {
+  let current = targetPath;
+  while (!fs.existsSync(current)) {
+    const next = path.dirname(current);
+    if (next === current) {
+      return fs.realpathSync(current);
+    }
+    current = next;
+  }
+  return fs.realpathSync(current);
+}
+
+function assertSafeProjectPath(repoRoot, targetPath, label = 'evidence path') {
+  const rootPath = path.resolve(repoRoot);
+  const rootReal = fs.realpathSync(rootPath);
+  const resolved = path.resolve(rootPath, targetPath);
+  const ancestorReal = realpathExistingAncestor(resolved);
+  const pathLooksInsideRoot = isPathInside(rootPath, resolved) || isPathInside(rootReal, resolved);
+
+  if (!pathLooksInsideRoot || !isPathInside(rootReal, ancestorReal)) {
+    throw new Error(`create-quiver: ${label} must stay inside the project root.`);
+  }
+
+  return resolved;
+}
+
+function resolveEvidenceOutputPath(repoRoot, outputPath, startedAtDate = new Date()) {
+  const resolved = outputPath
+    ? assertSafeProjectPath(repoRoot, outputPath, 'evidence output path')
+    : defaultEvidencePath(repoRoot, startedAtDate);
+  const directory = path.dirname(resolved);
+
+  if (fs.existsSync(resolved) && fs.lstatSync(resolved).isSymbolicLink()) {
+    throw new Error('create-quiver: evidence output path cannot be a symlink.');
+  }
+
+  fs.mkdirSync(directory, { recursive: true });
+  const rootReal = fs.realpathSync(repoRoot);
+  const directoryReal = fs.realpathSync(directory);
+  if (!isPathInside(rootReal, directoryReal)) {
+    throw new Error('create-quiver: evidence output path must stay inside the project root.');
+  }
+
+  return resolved;
+}
+
+function resolveEvidenceReadPath(repoRoot, evidencePath) {
+  if (!evidencePath) {
+    throw new Error('create-quiver: evidence show requires an evidence file path.');
+  }
+
+  const resolved = assertSafeProjectPath(repoRoot, evidencePath, 'evidence read path');
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`create-quiver: evidence file not found: ${evidencePath}`);
+  }
+
+  const rootReal = fs.realpathSync(repoRoot);
+  const fileReal = fs.realpathSync(resolved);
+  if (!isPathInside(rootReal, fileReal)) {
+    throw new Error('create-quiver: evidence read path must stay inside the project root.');
+  }
+
+  return resolved;
+}
+
+function signalExitCode(signal) {
+  if (!signal) {
+    return null;
+  }
+  return 128 + (SIGNAL_NUMBERS[signal] || 0) || 1;
+}
+
 function renderEvidenceMarkdown(record) {
   return `# Quiver Evidence
 
@@ -48,6 +142,7 @@ function renderEvidenceMarkdown(record) {
 - Duration ms: ${record.duration_ms}
 - Started at: ${record.started_at}
 - Finished at: ${record.finished_at}
+- Signal: ${record.signal || '-'}
 - Output truncated: ${record.output_truncated ? 'yes' : 'no'}
 
 ## Stdout
@@ -66,10 +161,11 @@ ${record.stderr || ''}
 
 function runEvidenceCommand(repoRoot, commandArgs, options = {}) {
   if (!Array.isArray(commandArgs) || commandArgs.length === 0) {
-    throw new Error('create-quiver: evidence run requires a command after --');
+    throw new Error(options.missingCommandMessage || 'create-quiver: evidence run requires a command after --');
   }
 
   const startedAtDate = new Date();
+  const outputPath = resolveEvidenceOutputPath(repoRoot, options.outputPath, startedAtDate);
   const started = Date.now();
   const result = (options.spawnSync || spawnSync)(commandArgs[0], commandArgs.slice(1), {
     cwd: repoRoot,
@@ -78,7 +174,8 @@ function runEvidenceCommand(repoRoot, commandArgs, options = {}) {
   });
   const finishedAtDate = new Date();
   const duration = Date.now() - started;
-  const exitCode = typeof result.status === 'number' ? result.status : 1;
+  const signal = result.signal || '';
+  const exitCode = typeof result.status === 'number' ? result.status : (signalExitCode(signal) || 1);
   const stdout = truncateText(redactSecrets(result.stdout || ''), options.maxOutput || DEFAULT_OUTPUT_LIMIT);
   const stderr = truncateText(redactSecrets(result.stderr || result.error?.message || ''), options.maxOutput || DEFAULT_OUTPUT_LIMIT);
   const record = {
@@ -87,15 +184,12 @@ function runEvidenceCommand(repoRoot, commandArgs, options = {}) {
     exit_code: exitCode,
     finished_at: finishedAtDate.toISOString(),
     output_truncated: stdout.truncated || stderr.truncated,
+    signal,
     stderr: stderr.text,
     stdout: stdout.text,
     started_at: startedAtDate.toISOString(),
   };
-  const outputPath = options.outputPath
-    ? path.resolve(repoRoot, options.outputPath)
-    : defaultEvidencePath(repoRoot, startedAtDate);
 
-  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
   fs.writeFileSync(outputPath, renderEvidenceMarkdown(record));
 
   return {
@@ -105,11 +199,72 @@ function runEvidenceCommand(repoRoot, commandArgs, options = {}) {
   };
 }
 
+function parseEvidenceMarkdown(content) {
+  const text = String(content || '');
+  const field = (label) => {
+    const match = text.match(new RegExp(`^- ${label}: (.*)$`, 'm'));
+    return match ? match[1].trim() : '';
+  };
+  const rawExitCode = field('Exit code');
+  const rawDuration = field('Duration ms');
+
+  return {
+    command: field('Command').replace(/^`|`$/g, ''),
+    duration_ms: Number.isFinite(Number(rawDuration)) ? Number(rawDuration) : null,
+    exit_code: Number.isFinite(Number(rawExitCode)) ? Number(rawExitCode) : null,
+    finished_at: field('Finished at'),
+    output_truncated: field('Output truncated') === 'yes',
+    signal: field('Signal') === '-' ? '' : field('Signal'),
+    started_at: field('Started at'),
+  };
+}
+
+function listEvidenceFiles(repoRoot) {
+  const evidenceDir = path.join(repoRoot, '.quiver', 'evidence');
+  if (!fs.existsSync(evidenceDir)) {
+    return [];
+  }
+
+  const rootReal = fs.realpathSync(repoRoot);
+  const dirReal = fs.realpathSync(evidenceDir);
+  if (!isPathInside(rootReal, dirReal)) {
+    throw new Error('create-quiver: evidence directory must stay inside the project root.');
+  }
+
+  return fs.readdirSync(evidenceDir)
+    .filter((entry) => entry.endsWith('.md'))
+    .sort()
+    .map((entry) => {
+      const filePath = path.join(evidenceDir, entry);
+      const content = fs.readFileSync(resolveEvidenceReadPath(repoRoot, filePath), 'utf8');
+      return {
+        path: path.relative(repoRoot, filePath).split(path.sep).join('/'),
+        ...parseEvidenceMarkdown(content),
+      };
+    });
+}
+
+function showEvidenceFile(repoRoot, evidencePath) {
+  const resolved = resolveEvidenceReadPath(repoRoot, evidencePath);
+  const content = fs.readFileSync(resolved, 'utf8');
+  return {
+    content,
+    path: path.relative(repoRoot, resolved).split(path.sep).join('/'),
+    record: parseEvidenceMarkdown(content),
+  };
+}
+
 module.exports = {
   DEFAULT_OUTPUT_LIMIT,
   defaultEvidencePath,
+  listEvidenceFiles,
+  parseEvidenceMarkdown,
   redactSecrets,
   renderEvidenceMarkdown,
+  resolveEvidenceOutputPath,
+  resolveEvidenceReadPath,
   runEvidenceCommand,
+  showEvidenceFile,
+  signalExitCode,
   truncateText,
 };

package/src/create-quiver/lib/git.js

@@ -2,6 +2,8 @@ const cp = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
+const DEFAULT_BASE_BRANCH_CANDIDATES = ['main', 'master', 'develop'];
+
 function runGit(args, cwd, options = {}) {
   return cp.execFileSync('git', args, {
     cwd,
@@ -123,6 +125,98 @@ function hasRemote(repoRoot, remoteName = 'origin') {
   return remoteList(repoRoot).includes(remoteName);
 }
 
+function normalizeBranchName(value) {
+  return String(value || '').trim();
+}
+
+function remoteHeadBranch(repoRoot, remote = 'origin') {
+  const value = tryGit(['symbolic-ref', '--quiet', '--short', `refs/remotes/${remote}/HEAD`], repoRoot);
+  const prefix = `${remote}/`;
+  return value.startsWith(prefix) ? value.slice(prefix.length) : '';
+}
+
+function uniqueBaseCandidates(candidates) {
+  const seen = new Set();
+  return candidates.filter((candidate) => {
+    const branch = normalizeBranchName(candidate.branch);
+    if (!branch || seen.has(branch)) {
+      return false;
+    }
+    seen.add(branch);
+    candidate.branch = branch;
+    return true;
+  });
+}
+
+function buildBaseBranchCandidates(repoRoot, options = {}) {
+  const remote = options.remote || 'origin';
+  const explicitBaseBranch = normalizeBranchName(options.explicitBaseBranch);
+  const preferredBaseBranch = normalizeBranchName(options.preferredBaseBranch);
+  const defaults = Array.isArray(options.defaultBranches) && options.defaultBranches.length > 0
+    ? options.defaultBranches
+    : DEFAULT_BASE_BRANCH_CANDIDATES;
+
+  if (explicitBaseBranch) {
+    return [{ branch: explicitBaseBranch, source: '--base', explicit: true }];
+  }
+
+  return uniqueBaseCandidates([
+    preferredBaseBranch ? { branch: preferredBaseBranch, source: options.preferredSource || 'slice.git.base_branch', explicit: false } : null,
+    { branch: remoteHeadBranch(repoRoot, remote), source: 'remote HEAD', explicit: false },
+    ...defaults.map((branch) => ({ branch, source: 'fallback', explicit: false })),
+  ].filter(Boolean));
+}
+
+function resolveBaseRef(repoRoot, options = {}) {
+  const remote = options.remote || 'origin';
+  const candidates = buildBaseBranchCandidates(repoRoot, options);
+
+  for (const candidate of candidates) {
+    if (remote && hasRemoteBranch(repoRoot, candidate.branch, remote)) {
+      return {
+        baseBranch: candidate.branch,
+        baseRef: `${remote}/${candidate.branch}`,
+        candidates,
+        explicit: candidate.explicit,
+        remote,
+        source: candidate.source,
+      };
+    }
+    if (hasLocalBranch(repoRoot, candidate.branch)) {
+      return {
+        baseBranch: candidate.branch,
+        baseRef: candidate.branch,
+        candidates,
+        explicit: candidate.explicit,
+        remote: '',
+        source: candidate.source,
+      };
+    }
+  }
+
+  if (options.missingOk === true) {
+    const first = candidates[0] || { branch: '', source: 'fallback', explicit: false };
+    return {
+      baseBranch: first.branch,
+      baseRef: '',
+      candidates,
+      explicit: first.explicit,
+      remote: '',
+      source: first.source,
+    };
+  }
+
+  throw new Error(`create-quiver: missing base branch. Tried: ${candidates.map((candidate) => candidate.branch).join(', ') || '(none)'}.`);
+}
+
+function resolveBaseBranchName(repoRoot, options = {}) {
+  const resolution = resolveBaseRef(repoRoot, {
+    ...options,
+    missingOk: true,
+  });
+  return resolution.baseBranch || DEFAULT_BASE_BRANCH_CANDIDATES[0];
+}
+
 function isCleanWorktree(repoRoot) {
   return Boolean(repoRoot && fs.existsSync(repoRoot) && isGitWorktree(repoRoot) && statusPorcelain(repoRoot) === '');
 }
@@ -195,8 +289,10 @@ function catFileExists(repoRoot, specRef) {
 
 module.exports = {
   branchDelete,
+  buildBaseBranchCandidates,
   catFileExists,
   currentBranch,
+  DEFAULT_BASE_BRANCH_CANDIDATES,
   fetchBranch,
   fetchRemote,
   hasLocalBranch,
@@ -211,7 +307,10 @@ module.exports = {
   isGitWorktree,
   isLinkedWorktree,
   revListCount,
+  remoteHeadBranch,
   remoteList,
+  resolveBaseBranchName,
+  resolveBaseRef,
   runGit,
   statusPorcelain,
   tryGit,

package/src/create-quiver/lib/i18n/messages/en.js

@@ -13,7 +13,9 @@ module.exports = {
       },
       groupTitles: {},
       commandDescriptions: {},
-      optionDescriptions: {},
+      optionDescriptions: {
+        'Show one human dashboard section': 'Show one human dashboard section (overview, specs, slices, blockers, warnings, agents, approvals, runs, active-slice, next-steps)',
+      },
     },
     'common.command.help': 'Run: npx create-quiver --help',
     'common.language.current': 'Language: {language}',
@@ -28,6 +30,9 @@ module.exports = {
     'common.unknown': 'unknown',
     'common.warning': 'Warning: {message}',
     'common.yes': 'yes',
+    'config.error.unsupported_language': 'unsupported language: {language}. Supported languages: {supported}. Run: npx create-quiver config language set {fallback}',
+    'config.error.unsupported_language_command': 'unsupported config language command: {command}. Supported commands: show, set',
+    'config.error.unsupported_section': 'unsupported config section: {section}. Supported sections: language',
     'ai_task.command': 'Command: {command}',
     'ai_task.context_pack': 'Context pack: {context}',
     'ai_task.documentation_debt': 'Documentation debt: {count}',
@@ -320,6 +325,14 @@ module.exports = {
     'analyze.detected_package_manager': 'Detected package manager: {manager}',
     'analyze.detected_primary_stack': 'Detected primary stack: {stack}',
     'analyze.dry_run_for': 'Project analysis dry-run for {path}',
+    'analyze.progress.artifacts_written': 'Analysis artifacts written',
+    'analyze.progress.context_refreshed': 'AI context refreshed',
+    'analyze.progress.refreshing_context': 'Refreshing AI context...',
+    'analyze.progress.scanned': 'Project scan completed',
+    'analyze.progress.scanning': 'Scanning project...',
+    'analyze.progress.state_updated': 'Analysis state updated',
+    'analyze.progress.updating_state': 'Updating Quiver state...',
+    'analyze.progress.writing_artifacts': 'Writing analysis artifacts...',
     'analyze.would_refresh': 'Would refresh {path}',
     'analyze.would_write': 'Would write {path}',
     'analyze.writes_none': 'Writes: none',
@@ -352,7 +365,11 @@ module.exports = {
     'demo.title.created': 'Quiver demo created',
     'demo.title.dry_run': 'Quiver demo dry-run',
     'evidence.command': 'Command: {command}',
+    'evidence.error.missing_command': 'evidence run requires a command after --',
+    'evidence.error.missing_subcommand': 'missing evidence subcommand. Use: npx create-quiver evidence <run|list|show>',
     'evidence.exit_code': 'Exit code: {code}',
+    'evidence.list.empty': 'No evidence files found.',
+    'evidence.list.title': 'Quiver evidence files',
     'evidence.output': 'Output: {path}',
     'evidence.recorded': 'Quiver evidence recorded',
     'init.agent_guidance.show.hint': 'Does not store credentials or execute providers',
@@ -379,6 +396,14 @@ module.exports = {
     'init.next_steps.review_agents': 'Review AGENTS.md, then {path}',
     'init.next_steps.review_workflow': 'Review {path}',
     'init.next_steps.title': 'Next steps:',
+    'init.progress.docs_written': 'Init docs written',
+    'init.progress.exporting_templates': 'Exporting compatibility templates...',
+    'init.progress.install_checked': 'Package install checked',
+    'init.progress.installing_package': 'Checking create-quiver package install...',
+    'init.progress.preparing_templates': 'Preparing packaged templates...',
+    'init.progress.templates_exported': 'Compatibility templates exported',
+    'init.progress.templates_ready': 'Packaged templates ready',
+    'init.progress.writing_docs': 'Writing init docs...',
     'init.profile.default.hint': 'Recommended AI-first contract',
     'init.profile.full.hint': 'Includes historical compatibility and visible templates',
     'init.profile.minimal.hint': 'Only essential documents',
@@ -396,6 +421,9 @@ module.exports = {
     'init.summary.project': 'Project',
     'init.summary.title': 'Selected configuration',
     'migrate.completed_for': 'Quiver migration completed for {path}',
+    'migrate.confirm.declined': 'migrate canceled. No files were written.',
+    'migrate.confirm.prompt': 'This command will modify project files under {path}. Run `npx create-quiver migrate --dry-run` to preview. Continue?',
+    'migrate.confirm.required': 'migrate writes require confirmation before modifying project files. Run `npx create-quiver migrate --dry-run` to preview, or pass `--yes` to continue in automation.',
     'migrate.dry_run_title': 'Quiver migration dry-run',
     'migrate.legacy_preserved': 'Legacy layout detected and preserved: {paths}',
     'migrate.next_command': 'Next command: {command}',
@@ -462,7 +490,9 @@ module.exports = {
     'flow.stage.technical-plan-stale': 'technical plan needs revision',
     'flow.suggested_sequence': 'Suggested sequence',
     'flow.title': 'Quiver guided flow',
+    'graph.empty.level': 'No slices found for graph level {level}.',
     'graph.empty.pending': 'No pending slices found.',
+    'graph.error.unsupported_format': 'unsupported graph format: {format}',
     'graph.level': 'Level {level}',
     'graph.lots_count': {
       one: '{count} lot',
@@ -494,6 +524,10 @@ module.exports = {
     'plan.header.status': 'STATUS',
     'plan.header.ticket': 'TICKET',
     'plan.header.title': 'TITLE',
+    'plan.missing_estimates_note': {
+      one: 'Note: {count} slice has no positive estimated_hours and is counted as 0h.',
+      other: 'Note: {count} slices have no positive estimated_hours and are counted as 0h.',
+    },
     'plan.title': 'Quiver plan',
     'plan.title.including_completed': 'Quiver plan (including completed)',
     'plan.title.ready': 'Ready slices',
@@ -665,11 +699,11 @@ module.exports = {
     'lifecycle.cleanup.dry_run.branch': 'DRY RUN: git branch {flag} {branch}',
     'lifecycle.cleanup.dry_run.slice': 'DRY RUN: slice={slice} branch={branch}',
     'lifecycle.cleanup.dry_run.worktree': 'DRY RUN: git worktree remove {force}{path}',
-    'lifecycle.cleanup.error.branch': 'normal cleanup must run from develop. Current branch: {branch}',
-    'lifecycle.cleanup.error.develop_stale': 'local develop is not up to date. Run git pull --ff-only before cleanup.',
+    'lifecycle.cleanup.error.branch': 'normal cleanup must run from {base}. Current branch: {branch}',
+    'lifecycle.cleanup.error.base_stale': 'local {base} is not up to date with {ref}. Run git pull --ff-only before cleanup.',
     'lifecycle.cleanup.error.dirty': 'the current checkout is not clean. Clean it before cleanup.',
     'lifecycle.cleanup.error.missing': "no worktree or local branch exists for '{slice}'.",
-    'lifecycle.cleanup.error.unmerged': "branch '{branch}' is not merged into origin/develop. Use --discard if the slice is intentionally discarded.",
+    'lifecycle.cleanup.error.unmerged': "branch '{branch}' is not merged into {ref}. Use --discard if the slice is intentionally discarded.",
     'lifecycle.cleanup.finished': "PASS: Cleanup completed for '{slice}'.",
     'lifecycle.cleanup.removed_active_slice': 'PASS: ACTIVE_SLICE.md removed',
     'lifecycle.cleanup.removed_branch': 'PASS: Local branch removed: {branch}',
@@ -724,15 +758,15 @@ module.exports = {
     'readiness.pr.branch.pass': 'PASS: Current branch matches the slice branch declaration.',
     'readiness.pr.case.pass': 'PASS: At least one documented use case.',
     'readiness.pr.clean.pass': 'PASS: Worktree is clean.',
-    'readiness.pr.commits.pass': 'PASS: Branch has own commits against origin/develop.',
-    'readiness.pr.error.absorbed': 'The branch was already absorbed by origin/develop. This gate applies before merge.',
+    'readiness.pr.commits.pass': 'PASS: Branch has own commits against {ref}.',
+    'readiness.pr.error.absorbed': 'The branch was already absorbed by {ref}. This gate applies before merge.',
     'readiness.pr.error.dirty': 'The worktree is not clean. Close the implementation before opening the PR.',
     'readiness.pr.error.missing_branch': 'Missing git.branch_name in the slice.',
     'readiness.pr.error.missing_pr': 'Missing pr.md next to the slice.',
     'readiness.pr.error.missing_section': "Missing required section '{heading}' in pr.md.",
     'readiness.pr.error.missing_subsection': "Missing subsection '{subheading}' inside How to Test.",
     'readiness.pr.error.no_case': 'How to Test must include at least one documented use case (#### Case 1: ...).',
-    'readiness.pr.error.no_commits': 'The branch has no own commits against origin/develop.',
+    'readiness.pr.error.no_commits': 'The branch has no own commits against {ref}.',
     'readiness.pr.error.rollback': 'Rollback must include at least one git revert command.',
     'readiness.pr.error.wrong_branch': 'Run this check from the slice branch. Current: {actual} Expected: {expected}',
     'readiness.pr.how_to_test.pass': 'PASS: How to Test includes environment, worktree access, startup, use cases, and technical verification.',
@@ -750,6 +784,11 @@ module.exports = {
     'readiness.spec_docs.pass': 'PASS: Local spec has SPEC.md, STATUS.md, and EVIDENCE_REPORT.md.',
     'readiness.warn': 'WARN: {message}',
     'spec_create.confirm_create': 'Create spec "{slug}"?',
+    'spec_create.error.approval_declined': 'spec create interactive approval declined. No files were written.',
+    'spec_create.error.interactive_tty_required': 'spec create --interactive requires an interactive TTY. Use --input, --spec, --review, and --dry-run for non-interactive automation.',
+    'spec_create.error.review_canceled': '{reason}\nReview artifact: {path}',
+    'spec_create.error.review_canceled.default_reason': 'spec create review was canceled.',
+    'spec_create.error.review_tty_required': 'spec create --review requires an interactive terminal or an injected editor runner.\nReview artifact: {path}',
     'spec_create.input.approved_plan_hint': 'Reviewed and approved technical plan',
     'spec_create.label.files_written': 'Files written: {count}',
     'spec_create.label.input_file': 'Input file: {path}',
@@ -817,6 +856,12 @@ module.exports = {
     'spec_validate.strict': 'Strict: {value}',
     'spec_validate.title': 'Quiver spec validation',
     'spec_validate.warnings': 'Warnings:',
+    'spec.error.directory_not_found': 'spec directory not found: {path}',
+    'spec.error.directory_already_exists': 'spec directory already exists: {path}',
+    'spec.error.missing_approved_plan_input': 'missing reviewed and approved plan input: {path}',
+    'spec.error.missing_directory_command': 'missing spec directory. Use: npx create-quiver spec <start|status|validate|close> <spec-dir>',
+    'spec.error.missing_directory_validate': 'missing spec directory. Use: npx create-quiver spec validate specs/<spec-slug>',
+    'spec.error.validate_failed': 'spec validate failed for {path}',
     'status.blocked': 'blocked',
     'status.cancelled': 'cancelled',
     'status.active': 'active',