@dotdotgod/cli 0.2.7 → 0.2.8

package/README.md

@@ -6,7 +6,7 @@ Command-line tools for dotdotgod project memory.
 
 Use this package when you want to initialize a docs-first project scaffold, validate project-memory docs, build a local graph/cache, search shared documentation locally, expand project references, or ask what should be checked after a file changes.
 
-These commands implement dotdotgod's project-memory loop — init, load, plan, impact — for shells, scripts, CI, and any agent without a dedicated adapter.
+These commands support dotdotgod's project-memory loop with initialization, documentation query, validation, and impact analysis for shells, scripts, CI, and agents without a dedicated adapter.
 
 ## Start Here
 
@@ -40,8 +40,6 @@ dotdotgod graph impact . --changed <path> --compact
 - `resolve` and `expand` map explicit or high-signal prompt references to project files.
 - `graph impact` ranks likely related specs, tests, docs, commands, and source files for one or more changed paths, with a combined ranking and per-file top five.
 - `traceability links` checks or repairs generated Markdown traceability-link sections.
-- `plan validate` validates active plan artifacts and simplified Plan Generator checkpoints before execution.
-- `plan stage create` creates an internal `.dotdotgod-plan/NN_STAGE_NAME.md` checkpoint for a simplified Plan Generator stage.
 - `trello sync` plans or writes Trello linked-doc metadata from configured docs paths.
 
 ## Commands
@@ -62,17 +60,12 @@ dotdotgod expand . "Update [[PLAN_MODE]] and [[HOOKS]]"
 dotdotgod expand . "PLAN_MODE 수정하자" --fuzzy
 dotdotgod traceability links . --check
 dotdotgod traceability links . --write
-dotdotgod plan validate docs/plan/<task-slug>/README.md
-dotdotgod plan validate docs/plan/<task-slug>/README.md --stage 04
-dotdotgod plan stage create 02 docs/plan/<task-slug>/README.md
 dotdotgod graph impact . --changed <path>
 dotdotgod graph impact . --changed <path> --changed <another-path> --compact
 dotdotgod graph impact . --changed <path> --changed <another-path> --yml
 dotdotgod graph communities .
 ```
 
-`--help`, `-h`, and `help` print usage to stdout. Command-specific help is available with `dotdotgod <command> --help`, including nested commands such as `dotdotgod graph impact --help`, `dotdotgod config init --help`, `dotdotgod plan stage create --help`, and `dotdotgod traceability links --help`.
-
 ## Which Command Should I Use?
 
 | Need | Command |
@@ -83,8 +76,6 @@ dotdotgod graph communities .
 | Search shared project documentation locally | `dotdotgod query . "project documentation"` |
 | Resolve `[[...]]` references from a prompt | `dotdotgod expand . "Update [[PLAN_MODE]]"` |
 | Repair generated traceability-link sections | `dotdotgod traceability links . --write` |
-| Validate an active plan before execution | `dotdotgod plan validate docs/plan/<task>/README.md` |
-| Create an internal Plan Generator stage checkpoint | `dotdotgod plan stage create 03 docs/plan/<task>/README.md` |
 | See what else to inspect after a change | `dotdotgod graph impact . --changed <path> --compact` |
 | Preview Trello linked-doc updates | `dotdotgod trello sync . --dry-run` |
 
@@ -115,7 +106,6 @@ The graph is built from maintained project files: Markdown links, README routes,
 | `dotdotgod validate <root>` | Checks dotdotgod docs/project-memory structure, local links, traceability blocks, generated traceability-link drift, config validity, and optional index freshness. |
 | `dotdotgod traceability links <root> --check` | Runs only the generated traceability-link and compact JSON drift check. |
 | `dotdotgod traceability links <root> --write` | Repairs generated traceability-link sections and rewrites canonical `json dotdotgod` blocks as compact JSON. |
-| `dotdotgod plan validate <plan-readme>` | Checks active-plan structure, required Markdown sections, decision/assumption blockers, atomic-task verification, and simplified Plan Generator checkpoints when present. |
 | `pnpm run verify` | Runs this repository's quality gate: generated-resource checks, package verify contracts, tests, typecheck, and docs validation where each package defines it. |
 
 Most users start with `validate`. Use `traceability links --write` only when generated traceability output needs repair, and use `verify` before release-style handoff in this repository.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdotgod/cli",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "CLI for dotdotgod validation, local documentation search, and graph indexing.",
   "type": "module",
   "license": "Elastic-2.0",

package/src/cli/usage.mjs

@@ -36,23 +36,6 @@ Create dotdotgod.config.json with the built-in default memory, traceability, val
   dotdotgod query <root> <query> [--limit n] [--json]
 
 Search shared project documentation with the local multilingual E5 vector index.`;
-    case 'plan':
-      return `Usage:
-  dotdotgod plan validate docs/plan/<task-slug>/README.md [--stage stage] [--json]
-  dotdotgod plan stage create <stage> [docs/plan/<task-slug>/README.md] [--json]`;
-    case 'plan validate':
-      return `Usage:
-  dotdotgod plan validate docs/plan/<task-slug>/README.md [--stage stage] [--json]
-
-Validates an active plan artifact before execution. Supports simplified Plan Generator stages and optional .dotdotgod-plan/NN_STAGE_NAME.md workspaces. Use --stage with a stage name or numeric prefix such as 04 or 05 to validate only that stage.`;
-    case 'plan stage':
-      return `Usage:
-  dotdotgod plan stage create <stage> [docs/plan/<task-slug>/README.md] [--json]`;
-    case 'plan stage create':
-      return `Usage:
-  dotdotgod plan stage create <stage> [docs/plan/<task-slug>/README.md] [--json]
-
-Creates the matching .dotdotgod-plan/NN_STAGE_NAME.md internal stage checkpoint for a simplified Plan Generator stage. <stage> accepts a numeric prefix such as 02 or a canonical stage name such as 02-context-load. If the plan path is omitted, exactly one active docs/plan/<task-slug>/README.md candidate must exist.`;
     case 'resolve':
       return `Usage:
   dotdotgod resolve <root> <ref> [--max-results n] [--include-archive] [--json]`;
@@ -108,8 +91,6 @@ Ranks nodes related to one or more changed files. <root> is the project root; re
   dotdotgod resolve <root> <ref> [--max-results n] [--include-archive] [--json]
   dotdotgod expand <root> <prompt> [--max-results n] [--include-archive] [--with-impact] [--fuzzy] [--json]
   dotdotgod traceability links <root> [--check|--write] [--json]
