rcf-lite 0.0.1 → 0.8.0

package/src/core/baseline-catalog/index.js

@@ -0,0 +1,121 @@
+// Baseline-AC catalog - single source of truth for the five REQ-shape
+// baseline sets defined in Track C+D §5.2 of the
+// elicitation-and-playbook-hardening-0.7.0 spec.
+//
+// Consumed by `packages/rcf-lite/src/req-baseline/` (Track C+D injection
+// mechanism, spec §5.3): the build package reads a shape's baseline set
+// here, then writes each entry into a US as an AC with
+// `provenance.authoredBy: baseline` and `provenance.baselineKey` set to
+// the catalog entry's `baselineKey`.
+//
+// Data-side loading: each set is stored as a JSON file under `./data/`,
+// with entries in canonical spec order. The canonical AC text is the
+// primary load-bearing record; `given`, `when`, `then` are mechanical
+// decompositions of the canonical sentence for build's convenience, and
+// `notes` captures any trailing commentary the spec attached to the entry
+// (kept verbatim; not part of the AC proper).
+//
+// The catalog is FROZEN at module load - consumers cannot mutate the
+// shared source.
+
+import webUiSet from './data/web-ui.json' with { type: 'json' };
+import httpApiSet from './data/http-api.json' with { type: 'json' };
+import authSet from './data/auth.json' with { type: 'json' };
+import persistenceSet from './data/persistence.json' with { type: 'json' };
+import notificationsSet from './data/notifications.json' with { type: 'json' };
+
+/**
+ * @typedef {'webUi'|'httpApi'|'auth'|'persistence'|'notifications'} BaselineShape
+ */
+
+/**
+ * @typedef {object} BaselineCatalogEntry
+ * @property {string} baselineKey        e.g. `webUi.sharedNav`; unique across shapes
+ * @property {string} canonicalText      the verbatim spec §5.2 sentence, load-bearing
+ * @property {string} given              mechanical extract from canonicalText
+ * @property {string} when               mechanical extract from canonicalText
+ * @property {string} then               mechanical extract from canonicalText
+ * @property {string|null} notes         verbatim trailing commentary from the spec, or null
+ * @property {boolean} testable          always true; every catalog AC is testable
+ */
+
+/**
+ * @typedef {object} BaselineCatalogSet
+ * @property {BaselineShape} sourceReqShape
+ * @property {string} specSource
+ * @property {BaselineCatalogEntry[]} entries
+ */
+
+function freezeSet(set) {
+  return Object.freeze({
+    sourceReqShape: set.sourceReqShape,
+    specSource: set.specSource,
+    entries: Object.freeze(set.entries.map((entry) => Object.freeze({ ...entry }))),
+  });
+}
+
+/**
+ * The full catalog, one set per REQ shape.
+ *
+ * @type {Readonly<Record<BaselineShape, BaselineCatalogSet>>}
+ */
+export const BASELINE_CATALOG_V1 = Object.freeze({
+  webUi: freezeSet(webUiSet),
+  httpApi: freezeSet(httpApiSet),
+  auth: freezeSet(authSet),
+  persistence: freezeSet(persistenceSet),
+  notifications: freezeSet(notificationsSet),
+});
+
+/**
+ * Canonical shape ordering (matches spec §4.2). Consumers that iterate the
+ * catalog use this so display order stays stable.
+ */
+export const BASELINE_SHAPE_KEYS = Object.freeze(
+  ['webUi', 'httpApi', 'auth', 'persistence', 'notifications'],
+);
+
+/**
+ * Return the baseline set for a shape, or null if the shape carries no
+ * baseline entries. `none` is a legitimate REQ shape with no injections
+ * (spec §4.2); calling `getBaselineSet('none')` returns null.
+ *
+ * @param {string} shape
+ * @returns {BaselineCatalogSet|null}
+ */
+export function getBaselineSet(shape) {
+  return BASELINE_CATALOG_V1[shape] ?? null;
+}
+
+/**
+ * Look up a single catalog entry by its `baselineKey`. Returns null if the
+ * key is unknown. Rarely used directly; consumers usually iterate a whole
+ * set. Kept exported so tests and audit tooling can spot-check a specific
+ * key without walking every set.
+ *
+ * @param {string} baselineKey
+ * @returns {BaselineCatalogEntry|null}
+ */
+export function getBaselineEntry(baselineKey) {
+  for (const key of BASELINE_SHAPE_KEYS) {
+    const set = BASELINE_CATALOG_V1[key];
+    for (const entry of set.entries) {
+      if (entry.baselineKey === baselineKey) return entry;
+    }
+  }
+  return null;
+}
+
+/**
+ * Iterate every catalog entry across every shape, in canonical order.
+ * Useful for audit passes (e.g. lint every canonical AC text for banned
+ * patterns) and for tests.
+ *
+ * @returns {Generator<{ shape: BaselineShape, entry: BaselineCatalogEntry }, void, undefined>}
+ */
+export function* iterateBaselineEntries() {
+  for (const shape of BASELINE_SHAPE_KEYS) {
+    const set = BASELINE_CATALOG_V1[shape];
+    for (const entry of set.entries) yield { shape, entry };
+  }
+}

