rcf-lite 0.28.1 → 0.28.4

package/src/cli/feedback.js

@@ -54,7 +54,7 @@ import {
   emitSessionStart,
   shouldAsk,
 } from '../feedback/hook.js';
-import { redact, allowedHosts, findResidualSecrets } from '../feedback/redact.js';
+import { redact, allowedHosts, findResidualSecrets, RESERVED_IDENTITY_TOKENS } from '../feedback/redact.js';
 import { fingerprint } from '../feedback/fingerprint.js';
 import { renderIssue, renderComment, renderBundle } from '../feedback/render.js';
 import { resolve as resolveDestination, listUnresolvedLibraries, findBlueprintRecord } from '../feedback/destination.js';
@@ -477,17 +477,58 @@ async function handleAdd(argv, ctx) {
 }
 
 /**
- * Classify an evidence pointer into `{ kind, value }`. A colon-separated
- * `path:line` pattern is 'file'; a bare identifier that looks like an
- * upper-cased id is 'id'; anything else is 'command'. The classification
- * is best-effort and does not gate the write.
+ * Classify an evidence pointer into `{ kind, value }`. The help text
+ * promises three shapes: command / path:line / id. The classifier
+ * distinguishes them by cheap shape rules:
+ *
+ * - `id`: a canonical uppercase-prefix RCF artefact id (`AC-15501-1`,
+ *   `REQ-155`, `FBS-181`, `US-15701`).
+ * - `file`: `path:line` (a non-space token ending in `:<digits>`) OR
+ *   a bare filesystem path shape - a slash-bearing, non-whitespace
+ *   token that ends in a known file extension. This is the shape a
+ *   `--evidence rcf/.blueprint-libraries/wsd/1.0.0/library.json`
+ *   argument carries (issue #245).
+ * - `command`: anything else. This is the fallback shape for a bare
+ *   verb invocation like `rcf feedback preview` or `pnpm --filter
+ *   rcf-lite test`.
+ *
+ * Classification is best-effort and never gates the write; the value
+ * itself is always preserved verbatim. The rendered preview label
+ * uses this kind so the operator sees which shape the pointer carries
+ * without having to re-run it.
  *
  * @param {string} value
  * @returns {{ kind: 'file' | 'id' | 'command', value: string }}
  */
+// 0.28.3 (issue #245): extension shortlist used by `classifyEvidence`
+// to recognise bare file-path evidence. Kept in lockstep with the
+// redactor's default extension allowlist so operators see the same
+// treatment on both sides. Duplicated deliberately (not imported) to
+// keep the CLI light on cross-module reads for a per-call classifier.
+const EVIDENCE_FILE_EXTENSIONS = new Set([
+  'md', 'mdx', 'json', 'yml', 'yaml', 'txt',
+  'js', 'mjs', 'cjs', 'ts', 'tsx',
+  'html', 'css', 'png', 'svg', 'sh', 'csv', 'log', 'lock',
+]);
+
 export function classifyEvidence(value) {
+  if (typeof value !== 'string' || value.length === 0) return { kind: 'command', value };
+  // Canonical RCF id shape: uppercase prefix, then digits (e.g. AC-15501-1).
   if (/^[A-Z]+-\d[\w-]*$/.test(value)) return { kind: 'id', value };
-  if (/^[^\s].*:\d+$/.test(value)) return { kind: 'file', value };
+  // path:line - a non-whitespace token ending in ":<digits>".
+  if (/^[^\s]+:\d+$/.test(value)) return { kind: 'file', value };
+  // Bare filesystem path or filename: no whitespace, ends in a known
+  // extension (issue #245). Whitespace anywhere disqualifies the
+  // candidate; that is almost certainly a shell command. A bare
+  // filename without a slash still counts because a --evidence
+  // pointer to README.md or CHANGELOG.md is common.
+  if (!/\s/.test(value)) {
+    const lastDot = value.lastIndexOf('.');
+    if (lastDot > 0 && lastDot < value.length - 1) {
+      const ext = value.slice(lastDot + 1).toLowerCase();
+      if (EVIDENCE_FILE_EXTENSIONS.has(ext)) return { kind: 'file', value };
+    }
+  }
   return { kind: 'command', value };
 }
 
