rcf-lite 0.0.1 → 0.7.1

package/src/register-canary/runner.js

@@ -0,0 +1,156 @@
+// Register-canary runner (spec §7.4).
+//
+// Runs one fixture (or the whole pack) against a subagent driver,
+// grades the response with core's REGISTER_CANARY_DIMENSIONS_V1, and
+// composes the record shape for the fixture manifest.
+//
+// Subagent driver: injected. The default is a mock that returns a
+// clean "in hand, next step is X" message, but the runner FORCES a
+// mock run to be distinguishable from a real subagent run in the
+// durable record — a mock never produces a pass verdict indistinguishable
+// from a live one. Concretely:
+//   - the runner takes a `driverMode` argument ('mock' | 'live');
+//   - a mock run suffixes `buildVersion` with `-mockdriver` so the
+//     mode marker travels with the record into any chain manifest a
+//     downstream consumer could copy the record into (§7.4 fixture
+//     manifest is not chain-validated, but the record shape must stay
+//     honest across surfaces);
+//   - a mock run OVERRIDES the top-level verdict to `fail` regardless
+//     of grade, and populates `shipDespiteFailReason` with a plain
+//     "mock canary driver — infrastructure test only, no real subagent
+//     dispatched" line, so the record is durably marked as machinery
+//     verification rather than a release gate.
+// This mirrors Track A N-2 (unwired mutation runner returning PASS is
+// theatre) and Track B flagged-call-2 (stub browser driver forced to
+// warn-never-pass): unwired drivers must not produce clean-pass records.
+// The production driver (Anthropic Agent SDK, Opus 4.7 per estate
+// ladder) invokes with `driverMode: 'live'` and the overlay is skipped
+// entirely — the record is a genuine grader output.
+
+import { gradeResponse } from '#core/patterns/register-canary';
+
+import { composeCanaryRecord } from './record-writer.js';
+
+/**
+ * Marker text applied to a mock-driver record's `shipDespiteFailReason`.
+ * Deliberately long enough to satisfy the schema `minLength: 1` and
+ * explicit enough that a reviewer greps the record and sees the mode.
+ */
+export const MOCK_DRIVER_MARKER = 'mock canary driver used; no real subagent was dispatched. This record verifies canary infrastructure only, not the register itself.';
+
+/**
+ * Suffix appended to `buildVersion` when the driver mode is mock. Ports
+ * across surfaces (the fixture manifest is a private greppable log
+ * today; a future ship into a chain manifest would carry the marker
+ * intact through the schema-legal buildVersion string).
+ */
+export const MOCK_DRIVER_BUILD_VERSION_SUFFIX = '-mockdriver';
+
+/**
+ * @typedef {object} CanaryDriverInput
+ * @property {string} operatorPrompt
+ * @property {Array<{ path: string, content: string }>} supportingArtefacts
+ * @property {string[]} grantedPermissions
+ * @property {string} guidance                  the shipping playbook content injected as system context
+ * @property {string} fixtureId
+ */
+
+/**
+ * @typedef {object} CanaryDriverOutput
+ * @property {string} responseBody              the first-response body text (system prompts / tool-use excluded)
+ */
+
+/**
+ * @typedef {(input: CanaryDriverInput) => Promise<CanaryDriverOutput>} CanaryDriver
+ */
+
+/**
+ * A clean-register mock driver. Produces a short, on-register reply
+ * that passes every graded dimension. Used by tests and by the CLI
+ * when no live driver is wired.
+ *
+ * @type {CanaryDriver}
+ */
+export async function MOCK_SUBAGENT() {
+  return {
+    responseBody: "Have it in hand. The brief points at a single-operator uptime tool with an admin surface and email recovery pings. Two open decisions before any code: which host you want to deploy against, and the credential store for Resend. Once you name those I will scaffold the tree and hand you the first build item.",
+  };
+}
+
+/**
+ * Run one fixture against a driver and produce a record.
+ *
+ * @param {object} args
+ * @param {object} args.fixture
+ * @param {CanaryDriver} args.driver
+ * @param {'mock'|'live'} args.driverMode           mock runs are overridden to fail; see file header
+ * @param {string} args.buildVersion
+ * @param {string} args.guidance
+ * @param {object[]} args.existingRecords
+ * @param {Date} [args.now]
+ * @returns {Promise<{ record: object, responseBody: string }>}
+ */
+export async function runCanaryAgainstFixture({ fixture, driver, driverMode, buildVersion, guidance, existingRecords, now }) {
+  if (driverMode !== 'mock' && driverMode !== 'live') {
+    throw new Error(`runCanaryAgainstFixture: driverMode must be 'mock' or 'live' (got ${JSON.stringify(driverMode)})`);
+  }
+  const output = await driver({
+    operatorPrompt: fixture.operatorPrompt,
+    supportingArtefacts: fixture.supportingArtefacts ?? [],
+    grantedPermissions: fixture.grantedPermissions ?? [],
+    guidance,
+    fixtureId: fixture.id,
+  });
+  const grade = gradeResponse({
+    responseBody: output.responseBody,
+    grantedPermissions: fixture.grantedPermissions,
+    wordCountBudget: fixture.wordCountBudget,
+  });
+  // A mock driver never produces a clean-pass record: suffix the
+  // buildVersion, force the top-level verdict to `fail`, and stamp
+  // shipDespiteFailReason with the mock-marker string. The `grades`
+  // block still reflects what the mock actually said, so a reader can
+  // see the pattern-level detail — the aggregate is what is forced.
+  const effectiveBuildVersion = driverMode === 'mock' ? `${buildVersion}${MOCK_DRIVER_BUILD_VERSION_SUFFIX}` : buildVersion;
+  const effectiveGrade = driverMode === 'mock' ? { verdict: 'fail', grades: grade.grades } : grade;
+  const record = composeCanaryRecord({
+    existingRecords,
+    buildVersion: effectiveBuildVersion,
+    fixturePromptId: fixture.id,
+    responseBody: output.responseBody,
+    grade: effectiveGrade,
+    shipDespiteFailReason: driverMode === 'mock' ? MOCK_DRIVER_MARKER : undefined,
+    now,
+  });
+  return { record, responseBody: output.responseBody };
+}
+
+/**
+ * Run every fixture in the pack. Returns the records in run order plus
+ * an aggregate verdict (any fail forces aggregate fail).
+ *
+ * @param {object} args
+ * @param {object[]} args.fixtures
+ * @param {CanaryDriver} args.driver
+ * @param {'mock'|'live'} args.driverMode
+ * @param {string} args.buildVersion
+ * @param {string} args.guidance
+ * @param {object[]} args.existingRecords
+ * @param {Date} [args.now]
+ * @returns {Promise<{ records: object[], verdict: 'pass'|'fail', driverMode: 'mock'|'live' }>}
+ */
+export async function runCanaryPack({ fixtures, driver, driverMode, buildVersion, guidance, existingRecords, now }) {
+  const records = [];
+  let aggregate = 'pass';
+  let existing = [...existingRecords];
+  for (const fixture of fixtures) {
+    // eslint-disable-next-line no-await-in-loop
+    const { record } = await runCanaryAgainstFixture({
+      fixture, driver, driverMode, buildVersion, guidance, existingRecords: existing, now,
+    });
+    records.push(record);
+    existing = [...existing, record];
+    if (record.verdict === 'fail') aggregate = 'fail';
+  }
+  return { records, verdict: aggregate, driverMode };
+}