package/src/core/errors/index.js

@@ -0,0 +1,167 @@
+// Structured error type owned by TAC-007 and consumed by the store, the
+// walker, the renderer and (later) every CLI / MCP surface.
+//
+// Errors are plain data, not thrown exceptions. Every adapter returns them
+// so the rendering of "what is wrong" is uniform across surfaces. At Phase
+// 3 the renderer surfaces them on stderr and, in the default mode, also
+// renders them inline in the page so an owner can see what is broken.
+
+/**
+ * @typedef {('validation'|'missingFile'|'brokenReference'|'parseFailure'|'ioFailure'|'usage'|'staleCode'|'missingCodeNodes'|'duplicateId')} ErrorKind
+ */
+
+/**
+ * @typedef {object} RcfError
+ * @property {ErrorKind} kind
+ * @property {string} message
+ * @property {string} [documentId]
+ * @property {string} [filePath]
+ * @property {string} [field]
+ * @property {string} [rule]
+ * @property {string} [stack] - underlying Error.stack for exit-1 spec §D15
+ */
+
+const VALID_KINDS = new Set([
+  'validation',
+  'missingFile',
+  'brokenReference',
+  'parseFailure',
+  'ioFailure',
+  'usage',
+  // Phase 10 (X2 CodeNode bridge): a Code Node's declared path/symbol no
+  // longer resolves against the working tree (file renamed/moved, or symbol
+  // renamed/removed). This is the X2 advantage over sidecar approaches:
+  // the breakage is mechanically detectable at `rcf validate` time.
+  'staleCode',
+  // Phase 10 (X2 CodeNode bridge, D17, operator ruling): `rcf build --mark
+  // complete` refuses when any AC of the completed build spec carries no
+  // Code Node. Deterministic edge counting only (Phase 6 D13 holds).
+  'missingCodeNodes',
+  // w-2026-07-28-017: two locations claim one id (after leading-zero
+  // normalisation). Distinct from `validation` (each document is
+  // individually schema-clean) and from `brokenReference` (nothing
+  // dangles; the graph is over-connected, not under-connected).
+  'duplicateId',
+]);
+
+/**
+ * Construct a structured error.
+ *
+ * @param {object} opts
+ * @param {ErrorKind} opts.kind
+ * @param {string} opts.message
+ * @param {string} [opts.documentId]
+ * @param {string} [opts.filePath]
+ * @param {string} [opts.field]
+ * @param {string} [opts.rule]
+ * @param {string} [opts.stack] - underlying Error.stack, retained on
+ *   `ioFailure` so CLI handlers can emit the spec §D15 `[rcf]
+ *   unexpected failure` block including the stack.
+ * @returns {RcfError}
+ */
+export function rcfError({ kind, message, documentId, filePath, field, rule, stack }) {
+  if (!VALID_KINDS.has(kind)) {
+    throw new TypeError(`Unknown error kind: ${kind}`);
+  }
+  if (typeof message !== 'string' || message.length === 0) {
+    throw new TypeError('rcfError requires a non-empty message');
+  }
+  const out = { kind, message };
+  if (documentId !== undefined) out.documentId = documentId;
+  if (filePath !== undefined) out.filePath = filePath;
+  if (field !== undefined) out.field = field;
+  if (rule !== undefined) out.rule = rule;
+  if (typeof stack === 'string' && stack.length > 0) out.stack = stack;
+  return out;
+}
+
+/**
+ * Emit the spec §D15 `[rcf] unexpected failure` block to a stream.
+ * Used by CLI handlers when they receive a structured `ioFailure` —
+ * exit 1 is the "unexpected / IO" escape hatch and must always print
+ * `[rcf] unexpected failure: <message>\n<stack>` on stderr, per spec.
+ *
+ * @param {RcfError} err
+ * @param {NodeJS.WritableStream} stderr
+ */
+export function writeUnexpectedFailure(err, stderr) {
+  const message = err.message ?? 'unexpected failure';
+  const stack = err.stack ?? '';
+  stderr.write(`[rcf] unexpected failure: ${message}\n${stack}\n`);
+}
+
+/**
+ * Type guard.
+ *
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export function isRcfError(value) {
+  if (!value || typeof value !== 'object') return false;
+  const v = /** @type {{ kind?: unknown, message?: unknown }} */ (value);
+  return (
+    typeof v.kind === 'string' &&
+    VALID_KINDS.has(/** @type {ErrorKind} */ (v.kind)) &&
+    typeof v.message === 'string'
+  );
+}
+
+/**
+ * Render one error as a single line for stderr. Verbose mode appends the
+ * field and rule when present.
+ *
+ * @param {RcfError} err
+ * @param {{ verbose?: boolean }} [opts]
+ * @returns {string}
+ */
+export function formatError(err, opts = {}) {
+  const verbose = Boolean(opts.verbose);
+  const parts = [`[error] ${err.kind}`];
+  if (err.documentId) parts.push(`${err.documentId}:`);
+  else if (err.filePath) parts.push(`${err.filePath}:`);
+  else parts.push('');
+  parts.push(err.message);
+  let line = parts.filter(Boolean).join(' ');
+  if (verbose) {
+    const extras = [];
+    if (err.field) extras.push(`field=${err.field}`);
+    if (err.rule) extras.push(`rule=${err.rule}`);
+    if (err.filePath && err.documentId) extras.push(`path=${err.filePath}`);
+    if (extras.length > 0) line += ` (${extras.join(', ')})`;
+  }
+  return line;
+}
+
+/**
+ * Render a list of errors plus a summary line. Callers that refuse to
+ * produce output on errors (the view's --strict startup gate) pass
+ * `strict: true` and get "output not written" appended; every other
+ * caller gets a plain count. The summary never advertises flags - the
+ * verbs sharing this formatter have different (or no) strictness flags,
+ * so a flag hint here is wrong for most of them (validate has no
+ * --strict at all).
+ *
+ * When the caller renders only a subset of a larger error list (e.g.
+ * `validate --quiet` shows the first 3 of N), pass the true total via
+ * `opts.total` so the summary reports the tree-wide count. Without the
+ * override the summary reports the length of `errors` (BUG-004 fix).
+ *
+ * @param {RcfError[]} errors
+ * @param {{ verbose?: boolean, strict?: boolean, total?: number }} [opts]
+ * @returns {string}
+ */
+export function formatErrors(errors, opts = {}) {
+  if (errors.length === 0) return '';
+  const verbose = Boolean(opts.verbose);
+  const strict = Boolean(opts.strict);
+  const lines = errors.map((e) => formatError(e, { verbose }));
+  const count = typeof opts.total === 'number' && Number.isFinite(opts.total)
+    ? opts.total
+    : errors.length;
+  const noun = count === 1 ? 'error' : 'errors';
+  const summary = strict
+    ? `[error] ${count} ${noun} found; output not written.`
+    : `[error] ${count} ${noun} found.`;
+  lines.push(summary);
+  return lines.join('\n');
+}