-  dotdotgod plan validate docs/plan/<task-slug>/README.md [--stage stage] [--json]
-  dotdotgod plan stage create <stage> [docs/plan/<task-slug>/README.md] [--json]
   dotdotgod trello sync <root> [--dry-run]
   dotdotgod graph impact <root> --changed <path> [--changed <path> ...] [--compact|--json|--yml|--yaml]
   dotdotgod graph communities <root> [--json]`;
@@ -156,9 +137,6 @@ export function helpCommandFromArgs(args) {
   if (nonHelp[0] === 'graph' && nonHelp[1]) return `graph ${nonHelp[1]}`;
   if (nonHelp[0] === 'trello' && nonHelp[1]) return `trello ${nonHelp[1]}`;
   if (nonHelp[0] === 'traceability' && nonHelp[1]) return `traceability ${nonHelp[1]}`;
-  if (nonHelp[0] === 'plan' && nonHelp[1] === 'stage' && nonHelp[2] === 'create') return 'plan stage create';
-  if (nonHelp[0] === 'plan' && nonHelp[1] === 'stage') return 'plan stage';
-  if (nonHelp[0] === 'plan' && nonHelp[1]) return `plan ${nonHelp[1]}`;
   if (nonHelp[0] === 'config' && nonHelp[1] === 'init') return 'config init';
   return nonHelp[0] ?? 'root';
 }

package/src/core.mjs

@@ -7,7 +7,6 @@ import { runQuery } from './commands/query.mjs';
 import { runResolve, runExpand } from './reference/resolve.mjs';
 import { runTraceability } from './commands/traceability.mjs';
 import { runGraph } from './commands/graph.mjs';
-import { runPlan } from './commands/plan.mjs';
 import { runTrelloSync } from './trello/sync.mjs';
 
 export { CACHE_VERSION } from './index/constants.mjs';
@@ -35,7 +34,6 @@ export { extractBracketReferences, extractFuzzyReferences, normalizeReferenceAli
 export { resolveReferenceCandidates, runResolve, runExpand } from './reference/resolve.mjs';
 export { parseTraceabilityOptions, runTraceability } from './commands/traceability.mjs';
 export { parseGraphOptions, runGraph } from './commands/graph.mjs';
-export { buildPlanValidationRepairPrompt, createPlanStageCheckpoint, formatPlanValidationText, PLAN_REQUIRED_HEADERS, PLAN_STAGE_DIRECTORIES, resolvePlanValidationStage, runPlan, validatePlanArtifact } from './commands/plan.mjs';
 export { planTrelloDryRun, runTrelloSync } from './trello/sync.mjs';
 export { parseTrelloMetadata, extractTrelloShortLink } from './trello/metadata.mjs';
 export { normalizeGitHubRemote, resolveGitHubFileUrl, resolveGitHubRepositoryIdentity } from './trello/github-url.mjs';
@@ -60,7 +58,6 @@ export async function runCli(argv = process.argv.slice(2)) {
   else if (command === 'expand') runExpand(args);
   else if (command === 'traceability') runTraceability(args);
   else if (command === 'graph') await runGraph(args);
-  else if (command === 'plan') runPlan(args);
   else if (command === 'trello') {
     const result = await Promise.resolve(runTrelloSync(args));
     if (result.stdout) process.stdout.write(result.stdout);

package/src/validate/run.mjs

@@ -37,7 +37,6 @@ export function runValidate(argv) {
     if (path.includes('/node_modules') || path === 'node_modules') return true;
     if (path.includes('/.git') || path === '.git') return true;
     if (path === CACHE_DIR || path.startsWith(`${CACHE_DIR}/`)) return true;
-    if (/^docs\/(?:plan|archive\/plan)\/[a-z0-9]+(?:-[a-z0-9]+)*\/\.dotdotgod-plan(?:\/|$)/.test(path)) return true;
     if (!options.includeLocalMemory && (path === 'docs/plan' || path.startsWith('docs/plan/') || path === 'docs/archive' || path.startsWith('docs/archive/'))) return true;
     return false;
   };
@@ -48,8 +47,7 @@ export function runValidate(argv) {
       if (entry.isDirectory()) {
         const docsRel = rel(docs, path);
         if (docsRel && !docsRel.startsWith('..')) {
-          const isPlanInternalWorkspaceDir = /^(?:plan|archive\/plan)\/[a-z0-9]+(?:-[a-z0-9]+)*\/\.dotdotgod-plan(?:\/|$)/.test(docsRel);
-          if (!isPlanInternalWorkspaceDir) for (const part of docsRel.split('/')) if (part && !isKebabCase(part)) addError(path, 'DIR_NAMING', `Directory must be kebab-case: ${part}`, null, 'rename this docs directory to kebab-case and update any links that reference it.');
+          for (const part of docsRel.split('/')) if (part && !isKebabCase(part)) addError(path, 'DIR_NAMING', `Directory must be kebab-case: ${part}`, null, 'rename this docs directory to kebab-case and update any links that reference it.');
         }
         walk(path);
       } else if (entry.isFile() && entry.name.endsWith('.md')) markdownFiles.push(path);
@@ -98,13 +96,11 @@ export function runValidate(argv) {
     const name = basename(file);
     const docsRel = rel(docs, file);
     const rootRel = rel(root, file);
-    const isPlanInternalWorkspaceFile = /^docs\/(?:plan|archive\/plan)\/[a-z0-9]+(?:-[a-z0-9]+)*\/\.dotdotgod-plan\/(?:[0-9]{2}-[a-z0-9]+(?:-[a-z0-9]+)*|[0-9]{2}_[A-Z0-9]+(?:_[A-Z0-9]+)*)\.md$/.test(rootRel);
-    if (docsRel && !docsRel.startsWith('..') && !isPlanInternalWorkspaceFile && !isUpperSnakeMarkdown(name)) addError(file, 'FILE_NAMING', `Markdown file must be UPPER_SNAKE_CASE.md or README.md: ${name}`, null, 'rename the markdown file to UPPER_SNAKE_CASE.md or README.md and update any links that reference it.');
+    if (docsRel && !docsRel.startsWith('..') && !isUpperSnakeMarkdown(name)) addError(file, 'FILE_NAMING', `Markdown file must be UPPER_SNAKE_CASE.md or README.md: ${name}`, null, 'rename the markdown file to UPPER_SNAKE_CASE.md or README.md and update any links that reference it.');
     const content = readFileSync(file, 'utf8');
     fileCache.set(file, content);
     const docArea = docsRel?.split('/')[0];
-    if (name !== 'README.md' && !isPlanInternalWorkspaceFile
-        && isUpperSnakeMarkdown(name) && FILENAME_QUALITY_AREAS.has(docArea)) {
+    if (name !== 'README.md' && isUpperSnakeMarkdown(name) && FILENAME_QUALITY_AREAS.has(docArea)) {
       const fp = validationPolicy.markdown?.filename ?? {};
       const allow = fp.allow ?? [];
       if (!allow.some((p) => matchPathPattern(rootRel, p)) && (fp.warnNumberedSeries ?? true)) {
@@ -144,8 +140,6 @@ export function runValidate(argv) {
   const byDir = new Map();
   for (const file of markdownFiles) byDir.set(dirname(file), [...(byDir.get(dirname(file)) ?? []), file]);
   for (const [dir, files] of byDir) {
-    const dirRel = rel(root, dir);
-    if (/^docs\/(?:plan|archive\/plan)\/[a-z0-9]+(?:-[a-z0-9]+)*\/\.dotdotgod-plan$/.test(dirRel)) continue;
     if (files.length > 1 && !files.some((file) => basename(file) === 'README.md')) addError(dir, 'MISSING_README', 'Directory with multiple markdown files must include README.md', null, 'add a README.md in this directory that indexes the important markdown files and their purpose.');
   }
   if (options.linkCheck) {

package/src/commands/plan-stage-contract.mjs

@@ -1,75 +0,0 @@
-export const PLAN_STAGE_DIRECTORIES = [
-  '01-intake',
-  '02-context-load',
-  '03-discovery',
-  '04-plan',
-];
-
-export const PLAN_INTERNAL_WORKSPACE = '.dotdotgod-plan';
-
-export const PLAN_INTERNAL_STAGE_DIRECTORIES = [
-  ...PLAN_STAGE_DIRECTORIES,
-  '05-workstream-handoff',
-];
-
-export const PLAN_REQUIRED_HEADERS = {
-  '01-intake': ['Request Summary', 'Goal', 'Scope', 'Non-goals', 'Constraints', 'Assumptions'],
-  '02-context-load': ['Memory Reads', 'Impact Candidates', 'Related Files'],
-  '03-discovery': ['Findings', 'Risks', 'Open Questions'],
-  '04-plan': ['Milestones', 'Atomic Tasks', 'Validation Plan', 'Resume Point'],
-  '05-workstream-handoff': [
-    'Workstream Handoff',
-    'Workstream Map',
-    'Shared Context',
-    'Workstreams',
-    'Integration Sequence',
-    'Todo Contract',
-  ],
-};
-
-export const PLAN_CONSTRUCTION_CHECKLISTS = {
-  '01-intake': ['Requirements', 'Constraints', 'Failure paths', 'Data shape', 'Verification', 'Integration impact'],
-  '02-context-load': ['Memory reads', 'Impact candidates', 'Related files', 'Boundary risk'],
-  '03-discovery': ['Findings', 'Risks', 'Open questions', 'Extension points'],
-  '04-plan': ['Milestones', 'Atomic tasks', 'Validation plan', 'Resume point'],
-  '05-workstream-handoff': ['Handoffs', 'Do-not rules', 'Focused verification', 'Chat-independent context'],
-};
-
-export const PLAN_BLOCKER_LABELS = new Map([
-  ['missing-plan', 'Plan file does not exist'],
-  ['invalid-plan-path', 'Plan file must be docs/plan/<task-slug>/README.md'],
-  ['invalid-task-slug', 'Plan task directory must be kebab-case'],
-  ['empty-plan', 'Plan README is empty'],
-  ['missing-stage', 'Missing required stage directory'],
-  ['missing-stage-readme', 'Missing stage README.md'],
-  ['missing-internal-stage', 'Missing internal stage checkpoint'],
-  ['open-internal-stage', 'Internal stage checkpoint is not completed'],
-  ['invalid-markdown-name', 'Invalid Markdown file name'],
-  ['missing-section', 'Missing required section'],
-  ['empty-section', 'Required section has no content'],
-  ['placeholder-section', 'Required section only contains placeholder content'],
-  ['pending-workstream', 'Required workstream is pending'],
-  ['unresolved-discussion', 'Discussion Queue has unresolved items'],
-  ['unresolved-assumption', 'Assumptions contain unresolved items'],
-  ['missing-atomic-acceptance', 'Atomic Tasks must define acceptance criteria'],
-  ['missing-atomic-verification', 'Atomic Tasks must define verification'],
-  ['missing-construction-checklist', 'Missing construction checklist'],
-  ['missing-checklist-item', 'Missing construction checklist item'],
-  ['malformed-checklist-item', 'Malformed construction checklist item'],
-  ['open-checklist-item', 'Construction checklist item is open'],
-  ['placeholder-checklist-item', 'Construction checklist item only contains placeholder content'],
-  ['missing-workstream-split-decision', 'Workstream Handoff must include an explicit split decision'],
-  ['incomplete-workstream-split', 'Split workstream handoff must include actionable workstream contracts'],
-  ['missing-workstream-no-split-rationale', 'No-split workstream handoff must include rationale'],
-]);
-
-export function buildPlanValidationNextStagePrompt(planPath, stage, stagePath) {
-  return [
-    `Continue Plan Mode stage advancement for ${planPath}.`,
-    `Current stage: ${stage}.`,
-    `Update the durable plan for human readers, then make ${stagePath} the machine-readable checkpoint that satisfies the current stage validation contract. Do not create later checkpoint files yet.`,
-    `In ${stagePath}, set Status: completed and include the current stage required sections plus \`## Stage ${stage.slice(0, 2)} Construction Checklist\` rows in the canonical \`- [x] Category: evidence\` form.`,
-    stage === '05-workstream-handoff' ? 'For this stage checkpoint, record `Split decision: yes` or `Split decision: no` in `## Workstream Handoff`. If splitting, make `## Workstream Map`, `## Workstreams`, and `## Integration Sequence` describe multiple actionable workstreams with required context, allowed/forbidden edits, tasks, validation, dependencies, and handoff output. If not splitting, record the no-split rationale and keep `## Todo Contract` actionable so Pi can extract execution todos.' : undefined,
-    `After completing this stage, stop and rerun \`dotdotgod plan validate ${planPath} --stage ${stage} --json\`.`,
-  ].filter(Boolean).join('\n\n');
-}