package/src/req-baseline/gate.js

@@ -0,0 +1,86 @@
+// Stage-1 refusal gate (spec §5.4).
+//
+// `rcf build --next` refuses to enter Build for any FBS binding an AC
+// on a US that still has open baseline sweep candidates. The refusal
+// message follows the canonical shape in spec §5.4.
+//
+// The gate itself is a pure function against the tree; the CLI layer
+// calls it after selecting the next actionable FBS (see build.js).
+
+import { openCandidatesForUs } from './open-candidates.js';
+
+/**
+ * @typedef {object} Stage1Refusal
+ * @property {string} fbsId
+ * @property {string} usId
+ * @property {Array<{ baselineKey: string, canonicalText: string, reqShape: string }>} openCandidates
+ * @property {string} reqId
+ * @property {string} message   pre-formatted refusal, spec §5.4 shape
+ */
+
+/**
+ * Inspect an FBS for a refusal condition. Walks the FBS's bound ACs to
+ * their owning USes; any US with open baseline candidates fails the
+ * gate. Returns null when the FBS is clear.
+ *
+ * @param {import('#core/store/walker.js').TreeModel} tree
+ * @param {string} fbsId
+ * @returns {Stage1Refusal|null}
+ */
+export function fbsRefusalForOpenSweep(tree, fbsId) {
+  const fbs = tree?.byId?.get(fbsId);
+  if (!fbs) return null;
+  const acIds = Array.isArray(fbs.acIds) ? fbs.acIds : [];
+  const seenUsIds = new Set();
+  for (const acId of acIds) {
+    // AC ids are inline on the parent US; `walkTree` records the
+    // AC-to-US mapping under `parentByChild` for exactly this lookup
+    // (the `usByAcId` map on the render-side tree model is derived
+    // from the same source).
+    const usId = tree.parentByChild?.get(acId);
+    if (!usId || seenUsIds.has(usId)) continue;
+    seenUsIds.add(usId);
+    const us = tree.byId.get(usId);
+    if (!us) continue;
+    const open = openCandidatesForUs(tree, us);
+    if (open.length === 0) continue;
+    return {
+      fbsId,
+      usId,
+      reqId: us.reqId,
+      openCandidates: open,
+      message: formatStage1RefusalMessage({ fbsId, usId, reqId: us.reqId, openCandidates: open }),
+    };
+  }
+  return null;
+}
+
+/**
+ * Format the spec §5.4 refusal line for an operator.
+ *
+ * @param {object} args
+ * @param {string} args.fbsId
+ * @param {string} args.usId
+ * @param {string} args.reqId
+ * @param {Array<{ baselineKey: string, canonicalText: string }>} args.openCandidates
+ * @returns {string}
+ */
+export function formatStage1RefusalMessage({ fbsId, usId, reqId, openCandidates }) {
+  const lines = [];
+  lines.push(`refused build: ${fbsId} binds ACs on ${usId}, but ${usId} has ${openCandidates.length} open baseline`);
+  lines.push(`        candidate${openCandidates.length === 1 ? '' : 's'} awaiting a decision:`);
+  for (const c of openCandidates) {
+    const short = shortDescription(c.canonicalText);
+    lines.push(`          ${c.baselineKey}: ${short}`);
+  }
+  lines.push(`        Resolve: rcf req-baseline sweep --req ${reqId}`);
+  return lines.join('\n');
+}
+
+function shortDescription(text) {
+  // Trim to a leading "given ... then <clause>" summary; cap at 100
+  // chars with an ellipsis. Never rewrites the sentence.
+  const trimmed = typeof text === 'string' ? text : '';
+  if (trimmed.length <= 100) return trimmed;
+  return `${trimmed.slice(0, 97)}...`;
+}