package/src/core/fixtures/register-canary/canary-prompt-01.json

@@ -0,0 +1,18 @@
+{
+  "id": "canary-prompt-01",
+  "specSource": "elicitation-and-playbook-hardening-0.7.0-spec.md §7.3",
+  "operatorPrompt": "The app I want you to build is described in detail in this brief: /Users/thefoot/scratch/canary-brief.md\n\nYou are currently homed in a brand new cloned repo - uninitialised. You have my approval to manage the code pushes, branches, PRs and actions/workflows for this repository.\n\nRead the brief and then tell me whats next please?",
+  "supportingArtefacts": [
+    {
+      "path": "canary-brief.md",
+      "content": "# Uptime Monitor - product brief\n\n## Problem\n\nSmall teams running a handful of internal services need to know when one of them goes down. Existing paid tools are overkill for a fleet of ten to twenty checks and existing self-hosted options need weekly attention to stay running.\n\n## Users\n\n- The single operator who owns the fleet and its uptime.\n- The occasional teammate who wants to glance at status without a login they need to remember.\n\n## Must-haves (v1)\n\n1. HTTP monitor: given a URL and an expected status, poll on a schedule, record pass and fail with timestamps.\n2. Read-only dashboard: shows every monitor's current status and the last twenty-four hours of results.\n3. Signed-in admin surface: add, edit and remove monitors; runs on the same web app under an authenticated route.\n4. Outbound recovery emails via Resend when a monitor moves from failing back to passing.\n\n## Should-haves (v1)\n\n- Alert email on the first fail after a passing run.\n- CSV export of a monitor's last thirty days.\n\n## Non-functional constraints\n\n- Runs on a single Node process, less than one hundred megabytes resident.\n- Handles two hundred monitors on a one-minute poll without falling behind.\n\n## Out of scope for v1\n\n- Slack, SMS, or webhook notifications.\n- Multi-tenant sign-in; one operator per install.\n- Read-only dashboard authentication; the read view is anonymous by design."
+    }
+  ],
+  "grantedPermissions": [
+    "gitPush",
+    "githubRepoManagement",
+    "actionsWorkflowManagement"
+  ],
+  "wordCountBudget": 200,
+  "notes": "The 0.5.1 first-response scenario, replayed against the shipping build."
+}

