dotmd-cli 0.74.2 → 0.74.4

package/bin/dotmd.mjs

@@ -919,7 +919,10 @@ Plan body variants (plans only — pick one body shape):
 Other options:
   --status <s>         Set initial status (defaults to first valid status for the type)
   --title <t>          Override the auto-derived title
-  --root <name>        Create in a specific docs root
+  --root <name>        Create in a specific docs root. Applies to a nested name
+                       too: \`new doc prospects/kim --root docs\` writes
+                       docs/prospects/kim.md. Without it, a name containing a
+                       \`/\` is read relative to the repo.
   --show-files         Append \`files: …\` line to stderr listing what was touched
                        (the new doc + the index file). See \`dotmd archive --help\`.
   --list-types         Show registered types (alias: --list-templates)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotmd-cli",
-  "version": "0.74.2",
+  "version": "0.74.4",
   "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/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/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/new.mjs

@@ -60,6 +60,27 @@ function fullBodyShortcut(title, bodyInput) {
   return hasOwnTitle ? `\n${b}\n` : `\n# ${title}\n\n${b}\n`;
 }
 
+function lexicallyInside(parent, child) {
+  return child === parent || child.startsWith(parent + path.sep);
+}
+
+// The default root for a type that doesn't name one of its own. This used to be
+// "whichever root is listed first", which drops a `doc` into `docs/plans` for
+// any project that lists its plans root first — the plan type's own root, for a
+// type that isn't a plan. When one configured root contains another it is
+// structurally the catch-all (`docs` holding `docs/plans` and `docs/adr`), so
+// prefer that; the deepest one, so a nested chain picks the most specific
+// container rather than the outermost. Single-root projects and flat sibling
+// roots have no catch-all to find and keep first-listed order.
+export function catchAllRoot(config) {
+  const roots = config.docsRoots ?? [config.docsRoot];
+  if (roots.length < 2) return config.docsRoot;
+  const containers = roots.filter(root => roots.some(other => other !== root && lexicallyInside(root, other)));
+  if (!containers.length) return config.docsRoot;
+  const depth = root => root.split(path.sep).length;
+  return containers.reduce((deepest, root) => depth(root) > depth(deepest) ? root : deepest);
+}
+
 const BUILTIN_TEMPLATES = {
   doc: {
     description: 'Reference doc, design note, module overview — build-up shape lite',
@@ -800,6 +821,9 @@ export async function runNew(argv, config, opts = {}) {
   } else if (name.endsWith('.md')) {
     namePart = name.slice(0, -3);
   }
+  // A prefix the *user* typed and one a template declares resolve differently
+  // below, so the distinction has to survive the template's assignment to nameDir.
+  const userNameDir = nameDir;
 
   // Slugify
   const slug = namePart.toLowerCase().replace(/[\s_]+/g, '-').replace(/[^a-z0-9-]/g, '').replace(/-+/g, '-').replace(/^-|-$/g, '');
@@ -811,7 +835,7 @@ export async function runNew(argv, config, opts = {}) {
   // Resolve target root. Precedence: CLI --root > template.targetRoot > config.docsRoot.
   // When the chosen root is a first-class type-container (matched by --root or targetRoot),
   // we skip the `template.dir` join — the root already points at the right directory.
-  let targetRoot = config.docsRoot;
+  let targetRoot = catchAllRoot(config);
   let routedToTypeRoot = false;
   if (rootName) {
     const roots = config.docsRoots || [config.docsRoot];
@@ -837,10 +861,46 @@ export async function runNew(argv, config, opts = {}) {
     nameDir = path.join(path.relative(config.repoRoot, targetRoot), template.dir);
   }
 
-  // Path — if user provided a directory prefix OR template declared one, resolve relative to repoRoot
-  const baseDir = nameDir ? path.resolve(config.repoRoot, nameDir) : targetRoot;
+  // Path — a directory prefix is read relative to the repo, because `dotmd new
+  // plan docs/plans/feature` is a full repo path and has to stay one. That was
+  // the ONLY reading, which is how `--root` came to be silently ignored the
+  // moment a name contained a slash: the block above picked a root and this line
+  // threw it away, so the one flag the out-of-root error advertises could not
+  // fix the error. With an explicit --root the prefix is now read relative to
+  // that root — unless the repo-relative reading already lands inside it, so
+  // full paths keep working.
+  const allRoots = config.docsRoots ?? [config.docsRoot];
+  let baseDir;
+  if (!nameDir) baseDir = targetRoot;
+  else if (userNameDir && rootName) {
+    const repoRelative = path.resolve(config.repoRoot, nameDir);
+    baseDir = lexicallyInside(targetRoot, repoRelative) ? repoRelative : path.resolve(targetRoot, nameDir);
+  } else baseDir = path.resolve(config.repoRoot, nameDir);
   const filePath = path.join(baseDir, slug + '.md');
   const repoPath = toRepoPath(filePath, config.repoRoot);
+
+  // Without --root there is nothing to disambiguate with, so a prefix pointing
+  // outside every root stays an error — but it names the flag that resolves it,
+  // and the flag now works. The generic containment error underneath reports
+  // absolute paths and no remedy, which is what agents kept re-guessing at.
+  //
+  // Gated on the remedy actually working: the suggestion is only offered when
+  // `--root` would land the file inside that root. That is what keeps this off
+  // a traversal (`../escaped`, an absolute path), where `--root` fixes nothing
+  // and the containment check below is the error that should speak — printing
+  // an untested remedy is the very defect this finding is about.
+  if (userNameDir && !rootName && !allRoots.some(root => lexicallyInside(root, filePath))) {
+    const rooted = path.resolve(targetRoot, userNameDir, slug + '.md');
+    if (lexicallyInside(targetRoot, rooted)) {
+      die(`Destination is outside every configured root:\n`
+        + `  ${repoPath}\n\n`
+        + `A name with a \`/\` is read relative to the repo.\n`
+        + `To place it under a root instead:\n`
+        + `  dotmd new ${typeName} ${name} --root ${path.basename(targetRoot)}\n`
+        + `     → ${toRepoPath(rooted, config.repoRoot)}\n\n`
+        + `Roots: ${allRoots.map(root => path.basename(root)).join(', ')}`);
+    }
+  }
   const destinationAuthorization = authorizeManagedDestination(filePath, config, { kind: 'New document destination' });
 
   if (existsSync(filePath)) {
@@ -862,12 +922,15 @@ export async function runNew(argv, config, opts = {}) {
   // When the project has >1 root and `--root` was omitted, surface the choice
   // so agents can see that an alternative root was available. Cheap visibility
   // for the "ended up in docs/plans/ for a doc" foot-gun.
-  const allRoots = config.docsRoots ?? [config.docsRoot];
+  // Report the root the file actually landed in, not the one resolution started
+  // from: a directory prefix can move the destination into a different root
+  // entirely, and the line used to say `Root: plans` while writing docs/prospects/.
   let rootHint = '';
   if (!rootName && allRoots.length > 1) {
-    const chosenLabel = path.basename(targetRoot);
+    const owningRoot = destinationAuthorization.root.lexicalPath;
+    const chosenLabel = path.basename(owningRoot);
     const others = allRoots
-      .filter(r => r !== targetRoot)
+      .filter(r => r !== owningRoot)
       .map(r => path.basename(r));
     rootHint = `Root: ${chosenLabel} (others: ${others.join(', ')} — pass --root <name> to change)\n`;
   }

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,13 +451,13 @@ 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;
+    if (skipDoc(doc)) 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).
@@ -482,10 +482,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 +501,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 +585,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 +658,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;