@dotdotgod/cli 0.1.43 → 0.1.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdotgod/cli",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "description": "CLI for dotdotgod validation, project memory snapshots, and graph indexing.",
   "type": "module",
   "license": "Elastic-2.0",

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

@@ -41,8 +41,9 @@ export const PLAN_BLOCKER_LABELS = new Map([
   ['invalid-task-slug', 'Plan task directory must be kebab-case'],
   ['empty-plan', 'Plan README is empty'],
   ['missing-stage', 'Missing required stage directory'],
-  ['missing-internal-stage', 'Missing internal stage file'],
   ['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'],
@@ -66,8 +67,9 @@ export function buildPlanValidationNextStagePrompt(planPath, stage, stagePath) {
   return [
     `Continue Plan Mode stage advancement for ${planPath}.`,
     `Current stage: ${stage}.`,
-    `Make ${planPath} satisfy the current stage's durable README requirements first. Use ${stagePath} only as an optional checkpoint/workflow note for this stage; do not make numbered checkpoint creation the goal and do not create later checkpoint files yet.`,
-    stage === '05-workstream-handoff' ? 'For this stage, 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,
+    `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

@@ -20,12 +20,14 @@ export {
   PLAN_STAGE_DIRECTORIES,
 };
 
-const PLACEHOLDER_RE = /^(?:[-*\s_`]*(?:tbd|todo|n\/a|placeholder|none)[.!?\s_`]*)+$/i;
-const CHECKLIST_OPEN_RE = /\b(?:open|unresolved|pending|needs confirmation|needs user|unknown)\b/i;
 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, '/');
 }
@@ -67,16 +69,6 @@ function contentHasValue(content) {
   return stripped.length > 0;
 }
 
-function isPlaceholderContent(content) {
-  const stripped = content
-    .split(/\r?\n/)
-    .map((line) => line.replace(/^\s*[-*+]\s+/, '').trim())
-    .filter(Boolean)
-    .join(' ')
-    .trim();
-  return Boolean(stripped) && PLACEHOLDER_RE.test(stripped);
-}
-
 function readMarkdownFiles(stageDir) {
   if (!existsSync(stageDir)) return [];
   return readdirSync(stageDir, { withFileTypes: true })
@@ -201,17 +193,37 @@ function readInternalStageState(taskDir, stageName) {
 
 function validateInternalStageState(root, taskDir, stageName, blockers) {
   const state = readInternalStageState(taskDir, stageName);
-  if (!state) return;
+  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);
-  const rel = projectRelative(root, state.file);
-  const looksLikeGeneratorState = /^Stage:\s*\S+\s*$/m.test(state.content) || /^Status:\s*\S+\s*$/m.test(state.content) || /^Updated:\s*\S+\s*$/m.test(state.content);
-  if (!looksLikeGeneratorState) return;
-  if (stage && stage !== stageName) addBlocker(blockers, 'missing-internal-stage', `Internal stage file has wrong Stage field: ${rel}`, { path: rel, stage: stageName });
-  if (!stage) addBlocker(blockers, 'missing-internal-stage', `Internal stage file is missing Stage: ${rel}`, { path: rel, stage: stageName });
-  if (!status) addBlocker(blockers, 'missing-internal-stage', `Internal stage file is missing valid Status: ${rel}`, { path: rel, stage: stageName });
-  if (!updated) addBlocker(blockers, 'missing-internal-stage', `Internal stage file is missing Updated: ${rel}`, { path: rel, stage: stageName });
+  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) {
@@ -244,33 +256,21 @@ function validateMarkdownNames(root, stageName, stageDir, blockers) {
   }
 }
 
-function sectionContains(content, words) {
-  const normalized = content.toLowerCase();
-  return words.some((word) => normalized.includes(word));
+function sectionContainsField(content, labels) {
+  const text = removeCodeBlocks(content);
+  return labels.some((label) => new RegExp(`(?:^|\\b)${escapeRegExp(label)}\\s*:\\s*\\S`, 'im').test(text));
 }
 
-function hasPendingRequiredWorkstream(content) {
-  return content.split(/\r?\n/).some((line) => {
-    const normalized = line.toLowerCase();
-    if (!normalized.includes('pending')) return false;
-    return /\byes\b|\brequired\b/.test(normalized);
-  });
+function hasUncheckedChecklistItem(content) {
+  return content.split(/\r?\n/).some((line) => /^\s*[-*+]\s*\[\s\]/.test(line));
 }
 
-function hasUnresolvedDiscussion(content) {
-  return content.split(/\r?\n/).some((line) => {
-    const normalized = line.toLowerCase();
-    if (/^\s*-\s*\[\s\]/.test(line)) return true;
-    return /status\s*:\s*(open|research[-_ ]requested|plan[-_ ]revision[-_ ]requested|unresolved|pending)/.test(normalized);
-  });
+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 hasUnresolvedAssumption(content) {
-  return content.split(/\r?\n/).some((line) => {
-    const normalized = line.toLowerCase();
-    if (/^\s*-\s*\[\s\]/.test(line)) return true;
-    return /\b(unresolved|pending|unknown|needs user|needs confirmation)\b/.test(normalized);
-  });
+function hasUnresolvedStructuredItem(content) {
+  return hasUncheckedChecklistItem(content) || hasOpenStructuredStatus(content);
 }
 
 function workstreamSplitDecision(content) {
@@ -278,36 +278,32 @@ function workstreamSplitDecision(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 /\b(?:rationale|reason|because)\b/i.test(content);
+  return fieldHasValue(content, 'No-split rationale');
 }
 
 function hasMultipleWorkstreams(content) {
-  const normalized = removeCodeBlocks(content).toLowerCase();
-  const explicitIds = new Set([...normalized.matchAll(/\b(?:workstream|ws)\s*[-:#]?\s*([a-z0-9]+)\b/g)].map((match) => match[1]));
-  if (explicitIds.size >= 2) return true;
-  const workstreamMentions = normalized.match(/\bworkstreams?\b/g) ?? [];
-  return workstreamMentions.length >= 2 && /\b(?:multiple|parallel|split)\b/.test(normalized);
+  return fieldOccurrences(content, 'Workstream ID') >= 2;
 }
 
 function hasActionableWorkstreamFields(content) {
-  const normalized = content.toLowerCase();
-  const fieldGroups = [
-    ['purpose', 'objective'],
-    ['required context', 'read'],
-    ['allowed edit'],
-    ['forbidden edit', 'do not edit', 'do-not edit'],
-    ['task'],
-    ['validation', 'verify'],
-    ['handoff output', 'output'],
-    ['dependenc'],
-  ];
-  return fieldGroups.every((group) => group.some((term) => normalized.includes(term)));
+  return ['Workstream ID', 'Purpose', 'Required context', 'Allowed edits', 'Forbidden edits', 'Tasks', 'Validation', 'Handoff output', 'Dependencies'].every((label) => fieldHasValue(content, label));
 }
 
 function hasActionableIntegrationFields(content) {
-  const normalized = content.toLowerCase();
-  return ['sequence', 'integrat'].every((term) => normalized.includes(term)) && ['validation', 'verify', 'handoff'].some((term) => normalized.includes(term));
+  return ['Step', 'Validation', 'Handoff'].every((label) => fieldHasValue(content, label));
 }
 
 function validateWorkstreamHandoffContract(root, files, stageName, blockers) {
@@ -324,9 +320,9 @@ function validateWorkstreamHandoffContract(root, files, stageName, blockers) {
   if (decision === 'no') {
     if (!hasNoSplitRationale(handoff.content)) {
       valid = false;
-      addBlocker(blockers, 'missing-workstream-no-split-rationale', 'Workstream Handoff with `Split decision: no` must include a rationale.', { path: relHandoff, stage: stageName, section: 'Workstream Handoff' });
+      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) || isPlaceholderContent(todo.content)) valid = false;
+    if (!todo || !contentHasValue(todo.content)) valid = false;
     return valid;
   }
 
@@ -336,15 +332,15 @@ function validateWorkstreamHandoffContract(root, files, stageName, blockers) {
   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 indicate multiple workstreams in Workstream Map, Workstreams, or Integration Sequence.', { path: projectRelative(root, map?.file ?? workstreams?.file ?? integration?.file ?? handoff.file), stage: stageName, section: 'Workstream Map' });
+    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 mention purpose/objective, required context/read, allowed edits, forbidden edits/do-not-edit, tasks, validation, handoff output, and dependencies.', { path: projectRelative(root, workstreams?.file ?? handoff.file), stage: stageName, section: 'Workstreams' });
+    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 describe actionable integration sequence and validation/handoff expectations.', { path: projectRelative(root, integration?.file ?? handoff.file), stage: stageName, section: 'Integration Sequence' });
+    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;
 }
@@ -358,25 +354,42 @@ function normalizeChecklistCategory(value) {
   return normalizeHeading(value).replace(/\s+/g, ' ');
 }
 
-function hasOpenChecklistEvidence(evidence) {
-  const normalized = evidence.toLowerCase();
-  if (/\bno\s+(?:open|unresolved|pending|unknown)\b/.test(normalized)) return false;
-  return CHECKLIST_OPEN_RE.test(normalized);
+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) => {
-    const match = /^\s*[-*+]\s*\[([^\]])\]\s*([^:]+):\s*(.*?)\s*$/.exec(line);
-    if (!match) return { line, lineNumber: index + 1, malformed: /^\s*[-*+]\s*/.test(line) && line.trim().length > 0 };
-    return {
-      line,
-      lineNumber: index + 1,
-      checked: match[1].trim().toLowerCase() === 'x',
-      category: match[2].trim(),
-      evidence: match[3].trim(),
-      malformed: false,
-    };
-  }).filter((row) => row.malformed || row.category);
+  return content
+    .split(/\r?\n/)
+    .map((line, index) => parseChecklistLine(line, index + 1))
+    .filter((row) => row?.malformed || row?.category);
 }
 
 function validateConstructionChecklist(root, files, stageName, blockers) {
@@ -395,22 +408,22 @@ function validateConstructionChecklist(root, files, stageName, blockers) {
   for (const row of rows) {
     if (row.malformed) {
       valid = false;
-      addBlocker(blockers, 'malformed-checklist-item', `Malformed construction checklist item at line ${row.lineNumber}: expected "- [x] Category: evidence".`, { path: relFound, stage: stageName, section: header });
+      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 || hasOpenChecklistEvidence(row.evidence)) {
+    if (!row.checked) {
       valid = false;
-      addBlocker(blockers, 'open-checklist-item', `Construction checklist item is open: ${row.category}`, { path: relFound, stage: stageName, section: header });
+      addBlocker(blockers, 'open-checklist-item', `Construction checklist item is unchecked: ${row.category}`, { path: relFound, stage: stageName, section: header });
     }
-    if (!contentHasValue(row.evidence) || isPlaceholderContent(row.evidence)) {
+    if (!contentHasValue(row.evidence)) {
       valid = false;
-      addBlocker(blockers, 'placeholder-checklist-item', `Construction checklist item only contains placeholder content: ${row.category}`, { path: relFound, stage: stageName, section: header });
+      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}`, { path: relFound, stage: stageName, section: header });
+      addBlocker(blockers, 'missing-checklist-item', `Missing construction checklist item: ${category}. Preferred format: "- [x] ${category}: evidence".`, { path: relFound, stage: stageName, section: header });
     }
   }
   return valid;
@@ -492,57 +505,48 @@ export function validatePlanArtifact(planPath, options = {}) {
   const durableFiles = discoverDurablePlanMarkdownFiles(taskDir);
   if (durableFiles.length > 1) summary.splitFiles.detected = true;
   for (const stageName of stagesToValidate) {
-    validateInternalStageState(root, taskDir, stageName, blockers);
-    const files = durableFiles.length > 0 ? durableFiles : [absolutePlanPath];
-    const stageReadme = absolutePlanPath;
-    summary.stages.present += 1;
-    let stageValid = true;
+    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 = findSection(files, header);
+      const found = files.length > 0 ? findSection(files, header) : undefined;
       if (!found) {
         stageValid = false;
-        addBlocker(blockers, 'missing-section', `Missing required section: ## ${header}`, { path: projectRelative(root, stageReadme), stage: stageName, section: header });
+        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 section has no content: ## ${header}`, { path: relFound, stage: stageName, section: header });
-        continue;
-      }
-      if (isPlaceholderContent(found.content)) {
-        stageValid = false;
-        addBlocker(blockers, 'placeholder-section', `Required section only contains placeholder content: ## ${header}`, { path: relFound, stage: stageName, section: header });
+        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 (!sectionContains(found.content, ['acceptance'])) {
+        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 (!sectionContains(found.content, ['verification', 'verify'])) {
+        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 === 'Role / Area Workstreams' && hasPendingRequiredWorkstream(found.content)) {
-        stageValid = false;
-        addBlocker(blockers, 'pending-workstream', 'Required role/area workstream is pending.', { path: relFound, stage: stageName, section: header });
-      }
-      if (header === 'Discussion Queue' && hasUnresolvedDiscussion(found.content)) {
+      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' && hasUnresolvedAssumption(found.content)) {
+      if (header === 'Assumptions' && hasUnresolvedStructuredItem(found.content)) {
         stageValid = false;
         addBlocker(blockers, 'unresolved-assumption', 'Assumptions contain unresolved items.', { path: relFound, stage: stageName, section: header });
       }
     }
-    if (!validateWorkstreamHandoffContract(root, files, stageName, blockers)) stageValid = false;
-    if (!validateConstructionChecklist(root, files, stageName, blockers)) stageValid = false;
+    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;
   }
 

package/src/validate/run.mjs

@@ -35,6 +35,7 @@ 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;
   };