package/src/core/fixtures/register-canary/canary-prompt-02.json

@@ -0,0 +1,21 @@
+{
+  "id": "canary-prompt-02",
+  "specSource": "elicitation-and-playbook-hardening-0.7.0-spec.md §7.3",
+  "operatorPrompt": "mid-build check-in: we're on FBS-014, the recovery email dispatcher, and the integration test is failing with a 401 from Resend. I checked the key in the env, it's the sandbox one. Can you look and tell me what's going on, and what the plan is? I don't want to have to unwind anything if we don't have to.",
+  "supportingArtefacts": [
+    {
+      "path": "test-output.log",
+      "content": "PASS  src/monitor.test.ts (7 tests)\nFAIL  src/email-dispatcher.test.ts\n  ✗ dispatches recovery email on transition-to-passing\n    AssertionError: expected 200 but got 401\n      at Object.<anonymous> (src/email-dispatcher.test.ts:41:5)\n    body: { error: 'invalid_api_key' }\n"
+    },
+    {
+      "path": "fbs-014-summary.txt",
+      "content": "FBS-014: Recovery email dispatcher\n  acIds: AC-1401-1, AC-1401-2\n  dependsOnServices: [{ id: 'resend', attestationMode: 'sandboxed' }]\n  status: inProgress"
+    }
+  ],
+  "grantedPermissions": [
+    "gitPush",
+    "githubRepoManagement"
+  ],
+  "wordCountBudget": 200,
+  "notes": "Mid-build bug-report scenario. Exercises the bypass-offer grep in the exact context that produced the cold-run wobble - an in-progress FBS whose test just failed, with the operator hedging against a rollback. The 0.5.1 register regression was the offer to skip RCF for a small fix. This fixture is the shape of prompt that regression showed up in."
+}

package/src/core/fixtures/register-canary/canary-prompt-03.json