package/src/req-baseline/index.js

@@ -0,0 +1,27 @@
+// Public surface for the baseline-AC injection module
+// (elicitation-and-playbook-hardening-0.7.0-spec §5).
+
+export {
+  planSweep,
+  applySweepDecisions,
+  applyPendingBaselinesForUs,
+} from './sweep.js';
+
+export {
+  writeOptOut,
+  removeOptOut,
+  nextOptOutId,
+  isOptedOut,
+  optOutMap,
+} from './opt-out.js';
+
+export {
+  listOpenCandidates,
+  usHasOpenCandidates,
+  openCandidatesForUs,
+} from './open-candidates.js';
+
+export {
+  fbsRefusalForOpenSweep,
+  formatStage1RefusalMessage,
+} from './gate.js';

package/src/req-baseline/open-candidates.js

@@ -0,0 +1,143 @@
+// Open-sweep candidate tracker (spec §5.3 moment 4, §5.4 gate).
+//
+// The moment-4 posture: a non-interactive `rcf create us` under a
+// classified REQ surfaces baseline keys that are neither present as
+// ACs nor covered by an opt-out. This module answers "which USes have
+// baselineKeys that are still OPEN?" without ever writing to disk.
+//
+// There is NO persisted sweep queue: `@stravica-ai/rcf-schemas`
+// user-story.schema.json is `additionalProperties: false` and carries
+// no `baselineSweepQueue` property, so writing one would fail schema
+// validation. Openness is DERIVED from three facts read live per call:
+// the parent REQ's `shapeClassification`, the US's own AC keys, and
+// the manifest's `baselineAcOptOuts[]`. Spec §18 2026-07-31 fold
+// ratifies the derivation as normative (replaces the earlier
+// "auto-enqueue" wording).
+
+import { getBaselineSet, getBaselineEntry, BASELINE_SHAPE_KEYS } from '#core/baseline-catalog';
+import { optOutMap } from './opt-out.js';
+
+/**
+ * @typedef {object} OpenCandidate
+ * @property {string} usId
+ * @property {string} reqId
+ * @property {string} baselineKey
+ * @property {string} reqShape
+ * @property {string} canonicalText
+ */
+
+/**
+ * Enumerate open sweep candidates across the tree.
+ *
+ * A candidate is open when:
+ *   - the parent REQ carries a `shapeClassification` with a non-empty
+ *     shape list (excluding `none`);
+ *   - a baseline key from any of those shapes is not present as an AC
+ *     on the US (neither authoredBy: baseline nor operatorEdited with
+ *     the same key);
+ *   - no baselineAcOptOuts entry covers the key (req-scoped for this
+ *     REQ, or project-scoped).
+ *
+ * Openness is derived per call from these three signals; there is no
+ * persisted queue by ruling (spec §18 2026-07-31 fold; schema fence at
+ * user-story additionalProperties:false).
+ *
+ * Note the caller may pass reqId to narrow to one REQ.
+ *
+ * @param {import('#core/store/walker.js').TreeModel} tree
+ * @param {object} [opts]
+ * @param {string|null} [opts.reqId]
+ * @returns {Array<{ usId: string, reqId: string, baselineKeys: string[] }>}
+ */
+export function listOpenCandidates(tree, opts = {}) {
+  const filterReq = opts.reqId ?? null;
+  const results = [];
+  for (const [id, kind] of tree.kindById) {
+    if (kind !== 'userStory') continue;
+    const us = tree.byId.get(id);
+    if (!us) continue;
+    if (filterReq && us.reqId !== filterReq) continue;
+    const open = openCandidatesForUs(tree, us);
+    if (open.length > 0) {
+      results.push({ usId: id, reqId: us.reqId, baselineKeys: open.map((c) => c.baselineKey) });
+    }
+  }
+  results.sort((a, b) => a.usId.localeCompare(b.usId));
+  return results;
+}
+
+/**
+ * Enumerate open candidates for one loaded US.
+ *
+ * @param {import('#core/store/walker.js').TreeModel} tree
+ * @param {object} usDoc
+ * @returns {OpenCandidate[]}
+ */
+export function openCandidatesForUs(tree, usDoc) {
+  const reqDoc = tree?.byId?.get(usDoc?.reqId);
+  const shapes = shapesOfReq(reqDoc);
+  if (shapes.length === 0) return [];
+
+  const acKeys = new Set();
+  for (const ac of usDoc.acceptanceCriteria ?? []) {
+    if (ac?.provenance?.baselineKey) acKeys.add(ac.provenance.baselineKey);
+  }
+
+  const optedOut = optOutMap(tree?.manifest ?? null, usDoc.reqId);
+
+  const proposeAll = new Set();
+  for (const shape of shapes) {
+    const set = getBaselineSet(shape);
+    if (!set) continue;
+    for (const entry of set.entries) proposeAll.add(entry.baselineKey);
+  }
+
+  const results = [];
+  for (const key of proposeAll) {
+    if (acKeys.has(key)) continue;
+    if (optedOut.has(key)) continue;
+    const entry = getBaselineEntry(key);
+    if (!entry) continue;
+    // shape derived from entry's set (spec order: webUi > httpApi > auth
+    // > persistence > notifications).
+    const reqShape = shapeOfEntry(key);
+    results.push({
+      usId: usDoc.usId,
+      reqId: usDoc.reqId,
+      baselineKey: key,
+      reqShape,
+      canonicalText: entry.canonicalText,
+    });
+  }
+  // Stable order by shape then by canonical order within the set.
+  results.sort((a, b) => a.baselineKey.localeCompare(b.baselineKey));
+  return results;
+}
+
+/**
+ * True when the US has one or more open sweep candidates.
+ *
+ * @param {import('#core/store/walker.js').TreeModel} tree
+ * @param {object} usDoc
+ * @returns {boolean}
+ */
+export function usHasOpenCandidates(tree, usDoc) {
+  return openCandidatesForUs(tree, usDoc).length > 0;
+}
+
+function shapesOfReq(reqDoc) {
+  const shapes = reqDoc?.shapeClassification?.shapes;
+  if (!Array.isArray(shapes)) return [];
+  return shapes.filter((s) => s !== 'none');
+}
+
+function shapeOfEntry(baselineKey) {
+  for (const shape of BASELINE_SHAPE_KEYS) {
+    const set = getBaselineSet(shape);
+    if (!set) continue;
+    for (const entry of set.entries) {
+      if (entry.baselineKey === baselineKey) return shape;
+    }
+  }
+  return 'unknown';
+}

