rcf-lite 0.28.1 → 0.28.2

package/src/feedback/redact.js

@@ -448,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
@@ -470,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);

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 });

package/src/view/doc-renderers/helpers.js

@@ -77,6 +77,43 @@ export function fieldList(label, items) {
   return `<section class="field-list"><h4>${escapeHtml(label)}</h4><ul>${li}</ul></section>`;
 }
 
+/**
+ * 0.28.2 (issue #235): render an array-of-object field as a HTML
+ * table with the schema-known columns. Empty columns are suppressed so
+ * schema-optional fields do not surface as blank columns. Every cell
+ * is escaped. Used by the TAD renderer for the three structured
+ * fields the TAD schema names (dataStores, coreEntities,
+ * externalSystems) so a review-surface reader sees a legible table
+ * instead of a single-line `JSON.stringify` dump.
+ *
+ * @param {string} label       section heading
+ * @param {object[]} rows       array of row objects (dropped when empty)
+ * @param {Array<{ key: string, label?: string }>} columns
+ * @returns {string}
+ */
+export function fieldObjectTable(label, rows, columns) {
+  if (!Array.isArray(rows) || rows.length === 0) return '';
+  if (!Array.isArray(columns) || columns.length === 0) return '';
+  // Drop columns that are empty across every row so a schema-optional
+  // field (`purpose`, `description`, `protocol`) does not surface as
+  // a blank column.
+  const usedColumns = columns.filter((col) => rows.some((r) => {
+    const v = r?.[col.key];
+    return v !== undefined && v !== null && String(v).length > 0;
+  }));
+  if (usedColumns.length === 0) return '';
+  const thead = usedColumns.map((c) => `<th>${escapeHtml(c.label ?? c.key)}</th>`).join('');
+  const tbody = rows.map((r) => {
+    const cells = usedColumns.map((c) => {
+      const v = r?.[c.key];
+      const text = v === undefined || v === null ? '' : String(v);
+      return `<td>${escapeHtml(text)}</td>`;
+    }).join('');
+    return `<tr>${cells}</tr>`;
+  }).join('');
+  return `<section class="field-list"><h4>${escapeHtml(label)}</h4><table class="field-table"><thead><tr>${thead}</tr></thead><tbody>${tbody}</tbody></table></section>`;
+}
+
 /**
  * Render the "Show raw JSON" disclosure block for a document.
  *

package/src/view/doc-renderers/tad.js

@@ -9,10 +9,34 @@ import {
   docLinkList,
   escapeHtml,
   fieldList,
+  fieldObjectTable,
   fieldPara,
   rawJsonDisclosure,
 } from './helpers.js';
 
+// 0.28.2 (issue #235): structured fields the TAD schema explicitly
+// types as arrays of objects. Each entry maps a field-key to the
+// schema-documented column layout so `renderOptionalSections` can
+// pick a table renderer over the raw-JSON dump the pre-fix code
+// emitted. Columns follow @stravica-ai/rcf-schemas@0.6.3
+// schemas/tad.schema.json.
+const TAD_STRUCTURED_FIELDS = {
+  dataStores: [
+    { key: 'name', label: 'Name' },
+    { key: 'kind', label: 'Kind' },
+    { key: 'purpose', label: 'Purpose' },
+  ],
+  coreEntities: [
+    { key: 'name', label: 'Name' },
+    { key: 'description', label: 'Description' },
+  ],
+  externalSystems: [
+    { key: 'name', label: 'Name' },
+    { key: 'purpose', label: 'Purpose' },
+    { key: 'protocol', label: 'Protocol' },
+  ],
+};
+
 /**
  * @param {object} tad
  * @param {object} ctx
@@ -63,12 +87,49 @@ function renderOptionalSections(tad) {
   for (const [key, label] of Object.entries(named)) {
     const section = tad[key];
     if (!section || typeof section !== 'object') continue;
-    const rows = Object.entries(section).map(([k, v]) => {
-      if (typeof v === 'string') return `<dt>${escapeHtml(k)}</dt><dd>${escapeHtml(v)}</dd>`;
-      if (Array.isArray(v)) return `<dt>${escapeHtml(k)}</dt><dd>${v.map((x) => `<code>${escapeHtml(typeof x === 'object' ? JSON.stringify(x) : x)}</code>`).join(', ')}</dd>`;
-      return `<dt>${escapeHtml(k)}</dt><dd><pre>${escapeHtml(JSON.stringify(v, null, 2))}</pre></dd>`;
-    }).join('\n');
-    out.push(`<section class="field-list"><h4>${escapeHtml(label)}</h4><dl>${rows}</dl></section>`);
+    // 0.28.2 (issue #235): pull the schema-known structured fields
+    // (dataStores, coreEntities, externalSystems) out of the generic
+    // dl loop and render them as tables. The remaining scalar and
+    // array-of-string fields keep their dl treatment.
+    const structuredBlocks = [];
+    const dlEntries = [];
+    for (const [k, v] of Object.entries(section)) {
+      if (TAD_STRUCTURED_FIELDS[k] && Array.isArray(v) && v.length > 0 && v.every((x) => x && typeof x === 'object')) {
+        const table = fieldObjectTable(prettyStructuredLabel(k), v, TAD_STRUCTURED_FIELDS[k]);
+        if (table) structuredBlocks.push(table);
+        continue;
+      }
+      if (typeof v === 'string') {
+        dlEntries.push(`<dt>${escapeHtml(k)}</dt><dd>${escapeHtml(v)}</dd>`);
+        continue;
+      }
+      if (Array.isArray(v)) {
+        // Array-of-string keeps the existing inline shape. An
+        // unknown array-of-object surface falls through to a nested
+        // disclosure so it stays legible even when the schema grows
+        // a new field before this renderer knows about it.
+        if (v.every((x) => typeof x !== 'object' || x === null)) {
+          dlEntries.push(`<dt>${escapeHtml(k)}</dt><dd>${v.map((x) => `<code>${escapeHtml(typeof x === 'object' ? JSON.stringify(x) : x)}</code>`).join(', ')}</dd>`);
+        } else {
+          const items = v.map((x) => `<li><pre>${escapeHtml(JSON.stringify(x, null, 2))}</pre></li>`).join('');
+          dlEntries.push(`<dt>${escapeHtml(k)}</dt><dd><ul>${items}</ul></dd>`);
+        }
+        continue;
+      }
+      dlEntries.push(`<dt>${escapeHtml(k)}</dt><dd><pre>${escapeHtml(JSON.stringify(v, null, 2))}</pre></dd>`);
+    }
+    const dl = dlEntries.length > 0 ? `<dl>${dlEntries.join('\n')}</dl>` : '';
+    const structured = structuredBlocks.join('\n');
+    out.push(`<section class="field-list"><h4>${escapeHtml(label)}</h4>${dl}${structured}</section>`);
   }
   return out.join('\n');
 }
+
+function prettyStructuredLabel(key) {
+  const map = {
+    dataStores: 'Data stores',
+    coreEntities: 'Core entities',
+    externalSystems: 'External systems',
+  };
+  return map[key] ?? key;
+}

package/src/view/style.css

@@ -294,6 +294,11 @@ article.doc h5 { margin: 0.6rem 0 0.3rem; font-size: 0.925rem; font-weight: 600;
 .field-list ul li { margin: 0.2rem 0; }
 .field-list dl dt { font-weight: 600; margin-top: 0.5rem; color: var(--colour-heading); }
 .field-list dl dd { margin-left: 0; margin-bottom: 0.35rem; }
+/* 0.28.2 (issue #235): structured TAD fields render as a table. */
+.field-list table.field-table { border-collapse: collapse; width: 100%; margin: 0.35rem 0 0.85rem; font-size: 0.95em; }
+.field-list table.field-table th, .field-list table.field-table td { text-align: left; padding: 0.35rem 0.55rem; border-bottom: 1px solid var(--colour-rule, rgba(0,0,0,0.12)); vertical-align: top; }
+.field-list table.field-table th { font-weight: 600; color: var(--colour-heading); background: var(--colour-tint, rgba(0,0,0,0.03)); }
+.field-list table.field-table tr:last-child td { border-bottom: 0; }
 
 /* --------------------------------------------------------------------
  * Acceptance criteria list (inside a US)