package/src/commands/plan.mjs

@@ -1,669 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
-import { commandUsage } from '../cli/usage.mjs';
-import { isKebabCase, isUpperSnakeMarkdown, removeCodeBlocks } from '../docs/markdown.mjs';
-import {
-  PLAN_BLOCKER_LABELS as BLOCKER_LABELS,
-  PLAN_CONSTRUCTION_CHECKLISTS,
-  PLAN_INTERNAL_STAGE_DIRECTORIES,
-  PLAN_INTERNAL_WORKSPACE,
-  PLAN_REQUIRED_HEADERS,
-  PLAN_STAGE_DIRECTORIES,
-  buildPlanValidationNextStagePrompt,
-} from './plan-stage-contract.mjs';
-
-export {
-  PLAN_CONSTRUCTION_CHECKLISTS,
-  PLAN_INTERNAL_STAGE_DIRECTORIES,
-  PLAN_INTERNAL_WORKSPACE,
-  PLAN_REQUIRED_HEADERS,
-  PLAN_STAGE_DIRECTORIES,
-};
-
-function normalizeHeading(value) {
-  return String(value ?? '').trim().toLowerCase().replace(/`/g, '').replace(/[\s/_-]+/g, ' ');
-}
-
-function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function projectRelative(root, file) {
-  return relative(root, file).replace(/\\/g, '/');
-}
-
-function buildBlockerRepairPrompt(blocker) {
-  const target = [blocker.path, blocker.stage, blocker.section ? `## ${blocker.section}` : undefined].filter(Boolean).join(' / ');
-  const location = target ? ` in ${target}` : '';
-  return `Update the active plan artifact${location} to resolve this blocker: ${blocker.message}`;
-}
-
-function addBlocker(blockers, code, message, details = {}) {
-  const blocker = { code, message: message ?? BLOCKER_LABELS.get(code) ?? code, ...details };
-  blockers.push({ ...blocker, prompt: buildBlockerRepairPrompt(blocker) });
-}
-
-function parseHeadedSections(content) {
-  const sections = [];
-  const lines = removeCodeBlocks(content).split(/\r?\n/);
-  let current;
-  for (let index = 0; index < lines.length; index += 1) {
-    const match = /^(#{1,6})\s+(.+?)\s*$/.exec(lines[index]);
-    if (match) {
-      if (current) sections.push(current);
-      current = { level: match[1].length, title: match[2].trim(), contentLines: [], line: index + 1 };
-    } else if (current) {
-      current.contentLines.push(lines[index]);
-    }
-  }
-  if (current) sections.push(current);
-  return sections;
-}
-
-function contentHasValue(content) {
-  const stripped = content
-    .split(/\r?\n/)
-    .filter((line) => !/^\s*<!--/.test(line))
-    .join('\n')
-    .trim();
-  return stripped.length > 0;
-}
-
-function readMarkdownFiles(stageDir) {
-  if (!existsSync(stageDir)) return [];
-  return readdirSync(stageDir, { withFileTypes: true })
-    .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
-    .map((entry) => join(stageDir, entry.name));
-}
-
-function internalWorkspaceDir(taskDir) {
-  return join(taskDir, PLAN_INTERNAL_WORKSPACE);
-}
-
-export function internalStageFileName(stageName) {
-  const match = /^(\d{2})-(.+)$/.exec(stageName);
-  if (!match) return `${String(stageName).replace(/-/g, '_').toUpperCase()}.md`;
-  return `${match[1]}_${match[2].replace(/-/g, '_').toUpperCase()}.md`;
-}
-
-function internalStageFile(taskDir, stageName) {
-  return join(internalWorkspaceDir(taskDir), internalStageFileName(stageName));
-}
-
-function resolvePlanReadme(root, planPath) {
-  const absolutePlanPath = isAbsolute(planPath) ? planPath : resolve(root, planPath);
-  const taskDir = dirname(absolutePlanPath);
-  const taskSlug = basename(taskDir);
-  const relPlanPath = projectRelative(root, absolutePlanPath);
-  const expectedPath = `docs/plan/${taskSlug}/README.md`;
-  return { absolutePlanPath, taskDir, taskSlug, relPlanPath, expectedPath };
-}
-
-function discoverActivePlanReadmes(root) {
-  const planRoot = join(root, 'docs/plan');
-  if (!existsSync(planRoot)) return [];
-  return readdirSync(planRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && !entry.isSymbolicLink())
-    .map((entry) => join(planRoot, entry.name, 'README.md'))
-    .filter((file) => existsSync(file))
-    .sort((left, right) => left.localeCompare(right));
-}
-
-function resolveCheckpointPlanPath(root, planPath) {
-  if (planPath) return resolvePlanReadme(root, planPath);
-  const candidates = discoverActivePlanReadmes(root);
-  if (candidates.length !== 1) {
-    const suffix = candidates.length > 1
-      ? ` Found ${candidates.length} candidates; pass docs/plan/<task-slug>/README.md explicitly.`
-      : ' Pass docs/plan/<task-slug>/README.md explicitly.';
-    throw new Error(`Could not infer an active plan.${suffix}`);
-  }
-  return resolvePlanReadme(root, candidates[0]);
-}
-
-function buildStageCheckpointContent(stageName, now = new Date()) {
-  return `Stage: ${stageName}\nStatus: created\nUpdated: ${now.toISOString()}\n`;
-}
-
-export function createPlanStageCheckpoint(stageValue, options = {}) {
-  const root = resolve(options.root ?? process.cwd());
-  const stageName = resolvePlanValidationStage(stageValue);
-  if (!stageName) throw new Error(`Invalid plan stage: ${stageValue}`);
-
-  const plan = resolveCheckpointPlanPath(root, options.planPath);
-  if (plan.relPlanPath !== plan.expectedPath) {
-    throw new Error(`Plan file must be docs/plan/<task-slug>/README.md: ${plan.relPlanPath}`);
-  }
-  if (!isKebabCase(plan.taskSlug)) {
-    throw new Error(`Plan task directory must be kebab-case: ${plan.taskSlug}`);
-  }
-  if (!existsSync(plan.absolutePlanPath)) {
-    throw new Error(`Plan file does not exist: ${plan.relPlanPath}`);
-  }
-
-  const workspace = internalWorkspaceDir(plan.taskDir);
-  const checkpointPath = internalStageFile(plan.taskDir, stageName);
-  if (existsSync(checkpointPath)) {
-    throw new Error(`Plan stage checkpoint already exists: ${projectRelative(root, checkpointPath)}`);
-  }
-
-  mkdirSync(workspace, { recursive: true });
-  writeFileSync(checkpointPath, buildStageCheckpointContent(stageName, options.now));
-  return {
-    ok: true,
-    planPath: plan.relPlanPath,
-    stage: stageName,
-    path: projectRelative(root, checkpointPath),
-  };
-}
-
-function hasInternalWorkspace(taskDir) {
-  const workspace = internalWorkspaceDir(taskDir);
-  return existsSync(workspace) && statSync(workspace).isDirectory();
-}
-
-function discoverDurablePlanMarkdownFiles(taskDir) {
-  const results = [];
-  function walk(directory) {
-    if (!existsSync(directory)) return;
-    for (const entry of readdirSync(directory, { withFileTypes: true })) {
-      if (entry.name === PLAN_INTERNAL_WORKSPACE || entry.isSymbolicLink()) continue;
-      const entryPath = join(directory, entry.name);
-      if (entry.isDirectory()) {
-        walk(entryPath);
-        continue;
-      }
-      if (entry.isFile() && entry.name.endsWith('.md')) results.push(entryPath);
-    }
-  }
-  walk(taskDir);
-  return results.sort((left, right) => {
-    if (basename(left) === 'README.md' && dirname(left) === taskDir) return -1;
-    if (basename(right) === 'README.md' && dirname(right) === taskDir) return 1;
-    return left.localeCompare(right);
-  });
-}
-
-function readInternalStageState(taskDir, stageName) {
-  const file = internalStageFile(taskDir, stageName);
-  if (!existsSync(file)) return undefined;
-  const content = readFileSync(file, 'utf8');
-  return { file, content };
-}
-
-function validateInternalStageState(root, taskDir, stageName, blockers) {
-  const state = readInternalStageState(taskDir, stageName);
-  const expectedPath = internalStageFile(taskDir, stageName);
-  const rel = projectRelative(root, state?.file ?? expectedPath);
-  if (!state) {
-    addBlocker(blockers, 'missing-internal-stage', `Missing internal stage checkpoint: ${rel}`, { path: rel, stage: stageName });
-    return { state: undefined, valid: false };
-  }
-
-  let valid = true;
-  const stage = contentMatch(state.content, /^Stage:\s*(\S+)\s*$/m);
-  const status = contentMatch(state.content, /^Status:\s*(created|blocked|completed)\s*$/m);
-  const updated = contentMatch(state.content, /^Updated:\s*(\S+)\s*$/m);
-  if (stage && stage !== stageName) {
-    valid = false;
-    addBlocker(blockers, 'missing-internal-stage', `Internal stage file has wrong Stage field: ${rel}`, { path: rel, stage: stageName });
-  }
-  if (!stage) {
-    valid = false;
-    addBlocker(blockers, 'missing-internal-stage', `Internal stage file is missing Stage: ${rel}`, { path: rel, stage: stageName });
-  }
-  if (!status) {
-    valid = false;
-    addBlocker(blockers, 'missing-internal-stage', `Internal stage file is missing valid Status: ${rel}`, { path: rel, stage: stageName });
-  } else if (status !== 'completed') {
-    valid = false;
-    addBlocker(blockers, 'open-internal-stage', `Internal stage checkpoint is not completed: ${rel}`, { path: rel, stage: stageName });
-  }
-  if (!updated) {
-    valid = false;
-    addBlocker(blockers, 'missing-internal-stage', `Internal stage file is missing Updated: ${rel}`, { path: rel, stage: stageName });
-  }
-  return { state, valid };
-}
-
-function contentMatch(content, pattern) {
-  return pattern.exec(content)?.[1];
-}
-
-function findSection(files, header) {
-  const wanted = normalizeHeading(header);
-  let fallback;
-  for (const file of files) {
-    const content = readFileSync(file, 'utf8');
-    for (const section of parseHeadedSections(content)) {
-      if (section.level < 2 || normalizeHeading(section.title) !== wanted) continue;
-      const found = { file, section, content: section.contentLines.join('\n') };
-      const isTaskReadme = basename(file) === 'README.md';
-      if (isTaskReadme || contentHasValue(found.content)) return found;
-      fallback ??= found;
-    }
-  }
-  return fallback;
-}
-
-function validateMarkdownNames(root, stageName, stageDir, blockers) {
-  for (const file of readMarkdownFiles(stageDir)) {
-    const name = basename(file);
-    const valid = isUpperSnakeMarkdown(name);
-    if (!valid) {
-      addBlocker(blockers, 'invalid-markdown-name', `Invalid Markdown file name: ${projectRelative(root, file)}`, { path: projectRelative(root, file) });
-    }
-  }
-}
-
-function sectionContainsField(content, labels) {
-  const text = removeCodeBlocks(content);
-  return labels.some((label) => new RegExp(`(?:^|\\b)${escapeRegExp(label)}\\s*:\\s*\\S`, 'im').test(text));
-}
-
-function hasUncheckedChecklistItem(content) {
-  return content.split(/\r?\n/).some((line) => /^\s*[-*+]\s*\[\s\]/.test(line));
-}
-
-function hasOpenStructuredStatus(content) {
-  return content.split(/\r?\n/).some((line) => /^\s*(?:[-*+]\s*)?(?:Status|DecisionState|Decision State)\s*:\s*(?:open|blocked|unresolved|pending|research[-_ ]requested|plan[-_ ]revision[-_ ]requested)\s*$/i.test(line));
-}
-
-function hasUnresolvedStructuredItem(content) {
-  return hasUncheckedChecklistItem(content) || hasOpenStructuredStatus(content);
-}
-
-function workstreamSplitDecision(content) {
-  const match = /\bsplit\s+decision\s*:\s*(yes|no)\b/i.exec(content);
-  return match?.[1].toLowerCase();
-}
-
-function fieldPattern(label, flags = 'im') {
-  return new RegExp(`^\\s*(?:[-*+]\\s*)?${escapeRegExp(label)}\\s*:\\s*(\\S.*)$`, flags);
-}
-
-function fieldHasValue(content, label) {
-  return Boolean(fieldPattern(label).exec(removeCodeBlocks(content))?.[1]?.trim());
-}
-
-function fieldOccurrences(content, label) {
-  return [...removeCodeBlocks(content).matchAll(fieldPattern(label, 'img'))].length;
-}
-
-function hasNoSplitRationale(content) {
-  return fieldHasValue(content, 'No-split rationale');
-}
-
-function hasMultipleWorkstreams(content) {
-  return fieldOccurrences(content, 'Workstream ID') >= 2;
-}
-
-function hasActionableWorkstreamFields(content) {
-  return ['Workstream ID', 'Purpose', 'Required context', 'Allowed edits', 'Forbidden edits', 'Tasks', 'Validation', 'Handoff output', 'Dependencies'].every((label) => fieldHasValue(content, label));
-}
-
-function hasActionableIntegrationFields(content) {
-  return ['Step', 'Validation', 'Handoff'].every((label) => fieldHasValue(content, label));
-}
-
-function validateWorkstreamHandoffContract(root, files, stageName, blockers) {
-  if (stageName !== '05-workstream-handoff') return true;
-  let valid = true;
-  const handoff = findSection(files, 'Workstream Handoff');
-  const todo = findSection(files, 'Todo Contract');
-  const relHandoff = projectRelative(root, handoff?.file ?? files[0]);
-  const decision = workstreamSplitDecision(handoff?.content ?? '');
-  if (!decision) {
-    addBlocker(blockers, 'missing-workstream-split-decision', 'Workstream Handoff must include `Split decision: yes` or `Split decision: no`.', { path: relHandoff, stage: stageName, section: 'Workstream Handoff' });
-    return false;
-  }
-  if (decision === 'no') {
-    if (!hasNoSplitRationale(handoff.content)) {
-      valid = false;
-      addBlocker(blockers, 'missing-workstream-no-split-rationale', 'Workstream Handoff with `Split decision: no` must include `No-split rationale:`.', { path: relHandoff, stage: stageName, section: 'Workstream Handoff' });
-    }
-    if (!todo || !contentHasValue(todo.content)) valid = false;
-    return valid;
-  }
-
-  const map = findSection(files, 'Workstream Map');
-  const workstreams = findSection(files, 'Workstreams');
-  const integration = findSection(files, 'Integration Sequence');
-  const splitContent = [map?.content, workstreams?.content, integration?.content].filter(Boolean).join('\n');
-  if (!hasMultipleWorkstreams(splitContent)) {
-    valid = false;
-    addBlocker(blockers, 'incomplete-workstream-split', 'Split Stage 05 handoff must include at least two `Workstream ID:` fields in Workstream Map, Workstreams, or Integration Sequence.', { path: projectRelative(root, map?.file ?? workstreams?.file ?? integration?.file ?? handoff.file), stage: stageName, section: 'Workstream Map' });
-  }
-  if (!workstreams || !hasActionableWorkstreamFields(workstreams.content)) {
-    valid = false;
-    addBlocker(blockers, 'incomplete-workstream-split', 'Workstreams must include non-empty structured fields: Workstream ID, Purpose, Required context, Allowed edits, Forbidden edits, Tasks, Validation, Handoff output, and Dependencies.', { path: projectRelative(root, workstreams?.file ?? handoff.file), stage: stageName, section: 'Workstreams' });
-  }
-  if (!integration || !hasActionableIntegrationFields(integration.content)) {
-    valid = false;
-    addBlocker(blockers, 'incomplete-workstream-split', 'Integration Sequence must include non-empty structured fields: Step, Validation, and Handoff.', { path: projectRelative(root, integration?.file ?? handoff.file), stage: stageName, section: 'Integration Sequence' });
-  }
-  return valid;
-}
-
-function constructionChecklistHeader(stageName) {
-  const match = /^(\d{2})-/.exec(stageName);
-  return `Stage ${match?.[1] ?? stageName} Construction Checklist`;
-}
-
-function normalizeChecklistCategory(value) {
-  return normalizeHeading(value).replace(/\s+/g, ' ');
-}
-
-function checklistStatusChecked(value) {
-  return /\[[xX]\]/.test(value) || /\bcompleted\b/i.test(value);
-}
-
-function parseChecklistLine(line, lineNumber) {
-  const trimmed = line.trim();
-  if (!trimmed) return undefined;
-  if (/^\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?$/.test(trimmed)) return undefined;
-
-  const canonical = /^\s*[-*+]\s*\[([^\]])\]\s*([^:]+):\s*(.*?)\s*$/.exec(line);
-  if (canonical) return { line, lineNumber, checked: canonical[1].trim().toLowerCase() === 'x', category: canonical[2].trim(), evidence: canonical[3].trim(), malformed: false };
-
-  const checkedDash = /^\s*[-*+]\s*\[([^\]])\]\s*(.+?)\s*[—–-]\s*(.*?)\s*$/.exec(line);
-  if (checkedDash) return { line, lineNumber, checked: checkedDash[1].trim().toLowerCase() === 'x', category: checkedDash[2].trim(), evidence: checkedDash[3].trim(), malformed: false };
-
-  const completedPrefix = /^\s*[-*+]\s*completed\s*[—–-]\s*\[([xX])\]\s*(.+?)(?::\s*(.*?))?\s*$/.exec(line);
-  if (completedPrefix) return { line, lineNumber, checked: true, category: completedPrefix[2].trim(), evidence: (completedPrefix[3] ?? 'completed').trim(), malformed: false };
-
-  const table = /^\s*\|(.+)\|\s*$/.exec(line);
-  if (table) {
-    const cells = table[1].split('|').map((cell) => cell.trim()).filter(Boolean);
-    if (cells.length >= 2 && !/^item$/i.test(cells[0]) && !/^category$/i.test(cells[0])) return { line, lineNumber, checked: checklistStatusChecked(cells.slice(1).join(' | ')), category: cells[0], evidence: cells.slice(1).join(' | '), malformed: false };
-    return undefined;
-  }
-
-  const colonStatus = /^\s*([^:|]+):\s*(completed\s*[—–-]\s*\[[xX]\]|\[[xX]\]|completed)(?:\s*[—–:\-]\s*(.*?))?\s*$/.exec(line);
-  if (colonStatus) return { line, lineNumber, checked: checklistStatusChecked(colonStatus[2]), category: colonStatus[1].trim(), evidence: (colonStatus[3] ?? colonStatus[2]).trim(), malformed: false };
-
-  return /^\s*[-*+]\s*/.test(line) ? { line, lineNumber, malformed: true } : undefined;
-}
-
-function parseChecklistRows(content) {
-  return content
-    .split(/\r?\n/)
-    .map((line, index) => parseChecklistLine(line, index + 1))
-    .filter((row) => row?.malformed || row?.category);
-}
-
-function validateConstructionChecklist(root, files, stageName, blockers) {
-  const requiredCategories = PLAN_CONSTRUCTION_CHECKLISTS[stageName] ?? [];
-  if (requiredCategories.length === 0) return true;
-  const header = constructionChecklistHeader(stageName);
-  const found = findSection(files, header);
-  if (!found) {
-    addBlocker(blockers, 'missing-construction-checklist', `Missing construction checklist: ## ${header}`, { path: projectRelative(root, files[0]), stage: stageName, section: header });
-    return false;
-  }
-  let valid = true;
-  const relFound = projectRelative(root, found.file);
-  const rows = parseChecklistRows(found.content);
-  const byCategory = new Map(rows.filter((row) => row.category).map((row) => [normalizeChecklistCategory(row.category), row]));
-  for (const row of rows) {
-    if (row.malformed) {
-      valid = false;
-      addBlocker(blockers, 'malformed-checklist-item', `Malformed construction checklist item at line ${row.lineNumber}: expected canonical "- [x] Category: evidence" or a completed table/status row with non-empty evidence.`, { path: relFound, stage: stageName, section: header });
-      continue;
-    }
-    if (!row.checked) {
-      valid = false;
-      addBlocker(blockers, 'open-checklist-item', `Construction checklist item is unchecked: ${row.category}`, { path: relFound, stage: stageName, section: header });
-    }
-    if (!contentHasValue(row.evidence)) {
-      valid = false;
-      addBlocker(blockers, 'empty-checklist-item', `Construction checklist item has no evidence: ${row.category}`, { path: relFound, stage: stageName, section: header });
-    }
-  }
-  for (const category of requiredCategories) {
-    if (!byCategory.has(normalizeChecklistCategory(category))) {
-      valid = false;
-      addBlocker(blockers, 'missing-checklist-item', `Missing construction checklist item: ${category}. Preferred format: "- [x] ${category}: evidence".`, { path: relFound, stage: stageName, section: header });
-    }
-  }
-  return valid;
-}
-
-export function buildPlanValidationRepairPrompt(result) {
-  if (result.ok) return undefined;
-  const lines = [
-    `Refine the active plan artifact so \`dotdotgod plan validate ${result.planPath} --json\` passes.`,
-    'Address every blocker below by editing the active plan files, preserving user decisions and marking unresolved questions in the Discussion Queue instead of guessing.',
-    '',
-    'Blockers:',
-  ];
-  for (const blocker of result.blockers) {
-    const location = [blocker.path, blocker.stage, blocker.section ? `## ${blocker.section}` : undefined].filter(Boolean).join(' / ');
-    lines.push(`- ${blocker.code}${location ? ` (${location})` : ''}: ${blocker.message}`);
-  }
-  lines.push('', 'After edits, rerun the plan validation command and summarize remaining blockers if any.');
-  return lines.join('\n');
-}
-
-function withPlanValidationRepairPrompt(result) {
-  if (result.ok) return result;
-  return { ...result, repairPrompt: buildPlanValidationRepairPrompt(result) };
-}
-
-function buildNextStageDetails(root, taskDir, relPlanPath, stageName) {
-  const stagePath = projectRelative(root, internalStageFile(taskDir, stageName));
-  return {
-    stage: stageName,
-    path: stagePath,
-    prompt: buildPlanValidationNextStagePrompt(relPlanPath, stageName, stagePath),
-  };
-}
-
-export function resolvePlanValidationStage(stageValue) {
-  const value = String(stageValue ?? '').trim();
-  if (!value) return undefined;
-  const matches = PLAN_INTERNAL_STAGE_DIRECTORIES.filter((stage) => stage === value || stage.startsWith(value));
-  return matches.length === 1 ? matches[0] : undefined;
-}
-
-function buildPlanValidationSummary(selectedStage, stagesForFullValidation = PLAN_STAGE_DIRECTORIES) {
-  const stages = selectedStage ? [selectedStage] : stagesForFullValidation;
-  return {
-    stages: { total: stages.length, present: 0, valid: 0, ...(selectedStage ? { selected: selectedStage } : {}) },
-    requiredSections: { total: stages.flatMap((stage) => PLAN_REQUIRED_HEADERS[stage] ?? []).length, present: 0, valid: 0 },
-    splitFiles: { detected: false },
-  };
-}
-
-export function validatePlanArtifact(planPath, options = {}) {
-  const root = resolve(options.root ?? process.cwd());
-  const plan = resolvePlanReadme(root, planPath);
-  const { absolutePlanPath, taskDir, taskSlug, relPlanPath } = plan;
-  const selectedStage = resolvePlanValidationStage(options.stage);
-  const blockers = [];
-  const warnings = [];
-
-  if (!existsSync(absolutePlanPath)) {
-    addBlocker(blockers, 'missing-plan', `Plan file does not exist: ${projectRelative(root, absolutePlanPath)}`, { path: projectRelative(root, absolutePlanPath) });
-    return withPlanValidationRepairPrompt({ ok: false, planPath: projectRelative(root, absolutePlanPath), blockers, warnings, summary: buildPlanValidationSummary(selectedStage) });
-  }
-
-  const expectedPrefix = plan.expectedPath;
-  if (relPlanPath !== expectedPrefix) {
-    addBlocker(blockers, 'invalid-plan-path', `Plan file must be docs/plan/<task-slug>/README.md: ${relPlanPath}`, { path: relPlanPath });
-  }
-  if (!isKebabCase(taskSlug)) {
-    addBlocker(blockers, 'invalid-task-slug', `Plan task directory must be kebab-case: ${taskSlug}`, { path: projectRelative(root, taskDir) });
-  }
-  if (!contentHasValue(readFileSync(absolutePlanPath, 'utf8'))) {
-    addBlocker(blockers, 'empty-plan', `Plan README is empty: ${relPlanPath}`, { path: relPlanPath });
-  }
-
-  const stagesForFullValidation = PLAN_INTERNAL_STAGE_DIRECTORIES;
-  const summary = buildPlanValidationSummary(selectedStage, stagesForFullValidation);
-  const stagesToValidate = selectedStage ? [selectedStage] : stagesForFullValidation;
-  const durableFiles = discoverDurablePlanMarkdownFiles(taskDir);
-  if (durableFiles.length > 1) summary.splitFiles.detected = true;
-  for (const stageName of stagesToValidate) {
-    const internal = validateInternalStageState(root, taskDir, stageName, blockers);
-    summary.stages.present += internal.state ? 1 : 0;
-    let stageValid = internal.valid;
-    const files = internal.state ? [internal.state.file] : [];
-    const fallbackPath = projectRelative(root, internalStageFile(taskDir, stageName));
-    for (const header of PLAN_REQUIRED_HEADERS[stageName]) {
-      const found = files.length > 0 ? findSection(files, header) : undefined;
-      if (!found) {
-        stageValid = false;
-        addBlocker(blockers, 'missing-section', `Missing required section in internal checkpoint: ## ${header}`, { path: fallbackPath, stage: stageName, section: header });
-        continue;
-      }
-      summary.requiredSections.present += 1;
-      const relFound = projectRelative(root, found.file);
-      if (!contentHasValue(found.content)) {
-        stageValid = false;
-        addBlocker(blockers, 'empty-section', `Required checkpoint section has no content: ## ${header}`, { path: relFound, stage: stageName, section: header });
-        continue;
-      }
-      summary.requiredSections.valid += 1;
-
-      if (header === 'Atomic Tasks') {
-        if (!sectionContainsField(found.content, ['Acceptance', 'Acceptance criteria'])) {
-          stageValid = false;
-          addBlocker(blockers, 'missing-atomic-acceptance', 'Atomic Tasks must define acceptance criteria.', { path: relFound, stage: stageName, section: header });
-        }
-        if (!sectionContainsField(found.content, ['Verification'])) {
-          stageValid = false;
-          addBlocker(blockers, 'missing-atomic-verification', 'Atomic Tasks must define verification.', { path: relFound, stage: stageName, section: header });
-        }
-      }
-      if (header === 'Discussion Queue' && hasUnresolvedStructuredItem(found.content)) {
-        stageValid = false;
-        addBlocker(blockers, 'unresolved-discussion', 'Discussion Queue has unresolved items.', { path: relFound, stage: stageName, section: header });
-      }
-      if (header === 'Assumptions' && hasUnresolvedStructuredItem(found.content)) {
-        stageValid = false;
-        addBlocker(blockers, 'unresolved-assumption', 'Assumptions contain unresolved items.', { path: relFound, stage: stageName, section: header });
-      }
-    }
-    if (files.length > 0 && !validateWorkstreamHandoffContract(root, files, stageName, blockers)) stageValid = false;
-    if (files.length > 0 && !validateConstructionChecklist(root, files, stageName, blockers)) stageValid = false;
-    if (stageValid) summary.stages.valid += 1;
-  }
-
-  const result = { ok: blockers.length === 0, planPath: relPlanPath, blockers, warnings, summary, ...(selectedStage ? { stage: selectedStage } : {}) };
-  if (result.ok && selectedStage) {
-    const stageIndex = PLAN_INTERNAL_STAGE_DIRECTORIES.indexOf(selectedStage);
-    const nextStageName = stageIndex >= 0 ? PLAN_INTERNAL_STAGE_DIRECTORIES[stageIndex + 1] : undefined;
-    if (nextStageName) result.nextStage = buildNextStageDetails(root, taskDir, relPlanPath, nextStageName);
-  }
-  return withPlanValidationRepairPrompt(result);
-}
-
-export function formatPlanValidationText(result) {
-  const stageSuffix = result.stage ? ` (${result.stage})` : '';
-  if (result.ok) {
-    const lines = [`✅ Plan validation passed: ${result.planPath}${stageSuffix}`, `Stages: ${result.summary.stages.valid}/${result.summary.stages.total}`, `Required sections: ${result.summary.requiredSections.valid}/${result.summary.requiredSections.total}`];
-    if (result.nextStage?.prompt) lines.push('', 'Next stage:', result.nextStage.prompt);
-    return lines.join('\n');
-  }
-  const lines = [`❌ Plan validation failed: ${result.planPath}${stageSuffix}`, '', 'Blockers:'];
-  for (const blocker of result.blockers) {
-    lines.push(`- ${blocker.message}`);
-  }
-  if (result.repairPrompt) {
-    lines.push('', 'Agent prompt:', result.repairPrompt);
-  }
-  lines.push('', 'Next:', '- refine the plan before execution');
-  return lines.join('\n');
-}
-
-function runPlanValidate(args) {
-  const [planPath, ...rest] = args;
-  if (!planPath || planPath.startsWith('-')) {
-    console.error('Missing plan path.');
-    console.error(commandUsage('plan validate'));
-    process.exit(2);
-  }
-  const json = rest.includes('--json');
-  let stage;
-  let stageProvided = false;
-  for (let index = 0; index < rest.length; index += 1) {
-    const arg = rest[index];
-    if (arg === '--json') continue;
-    if (arg === '--stage') {
-      stageProvided = true;
-      stage = rest[index + 1];
-      if (!stage || stage.startsWith('-')) {
-        console.error('Missing plan validation stage.');
-        console.error(commandUsage('plan validate'));
-        process.exit(2);
-      }
-      index += 1;
-      continue;
-    }
-    console.error(`Unknown plan validate option: ${arg}`);
-    console.error(commandUsage('plan validate'));
-    process.exit(2);
-  }
-  if (stageProvided && !resolvePlanValidationStage(stage)) {
-    console.error(`Invalid plan validation stage: ${stage}`);
-    console.error(commandUsage('plan validate'));
-    process.exit(2);
-  }
-  const result = validatePlanArtifact(planPath, { stage });
-  if (json) console.log(JSON.stringify(result, null, 2));
-  else console.log(formatPlanValidationText(result));
-  process.exit(result.ok ? 0 : 1);
-}
-
-function runPlanStage(args) {
-  const [subcommand, stage, ...rest] = args;
-  if (subcommand !== 'create') {
-    console.error(`Unknown plan stage command: ${subcommand ?? ''}`.trim());
-    console.error(commandUsage('plan stage'));
-    process.exit(2);
-  }
-  if (!stage || stage.startsWith('-')) {
-    console.error('Missing plan stage.');
-    console.error(commandUsage('plan stage create'));
-    process.exit(2);
-  }
-  let json = false;
-  let planPath;
-  for (const arg of rest) {
-    if (arg === '--json') {
-      json = true;
-      continue;
-    }
-    if (arg.startsWith('-')) {
-      console.error(`Unknown plan stage create option: ${arg}`);
-      console.error(commandUsage('plan stage create'));
-      process.exit(2);
-    }
-    if (planPath) {
-      console.error(`Unexpected plan stage create argument: ${arg}`);
-      console.error(commandUsage('plan stage create'));
-      process.exit(2);
-    }
-    planPath = arg;
-  }
-  try {
-    const result = createPlanStageCheckpoint(stage, { planPath });
-    if (json) console.log(JSON.stringify(result, null, 2));
-    else console.log(`Created plan stage checkpoint: ${result.path}`);
-    process.exit(0);
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    console.error(commandUsage('plan stage create'));
-    process.exit(2);
-  }
-}
-
-export function runPlan(args) {
-  const [subcommand, ...rest] = args;
-  if (subcommand === 'validate') runPlanValidate(rest);
-  if (subcommand === 'stage') runPlanStage(rest);
-  console.error(`Unknown plan command: ${subcommand ?? ''}`.trim());
-  console.error(commandUsage('plan'));
-  process.exit(2);
-}