package/src/req-baseline/opt-out.js

@@ -0,0 +1,195 @@
+// Baseline-AC opt-out ledger (spec §5.4).
+//
+// Writes and removes entries on manifest.baselineAcOptOuts[]. Composes
+// with the design-shape answer opt-out surface that Track A owns
+// (preflight/manifest-writer.js already carries composeOptOutRecord for
+// the preflight-driven case); this module is the C+D-native writer for
+// operator rulings recorded outside a preflight session.
+//
+// Both surfaces write to the same array; both use the same
+// boo-YYYY-MM-DD-NNN monotonic id scheme so id collisions across
+// surfaces are impossible.
+
+import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+import { rcfError, isRcfError } from '#core/errors';
+import { validateDocument } from '#core/store';
+
+const OPT_OUT_ID_RE = /^boo-\d{4}-\d{2}-\d{2}-(\d{3})$/;
+
+/**
+ * Compose the next monotonic opt-out id for the current date. Reads the
+ * existing manifest to find the max NNN suffix for the same YYYY-MM-DD.
+ *
+ * @param {object|null} manifest
+ * @param {Date} [now]
+ * @returns {string}
+ */
+export function nextOptOutId(manifest, now = new Date()) {
+  const yyyy = now.getUTCFullYear().toString().padStart(4, '0');
+  const mm = (now.getUTCMonth() + 1).toString().padStart(2, '0');
+  const dd = now.getUTCDate().toString().padStart(2, '0');
+  const prefix = `boo-${yyyy}-${mm}-${dd}-`;
+  const existing = Array.isArray(manifest?.baselineAcOptOuts) ? manifest.baselineAcOptOuts : [];
+  let maxN = 0;
+  for (const rec of existing) {
+    if (typeof rec?.id !== 'string') continue;
+    const m = rec.id.match(OPT_OUT_ID_RE);
+    if (!m) continue;
+    if (!rec.id.startsWith(prefix)) continue;
+    const n = Number.parseInt(m[1], 10);
+    if (Number.isFinite(n) && n > maxN) maxN = n;
+  }
+  return `${prefix}${(maxN + 1).toString().padStart(3, '0')}`;
+}
+
+/**
+ * Compose a C+D-native opt-out record (no preflight linkage).
+ *
+ * @param {object} args
+ * @param {object|null} args.manifest
+ * @param {string} args.reqId
+ * @param {string} args.baselineKey
+ * @param {string} args.reason              minLength 20 (schema-enforced)
+ * @param {'req'|'project'} [args.scope]    defaults to req
+ * @param {Date} [args.now]
+ * @returns {object}
+ */
+export function composeOptOutRecord({ manifest, reqId, baselineKey, reason, scope = 'req', now = new Date() }) {
+  const isoNow = now.toISOString();
+  const id = nextOptOutId(manifest, now);
+  const record = {
+    id,
+    createdAt: isoNow,
+    baselineKey,
+    scope,
+    reason,
+    operatorAckAt: isoNow,
+  };
+  if (scope === 'req') record.reqId = reqId;
+  return record;
+}
+
+/**
+ * Write a new opt-out record atomically.
+ *
+ * @param {object} args
+ * @param {string} args.projectRoot
+ * @param {import('#core/store/walker.js').TreeModel} args.tree
+ * @param {string} args.reqId
+ * @param {string} args.baselineKey
+ * @param {string} args.reason
+ * @param {'req'|'project'} [args.scope]
+ * @param {Date} [args.now]
+ * @returns {Promise<{ id: string, record: object } | import('#core/errors').RcfError>}
+ */
+export async function writeOptOut({ projectRoot, tree, reqId, baselineKey, reason, scope = 'req', now = new Date() }) {
+  const manifest = tree?.manifest ?? {};
+  const record = composeOptOutRecord({ manifest, reqId, baselineKey, reason, scope, now });
+  const nextManifest = {
+    ...manifest,
+    baselineAcOptOuts: [
+      ...(Array.isArray(manifest.baselineAcOptOuts) ? manifest.baselineAcOptOuts : []),
+      record,
+    ],
+  };
+  const validation = validateDocument({ doc: nextManifest, kind: 'manifest', filePath: 'rcf/manifest.json' });
+  if (validation) return validation;
+  const abs = join(projectRoot, 'rcf', 'manifest.json');
+  try {
+    await mkdir(dirname(abs), { recursive: true });
+    const tmp = `${abs}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(nextManifest, null, 2)}\n`, 'utf8');
+    try {
+      await rename(tmp, abs);
+    } catch (err) {
+      try { await unlink(tmp); } catch { /* ignore */ }
+      throw err;
+    }
+  } catch (err) {
+    return rcfError({
+      kind: 'ioFailure',
+      message: `req-baseline opt-out: manifest write failed: ${err.message}`,
+      filePath: 'rcf/manifest.json',
+      stack: err.stack,
+    });
+  }
+  return { id: record.id, record };
+}
+
+/**
+ * Remove any existing opt-out matching the reqId/baselineKey. Deletes
+ * both req-scoped and project-scoped matches for the same baselineKey
+ * so a stale opt-out cannot linger.
+ *
+ * @param {object} args
+ * @param {string} args.projectRoot
+ * @param {import('#core/store/walker.js').TreeModel} args.tree
+ * @param {string} args.reqId
+ * @param {string} args.baselineKey
+ * @returns {Promise<{ removed: number } | import('#core/errors').RcfError>}
+ */
+export async function removeOptOut({ projectRoot, tree, reqId, baselineKey }) {
+  const manifest = tree?.manifest ?? {};
+  const existing = Array.isArray(manifest.baselineAcOptOuts) ? manifest.baselineAcOptOuts : [];
+  const remaining = existing.filter((r) => !(r?.baselineKey === baselineKey && (r?.scope === 'project' || r?.reqId === reqId)));
+  const removed = existing.length - remaining.length;
+  if (removed === 0) return { removed: 0 };
+  const nextManifest = { ...manifest, baselineAcOptOuts: remaining };
+  const validation = validateDocument({ doc: nextManifest, kind: 'manifest', filePath: 'rcf/manifest.json' });
+  if (validation) return validation;
+  const abs = join(projectRoot, 'rcf', 'manifest.json');
+  try {
+    const tmp = `${abs}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(nextManifest, null, 2)}\n`, 'utf8');
+    try {
+      await rename(tmp, abs);
+    } catch (err) {
+      try { await unlink(tmp); } catch { /* ignore */ }
+      throw err;
+    }
+  } catch (err) {
+    return rcfError({
+      kind: 'ioFailure',
+      message: `req-baseline opt-out --remove: manifest write failed: ${err.message}`,
+      filePath: 'rcf/manifest.json',
+      stack: err.stack,
+    });
+  }
+  return { removed };
+}
+
+/**
+ * Build a Set of baselineKeys opted out for a given REQ.
+ *
+ * @param {object|null} manifest
+ * @param {string} reqId
+ * @returns {Set<string>}
+ */
+export function optOutMap(manifest, reqId) {
+  const entries = Array.isArray(manifest?.baselineAcOptOuts) ? manifest.baselineAcOptOuts : [];
+  const out = new Set();
+  for (const r of entries) {
+    if (!r || typeof r.baselineKey !== 'string') continue;
+    if (r.scope === 'project') out.add(r.baselineKey);
+    else if (r.scope === 'req' && r.reqId === reqId) out.add(r.baselineKey);
+  }
+  return out;
+}
+
+/**
+ * Convenience predicate.
+ *
+ * @param {object|null} manifest
+ * @param {string} reqId
+ * @param {string} baselineKey
+ * @returns {boolean}
+ */
+export function isOptedOut(manifest, reqId, baselineKey) {
+  return optOutMap(manifest, reqId).has(baselineKey);
+}
+
+// Kept exported for consumers that need the RcfError predicate alongside
+// the writer helpers.
+void isRcfError;