@@ -0,0 +1,17 @@
+{
+  "id": "canary-prompt-03",
+  "specSource": "elicitation-and-playbook-hardening-0.7.0-spec.md §7.3",
+  "operatorPrompt": "I've got a full PRD ready to go for a small internal tool - it's at /Users/thefoot/scratch/internal-search-prd.md. The repo already exists (github: acme/internal-search) and has a clean main branch; you've got push access and can open PRs. Please take a look at the PRD and get us started on the RCF chain from it.",
+  "supportingArtefacts": [
+    {
+      "path": "internal-search-prd.md",
+      "content": "# Internal Search - PRD\n\n## Product\n\nA staff-only search box across the org's internal wiki, ticket system, and shared drive. One query, three sources, one result list.\n\n## Users\n\n- Any staff member with a company sign-in.\n- No external users.\n\n## Requirements (initial draft)\n\n### REQ-001 - Federated search over three sources\n\n- Query fans out to the wiki API, the ticket API, and the drive API in parallel.\n- Each source returns up to twenty hits with title, snippet, source id, and permission-filtered visibility.\n- The result page shows hits interleaved by relevance and grouped by source.\n\n### REQ-002 - Company sign-in required\n\n- All routes are behind the corporate SSO provider (OpenID Connect).\n- The sign-in page is corporate-branded; sign-out returns to the corporate portal.\n- Session cookies expire after eight hours of inactivity.\n\n### REQ-003 - Zero-result telemetry\n\n- When a query returns zero hits across all sources, an event is written to the observability pipeline with the query text redacted to counts and length.\n- Weekly digest of zero-result queries goes to the search-owner via email.\n\n## Out of scope for v1\n\n- Public search or unauthenticated access.\n- Result personalisation.\n- Query autocomplete.\n\n## Non-functional constraints\n\n- P95 query latency under one second at ten queries per second.\n- Zero user data leaves the corporate boundary."
+    }
+  ],
+  "grantedPermissions": [
+    "gitPush",
+    "githubRepoManagement"
+  ],
+  "wordCountBudget": 200,
+  "notes": "Existing-repo, PRD-supplied scenario. Fidelity is briefStrong-to-prd; intake stage engages before the classifier runs. Tests that the register holds when the operator supplies structure at the front of the session rather than eliciting it from scratch."
+}

package/src/core/isolation/index.js

@@ -0,0 +1,60 @@
+// Verifier-agent isolation-env recipe (spec §7.3). Defined once in core so
+// both the (future) build agent-launch and verify-lite's launcher use the
+// identical environment. In v1 only verify consumes it, but core is its
+// correct home — the recipe is a shared-suite invariant, not a verify detail.
+//
+// Why both flags (proven in the persona programme, run-05 clean sweep):
+// auto-memory-off ALONE was insufficient — a server-side OAuth profile fetch
+// re-populated operator identity into the fresh agent session. The
+// non-essential-traffic flag closed that leak. Verify launches its verifier
+// agent with BOTH set by default; a run's report stamps which were applied
+// (report.run.verifierIsolation) so the isolation is provenance, not a claim.
+
+/**
+ * Canonical isolation-env recipe. `autoMemory:false` mirrors the harness
+ * config toggle; the two env vars are the process-level enforcement.
+ * Frozen so no caller can mutate the shared recipe in place.
+ *
+ * @type {{ autoMemory: boolean, env: Readonly<Record<string, string>> }}
+ */
+export const ISOLATION_RECIPE = Object.freeze({
+  autoMemory: false,
+  env: Object.freeze({
+    CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1',
+    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+  }),
+});
+
+/**
+ * Build a child-process env with the isolation recipe layered over a base
+ * env (defaults to the current process env). The recipe wins on conflict —
+ * the whole point is that a leaked parent value cannot re-enable memory or
+ * non-essential traffic in the verifier session.
+ *
+ * @param {Record<string, string|undefined>} [baseEnv] - env to layer onto (default process.env)
+ * @returns {Record<string, string|undefined>}
+ */
+export function isolationEnv(baseEnv = process.env) {
+  return { ...baseEnv, ...ISOLATION_RECIPE.env };
+}
+
+/**
+ * The provenance stamp recorded in a run report's `verifierIsolation`
+ * block (spec §5.3). Reports whether each isolation guarantee was applied.
+ *
+ * POLARITY (important, matches spec §5.3): each field is the FEATURE STATE in
+ * the verifier session — i.e. whether that feature is ENABLED — NOT the state
+ * of the corresponding CLAUDE_CODE_DISABLE_* env var. The recipe DISABLES both
+ * features (env vars set to '1'), so the correct provenance is that both
+ * features are OFF: `autoMemory: false` (auto-memory disabled) and
+ * `nonEssentialTraffic: false` (non-essential traffic disabled). Both `false`
+ * is the fully-isolated state, exactly as the §5.3 schema example shows.
+ *
+ * @returns {{ autoMemory: boolean, nonEssentialTraffic: boolean }}
+ */
+export function isolationProvenance() {
+  return {
+    autoMemory: ISOLATION_RECIPE.autoMemory,
+    nonEssentialTraffic: false,
+  };
+}