@@ -624,6 +665,14 @@ async function handleStatus(argv, ctx) {
       visibility: dest.visibility ?? 'unresolved',
       derived: !!dest.derived,
       reason: dest.reason ?? null,
+      // Issue #244 (0.28.3): the preview surface prints
+      // `source: <library-manifest|package-bugs-url|derived|...>` so
+      // the operator can see WHICH resolver path picked the destination.
+      // The --json surface must expose the same field for programmatic
+      // verifiers per AC-15502-2 (--json emits the same as text). The
+      // field is null when the resolver did not attach one (e.g. an
+      // unresolved library).
+      source: dest.source ?? null,
     });
   }
 
@@ -672,6 +721,12 @@ async function handleStatus(argv, ctx) {
         ? `${row.repo} (${row.visibility}${row.derived ? ', derived' : ''})`
         : `(unresolved${row.reason ? `: ${row.reason}` : ''})`;
       stdout.write(`  - ${row.ref} -> ${cell}\n`);
+      // Issue #244 (0.28.3): print the resolver source so text and
+      // --json carry the same disclosure. Preview already prints this;
+      // status now matches per AC-15502-2 parity.
+      if (row.source) {
+        stdout.write(`    source: ${row.source}\n`);
+      }
     }
   }
   return 0;
@@ -1003,15 +1058,76 @@ async function handlePreview(argv, ctx) {
  */
 async function buildRedactionContext(projectRoot) {
   let operatorName;
+  // 0.28.3 (R5g, issue #246): track why identity folding might be
+  // disabled so we can emit exactly one visible stderr warning
+  // instead of leaving the operator to guess. `disabledReason` is
+  // one of 'no-profile' (rcf/.identity/profile.md is missing or
+  // unreadable), 'no-name-line' (present but no `## Name` heading),
+  // 'blank-name' (whitespace-only), 'placeholder' (matches the
+  // placeholder/todo regex), 'stopword-only' (Name contains only
+  // reserved-noun tokens), or null when a foldable identity was
+  // extracted.
+  let disabledReason = 'no-profile';
   try {
     const profile = await readFile(resolve(projectRoot, 'rcf', '.identity', 'profile.md'), 'utf8');
-    const m = profile.match(/^##\s+Name\s*\n([^\n]+)/m);
-    if (m) {
-      const n = m[1].trim();
-      if (n && !/placeholder|todo|your name/i.test(n)) operatorName = n;
+    // Codex P1-2: extract the Name-section body up to the next `## `
+    // heading or EOF, using ONLY horizontal whitespace on the heading
+    // line so an empty section (`## Name\n\n## Role\n...`) does not
+    // greedy-match into the next section's heading. Bind the search
+    // to the first `## Name` header only.
+    // JS regex has no `\Z`; use a lookahead for the next `## ` header
+    // OR end of string. `[\s\S]*?` is lazy so it stops at the first
+    // matching lookahead.
+    const nameSection = profile.match(/^##[ \t]+Name[ \t]*\n([\s\S]*?)(?=^##[ \t]+|$(?![\s\S]))/m);
+    if (!nameSection) {
+      disabledReason = 'no-name-line';
+    } else {
+      // The first non-empty non-comment line inside the Name section is
+      // the operator's identity. Strip whitespace and leading/trailing
+      // markdown emphasis so a shipped placeholder like
+      // `_(who you are; how you want the agent to address you)_` is
+      // seen as text, not folded as a name token.
+      const nonEmpty = nameSection[1].split('\n').map((l) => l.trim()).filter((l) => l.length > 0);
+      const first = nonEmpty[0];
+      if (!first) {
+        disabledReason = 'blank-name';
+      } else if (/^_\(.*\)_$/i.test(first) || /placeholder|todo|your name/i.test(first) || /^_.*(who you are|how you want).*_$/i.test(first)) {
+        // Codex P1-3: recognise the shipped seed placeholder shape
+        // `_(who you are; how you want the agent to address you)_`
+        // as a placeholder so the untouched generated profile emits
+        // the disabled-folding warning rather than folding the
+        // placeholder text as a name.
+        disabledReason = 'placeholder';
+      } else {
+        operatorName = first;
+        const rawTokens = first.split(/\s+/);
+        const foldable = rawTokens.filter((t) => t.length > 3 && !RESERVED_IDENTITY_TOKENS.has(t.toLowerCase()));
+        if (foldable.length === 0) {
+          disabledReason = 'stopword-only';
+        } else {
+          disabledReason = null;
+        }
+      }
     }
   } catch { /* absent is fine */ }
 
+  // Emit the one-line warning once per context build. All disabled
+  // reasons carry the same fix pointer so the operator knows how to
+  // arm folding without having to read the source.
+  if (disabledReason) {
+    const path = 'rcf/.identity/profile.md';
+    const detail = {
+      'no-profile': `${path} is missing`,
+      'no-name-line': `${path} has no \`## Name\` heading`,
+      'blank-name': `${path} \`## Name\` line is empty`,
+      'placeholder': `${path} \`## Name\` line is a placeholder`,
+      'stopword-only': `${path} \`## Name\` line contains only reserved nouns`,
+    }[disabledReason] ?? path;
+    process.stderr.write(
+      `[warn] operator-identity: ${detail}; identity folding is disabled. Add a real \`## Name\` line to arm the redactor.\n`
+    );
+  }
+
   let projectName;
   const remotes = new Set();
   try {
@@ -1033,11 +1149,21 @@ async function buildRedactionContext(projectRoot) {
   } catch { /* no git or no remotes is fine */ }
 
   let allowHostsExt = [];
+  let allowExtensionsExt = [];
   try {
     const settings = JSON.parse(await readFile(resolve(projectRoot, 'rcf', 'feedback-settings.json'), 'utf8'));
     if (Array.isArray(settings?.redaction?.allowHosts)) {
       allowHostsExt = settings.redaction.allowHosts;
     }
+    // 0.28.2 (Codex review follow-up on #233): the operator's
+    // per-project extension shortlist must reach the redactor the
+    // same way `allowHosts` does. Previously the CLI dropped
+    // `settings.redaction.allowExtensions` on the floor, so an
+    // operator adding `xyz` to keep `file.xyz` intact saw the fold
+    // fire in preview and submit.
+    if (Array.isArray(settings?.redaction?.allowExtensions)) {
+      allowExtensionsExt = settings.redaction.allowExtensions;
+    }
   } catch { /* absent is fine */ }
   // Assemble the extended allow-list once so downstream callers can
   // print it if they want to; the redactor itself accepts the raw
@@ -1059,6 +1185,7 @@ async function buildRedactionContext(projectRoot) {
     operatorName,
     gitRemote: [...remotes].filter((r) => typeof r === 'string' && r.length > 0),
     allowHosts: allowHostsExt,
+    allowExtensions: allowExtensionsExt,
   };
 }
 
@@ -1215,11 +1342,21 @@ const SUBMIT_OPTIONS = /** @type {const} */ ({
  *
  * Dedupe (per entry passing preflight): gh search issues on the
  * destination for `rcf-feedback-fingerprint: <fp>` (open, in:body,
- * limit 5). Zero hits -> create. One hit -> +1 comment. Many hits ->
- * comment on the lowest number and mention the others. Search failure
- * -> create with dedupe:unchecked. Closed search runs only after a
- * zero-hit open search so the create body can reference the prior
- * number.
+ * limit 5). Every returned candidate is then re-read via
+ * ghIssueGetBody, and only candidates whose body carries
+ * `rcf-feedback-fingerprint: <fp>` on its own line AND whose anchor /
+ * kind / target markers do not disagree with the entry's are counted
+ * as verified matches (0.28.2, issue #234, Barry ruling 2026-09-21).
+ * A search hit that does not verify is a NON-MATCH and is dropped
+ * before the fold decision. Zero verified hits -> create; one -> fold
+ * comment on that number; many -> fold on the lowest and mention the
+ * others. The fold comment carries the full report (title, body,
+ * evidence, environment) prefaced with "Apparent duplicate of the
+ * issue subject; posting the full report so a human can judge." The
+ * retired "+1 from another reporter." payload is gone. Search
+ * failure -> create with dedupe:unchecked. Closed search runs only
+ * after a zero-hit open search so the create body can reference the
+ * prior number.
  *
  * Create/comment failure (network/4xx/5xx/ratelimit or unexpected
  * label rejection): retry once WITHOUT labels; still failing, bundle
@@ -1381,18 +1518,47 @@ async function handleSubmit(argv, ctx) {
       let dedupe = 'new';
       let closedRef = null;
       let matches = [];
+      let searchMatches = [];
       if (!searchOpen.ok) {
         dedupe = 'unchecked';
       } else {
-        matches = searchOpen.value?.matches ?? [];
+        searchMatches = searchOpen.value?.matches ?? [];
+      }
+
+      // 0.28.2 (issue #234, Barry ruling 2026-09-21): the search hit
+      // alone is not a fold decision. Re-read each candidate body via
+      // ghIssueGetBody and keep only those whose body carries
+      // `rcf-feedback-fingerprint: <fp>` on its own line AND whose
+      // anchor / kind / target markers do not disagree with the
+      // entry's. A search hit whose body does not verify is a
+      // NON-MATCH and is dropped before the fold decision.
+      if (searchMatches.length > 0 && typeof gh.ghIssueGetBody === 'function') {
+        const verified = [];
+        for (const m of searchMatches) {
+          const v = await gh.ghIssueGetBody({ repo: destination.repo, number: m.number });
+          if (!v.ok || typeof v.value?.body !== 'string') continue;
+          const body = v.value.body;
+          if (!hasFingerprintLine(body, built.fingerprint)) continue;
+          if (!candidateMatchesEntry(body, e)) continue;
+          verified.push({ ...m, title: m.title ?? extractTitle(body) ?? null });
+        }
+        matches = verified;
+      } else {
+        matches = searchMatches;
       }
 
       if (flags['dry-run']) {
-        const plan = matches.length === 1
-          ? `comment on #${matches[0].number}`
-          : matches.length > 1
-            ? `comment on #${matches.sort((a, b) => a.number - b.number)[0].number} (${matches.length} matches)`
-            : 'create';
+        let plan;
+        if (matches.length === 1) {
+          const t = matches[0].title;
+          plan = `commented on #${matches[0].number} (fingerprint match${t ? `: ${t}` : ''})`;
+        } else if (matches.length > 1) {
+          const sorted = matches.slice().sort((a, b) => a.number - b.number);
+          const t = sorted[0]?.title;
+          plan = `commented on #${sorted[0].number} (fingerprint match${t ? `: ${t}` : ''}, ${matches.length} verified)`;
+        } else {
+          plan = `created (title: ${built.rendered.title})`;
+        }
         stdout.write(`${e.id} -> dry-run ${plan} (${dedupe === 'unchecked' ? 'unchecked' : matches.length === 0 ? 'new' : 'comment'})\n`);
         continue;
       }
@@ -1425,26 +1591,28 @@ async function handleSubmit(argv, ctx) {
           labels: usedLabels,
         });
       } else if (matches.length === 1) {
-        // Comment.
+        // Verified fingerprint match: comment. Comment carries the
+        // full report per Barry's 2026-09-21 ruling on #234.
         dedupe = 'comment';
-        const commentBody = renderComment(e, {
-          body: built.redacted.body,
-          ledger: built.redacted.ledger,
-        }, { fingerprint: built.fingerprint, includeBody: false }).body;
+        const commentBody = renderComment(e, built.redacted, {
+          fingerprint: built.fingerprint,
+          matchedTitle: matches[0].title ?? null,
+        }).body;
         result = await commentWithRetry(gh, {
           repo: destination.repo,
           number: matches[0].number,
           body: commentBody,
         });
       } else {
-        // Many: comment on lowest, mention the others.
+        // Many verified matches: comment on lowest, mention the
+        // others. The comment still carries the full report.
         dedupe = 'comment';
         const sorted = matches.slice().sort((a, b) => a.number - b.number);
         const others = sorted.slice(1).map((m) => `#${m.number}`).join(', ');
-        const base = renderComment(e, {
-          body: built.redacted.body,
-          ledger: built.redacted.ledger,
-        }, { fingerprint: built.fingerprint, includeBody: false }).body;
+        const base = renderComment(e, built.redacted, {
+          fingerprint: built.fingerprint,
+          matchedTitle: sorted[0].title ?? null,
+        }).body;
         const commentBody = `${base}\nalso see ${others}\n`;
         result = await commentWithRetry(gh, {
           repo: destination.repo,
@@ -1463,7 +1631,23 @@ async function handleSubmit(argv, ctx) {
           droppedLabels,
           sessionId,
         });
-        stdout.write(`${e.id} -> ${result.url} (${dedupe})\n`);
+        // 0.28.2 (issue #234): row shape names the outcome and the
+        // matched issue's title so a wrong fold is visible on the
+        // same line a human already sees. The create path prints the
+        // title of the entry we just filed; the comment path prints
+        // the matched candidate's title.
+        const number = extractIssueNumberFromUrl(result.url);
+        const numberSuffix = number ? `#${number}` : '';
+        if (dedupe === 'comment') {
+          const sorted = matches.slice().sort((a, b) => a.number - b.number);
+          const matchedTitle = sorted[0]?.title ?? null;
+          const foldTail = matchedTitle ? `: ${matchedTitle}` : '';
+          stdout.write(`${e.id} -> commented on ${numberSuffix} (fingerprint match${foldTail}) ${result.url}\n`);
+        } else if (dedupe === 'unchecked') {
+          stdout.write(`${e.id} -> created ${numberSuffix} (${built.rendered.title}, dedupe unchecked) ${result.url}\n`);
+        } else {
+          stdout.write(`${e.id} -> created ${numberSuffix} (${built.rendered.title}) ${result.url}\n`);
+        }
         summary.submitted += 1;
       } else {
         // Retry-without-labels failed too: bundle this one entry.
@@ -1793,6 +1977,106 @@ function at(now) {
   return now().toISOString().replace(/\.\d{3}Z$/, 'Z');
 }
 
+// -- 0.28.2 (issue #234) fold-decision helpers ----------------------------
+//
+// A search hit alone is not a fold: submit re-reads the candidate
+// body and folds only when the fingerprint line is literally present
+// on its own line AND the anchor / kind / target markers do not
+// contradict the entry's. This is the code side of Barry's ruling on
+// #234 (2026-09-21) and of the amended AC-15701-2.
+
+/**
+ * True when `body` contains a line reading exactly
+ * `rcf-feedback-fingerprint: <fp>` (case-sensitive, own line).
+ *
+ * @param {string} body
+ * @param {string} fp
+ * @returns {boolean}
+ */
+function hasFingerprintLine(body, fp) {
+  if (typeof body !== 'string' || typeof fp !== 'string' || fp.length === 0) return false;
+  const target = `rcf-feedback-fingerprint: ${fp}`;
+  const lines = body.split(/\r?\n/);
+  for (const l of lines) {
+    if (l.trim() === target) return true;
+  }
+  return false;
+}
+
+/**
+ * Defence-in-depth: with a truncated fingerprint (12 hex chars) a
+ * collision is negligible but not zero. We refuse to fold when the
+ * candidate body's environment-table markers for anchor, kind or the
+ * blueprint slug disagree with the entry's own values.
+ *
+ * @param {string} body
+ * @param {object} entry
+ * @returns {boolean}
+ */
+function candidateMatchesEntry(body, entry) {
+  if (typeof body !== 'string') return false;
+  const marker = (label) => {
+    const re = new RegExp(`\\|\\s*${label}\\s*\\|\\s*([^|\\n]+?)\\s*\\|`, 'i');
+    const m = body.match(re);
+    return m ? m[1].trim() : null;
+  };
+  const bodyAnchor = marker('anchor');
+  const bodyKind = marker('kind');
+  const bodyBlueprint = marker('blueprint');
+  const bodyTarget = marker('target');
+  const entryAnchor = (entry?.anchor ?? '-').trim();
+  const entryKind = (entry?.kind ?? 'core').trim();
+  const entryTargetRef = typeof entry?.target?.ref === 'string' ? entry.target.ref.trim() : '';
+  const entryBlueprintSlug = entry?.kind === 'blueprint'
+    ? String(entry?.target?.effectiveSlug ?? entry?.target?.ref ?? '').trim()
+    : null;
+  if (bodyAnchor !== null && bodyAnchor.toUpperCase() !== entryAnchor.toUpperCase()) return false;
+  if (bodyKind !== null && bodyKind.toLowerCase() !== entryKind.toLowerCase()) return false;
+  if (entryBlueprintSlug && bodyBlueprint !== null && bodyBlueprint !== '-') {
+    // The blueprint cell carries the slug as its first whitespace-
+    // separated token, followed by an optional version and library
+    // trail. Compare only the head.
+    const head = bodyBlueprint.split(/\s+/)[0];
+    if (head && head !== entryBlueprintSlug) return false;
+  }
+  // 0.28.2 (Codex review follow-up on #234): core entries also carry
+  // a "target" line on the environment table. Refuse to fold across a
+  // differing target (verb path) even when kind and anchor agree,
+  // matching the amended AC-15701-2 anchor-and-target rule for both
+  // kinds.
+  if (entryKind.toLowerCase() === 'core' && entryTargetRef && bodyTarget !== null && bodyTarget !== '-') {
+    if (bodyTarget !== entryTargetRef) return false;
+  }
+  return true;
+}
+
+/**
+ * Pull the first `## Report: <title>` header from a candidate body,
+ * used to name the matched issue on the stdout row when the search
+ * response did not carry one.
+ *
+ * @param {string} body
+ * @returns {string | null}
+ */
+function extractTitle(body) {
+  if (typeof body !== 'string') return null;
+  const m = body.match(/^##\s+Report:\s+(.+)$/m);
+  return m ? m[1].trim() : null;
+}
+
+/**
+ * Extract the numeric issue id from a github.com issue URL. Used only
+ * to shape the stdout row.
+ *
+ * @param {string | undefined} url
+ * @returns {number | null}
+ */
+function extractIssueNumberFromUrl(url) {
+  if (typeof url !== 'string') return null;
+  const m = url.match(/\/issues\/(\d+)/);
+  return m ? Number(m[1]) : null;
+}
+
 // -- opt-in / opt-out (slice 5, FBS-184) ----------------------------------
 
 const OPT_OPTIONS = /** @type {const} */ ({

package/src/cli/help.js

@@ -45,6 +45,8 @@ import { HELP as REQ_BASELINE_HELP } from './req-baseline.js';
 import { HELP as INTAKE_HELP } from './intake.js';
 import { HELP as BLUEPRINT_HELP } from './blueprint.js';
 import { HELP as STANDARDS_HELP } from './standards.js';
+import { HELP as LEDGER_HELP } from './ledger.js';
+import { HELP as READINESS_HELP } from './readiness.js';
 
 // Verify group members (from the verify-suite subtree).
 import { HELP as VERIFY_RUN_HELP } from '../verify/cli/run.js';
@@ -93,6 +95,8 @@ define       Author the RCF tree.
   design <fbs-id> <verb>   Design substage for a UI-bearing FBS.
   blueprint <verb>         Compose blueprints onto the project.
   standards <verb>         Register standards packs against the project.
+  ledger <name> <verb>     Sidecar-ledger CRUD under rcf/define/.
+  readiness                DEFINE stage-gate readiness view.
 
 build        Drive the FBS queue and the five-stage build cycle.
   queue                    Show the FBS build queue.
@@ -189,6 +193,11 @@ Verbs:
   design <fbs-id> <verb>   Design substage for a UI-bearing FBS.
   blueprint <verb>         Compose blueprints onto the project.
   standards <verb>         Register standards packs against the project.
+  ledger <name> <verb>     Sidecar-ledger CRUD under rcf/define/
+                           (brief | decisions | concerns | probes;
+                            verbs: add | resolve | list).
+  readiness                DEFINE stage-gate readiness view; twin of
+                           the viewer's Readiness tab (slice 5).
 
 Run 'rcf help define <verb>' for per-verb help.
 `;
@@ -284,6 +293,8 @@ export const HELP_MAP = {
     design: DESIGN_HELP,
     blueprint: BLUEPRINT_HELP,
     standards: STANDARDS_HELP,
+    ledger: LEDGER_HELP,
+    readiness: READINESS_HELP,
   },
   build: {
     queue: BUILD_HELP,

package/src/cli/intake.js

@@ -12,7 +12,8 @@
 import { readFile } from 'node:fs/promises';
 import { parseArgs } from 'node:util';
 
-import { walkTree } from '#core/store';
+import { walkTree, validateComposedRecord } from '#core/store';
+import { FIDELITY_LEVELS } from '../intake/fidelity.js';
 
 import { findProjectRoot } from '../view/index.js';
 import {
@@ -44,16 +45,25 @@ Options:
   --kind <kind>              Hint the artefact kind: napkin |
                              productBrief | prd | prdPlusTad | other
   --input <config.json>      Non-interactive mode: pre-filled artefacts
-                             + findings + acknowledgements
-  --dry-run                  Print the plan without writing the record
+                             + findings + acknowledgements. The
+                             fidelity in the input file must be one
+                             of the allowed values below.
+  --dry-run                  Print the plan without writing the record;
+                             the composed record is still run through
+                             the same manifest schema pass the write
+                             path runs (0.28.2 fix for #230), so a
+                             preview fails on the same schema misses.
   --json                     Emit the intakeClassification block as JSON
   --quiet                    Suppress non-error confirmations
   --help                     Print this help
 
+Fidelity enum (allowed values on --input.fidelity):
+  ${FIDELITY_LEVELS.join(', ')}
+
 Exit codes:
   0  success
   2  usage error (missing --artefact/--input, unreadable file)
-  3  validation failure on the written manifest
+  3  validation failure on the composed record (including --dry-run)
 `;
 
 /**
@@ -124,6 +134,17 @@ export async function main(argv, deps = {}) {
   }
 
   if (flags['dry-run']) {
+    // 0.28.2 (issue #230): run the same schema pass the writer runs so
+    // a preview no longer passes on a value the real run refuses.
+    const dryValidation = validateComposedRecord({
+      tree: walkResult.tree,
+      record: outcome.record,
+      verb: 'intake',
+    });
+    if (dryValidation) {
+      stderr.write(`[error] ${dryValidation.kind} ${dryValidation.message}\n`);
+      return 3;
+    }
     if (flags.json) {
       stdout.write(`${JSON.stringify(outcome.record, null, 2)}\n`);
     } else {