dotmd-cli 0.74.3 → 0.74.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotmd-cli",
-  "version": "0.74.3",
+  "version": "0.74.5",
   "description": "CLI for managing markdown documents with YAML frontmatter — index, query, validate, graph, export, lifecycle, and AI summaries.",
   "type": "module",
   "license": "MIT",

package/src/config.mjs

@@ -146,6 +146,13 @@ function normalizeRichStatuses(config, userConfig) {
     archiveStatuses: [],
     skipStaleFor: [],
     skipWarningsFor: [],
+    // Same membership as `skipWarningsFor`, but kept per declaring type. The flat
+    // list is a union of status NAMES, so a name any type marks quiet suppresses
+    // warnings for every other type that happens to share it — `journey.active`
+    // silencing every `active` plan in the repo. Statuses are type-scoped
+    // everywhere else (`typeStatuses`, `isValidStatus`), so the suppression that
+    // reads them has to be too.
+    skipWarningsForByType: {},
     terminalStatuses: [],
     moduleRequiredFor: [],
     // F15: status-name → directory-name (defaults to the status name verbatim).
@@ -166,6 +173,10 @@ function normalizeRichStatuses(config, userConfig) {
     if (typeof typeDef.statuses !== 'object') continue;
 
     hasRich = true;
+    // Claim the key even when no status is quiet: an empty list means "this type
+    // declared its statuses and suppresses nothing", which must not fall back to
+    // the global union. Absent entirely means "type never declared rich statuses".
+    derived.skipWarningsForByType[typeName] ??= [];
     const statusNames = [];
     const typeContext = { expanded: [], listed: [], counted: [] };
     const typeStaleDays = {};
@@ -203,7 +214,10 @@ function normalizeRichStatuses(config, userConfig) {
       if (p.archive && !derived.archiveStatuses.includes(name)) derived.archiveStatuses.push(name);
       if (p.startable && !derived.startableStatuses.includes(name)) derived.startableStatuses.push(name);
       if ((p.skipStale || quietImpliesSkipStale) && !derived.skipStaleFor.includes(name)) derived.skipStaleFor.push(name);
-      if ((p.skipWarnings || quietImpliesSkipWarnings) && !derived.skipWarningsFor.includes(name)) derived.skipWarningsFor.push(name);
+      if (p.skipWarnings || quietImpliesSkipWarnings) {
+        if (!derived.skipWarningsFor.includes(name)) derived.skipWarningsFor.push(name);
+        (derived.skipWarningsForByType[typeName] ??= []).push(name);
+      }
       if (p.terminal && !derived.terminalStatuses.includes(name)) derived.terminalStatuses.push(name);
       if (p.requiresModule && !derived.moduleRequiredFor.includes(name)) derived.moduleRequiredFor.push(name);
       if (p.filed && !derived.filedStatuses[name]) {
@@ -253,8 +267,17 @@ function applyDerivedConfig(config, userConfig, derived) {
   if (!userConfig.lifecycle?.skipStaleFor && derived.skipStaleFor.length) {
     config.lifecycle.skipStaleFor = derived.skipStaleFor;
   }
+  // Assigned on BOTH branches, never conditionally: `config.lifecycle` can be the
+  // module-level DEFAULTS.lifecycle object itself (deepMerge shallow-copies, so a
+  // user config with no `lifecycle` key shares the reference), and a conditional
+  // write would leave a previous resolveConfig call's map in place.
   if (!userConfig.lifecycle?.skipWarningsFor && derived.skipWarningsFor.length) {
     config.lifecycle.skipWarningsFor = derived.skipWarningsFor;
+    config.lifecycle.skipWarningsForByType = derived.skipWarningsForByType;
+  } else {
+    // An explicit `lifecycle.skipWarningsFor` is a deliberate repo-wide statement
+    // and stays type-blind.
+    config.lifecycle.skipWarningsForByType = {};
   }
   if (!userConfig.lifecycle?.terminalStatuses && derived.terminalStatuses.length) {
     config.lifecycle.terminalStatuses = derived.terminalStatuses;
@@ -504,6 +527,17 @@ export async function resolveConfig(cwd, explicitConfigPath) {
   const startableStatuses = new Set(lifecycle.startableStatuses ?? ['active', 'planned']);
   const skipStaleFor = new Set(lifecycle.skipStaleFor);
   const skipWarningsFor = new Set(lifecycle.skipWarningsFor);
+  const skipWarningsForByType = new Map(
+    Object.entries(lifecycle.skipWarningsForByType ?? {}).map(([type, names]) => [type, new Set(names)]),
+  );
+  // Does `status` suppress warning-only checks for a doc of this type? A type that
+  // declared rich statuses answers for itself — including answering "no" for a
+  // name some other type marked quiet. Everything else (no rich statuses, an
+  // explicit global `skipWarningsFor`, a doc with no type) reads the flat set.
+  const skipsWarnings = (status, type) => {
+    const own = type != null ? skipWarningsForByType.get(type) : undefined;
+    return own ? own.has(status) : skipWarningsFor.has(status);
+  };
   const terminalStatuses = new Set(lifecycle.terminalStatuses);
   // F15: filedStatuses keyed by status name, value = directory name. Empty
   // object when no status opts in via `filed: true` (or `filed: '<dirname>'`).
@@ -555,7 +589,7 @@ export async function resolveConfig(cwd, explicitConfigPath) {
     rootValidStatuses,
     staleDaysByStatus,
 
-    lifecycle: { archiveStatuses, startableStatuses, skipStaleFor, skipWarningsFor, terminalStatuses, filedStatuses, archiveNestedTypes },
+    lifecycle: { archiveStatuses, startableStatuses, skipStaleFor, skipWarningsFor, skipWarningsForByType, skipsWarnings, terminalStatuses, filedStatuses, archiveNestedTypes },
 
     validSurfaces,
     validModules,

package/src/extractors.mjs

@@ -41,8 +41,17 @@ export function extractNextStep(body) {
 
 export function extractBodyLinks(body) {
   if (!body) return [];
-  // Strip fenced code blocks and inline code to avoid false positives
-  const stripped = body.replace(/^```[\s\S]*?^```/gm, '').replace(/`[^`]+`/g, '');
+  // Strip fenced code blocks, then MASK inline code rather than delete it.
+  // Deleting it ate the commonest link idiom in a plan hub: [`plan.md`](plan.md)
+  // has its link TEXT as a code span, so removing the span left `[](plan.md)`,
+  // which the regex below rejects for having empty text. A hub with hundreds of
+  // such links reported one — and since this list is what validates body links,
+  // every one of them was also never checked for breakage. Masking to same-length
+  // filler keeps the link matchable while still neutralizing a link that is
+  // itself inside code (`[fake](x.md)` stays unmatched), and preserves offsets.
+  const stripped = body
+    .replace(/^```[\s\S]*?^```/gm, '')
+    .replace(/`[^`]+`/g, match => 'x'.repeat(match.length));
   const links = [];
   // Match [text](path.md) or [text](path.md#anchor), skip images (preceded by !)
   const regex = /(?<!!)\[([^\]]+)\]\(([^)]+\.md(?:#[^)]*)?)\)/g;

package/src/frontmatter-fix.mjs

@@ -33,7 +33,7 @@ export function runFrontmatterFix(config, opts = {}) {
     const status = asString(parsed.status);
     if (config.lifecycle.terminalStatuses.has(status)
       || config.lifecycle.archiveStatuses.has(status)
-      || config.lifecycle.skipWarningsFor.has(status)) continue;
+      || config.lifecycle.skipsWarnings(status, docType)) continue;
 
     const ops = [];
     for (const { name, cap, target, heading } of FIELDS) {

package/src/hub-membership.mjs

@@ -39,10 +39,10 @@ const BACKREF_KIND = 'hub-membership-backref';
 
 export function checkHubMembershipDrift(docs, config) {
   const warnings = [];
-  const quiet = new Set([
-    ...(config.lifecycle?.terminalStatuses ?? []),
-    ...(config.lifecycle?.skipWarningsFor ?? []),
-  ]);
+  // Per-doc: warning suppression is type-scoped, so a status name quiet for one
+  // type stays loud for another that declared the same name.
+  const quiet = (d) => config.lifecycle?.terminalStatuses?.has(d.status)
+    || config.lifecycle?.skipsWarnings(d.status, d.type);
   const byPath = new Map(docs.map(doc => [doc.path, doc]));
   const refFields = [
     ...(config.referenceFields?.bidirectional ?? []),
@@ -82,7 +82,7 @@ export function checkHubMembershipDrift(docs, config) {
   // it lives. Warns on the HUB: the hub's list is the half that lost the entry.
   const knownCache = new Map();
   for (const child of docs) {
-    if (quiet.has(child.status)) continue;
+    if (quiet(child)) continue;
     const parents = child.refFields?.parent_plan ?? [];
     if (parents.length === 0) continue;
     const dir = dirOf(child);
@@ -92,7 +92,7 @@ export function checkHubMembershipDrift(docs, config) {
       // parent rows nothing, and demanding a link back there would be a new
       // opinion rather than a drift check.
       if (!hub || hub.path === child.path || !isHubDoc(hub)) continue;
-      if (quiet.has(hub.status)) continue;
+      if (quiet(hub)) continue;
       if (!knownCache.has(hub.path)) knownCache.set(hub.path, knownTo(hub));
       if (knownCache.get(hub.path).has(child.path)) continue;
       warnings.push({
@@ -113,7 +113,7 @@ export function checkHubMembershipDrift(docs, config) {
   // back-ref is never reported twice. Warns on the CHILD, matching that check:
   // it's the file that needs the edit.
   for (const hub of docs) {
-    if (!isHubDoc(hub) || quiet.has(hub.status)) continue;
+    if (!isHubDoc(hub) || quiet(hub)) continue;
     let body;
     try { ({ body } = extractFrontmatter(readFileSync(path.join(config.repoRoot, hub.path), 'utf8'))); }
     catch { continue; }
@@ -131,7 +131,7 @@ export function checkHubMembershipDrift(docs, config) {
       const child = resolve(ref, dir);
       if (!child || child.path === hub.path || seen.has(child.path)) continue;
       seen.add(child.path);
-      if (quiet.has(child.status)) continue;                 // closed work is normal history
+      if (quiet(child)) continue;                 // closed work is normal history
       if (inFrontmatterRunlist.has(child.path)) continue;    // checkRunlistBackPointers owns it
       if (isHubDoc(child)) continue;                         // a hub under a hub is the roadmap tier
       if (child.type && child.type !== 'plan') continue;     // `parent_plan` is a plan relationship

package/src/hub.mjs

@@ -242,9 +242,31 @@ export function detectBodyRunlistRefs(body) {
   let match;
   while ((match = linkSectionRe.exec(body)) !== null) {
     const section = sliceSection(match.index + match[0].length);
+    // Line by line, because the SHAPE decides what a link means, not the
+    // heading's name. A section titled `## Runlist index — by category` matches
+    // this heading list but is written as tables, and taking every link in it
+    // made each row's descriptive prose a membership claim: a row about plan A
+    // whose prose says "spawned children B, C" ranked B and C as the hub's own,
+    // then warned B and C for not naming the hub as parent. In a table, only the
+    // row's first link is the ranked plan — the same rule the ranked-queue
+    // branch below already applies.
     const allLinks = new RegExp(linkRe.source, 'g');
-    let link;
-    while ((link = allLinks.exec(section)) !== null) refs.push(link[1]);
+    for (const rawLine of section.split('\n')) {
+      const line = rawLine.trim();
+      if (line.startsWith('|')) {
+        const link = firstRowLink(line);
+        if (link) refs.push(link);
+        continue;
+      }
+      // One ranked item per line, first link wins — the same rule as a table
+      // row. A ranked item routinely carries commentary that links elsewhere
+      // ("Phase 7's open item closes on a route decision in [other-plan.md]"),
+      // and counting those made the hub claim plans it was only citing. A hub
+      // that means to rank two plans lists them on two lines.
+      allLinks.lastIndex = 0;
+      const link = allLinks.exec(line);
+      if (link) refs.push(link[1]);
+    }
 
     const checklistRe = /^\s*[-*]\s+\[[ xX]\]\s+([^\s)]+\.md(?:#[^\s)]+)?)/gm;
     let item;

package/src/lint.mjs

@@ -79,7 +79,7 @@ export function runLint(argv, config, opts = {}) {
     const parsed = parseSimpleFrontmatter(frontmatter);
     const repoPath = toRepoPath(filePath, config.repoRoot);
     const fixes = [];
-    const skipWarnings = config.lifecycle.skipWarningsFor.has(asString(parsed.status));
+    const skipWarnings = config.lifecycle.skipsWarnings(asString(parsed.status), asString(parsed.type));
 
     // Missing type (fixable — infer from root: plans → 'plan', else 'doc')
     if (!asString(parsed.type)) {

package/src/render.mjs

@@ -291,8 +291,8 @@ function _renderContext(index, config, opts = {}) {
     lines.push('Stale: none');
   }
 
-  const withErrors = index.docs.filter(d => d.errors.length > 0 && !config.lifecycle.skipWarningsFor.has(d.status));
-  const withWarnings = index.docs.filter(d => d.warnings.length > 0 && !config.lifecycle.skipWarningsFor.has(d.status));
+  const withErrors = index.docs.filter(d => d.errors.length > 0 && !config.lifecycle.skipsWarnings(d.status, d.type));
+  const withWarnings = index.docs.filter(d => d.warnings.length > 0 && !config.lifecycle.skipsWarnings(d.status, d.type));
   if (withErrors.length || withWarnings.length) {
     const parts = [];
     if (withErrors.length) parts.push(`${withErrors.length} with errors`);

package/src/stats.mjs

@@ -15,7 +15,7 @@ export function buildStats(index, config) {
     }
   }
   const scoped = docs.filter(d => scope.includes(d.status));
-  const nonArchived = docs.filter(d => !config.lifecycle.skipWarningsFor.has(d.status));
+  const nonArchived = docs.filter(d => !config.lifecycle.skipsWarnings(d.status, d.type));
 
   // Health
   const staleCount = nonArchived.filter(d => d.isStale).length;

package/src/status-metadata.mjs

@@ -22,7 +22,7 @@ export function resolveStatusMetadata(config) {
 
     byType[type] = statuses.map((name, rank) => {
       const skipStale = config.lifecycle.skipStaleFor.has(name);
-      const skipWarnings = config.lifecycle.skipWarningsFor.has(name);
+      const skipWarnings = config.lifecycle.skipsWarnings(name, type);
       const hasTypeStaleDays = Object.prototype.hasOwnProperty.call(typeDef.staleDays ?? {}, name);
       return {
         name,

package/src/statuses.mjs

@@ -451,7 +451,7 @@ async function runMigrateType(args, config, opts) {
     if (lc.terminalStatuses.has(name)) props.terminal = true;
     // Apply quiet sugar when both skipStale and skipWarnings hold; otherwise emit the individual flag.
     const skipStale = lc.skipStaleFor.has(name);
-    const skipWarnings = lc.skipWarningsFor.has(name);
+    const skipWarnings = lc.skipsWarnings(name, typeName);
     if (skipStale && skipWarnings) props.quiet = true;
     else {
       if (skipStale) props.skipStale = true;

package/src/sync-status.mjs

@@ -89,16 +89,16 @@ export function collectHubStatusRows(docs, config, { hubPaths = null } = {}) {
     const key = doc.path.toLowerCase();
     docByFoldedPath.set(key, docByFoldedPath.has(key) ? null : doc);
   }
-  const quiet = new Set([
-    ...(config.lifecycle?.terminalStatuses ?? []),
-    ...(config.lifecycle?.skipWarningsFor ?? []),
-  ]);
+  // Per-doc: warning suppression is type-scoped, so a status name quiet for one
+  // type stays loud for another that declared the same name.
+  const quiet = (d) => config.lifecycle?.terminalStatuses?.has(d.status)
+    || config.lifecycle?.skipsWarnings(d.status, d.type);
   const out = [];
 
   for (const hub of docs) {
     if (!isHubDoc(hub)) continue;
     if (hubPaths) { if (!hubPaths.has(hub.path)) continue; }
-    else if (quiet.has(hub.status)) continue;
+    else if (quiet(hub)) continue;
 
     let raw;
     try { raw = readFileSync(path.join(config.repoRoot, hub.path), 'utf8'); } catch { continue; }

package/src/validate.mjs

@@ -93,7 +93,7 @@ export function validateDoc(doc, frontmatter, headingTitle, config) {
 
   const knownStatus = isValidStatus(doc.status, doc.root, config, doc.type);
 
-  if (knownStatus && !config.lifecycle.skipWarningsFor.has(doc.status) && !doc.updated) {
+  if (knownStatus && !config.lifecycle.skipsWarnings(doc.status, doc.type) && !doc.updated) {
     doc.errors.push({ path: doc.path, level: 'error', message: 'Missing frontmatter `updated` for non-archived doc.' });
   }
 
@@ -130,7 +130,7 @@ export function validateDoc(doc, frontmatter, headingTitle, config) {
     doc.errors.push({ path: doc.path, level: 'error', message: '`modules` is required for this status; declare a real module from `taxonomy.modules`, or `none` as the explicit no-module sentinel.' });
   }
 
-  if (config.validSurfaces && !config.lifecycle.skipWarningsFor.has(doc.status)) {
+  if (config.validSurfaces && !config.lifecycle.skipsWarnings(doc.status, doc.type)) {
     const knownSurfaces = [...config.validSurfaces];
     for (const surface of doc.surfaces) {
       if (!config.validSurfaces.has(surface)) {
@@ -153,7 +153,7 @@ export function validateDoc(doc, frontmatter, headingTitle, config) {
   // target is inlined in the message so `dotmd lint --fix` users see exactly
   // what they'll end up with — and so non-fix readers can hand-migrate.
   // Suppress for archived/terminal docs (same noise-control rule as F2).
-  if (!config.lifecycle.skipWarningsFor.has(doc.status)) {
+  if (!config.lifecycle.skipsWarnings(doc.status, doc.type)) {
     for (const { singular, plural } of [{ singular: 'module', plural: 'modules' }, { singular: 'surface', plural: 'surfaces' }]) {
       const singularValue = frontmatter[singular];
       if (!Object.prototype.hasOwnProperty.call(frontmatter, singular)) continue;
@@ -190,13 +190,13 @@ export function validateDoc(doc, frontmatter, headingTitle, config) {
     doc.warnings.push({ path: doc.path, level: 'warning', message: 'Missing `title` and no H1 found for fallback.' });
   }
 
-  if (!skipTitleSummary && !config.lifecycle.skipWarningsFor.has(doc.status) && !asString(frontmatter.summary) && !doc.summary) {
+  if (!skipTitleSummary && !config.lifecycle.skipsWarnings(doc.status, doc.type) && !asString(frontmatter.summary) && !doc.summary) {
     doc.warnings.push({ path: doc.path, level: 'warning', message: 'Missing `summary` and no blockquote fallback found.' });
   }
 
   // Determine which statuses should have current_state and next_step (plans only, not docs/research)
   const isPlanWork = knownStatus && doc.status && (!doc.type || doc.type === 'plan')
-    && !config.lifecycle.terminalStatuses.has(doc.status) && !config.lifecycle.skipWarningsFor.has(doc.status);
+    && !config.lifecycle.terminalStatuses.has(doc.status) && !config.lifecycle.skipsWarnings(doc.status, doc.type);
 
   if (isPlanWork && !asString(frontmatter.current_state)) {
     doc.warnings.push({ path: doc.path, level: 'warning', message: 'Missing `current_state`; index output is using a fallback or placeholder.' });
@@ -259,7 +259,7 @@ export function validateDoc(doc, frontmatter, headingTitle, config) {
   const docDir = path.dirname(path.join(config.repoRoot, doc.path));
   const allRefFields = [...(config.referenceFields.bidirectional || []), ...(config.referenceFields.unidirectional || [])];
   const skipRefValidation = config.lifecycle.terminalStatuses.has(doc.status)
-    || config.lifecycle.skipWarningsFor.has(doc.status);
+    || config.lifecycle.skipsWarnings(doc.status, doc.type);
   if (!skipRefValidation) {
     for (const field of allRefFields) {
       for (const relPath of (doc.refFields[field] || [])) {
@@ -406,14 +406,14 @@ export function checkBidirectionalReferences(docs, config) {
 // child it doesn't own without nagging the child to add `parent_plan:`.
 export function checkRunlistBackPointers(docs, config) {
   const warnings = [];
-  const skipStatuses = new Set([
-    ...(config.lifecycle.terminalStatuses ?? []),
-    ...(config.lifecycle.skipWarningsFor ?? []),
-  ]);
+  // Per-doc, not a precomputed name set: warning suppression is type-scoped, so
+  // the same status name can be quiet for one type and loud for another.
+  const skipDoc = (d) => config.lifecycle.terminalStatuses.has(d.status)
+    || config.lifecycle.skipsWarnings(d.status, d.type);
   const byPath = new Map(docs.map(d => [d.path, d]));
 
   for (const hub of docs) {
-    if (skipStatuses.has(hub.status)) continue;
+    if (skipDoc(hub)) continue;
     const runlistRefs = hub.refFields?.runlist ?? [];
     const runlistDirs = hub.refFieldDirections?.runlist ?? [];
     if (runlistRefs.length === 0) continue;
@@ -427,7 +427,7 @@ export function checkRunlistBackPointers(docs, config) {
       const childPath = toRepoPath(resolved, config.repoRoot);
       const child = byPath.get(childPath);
       if (!child) continue;
-      if (skipStatuses.has(child.status)) continue;
+      if (skipDoc(child)) continue;
       const childParents = (child.refFields?.parent_plan ?? []).map(p => {
         const abs = resolveRefPath(p, path.dirname(path.join(config.repoRoot, child.path)), config.repoRoot);
         return abs ? toRepoPath(abs, config.repoRoot) : p;
@@ -451,17 +451,21 @@ export function checkRunlistBackPointers(docs, config) {
 // it explicit. Skips terminal/quiet statuses like every other warning-only check.
 export function checkCoordinationHubExecutionMode(docs, config) {
   const warnings = [];
-  const skipStatuses = new Set([
-    ...(config.lifecycle.terminalStatuses ?? []),
-    ...(config.lifecycle.skipWarningsFor ?? []),
-  ]);
+  // Per-doc, not a precomputed name set: warning suppression is type-scoped, so
+  // the same status name can be quiet for one type and loud for another.
+  const skipDoc = (d) => config.lifecycle.terminalStatuses.has(d.status)
+    || config.lifecycle.skipsWarnings(d.status, d.type);
   for (const doc of docs) {
     if (doc.type && doc.type !== 'plan') continue;
-    if (skipStatuses.has(doc.status)) continue;
-    // A roadmap (`execution_mode: roadmap`) is already an explicit held-out hub —
-    // just a tier up. Don't nudge it toward `coordination` even when its slug is
-    // `*-runlist` (e.g. a `master-runlist` promoted to a roadmap).
-    if (doc.executionMode === 'coordination' || doc.executionMode === 'roadmap') continue;
+    if (skipDoc(doc)) continue;
+    // ANY explicit `execution_mode` ends it. The field is the canonical signal
+    // and the slug is only a fallback for hubs that predate it, so a plan that
+    // already answered — `implementation`, `roadmap`, anything — has said what it
+    // is. Nudging past that misfires on exactly one population: plans ABOUT
+    // runlists, whose slug contains the word while the document is ordinary work.
+    // (A real one: a plan to rename the runlist concept, declared
+    // `execution_mode: implementation`, nagged to call itself a coordination hub.)
+    if (doc.executionMode) continue;
     const base = (doc.path.split('/').pop() || '').replace(/\.md$/, '');
     if (base !== 'runlist' && !base.endsWith('-runlist')) continue;
     warnings.push({
@@ -482,10 +486,10 @@ export function checkCoordinationHubExecutionMode(docs, config) {
 // coordination hub that merely references one sibling runlist isn't mislabelled.
 export function checkRoadmapHubExecutionMode(docs, config) {
   const warnings = [];
-  const skipStatuses = new Set([
-    ...(config.lifecycle.terminalStatuses ?? []),
-    ...(config.lifecycle.skipWarningsFor ?? []),
-  ]);
+  // Per-doc, not a precomputed name set: warning suppression is type-scoped, so
+  // the same status name can be quiet for one type and loud for another.
+  const skipDoc = (d) => config.lifecycle.terminalStatuses.has(d.status)
+    || config.lifecycle.skipsWarnings(d.status, d.type);
   const byPath = new Map(docs.map(d => [d.path, d]));
   const byBasename = new Map();
   for (const d of docs) {
@@ -501,7 +505,7 @@ export function checkRoadmapHubExecutionMode(docs, config) {
   };
   for (const doc of docs) {
     if (doc.type && doc.type !== 'plan') continue;
-    if (skipStatuses.has(doc.status)) continue;
+    if (skipDoc(doc)) continue;
     if (doc.executionMode === 'roadmap') continue;       // already a roadmap
     if (doc.executionMode !== 'coordination') continue;  // only nudge explicit coordination hubs
     const refs = doc.refFields?.related_plans ?? [];
@@ -585,7 +589,7 @@ export function validatePlanShape(doc, body, frontmatter, config) {
   if (doc.type !== 'plan') return;
   // Skip plans in terminal/archive statuses (closed work shouldn't generate noise)
   if (config.lifecycle.terminalStatuses.has(doc.status) || config.lifecycle.archiveStatuses.has(doc.status)) return;
-  if (config.lifecycle.skipWarningsFor.has(doc.status)) return;
+  if (config.lifecycle.skipsWarnings(doc.status, doc.type)) return;
 
   // 1. next_step length cap (800 chars). Was 300; raised in parallel with
   // current_state for the same reason: agents need to encode "what to do next"
@@ -658,7 +662,7 @@ export function validatePlanShape(doc, body, frontmatter, config) {
 export function validateDocShape(doc, body, frontmatter, config) {
   if (doc.type !== 'doc') return;
   if (config.lifecycle.terminalStatuses.has(doc.status) || config.lifecycle.archiveStatuses.has(doc.status)) return;
-  if (config.lifecycle.skipWarningsFor.has(doc.status)) return;
+  if (config.lifecycle.skipsWarnings(doc.status, doc.type)) return;
 
   if (!body) return;