rcf-lite 0.28.0 → 0.28.2

package/src/feedback/destination.js

@@ -7,7 +7,14 @@
 //
 // Resolution order (design section 3.3):
 //   1. --kind core                        -> CORE_REPO (public)
-//   2. --kind blueprint, no libraryPrefix -> CORE_REPO (shelf; public)
+//   2. --kind blueprint, no libraryPrefix -> library-slug inference
+//      (AC-15801-4 / design amendment R5a): if the applied slug is
+//      owned by exactly one registered library that resolves to a
+//      destination (issuesRepo or derivable sourceRef), route there
+//      with source: 'library-slug-inference'; if two or more libraries
+//      own the slug and resolve, return unresolved with reason
+//      'ambiguous-library-slug' and a candidates[] array of prefixes;
+//      otherwise fall through to CORE_REPO (shelf; public).
 //   3. --kind blueprint, libraryPrefix    -> registry entry issuesRepo
 //                                            (declared destination wins;
 //                                            visibility from the entry)
@@ -210,9 +217,10 @@ function recordEffectiveSlug(record) {
  * @property {'public' | 'private' | 'unresolved'} visibility
  * @property {'core' | 'shelf' | 'library'} kind
  * @property {boolean} derived            true when repo came from sourceRef derivation
- * @property {string} [reason]            filled on unresolved: 'no-issues-field' | 'no-github-source' | 'no-libraryprefix-record' | 'unknown-target'
+ * @property {string} [reason]            filled on unresolved: 'no-issues-field' | 'no-github-source' | 'no-libraryprefix-record' | 'unknown-target' | 'ambiguous-library-slug'
+ * @property {string[]} [candidates]      filled on unresolved with reason 'ambiguous-library-slug': sorted library prefixes owning the slug
  * @property {string} [publisherContact]  registry entry's publisher.contact (bundle uses it)
- * @property {string} [source]            'library-manifest' | 'sourceRef-derivation' | 'package-bugs-url' | 'shelf-constant'
+ * @property {string} [source]            'library-manifest' | 'sourceRef-derivation' | 'package-bugs-url' | 'shelf-constant' | 'library-slug-inference'
  */
 
 /**
@@ -263,8 +271,27 @@ export async function resolve(entry, context = {}) {
 
   const libraryPrefix = record.libraryPrefix ?? entry?.target?.libraryPrefix ?? null;
 
-  // Shelf blueprint (no libraryPrefix) -> Stravica/rcf-lite.
+  // Shelf blueprint (no libraryPrefix on the manifest record). Before
+  // falling through to the shelf constant, cross-check the registry:
+  // if exactly one registered library owns a blueprint with the applied
+  // slug AND that library resolves to a destination, route to that
+  // library so a bare-slug apply of a library-shared name still lands
+  // on the library owner's repo (design amendment R5, AC-15801-4).
   if (!libraryPrefix) {
+    const inferred = inferLibraryFromSlug(record, registry);
+    if (inferred.kind === 'single') {
+      return inferred.destination;
+    }
+    if (inferred.kind === 'ambiguous') {
+      return {
+        repo: null,
+        visibility: 'unresolved',
+        kind: 'library',
+        derived: false,
+        reason: 'ambiguous-library-slug',
+        candidates: inferred.candidates,
+      };
+    }
     return {
       repo: CORE_REPO,
       visibility: 'public',
@@ -359,3 +386,70 @@ function findLibraryEntry(registry, libraryPrefix) {
   const libs = Array.isArray(registry?.libraries) ? registry.libraries : [];
   return libs.find((l) => l?.libraryPrefix === libraryPrefix) ?? null;
 }
+
+/**
+ * AC-15801-4 / design amendment R5a: given a manifest record with no
+ * libraryPrefix, cross-check the registry to see whether the applied
+ * slug is owned by exactly one registered library that resolves to a
+ * destination. Returns:
+ *   { kind: 'none' }                                 no library owns the slug (or none resolve)
+ *   { kind: 'single', destination }                  exactly one library owns the slug and resolves
+ *   { kind: 'ambiguous', candidates: string[] }      two or more libraries own the slug and resolve
+ *
+ * The resolver only calls this on the shelf-constant fall-through
+ * branch, so it never overrides an existing libraryPrefix resolution.
+ *
+ * @param {object} record                              manifest.blueprints[] record
+ * @param {object | null | undefined} registry         parsed rcf/blueprint-libraries.json
+ */
+function inferLibraryFromSlug(record, registry) {
+  const slug = typeof record?.slug === 'string' ? record.slug : null;
+  if (!slug) return { kind: 'none' };
+  const libs = Array.isArray(registry?.libraries) ? registry.libraries : [];
+  const owners = [];
+  for (const lib of libs) {
+    if (!lib || typeof lib !== 'object') continue;
+    if (typeof lib.libraryPrefix !== 'string' || lib.libraryPrefix.length === 0) continue;
+    const bps = Array.isArray(lib.blueprints) ? lib.blueprints : [];
+    const owns = bps.some((b) => b && typeof b.slug === 'string' && b.slug === slug);
+    if (!owns) continue;
+    const declared = typeof lib.issuesRepo === 'string' && lib.issuesRepo.length > 0 ? lib.issuesRepo : null;
+    const derivedRepo = declared ? null : parseGithubSource(lib.sourceRef ?? '');
+    if (!declared && !derivedRepo) continue;
+    const contact = typeof lib?.publisher?.contact === 'string' ? lib.publisher.contact : undefined;
+    owners.push({ lib, declared, derivedRepo, contact });
+  }
+  if (owners.length === 0) return { kind: 'none' };
+  if (owners.length === 1) {
+    const [o] = owners;
+    if (o.declared) {
+      const declaredVisibility = o.lib.issuesVisibility === 'private' ? 'private'
+        : o.lib.issuesVisibility === 'public' ? 'public'
+          : 'public';
+      return {
+        kind: 'single',
+        destination: {
+          repo: o.declared,
+          visibility: declaredVisibility,
+          kind: 'library',
+          derived: false,
+          source: 'library-slug-inference',
+          ...(o.contact ? { publisherContact: o.contact } : {}),
+        },
+      };
+    }
+    return {
+      kind: 'single',
+      destination: {
+        repo: o.derivedRepo,
+        visibility: 'public',
+        kind: 'library',
+        derived: true,
+        source: 'library-slug-inference',
+        ...(o.contact ? { publisherContact: o.contact } : {}),
+      },
+    };
+  }
+  const candidates = owners.map((o) => o.lib.libraryPrefix).sort();
+  return { kind: 'ambiguous', candidates };
+}

package/src/feedback/gh.js

@@ -5,8 +5,9 @@
 //   - ghLabelList({ repo })             list existing label names
 //   - ghRepoView({ repo })               visibility + viewerPermission + hasIssuesEnabled
 //   - ghIssueSearch({ repo, query, state, limit })   dedupe search
+//   - ghIssueGetBody({ repo, number })                re-read a candidate body for fingerprint verification (0.28.2 / #234)
 //   - ghIssueCreate({ repo, title, body, labels })   create one issue
-//   - ghIssueComment({ repo, number, body })         +1 comment
+//   - ghIssueComment({ repo, number, body })         fold comment (carries the full report; the "+1 from another reporter" payload retired in 0.28.2 per Barry's 2026-09-21 ruling on #234)
 //   - ghLabelCreate({ repo, name, description, color })  bootstrap only
 //
 // Every function returns a typed result. Errors are classified into
@@ -68,6 +69,7 @@ export async function loadGhAdapter(env = process.env) {
  * @property {(opts: { repo: string }) => Promise<GhResult>} ghLabelList
  * @property {(opts: { repo: string }) => Promise<GhResult>} ghRepoView
  * @property {(opts: { repo: string, query: string, state?: 'open' | 'closed', limit?: number }) => Promise<GhResult>} ghIssueSearch
+ * @property {(opts: { repo: string, number: number }) => Promise<GhResult>} ghIssueGetBody
  * @property {(opts: { repo: string, title: string, body: string, labels: string[] }) => Promise<GhResult>} ghIssueCreate
  * @property {(opts: { repo: string, number: number, body: string }) => Promise<GhResult>} ghIssueComment
  * @property {(opts: { repo: string, name: string, description?: string, color?: string }) => Promise<GhResult>} ghLabelCreate
@@ -189,6 +191,29 @@ export async function ghIssueSearch(opts) {
   }
 }
 
+/**
+ * `gh issue view <n> --repo <repo> --json body`. Re-reads the body of
+ * a candidate issue for the fingerprint-verification step introduced
+ * in 0.28.2 (issue #234): a search hit whose body does not carry the
+ * fingerprint line on its own line is a non-match and is discarded
+ * before the fold decision. Returns { body }.
+ *
+ * @param {{ repo: string, number: number }} opts
+ * @returns {Promise<GhResult>}
+ */
+export async function ghIssueGetBody(opts) {
+  const args = ['issue', 'view', String(opts.number), '--repo', opts.repo, '--json', 'body'];
+  const r = await runGh(args);
+  if (!r.ok) return r;
+  try {
+    const parsed = JSON.parse(r.value.stdout);
+    const body = typeof parsed?.body === 'string' ? parsed.body : '';
+    return { ok: true, value: { body } };
+  } catch (err) {
+    return { ok: false, kind: 'unknown', message: `issue-view parse failed: ${err.message}` };
+  }
+}
+
 /**
  * `gh issue create --repo <repo> --title <t> --body-file - --label
  * <l1> --label <l2>...` reads the body from stdin so a long body is
@@ -370,6 +395,7 @@ export const DEFAULT_ADAPTER = Object.freeze({
   ghLabelList,
   ghRepoView,
   ghIssueSearch,
+  ghIssueGetBody,
   ghIssueCreate,
   ghIssueComment,
   ghLabelCreate,

package/src/feedback/redact-allowlist.json

@@ -10,5 +10,12 @@
     "developer.mozilla.org",
     "localhost",
     "127.0.0.1"
+  ],
+  "extensions": [
+    "md", "mdx", "json", "yml", "yaml", "txt",
+    "js", "mjs", "cjs", "ts", "tsx",
+    "html", "css",
+    "png", "svg",
+    "sh", "csv", "log", "lock"
   ]
 }

package/src/feedback/redact.js

@@ -32,6 +32,26 @@ const BUNDLED_ALLOWLIST = JSON.parse(
 /** Body size cap (bytes). Mirrors src/cli/feedback.js:BODY_CAP_BYTES. */
 export const BODY_CAP_BYTES = 8 * 1024;
 
+/**
+ * Common-noun stopwords the operator-identity substitution never folds
+ * (AC-15601-5 / design amendment R5c). The rcf-lite ecosystem uses
+ * `agent` as a canonical noun (RULE 17, docs paths such as
+ * `how-the-agent-files-feedback`); if the operator's identity name
+ * happens to contain one of these words, the token loop skips it so
+ * the docs URL and prose like `when the agent stops` survive. Real
+ * given names in the identity still fold. The list is intentionally
+ * conservative: anything a normal profile.md ## Name line might carry
+ * as a common English or engineering noun.
+ */
+export const RESERVED_IDENTITY_TOKENS = Object.freeze(new Set([
+  'agent', 'agents', 'user', 'users', 'operator', 'operators',
+  'admin', 'admins', 'root', 'client', 'clients', 'server', 'servers',
+  'service', 'services', 'system', 'systems', 'name', 'main', 'test',
+  'code', 'api', 'apis', 'anon', 'anonymous', 'human', 'humans',
+  'dev', 'ops', 'sre', 'docs', 'developer', 'developers', 'engineer',
+  'engineers', 'team', 'teams',
+]));
+
 /**
  * Open secret-key vocabulary (design amendment R3a). A key/value pair
  * is treated as a secret when the key, right-bounded at a word edge so
@@ -389,9 +409,20 @@ export function redact(input, context = {}) {
   if (context.operatorName) {
     const opName = context.operatorName.trim();
     if (opName.length > 0) {
-      text = replaceAndLog(text, escapedLiteral(opName), '<operator>', 'operator-identity', ledger);
-      for (const tok of opName.split(/\s+/)) {
-        if (tok.length > 3) {
+      // AC-15601-5 / design amendment R5c: never fold a common noun
+      // that happens to appear in the identity string. The rcf-lite
+      // ecosystem uses 'agent' as a canonical noun (RULE 17, docs
+      // paths); folding it as operator-identity mangles the docs URL
+      // `how-the-agent-files-feedback` and prose like `when the
+      // agent stops`. Substitution still fires for a real given name
+      // (Alice, Smith) even when the full identity string carries a
+      // stopword. When the identity contains ONLY stopwords (a
+      // placeholder-in-disguise), skip identity folds entirely.
+      const rawTokens = opName.split(/\s+/);
+      const foldable = rawTokens.filter((t) => t.length > 3 && !RESERVED_IDENTITY_TOKENS.has(t.toLowerCase()));
+      if (foldable.length > 0) {
+        text = replaceAndLog(text, escapedLiteral(opName), '<operator>', 'operator-identity', ledger);
+        for (const tok of foldable) {
           text = replaceAndLog(text, `\\b${escapeRe(tok)}\\b`, '<operator>', 'operator-identity', ledger);
         }
       }
@@ -399,7 +430,7 @@ export function redact(input, context = {}) {
   }
   if (context.projectName) {
     const pn = context.projectName.trim();
-    if (pn.length > 0) {
+    if (pn.length > 0 && !RESERVED_IDENTITY_TOKENS.has(pn.toLowerCase())) {
       text = replaceAndLog(text, `\\b${escapeRe(pn)}\\b`, '<project>', 'operator-identity', ledger);
     }
   }
@@ -417,6 +448,18 @@ export function redact(input, context = {}) {
     ...(Array.isArray(context.allowHosts) ? context.allowHosts : []),
   ].map((h) => h.toLowerCase()));
 
+  // Rule 4 narrowing (0.28.2, issue #233, design amendment R5d): a
+  // token whose trailing dot-label is a known file extension is NOT
+  // a hostname. This kills the `Backstory-product-brief.md` and
+  // `intake.json` false positives Barry hit in the WSD round-trip.
+  // The bundled shortlist lives in redact-allowlist.json under the
+  // new `extensions` field; the operator overlay merges via
+  // context.allowExtensions.
+  const allowExtensions = new Set([
+    ...(Array.isArray(BUNDLED_ALLOWLIST.extensions) ? BUNDLED_ALLOWLIST.extensions : []),
+    ...(Array.isArray(context.allowExtensions) ? context.allowExtensions : []),
+  ].map((e) => String(e).toLowerCase()));
+
   // Rule 9: URL-embedded credentials (design amendment R3b, added
   // round 4 for F-P0-B). Runs BEFORE the rule-4 hostname pass so a
   // Slack/Discord webhook URL whose path IS the credential has that
@@ -439,9 +482,26 @@ export function redact(input, context = {}) {
   // preceded by @ (already handled by rule 3), a slash or backslash
   // (path fragment; the winAbsRe substitution leaves `<path>\file.ext`
   // which must not fold to `<host>`), a digit-dot (IP handled by
-  // rule 5b), or another word character (a longer host suffix).
-  const bareHostRe = /(?<![@/\\\w.])(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}(?![\w.-])/g;
+  // rule 5b), a hyphen or another word character (a longer host
+  // suffix or a filename-internal segment). Adding `-` to the
+  // lookbehind is the 0.28.2 (issue #233) fix that stops
+  // `Backstory-product-brief.md` folding on its internal
+  // `product-brief.md` slice; the extension-refusal step below is the
+  // second layer.
+  const bareHostRe = /(?<![@/\\\w.\-])(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}(?![\w.-])/g;
   text = replaceRegex(text, bareHostRe, (host) => {
+    // 0.28.2 (issue #233, design amendment R5d): a candidate whose
+    // trailing dot-label is a known file extension is not a hostname;
+    // leave it intact and record no ledger row (we are not redacting,
+    // we are correctly leaving alone). This narrowing catches shapes
+    // like `report.log`, `intake.json` and `Backstory-example.md`
+    // that pass the lookbehind guard because they start after a
+    // whitespace or line boundary.
+    const lastDot = host.lastIndexOf('.');
+    if (lastDot > 0) {
+      const trailingLabel = host.slice(lastDot + 1).toLowerCase();
+      if (allowExtensions.has(trailingLabel)) return host;
+    }
     if (isHostAllowed(host, allowHosts)) return host;
     return '<host>';
   }, 'hostname', ledger);
@@ -846,6 +906,15 @@ function looksHighEntropyPath(value) {
   if (typeof value !== 'string') return false;
   if (value.length < 16) return false;
   if (!/^[A-Za-z0-9._~+/=-]+$/.test(value)) return false;
+  // AC-15601-5 canon-phrase guard: a lowercase kebab-case segment with
+  // three or more hyphen-separated word parts is a documentation slug,
+  // not a credential. The rcf-lite docs URL
+  // `how-the-agent-files-feedback` is 28 chars, 2 classes (lowercase
+  // and separator), and would otherwise trip the 16-char, 2-class rule
+  // and produce `<url-credential>` inside the docs URL. Real credential
+  // segments in URL paths (webhook tokens, session ids, presigned
+  // credentials) are mixed-case-alphanumeric, not kebab-case English.
+  if (/^[a-z]+(-[a-z]+){2,}$/.test(value)) return false;
   let classes = 0;
   if (/[A-Z]/.test(value)) classes += 1;
   if (/[a-z]/.test(value)) classes += 1;

package/src/feedback/render.js

@@ -110,27 +110,39 @@ function truncateToBytes(text, maxBytes) {
 }
 
 /**
- * Render the `+1 from another reporter` comment body used on the
- * dedupe path (slice 4). Kept in this module because triage sees one
- * shape from `create` and `comment`.
+ * Render the fold comment body used on the dedupe path (slice 4).
+ * 0.28.2 (issue #234, Barry ruling 2026-09-21): the retired
+ * "+1 from another reporter." payload is gone; the comment always
+ * carries the full report so a human can judge whether the fold is
+ * correct. The header line names the fold decision. The visible
+ * fingerprint line at the bottom stays so a later submit can still
+ * match on it.
  *
  * @param {object} entry
- * @param {{ body: string, ledger: Array<{ rule: string, count: number }> }} redacted
- * @param {{ fingerprint: string, includeBody?: boolean }} meta
+ * @param {{ title: string, body: string, evidence: Array<{ kind: string, value: string }>, ledger: Array<{ rule: string, count: number }> }} redacted
+ * @param {{ fingerprint: string, matchedTitle?: string }} meta
  * @returns {RenderedComment}
  */
 export function renderComment(entry, redacted, meta) {
   const lines = [];
-  lines.push('+1 from another reporter.');
+  lines.push('Apparent duplicate of the issue subject; posting the full report so a human can judge.');
+  lines.push('');
+  lines.push(`## Report: ${renderTitle(entry, redacted.title)}`);
+  lines.push('');
+  lines.push(redacted.body);
   lines.push('');
-  lines.push(...renderEnvironmentTable(entry).split('\n'));
-  if (meta.includeBody) {
-    lines.push('');
-    lines.push('Report body:');
-    lines.push('');
-    lines.push(redacted.body);
+  lines.push('---');
+  lines.push('**Evidence**');
+  if (Array.isArray(redacted.evidence) && redacted.evidence.length > 0) {
+    for (const ev of redacted.evidence) {
+      lines.push(`- \`${ev.value}\` (${ev.kind})`);
+    }
+  } else {
+    lines.push('- (none)');
   }
   lines.push('');
+  lines.push(renderEnvironmentTable(entry));
+  lines.push('');
   lines.push(`rcf-feedback-fingerprint: ${meta.fingerprint}`);
   return { body: `${lines.join('\n')}\n` };
 }
@@ -241,10 +253,20 @@ function renderEnvironmentTable(entry) {
       t.libraryPrefix ? `(library ${t.libraryPrefix}${t.libraryRef ? ` ${t.libraryRef}` : ''}${t.resolvedSha ? `, git ${String(t.resolvedSha).slice(0, 7)}` : t.tarballSha256 ? `, tarball ${String(t.tarballSha256).slice(0, 7)}` : ''})` : null,
     ].filter(Boolean).join(' ')
     : 'n/a';
+  // 0.28.2 (issue #234): a "target" row goes on the environment
+  // table for core entries too, so submit's fingerprint-verification
+  // step can compare the entry's verb path against a candidate's
+  // recorded target and refuse to fold across differing targets. For
+  // blueprint entries the blueprint cell already carries the target
+  // identity, so the target row is left as "-" to avoid duplication.
+  const targetCell = kind === 'blueprint'
+    ? '-'
+    : (typeof t.ref === 'string' && t.ref.length > 0 ? t.ref : '-');
   const rows = [
     ['field', 'value'],
     ['kind', kind],
     ['blueprint', blueprintCell],
+    ['target', targetCell],
     ['anchor', entry?.anchor ?? '-'],
     ['symptom class', entry?.symptomClass ?? '-'],
     ['severity', entry?.severity ?? '-'],

package/src/intake/manifest-writer.js

@@ -9,7 +9,7 @@ import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
 import { rcfError } from '#core/errors';
-import { validateDocument } from '#core/store';
+import { buildNextManifest, validateDocument } from '#core/store';
 
 const ID_RE = /^ic-\d{4}-\d{2}-\d{2}-(\d{3})$/;
 
@@ -73,8 +73,11 @@ export function composeIntakeRecord({ manifest, fidelity, artefacts, validationF
  * @returns {Promise<{ record: object } | import('#core/errors').RcfError>}
  */
 export async function writeIntakeRecord({ projectRoot, tree, record }) {
-  const manifest = tree?.manifest ?? {};
-  const nextManifest = { ...manifest, intakeClassification: record };
+  // 0.28.2 (Codex review follow-up on #230): the writer synthesises
+  // the next manifest via the same `buildNextManifest` helper the
+  // dry-run branch uses, so preview and write share one composition
+  // path. `validateDocument` then runs on the identical shape.
+  const nextManifest = buildNextManifest({ manifest: tree?.manifest ?? {}, record, verb: 'intake' });
   const validation = validateDocument({ doc: nextManifest, kind: 'manifest', filePath: 'rcf/manifest.json' });
   if (validation) return validation;
   const abs = join(projectRoot, 'rcf', 'manifest.json');

package/src/intake/orchestrator.js

@@ -82,23 +82,60 @@ export async function runIntakePhases({ projectRoot, artefactPaths, kindHint = n
 
   // Fold non-interactive input: extra findings, operator responses,
   // and elicitationScope hints all land here.
+  //
+  // 0.28.2 (issue #229): findings are material-scoped, not
+  // artefact-scoped. Two artefacts that both trip the same branch
+  // ("web UI but no sign-in surface named") emit the same finding
+  // twice with byte-identical detail text, and downstream that
+  // inflated `findings=2` on a record with one finding. Dedupe by
+  // `${kind}::${detail}` (first-wins) before timestamping so the
+  // material carries one finding, not N.
+  //
+  // Same commit fixes the second half of #229: operator-supplied
+  // `validationFindings` on --input were dropped unless the kind was
+  // `otherDeclared`. Fold every input finding into the same map so
+  // an operator-authored `impliedButNotStated`, `contradiction` or
+  // `missingLoadBearingConstraint` survives the round-trip and
+  // coalesces with a scanned duplicate (the operator's response is
+  // preserved when it does).
   const inputFindings = Array.isArray(input?.validationFindings) ? input.validationFindings : [];
+
+  /** @type {Map<string, object>} */
+  const foldedFindings = new Map();
+  const foldKey = (f) => `${String(f.kind ?? '')}::${String(f.detail ?? '')}`;
+  for (const f of allFindings) {
+    const k = foldKey(f);
+    if (!foldedFindings.has(k)) foldedFindings.set(k, f);
+  }
+  for (const f of inputFindings) {
+    if (typeof f?.kind !== 'string' || typeof f?.detail !== 'string') continue;
+    const k = foldKey(f);
+    if (!foldedFindings.has(k)) foldedFindings.set(k, f);
+  }
+
+  // 0.28.2 (Codex review follow-up on #229): the response lookup is
+  // keyed by (kind, detail) too, so resolving one finding never
+  // silently marks a different-kind finding with the same detail as
+  // resolved. Previously the lookup was `detail` only and an
+  // answered `impliedButNotStated` leaked its response onto an
+  // unanswered `contradiction` with the same detail string.
   const inputResponses = new Map();
   for (const f of inputFindings) {
-    if (typeof f?.detail === 'string' && typeof f?.operatorResponse === 'string') {
-      inputResponses.set(f.detail, f.operatorResponse);
+    if (typeof f?.kind === 'string'
+      && typeof f?.detail === 'string'
+      && typeof f?.operatorResponse === 'string') {
+      inputResponses.set(foldKey(f), f.operatorResponse);
     }
-    if (f?.kind === 'otherDeclared') allFindings.push(f);
   }
 
   const isoNow = now.toISOString();
-  const findingsWithTimestamps = allFindings.map((f) => {
-    const entry = { kind: f.kind, detail: f.detail, raisedAt: isoNow };
+  const findingsWithTimestamps = Array.from(foldedFindings.values()).map((f) => {
+    const entry = { kind: f.kind, detail: f.detail, raisedAt: f.raisedAt ?? isoNow };
     if (f.kindDescription) entry.kindDescription = f.kindDescription;
-    const response = inputResponses.get(f.detail) ?? input?.operatorResponse;
+    const response = f.operatorResponse ?? inputResponses.get(foldKey(f)) ?? input?.operatorResponse;
     if (typeof response === 'string' && response.length > 0) {
       entry.operatorResponse = response;
-      entry.resolvedAt = isoNow;
+      entry.resolvedAt = f.resolvedAt ?? isoNow;
     }
     return entry;
   });

package/src/preflight/manifest-writer.js

@@ -19,7 +19,7 @@ import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
 import { rcfError } from '#core/errors';
-import { validateDocument } from '#core/store';
+import { buildNextManifest, validateDocument } from '#core/store';
 
 /**
  * @typedef {object} PreflightServiceRuling
@@ -210,16 +210,16 @@ export function composeOptOutRecord({
 export async function writePreflightRecord({
   projectRoot, tree, record, optOuts = [], options = {},
 }) {
-  const manifest = tree.manifest ?? {};
-  const nextManifest = { ...manifest };
-
-  const existingPfc = Array.isArray(nextManifest.preFlightConfig) ? nextManifest.preFlightConfig : [];
-  nextManifest.preFlightConfig = [...existingPfc, record];
-
-  if (optOuts.length > 0) {
-    const existingOptOuts = Array.isArray(nextManifest.baselineAcOptOuts) ? nextManifest.baselineAcOptOuts : [];
-    nextManifest.baselineAcOptOuts = [...existingOptOuts, ...optOuts];
-  }
+  // 0.28.2 (Codex review follow-up on #232): compose the next
+  // manifest via the shared `buildNextManifest` helper so the write
+  // and dry-run branches produce byte-identical shapes; validation
+  // then runs on the same result.
+  const nextManifest = buildNextManifest({
+    manifest: tree.manifest ?? {},
+    record,
+    verb: 'preflight',
+    extraRecords: optOuts,
+  });
 
   const relPath = 'rcf/manifest.json';
   const validation = validateDocument({ doc: nextManifest, kind: 'manifest', filePath: relPath });

package/src/req-baseline/sweep.js

@@ -87,10 +87,20 @@ export async function applySweepDecisions({ projectRoot, tree, decisions, now =
     const usDoc = tree.byId.get(usId);
     if (!usDoc) continue;
 
+    // 0.28.2 (issue #231): a per-US allocator seeded ONCE from the
+    // current maxN on `usDoc.acceptanceCriteria`, then handed to each
+    // `composeBaselineAc` for the run. `nextAcId` was stateless
+    // across iterations, so every candidate accepted for one US
+    // received the identical `AC-<usNum>-<maxN+1>` and the writer's
+    // post-write validation refused the tree with a duplicate-id
+    // breakage. Ordinal allocation is monotone within a batch and
+    // across batches (a later sweep on the same US resumes from the
+    // new maxN in the tree).
+    const allocator = makeAcIdAllocator(usDoc);
     const acsToAppend = [];
     for (const d of list) {
       if (d.action === 'accept') {
-        const ac = composeBaselineAc({ usDoc, candidate: d.candidate, now });
+        const ac = composeBaselineAc({ usDoc, candidate: d.candidate, now, idOverride: allocator() });
         acsToAppend.push(ac);
         writtenAcIds.push(ac.id);
         accepted += 1;
@@ -172,9 +182,9 @@ export async function applyPendingBaselinesForUs({ tree, usId }) {
  * @param {Date} args.now
  * @returns {object}
  */
-export function composeBaselineAc({ usDoc, candidate, now }) {
+export function composeBaselineAc({ usDoc, candidate, now, idOverride = null }) {
   const isoNow = now.toISOString();
-  const id = nextAcId(usDoc);
+  const id = typeof idOverride === 'string' && idOverride.length > 0 ? idOverride : nextAcId(usDoc);
   const canonicalText = candidate.canonicalText;
   const gwt = candidate.given || candidate.when || candidate.then
     ? { given: candidate.given ?? '', when: candidate.when ?? '', then: candidate.then ?? '' }
@@ -200,8 +210,22 @@ export function composeBaselineAc({ usDoc, candidate, now }) {
 const AC_HIER_ID_RE = /^AC-(\d{3,})-(\d+)$/;
 
 function nextAcId(usDoc) {
+  const alloc = makeAcIdAllocator(usDoc);
+  return alloc();
+}
+
+/**
+ * 0.28.2 (issue #231): return a monotone AC-id allocator seeded once
+ * from `usDoc.acceptanceCriteria`. Every subsequent call returns
+ * `AC-<usNum>-<n++>`; a caller that accepts N baseline candidates for
+ * one US in one sweep now gets N distinct ids, and the writer's
+ * duplicate-id refusal on `updateDocument` no longer bites.
+ *
+ * @param {object} usDoc
+ * @returns {() => string}
+ */
+export function makeAcIdAllocator(usDoc) {
   const acs = Array.isArray(usDoc.acceptanceCriteria) ? usDoc.acceptanceCriteria : [];
-  // Prefer hierarchical form matching the US id, e.g. US-201 → AC-201-1.
   const usNum = (usDoc.usId ?? '').match(/^US-(\d+)$/)?.[1];
   let maxN = 0;
   for (const ac of acs) {
@@ -212,7 +236,12 @@ function nextAcId(usDoc) {
     const n = Number.parseInt(tail, 10);
     if (Number.isFinite(n) && n > maxN) maxN = n;
   }
-  return usNum ? `AC-${usNum}-${maxN + 1}` : `AC-${(Math.floor(Math.random() * 999)).toString().padStart(3, '0')}-1`;
+  let counter = maxN;
+  return () => {
+    counter += 1;
+    if (!usNum) return `AC-${(Math.floor(Math.random() * 999)).toString().padStart(3, '0')}-${counter}`;
+    return `AC-${usNum}-${counter}`;
+  };
 }
 
 function extractGwt(text) {

package/src/ui-baseline/manifest-writer.js

@@ -18,7 +18,7 @@ import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 
 import { rcfError } from '#core/errors';
-import { validateDocument } from '#core/store';
+import { buildNextManifest, validateDocument } from '#core/store';
 
 import { composeDefaults, deepGet, deepSet } from './defaults.js';
 import { CATALOGUE_V1 } from '../preflight/design-shapes.js';
@@ -150,15 +150,16 @@ export function preflightSeamOverrides(manifest, catalogue = CATALOGUE_V1) {
 export async function writeUiBaselineRecord({
   projectRoot, tree, record, options = {},
 }) {
-  const manifest = tree.manifest ?? {};
-  const nextManifest = { ...manifest };
-  const priorBaseline = nextManifest.uiBaseline ?? null;
-
-  if (priorBaseline && options.reset) {
-    const history = Array.isArray(nextManifest.uiBaselineHistory) ? nextManifest.uiBaselineHistory : [];
-    nextManifest.uiBaselineHistory = [...history, priorBaseline];
-  }
-  nextManifest.uiBaseline = record;
+  // 0.28.2 (Codex review follow-up on the shared helper): compose via
+  // the shared `buildNextManifest` helper so write and dry-run
+  // produce the same shape. `options.reset` still drives the
+  // history-move branch inside the helper.
+  const nextManifest = buildNextManifest({
+    manifest: tree.manifest ?? {},
+    record,
+    verb: 'uiBaselineInit',
+    options: { reset: Boolean(options.reset) },
+  });
 
   const relPath = 'rcf/manifest.json';
   const validation = validateDocument({ doc: nextManifest, kind: 'manifest', filePath: relPath });