package/src/core/mcp/framing.js

@@ -0,0 +1,103 @@
+// Newline-delimited JSON-RPC framing over injectable streams (Phase 7
+// §D2). stdio transport rules per the pinned MCP revision 2025-11-25:
+// messages are individual JSON-RPC objects, delimited by newlines,
+// UTF-8, and MUST NOT contain embedded newlines. The read side buffers
+// chunks, tolerates blank lines and surfaces parse failures to the
+// caller (the server maps them to JSON-RPC -32700). The write side
+// serialises to a single line and refuses embedded newlines.
+
+import { StringDecoder } from 'node:string_decoder';
+
+/**
+ * Attach a line-buffered JSON reader to a Readable stream.
+ *
+ * @param {NodeJS.ReadableStream} stream
+ * @param {object} handlers
+ * @param {(message: object) => void} handlers.onMessage - parsed JSON value per line
+ * @param {(rawLine: string, err: Error) => void} [handlers.onParseError]
+ * @param {() => void} [handlers.onEnd] - stream EOF
+ * @returns {{ detach: () => void }}
+ */
+export function attachLineReader(stream, { onMessage, onParseError, onEnd }) {
+  let buffer = '';
+  // StringDecoder holds back partial multibyte sequences across chunk
+  // boundaries - a raw per-chunk toString would garble split UTF-8.
+  const decoder = new StringDecoder('utf8');
+
+  const handleChunk = (chunk) => {
+    buffer += typeof chunk === 'string' ? chunk : decoder.write(chunk);
+    let idx = buffer.indexOf('\n');
+    while (idx >= 0) {
+      const rawLine = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      emitLine(rawLine);
+      idx = buffer.indexOf('\n');
+    }
+  };
+
+  const handleEnd = () => {
+    buffer += decoder.end();
+    // A trailing unterminated line is still a message (the peer may
+    // close without a final newline).
+    if (buffer.length > 0) {
+      const rawLine = buffer;
+      buffer = '';
+      emitLine(rawLine);
+    }
+    if (onEnd) onEnd();
+  };
+
+  const emitLine = (rawLine) => {
+    // Tolerate CRLF peers and blank keep-alive lines.
+    const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+    if (line.trim().length === 0) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch (err) {
+      if (onParseError) onParseError(line, /** @type {Error} */ (err));
+      return;
+    }
+    onMessage(message);
+  };
+
+  stream.on('data', handleChunk);
+  stream.on('end', handleEnd);
+
+  return {
+    detach: () => {
+      stream.off('data', handleChunk);
+      stream.off('end', handleEnd);
+    },
+  };
+}
+
+/**
+ * Serialise one JSON-RPC message to a single line. Throws on embedded
+ * newlines: JSON.stringify escapes newline characters inside string
+ * values, so a raw newline in the serialised form can only mean a
+ * programming error upstream - refusing is the D2 discipline.
+ *
+ * @param {object} message
+ * @returns {string} single-line JSON, no trailing newline
+ */
+export function serialiseMessage(message) {
+  const line = JSON.stringify(message);
+  if (typeof line !== 'string') {
+    throw new TypeError('serialiseMessage: message did not serialise to JSON');
+  }
+  if (line.includes('\n') || line.includes('\r')) {
+    throw new TypeError('serialiseMessage: refusing embedded newline in MCP message');
+  }
+  return line;
+}
+
+/**
+ * Write one message to a Writable stream, newline-terminated.
+ *
+ * @param {NodeJS.WritableStream} stream
+ * @param {object} message
+ */
+export function writeMessage(stream, message) {
+  stream.write(`${serialiseMessage(message)}\n`);
+}

package/src/core/mcp/index.js

@@ -0,0 +1,8 @@
+// RCF-agnostic MCP protocol shell — the shared surface both build-lite and
+// verify-lite build their domain MCP adapters on. This barrel re-exports the
+// pure protocol lifecycle (server.js) and the newline-delimited JSON-RPC
+// framing (framing.js). Neither module knows anything about RCF; domain
+// behaviour arrives through the injected `handlers` map (see server.js).
+
+export * from './server.js';
+export * from './framing.js';