rcf-lite 0.25.0 → 0.26.0

package/src/blueprint/disposition-ledger.js

@@ -0,0 +1,224 @@
+// Per-slug disposition ledger for applied blueprints. Sits alongside
+// the existing `<slug>.applied.json` sidecar (see capabilities.js) and
+// records one entry per AC contributed by the blueprint, plus the
+// disposition the applying agent (or the operator) recorded.
+//
+// Schema follow-up: a `$defs/blueprintDispositionLedger` shape lands
+// on `@stravica-ai/rcf-schemas` alongside the four fields the 0.6.2
+// bump already ships (deliveredBy, ownerRef, disposition,
+// vendorCitation). Until it does, the ledger validates itself via the
+// local `validateRecord` guard so a malformed write refuses before
+// touching the file.
+//
+// Ledger location: `rcf/blueprints/<slug>.disposition.json`.
+
+import { readFile, mkdir, writeFile, stat } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+
+const ACTIONS = new Set([
+  'pending-disposition',
+  'pending-operator',
+  'accepted',
+  'adjusted',
+  'dropped',
+  'escalated-as-defect',
+]);
+
+/**
+ * @typedef {object} DispositionRecord
+ * @property {string} acId
+ * @property {string} storyId
+ * @property {'fixed'|'template'} [sourceDisposition]
+ * @property {'pending-disposition'|'pending-operator'|'accepted'|'adjusted'|'dropped'|'escalated-as-defect'} action
+ * @property {string} [reason]
+ * @property {string} [resolvedAt]
+ * @property {string} [resolvedBy]
+ * @property {string} [escalatedAt]
+ * @property {boolean} [escalatedToOperator]
+ * @property {string} [defectUrl]
+ */
+
+/**
+ * Ledger file path (relative to project root).
+ *
+ * @param {string} slug
+ */
+export function ledgerRelPath(slug) {
+  return join('rcf', 'blueprints', `${slug}.disposition.json`);
+}
+
+/**
+ * Absolute path helper.
+ */
+export function ledgerAbsPath(projectRoot, slug) {
+  return join(projectRoot, ledgerRelPath(slug));
+}
+
+/**
+ * Best-effort shape check for a single ledger record. Returns null on
+ * ok, an error string on any refusal.
+ *
+ * @param {any} rec
+ * @returns {string | null}
+ */
+function validateRecord(rec) {
+  if (!rec || typeof rec !== 'object') return 'record is not an object';
+  if (typeof rec.acId !== 'string' || rec.acId.length === 0) return 'acId is missing';
+  if (typeof rec.storyId !== 'string' || rec.storyId.length === 0) return 'storyId is missing';
+  if (typeof rec.action !== 'string' || !ACTIONS.has(rec.action)) return `action must be one of ${[...ACTIONS].join(', ')}; got '${rec.action}'`;
+  if (rec.sourceDisposition !== undefined && rec.sourceDisposition !== 'fixed' && rec.sourceDisposition !== 'template') {
+    return `sourceDisposition must be 'fixed' or 'template' when set; got '${rec.sourceDisposition}'`;
+  }
+  return null;
+}
+
+/**
+ * Read a slug's ledger from disk. Missing file returns null.
+ *
+ * @param {string} projectRoot
+ * @param {string} slug
+ * @returns {Promise<{ slug: string, schemaVersion: number, records: DispositionRecord[] } | null>}
+ */
+export async function readLedger(projectRoot, slug) {
+  const abs = ledgerAbsPath(projectRoot, slug);
+  try {
+    const raw = await readFile(abs, 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+/**
+ * Presence check for the ledger file. Does not parse.
+ *
+ * @param {string} projectRoot
+ * @param {string} slug
+ * @returns {Promise<boolean>}
+ */
+export async function ledgerExists(projectRoot, slug) {
+  try { await stat(ledgerAbsPath(projectRoot, slug)); return true; } catch { return false; }
+}
+
+/**
+ * Write a whole ledger document (overwrites). Validates every record
+ * before touching disk; a bad record returns { error: string } and
+ * writes nothing.
+ *
+ * @param {object} args
+ * @param {string} args.projectRoot
+ * @param {string} args.slug
+ * @param {DispositionRecord[]} args.records
+ * @returns {Promise<{ path: string } | { error: string }>}
+ */
+export async function writeLedger({ projectRoot, slug, records }) {
+  if (!Array.isArray(records)) return { error: 'records must be an array' };
+  for (const r of records) {
+    const err = validateRecord(r);
+    if (err) return { error: `invalid ledger record for AC '${r?.acId ?? '?'}': ${err}` };
+  }
+  const abs = ledgerAbsPath(projectRoot, slug);
+  await mkdir(dirname(abs), { recursive: true });
+  const payload = { slug, schemaVersion: 1, records };
+  await writeFile(abs, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  return { path: ledgerRelPath(slug) };
+}
+
+/**
+ * Initialise a ledger for a freshly-applied blueprint. One record
+ * per AC contributed by the blueprint. Existing ledger (re-apply)
+ * is left byte-identical so operator disposition edits are never
+ * clobbered; the return value carries `alreadyExisted: true`.
+ *
+ * A `fixed` AC (per rcf-schemas 0.6.2 `$defs.acDisposition`) lands as
+ * `accepted` with the sentinel reason `fixed-mechanism-inherited`,
+ * per spec section 3.6.
+ *
+ * @param {object} args
+ * @param {string} args.projectRoot
+ * @param {string} args.slug
+ * @param {Array<{ id: string, storyId: string, sourceDisposition?: 'fixed'|'template' }>} args.acDescriptors
+ * @param {Date}   [args.now]
+ * @returns {Promise<{ path: string, alreadyExisted: boolean, recordCount: number }>}
+ */
+export async function initialiseLedger({ projectRoot, slug, acDescriptors, now = new Date() }) {
+  if (await ledgerExists(projectRoot, slug)) {
+    const existing = await readLedger(projectRoot, slug);
+    return { path: ledgerRelPath(slug), alreadyExisted: true, recordCount: existing?.records?.length ?? 0 };
+  }
+  const iso = now.toISOString().slice(0, 10);
+  const records = acDescriptors.map((d) => {
+    const base = { acId: d.id, storyId: d.storyId };
+    if (d.sourceDisposition === 'fixed') {
+      return { ...base, sourceDisposition: 'fixed', action: 'accepted', reason: 'fixed-mechanism-inherited', resolvedAt: iso, resolvedBy: 'blueprint-author' };
+    }
+    if (d.sourceDisposition === 'template') {
+      return { ...base, sourceDisposition: 'template', action: 'pending-disposition' };
+    }
+    return { ...base, action: 'pending-disposition' };
+  });
+  const res = await writeLedger({ projectRoot, slug, records });
+  if ('error' in res) throw new Error(`ledger init failed: ${res.error}`);
+  return { path: res.path, alreadyExisted: false, recordCount: records.length };
+}
+
+/**
+ * Update or append a single AC record. If the acId is present, its
+ * fields are merged (later fields win); otherwise the record is
+ * appended. Returns { updated: boolean, path } on success.
+ */
+export async function upsertLedgerRecord({ projectRoot, slug, record }) {
+  const err = validateRecord(record);
+  if (err) return { error: err };
+  const doc = (await readLedger(projectRoot, slug)) ?? { slug, schemaVersion: 1, records: [] };
+  let updated = false;
+  const next = doc.records.map((r) => {
+    if (r.acId === record.acId) { updated = true; return { ...r, ...record }; }
+    return r;
+  });
+  if (!updated) next.push(record);
+  const res = await writeLedger({ projectRoot, slug, records: next });
+  if ('error' in res) return res;
+  return { updated, path: res.path };
+}
+
+// The prompt the operator sees at apply time. Kept a canonical string
+// so tests can assert against it and the dispatch spec can echo it
+// verbatim. Contains no em-dashes and no internal identifiers so it
+// reads cleanly in third-party output.
+export const APPLY_DISPOSITION_PROMPT = (slug, version, count) => (
+  `Blueprint '${slug}' v${version} contributed ${count} acceptance criteria. `
+  + `For each, you or the applying agent must record a disposition (accept as authored, adjust with a stated reason, `
+  + `drop with a stated reason, or escalate to the operator). `
+  + `Run 'rcf define blueprint dispositions ${slug}' at any time to see the current state; `
+  + `the applying agent will drive the walk unless you want to do it yourself.`
+);
+
+/**
+ * Ledger schema documentation the follow-up rcf-schemas PR will land.
+ * Kept close to the writer so the local guard and the eventual schema
+ * definition stay in step.
+ */
+export const LEDGER_SCHEMA_NOTE = `
+The per-slug disposition ledger is a JSON object with:
+  { slug: string,
+    schemaVersion: 1,
+    records: [
+      { acId: string,
+        storyId: string,
+        sourceDisposition?: 'fixed' | 'template',
+        action: 'pending-disposition' | 'pending-operator' | 'accepted' | 'adjusted' | 'dropped' | 'escalated-as-defect',
+        reason?: string,
+        resolvedAt?: string (ISO date),
+        resolvedBy?: string,
+        escalatedAt?: string (ISO date),
+        escalatedToOperator?: boolean,
+        defectUrl?: string
+      }, ...
+    ]
+  }
+Follow-up: a $defs/blueprintDispositionLedger schema on @stravica-ai/rcf-schemas
+will make the shape validator-checkable; today the ledger writer guards it
+inline (see validateRecord).
+`.trim();

package/src/blueprint/dispositions.js

@@ -0,0 +1,44 @@
+// `rcf define blueprint dispositions <slug> [--json]` sub-verb.
+// Read-only view over the per-slug disposition ledger written by
+// `disposition-ledger.js`. Emits either a human-readable table (one
+// AC per line) or a JSON dump.
+
+import { readLedger, ledgerRelPath } from './disposition-ledger.js';
+
+/**
+ * @param {object} args
+ * @param {string} args.projectRoot
+ * @param {string} args.slug
+ * @param {boolean} [args.asJson]
+ * @returns {Promise<{ output: string, exitCode: number }>}
+ */
+export async function renderDispositions({ projectRoot, slug, asJson = false }) {
+  const doc = await readLedger(projectRoot, slug);
+  if (!doc) {
+    if (asJson) {
+      return {
+        output: `${JSON.stringify({ slug, present: false, ledgerPath: ledgerRelPath(slug), records: [] }, null, 2)}\n`,
+        exitCode: 0,
+      };
+    }
+    return {
+      output: `[blueprint] no disposition ledger found for '${slug}' at ${ledgerRelPath(slug)}\n`,
+      exitCode: 0,
+    };
+  }
+  if (asJson) {
+    return {
+      output: `${JSON.stringify({ slug, present: true, ledgerPath: ledgerRelPath(slug), records: doc.records }, null, 2)}\n`,
+      exitCode: 0,
+    };
+  }
+  const lines = [`[blueprint] '${slug}' disposition ledger (${doc.records.length} record(s)) at ${ledgerRelPath(slug)}:`];
+  for (const rec of doc.records) {
+    const parts = [rec.acId, rec.storyId, rec.action];
+    if (rec.reason) parts.push(`reason: ${rec.reason}`);
+    if (rec.resolvedAt) parts.push(`resolvedAt: ${rec.resolvedAt}`);
+    if (rec.escalatedAt) parts.push(`escalatedAt: ${rec.escalatedAt}`);
+    lines.push(`  ${parts.join('  ')}`);
+  }
+  return { output: `${lines.join('\n')}\n`, exitCode: 0 };
+}

package/src/blueprint/index.js

@@ -62,3 +62,22 @@ export {
   parseUstar,
   sha256Hex,
 } from './library-fetcher-tarball.js';
+export {
+  loadForLint,
+  loadSuppressions,
+  runLint,
+  runPass1,
+  runPass2,
+} from './consistency-lint.js';
+export {
+  APPLY_DISPOSITION_PROMPT,
+  LEDGER_SCHEMA_NOTE,
+  initialiseLedger,
+  ledgerAbsPath,
+  ledgerExists,
+  ledgerRelPath,
+  readLedger,
+  upsertLedgerRecord,
+  writeLedger,
+} from './disposition-ledger.js';
+export { renderDispositions } from './dispositions.js';

package/src/browser-verify/manifest-writer.js

@@ -94,7 +94,10 @@ export function composeBrowserVerificationRecord({
   invariantChecks, authSmokeChecks = [], probePacks = [], notes, now = new Date(),
 }) {
   const id = nextBrowserVerificationId(manifest, fbsId);
-  const verdict = aggregateVerdict(invariantChecks, authSmokeChecks, probePacks);
+  const composedProbePacks = Array.isArray(probePacks)
+    ? probePacks.map(remapPackForPositiveEvidence)
+    : probePacks;
+  const verdict = aggregateVerdict(invariantChecks, authSmokeChecks, composedProbePacks);
   const record = {
     id,
     fbsId,
@@ -107,11 +110,59 @@ export function composeBrowserVerificationRecord({
     verdict,
   };
   if (authSmokeChecks && authSmokeChecks.length > 0) record.authSmokeChecks = authSmokeChecks;
-  if (Array.isArray(probePacks) && probePacks.length > 0) record.probePacks = probePacks;
+  if (Array.isArray(composedProbePacks) && composedProbePacks.length > 0) record.probePacks = composedProbePacks;
   if (typeof notes === 'string' && notes.length > 0) record.notes = notes;
   return record;
 }
 
+/**
+ * Positive-evidence remap (authoring standard section 7d / section 8c).
+ *
+ * A `checks[]` or `preChecks[]` record with `verdict: 'pass'` is legal
+ * only when it carries either an `evidence` field of one of the four
+ * shapes named in section 7d (a request id, a response body excerpt, a
+ * created-then-deleted resource id in an inventory diff, or a
+ * rendered-bytes hash), or an `accountBoundSkipped: true` field with a
+ * non-empty `reason`. A pass record with neither is remapped to
+ * `verdict: 'fail'` with `detail: 'positive-evidence-missing'` at
+ * record-composition time; the composed record is what the manifest
+ * carries so the fail surfaces at the ship gate.
+ *
+ * @param {object} pack
+ * @returns {object}
+ */
+function remapPackForPositiveEvidence(pack) {
+  if (!pack || typeof pack !== 'object') return pack;
+  const nextPack = { ...pack };
+  if (Array.isArray(pack.checks)) {
+    nextPack.checks = pack.checks.map(remapCheckForPositiveEvidence);
+  }
+  if (Array.isArray(pack.preChecks)) {
+    nextPack.preChecks = pack.preChecks.map(remapCheckForPositiveEvidence);
+  }
+  return nextPack;
+}
+
+function remapCheckForPositiveEvidence(check) {
+  if (!check || typeof check !== 'object') return check;
+  if (check.verdict !== 'pass') return check;
+  if (checkCarriesPositiveEvidence(check)) return check;
+  return { ...check, verdict: 'fail', detail: 'positive-evidence-missing' };
+}
+
+function checkCarriesPositiveEvidence(check) {
+  if (check.accountBoundSkipped === true) {
+    const reason = check.reason;
+    if (typeof reason === 'string' && reason.length > 0) return true;
+    return false;
+  }
+  if (check.evidence != null) {
+    if (typeof check.evidence === 'string') return check.evidence.length > 0;
+    if (typeof check.evidence === 'object') return true;
+  }
+  return false;
+}
+
 function stripSeverity(check) {
   const out = { invariant: check.invariant, verdict: check.verdict };
   if (typeof check.detail === 'string' && check.detail.length > 0) out.detail = check.detail;

package/src/browser-verify/pack-runner.js

@@ -81,10 +81,16 @@ export async function runProbePacksForFbs({
     for (const pre of pack.preChecks) {
       let verdict = 'pass';
       let detail;
+      let preEvidence;
+      let preAccountBoundSkipped;
+      let preReason;
       try {
         const outcome = await pre.run({ fbs, uiBaseline, manifest, runtimeUrl, fetch, browser });
         verdict = outcome?.verdict ?? 'pass';
         detail = outcome?.detail;
+        preEvidence = outcome?.evidence;
+        preAccountBoundSkipped = outcome?.accountBoundSkipped;
+        preReason = outcome?.reason;
       } catch (err) {
         verdict = 'fail';
         detail = `pre-check threw: ${err.message}`;
@@ -94,6 +100,9 @@ export async function runProbePacksForFbs({
         verdict,
         severity: pre.severity,
         ...(typeof detail === 'string' && detail.length > 0 ? { detail } : {}),
+        ...(preEvidence != null ? { evidence: preEvidence } : {}),
+        ...(preAccountBoundSkipped === true ? { accountBoundSkipped: true } : {}),
+        ...(typeof preReason === 'string' && preReason.length > 0 ? { reason: preReason } : {}),
       });
       if (verdict === 'fail') failedPreCheckIds.add(pre.id);
       if (verdict === 'fail' && pre.severity === 'block') highest = 'block';
@@ -154,10 +163,16 @@ export async function runProbePacksForFbs({
         : { browser, fetch, runtimeUrl, route: primaryRoute, theme: primaryTheme, projectRoot };
       let verdict = 'pass';
       let detail;
+      let checkEvidence;
+      let checkAccountBoundSkipped;
+      let checkReason;
       try {
         const outcome = await check.run(context);
         verdict = outcome?.verdict ?? 'pass';
         detail = outcome?.detail;
+        checkEvidence = outcome?.evidence;
+        checkAccountBoundSkipped = outcome?.accountBoundSkipped;
+        checkReason = outcome?.reason;
       } catch (err) {
         verdict = 'fail';
         detail = `check threw: ${err.message}`;
@@ -167,6 +182,9 @@ export async function runProbePacksForFbs({
         verdict,
         severity: check.severity,
         ...(typeof detail === 'string' && detail.length > 0 ? { detail } : {}),
+        ...(checkEvidence != null ? { evidence: checkEvidence } : {}),
+        ...(checkAccountBoundSkipped === true ? { accountBoundSkipped: true } : {}),
+        ...(typeof checkReason === 'string' && checkReason.length > 0 ? { reason: checkReason } : {}),
       });
       if (verdict === 'fail' && check.severity === 'block') highest = 'block';
       else if (verdict === 'fail' && check.severity === 'warn' && highest !== 'block') highest = 'warn';

package/src/cli/blueprint.js

@@ -36,6 +36,12 @@ import {
 } from '../blueprint/index.js';
 import { conflictReportJson, renderConflictReport } from '../blueprint/conflicts.js';
 import { handleLibraryVerb, LIBRARY_HELP } from './blueprint-library.js';
+import {
+  loadForLint,
+  loadSuppressions,
+  runLint,
+  renderDispositions,
+} from '../blueprint/index.js';
 
 export const HELP = `Usage: rcf define blueprint <verb> [options]
 
@@ -115,6 +121,23 @@ Verbs:
                          'rcf define blueprint library --help' for the
                          full surface. Phase 2b covers local sources;
                          network fetchers land in Phase 2c.
+  lint-consistency <source>
+                         Run the single-definition ownership and REQ
+                         delivery lint over one blueprint source (pass 1
+                         catches literals restated outside their owning
+                         TAC; pass 2 catches REQs promising properties
+                         with no delivering TAC or ADR). Exit 0 on
+                         clean, exit 3 on unsuppressed findings, exit 2
+                         on usage error. --json emits the machine
+                         envelope; pass-1 findings are suppressible via
+                         a "Known chain-consistency-lint suppressions"
+                         section in the blueprint README (see spec
+                         section 5.8).
+  dispositions <slug>    Read the per-slug disposition ledger at
+                         rcf/blueprints/<slug>.disposition.json. Prints
+                         one line per contributed AC with its recorded
+                         disposition; --json emits the raw ledger.
+                         Read-only.
 
 Options:
   --namespace <slug>     Override the blueprint's default namespace
@@ -204,6 +227,11 @@ const OPTION_SPEC = {
   'allow-no-queue-yet': { type: 'boolean' },
   answer: { type: 'string', multiple: true },
   answers: { type: 'string' },
+  // Integration and contradiction protocol (spec 2026-09-09 section
+  // 3.6 and 7.1): the operator (or the wrapping harness) can suppress
+  // the disposition prompt printed after a fresh apply. The ledger is
+  // still written; only the human-facing prompt line is skipped.
+  'no-disposition-prompt': { type: 'boolean' },
 };
 
 /**
@@ -244,6 +272,14 @@ export async function main(argv, deps = {}) {
     return handleLibraryVerb(parsed, rest, { stdout, stderr, cwd, now, stdin: deps.stdin });
   }
 
+  // `lint-consistency <source>` runs over a blueprint source directory
+  // and does not require an rcf/ tree; wire it before the projectRoot
+  // walk so it stays usable from a fresh clone (and from the shipping
+  // CI gate).
+  if (verb === 'lint-consistency') {
+    return handleLintConsistencyVerb({ rest, parsed, cwd, stdout, stderr });
+  }
+
   const projectRoot = await findProjectRoot(cwd);
   if (!projectRoot) {
     stderr.write('[error] no rcf/ tree found in this directory or any ancestor.\n');
@@ -433,6 +469,13 @@ export async function main(argv, deps = {}) {
     }
     if (!parsed.values.quiet) {
       stdout.write(`[blueprint] applied '${result.slug}' at ${result.version} (${result.contributions.length} contribution(s)).\n`);
+      // Disposition prompt (spec section 3.6 + 3.7). Printed once per
+      // fresh apply; a re-apply on the same slug omits it because the
+      // ledger is left untouched. Suppressible with the CLI flag
+      // --no-disposition-prompt.
+      if (result.dispositionPrompt && parsed.values['no-disposition-prompt'] !== true) {
+        stdout.write(`${result.dispositionPrompt}\n`);
+      }
     }
     // Companion-suggestion mechanism (spec 2.6). Runs AFTER the apply
     // writes so a failed apply never produces a suggestion block.
@@ -614,6 +657,17 @@ export async function main(argv, deps = {}) {
     });
   }
 
+  if (verb === 'dispositions') {
+    if (rest.length === 0) {
+      stderr.write('[error] blueprint dispositions: missing <slug>\n');
+      return 2;
+    }
+    const slug = rest[0];
+    const rendered = await renderDispositions({ projectRoot, slug, asJson: parsed.values.json === true });
+    stdout.write(rendered.output);
+    return rendered.exitCode;
+  }
+
   stderr.write(`[error] blueprint: unknown verb '${verb}'\n`);
   stderr.write(HELP);
   return 2;
@@ -850,6 +904,55 @@ function parseResolveOptions(rawList, reason) {
  * @param {{ stdin: NodeJS.ReadableStream, stdout: NodeJS.WritableStream }} deps
  * @returns {Promise<(prompt: string) => Promise<string>>}
  */
+/**
+ * `rcf define blueprint lint-consistency <source>` handler. Resolves
+ * <source> (path or shelf slug), loads the blueprint via loadForLint,
+ * reads any suppressions in the blueprint's README, runs both passes,
+ * and prints either a human summary or a JSON envelope.
+ *
+ * Exit codes:
+ *   0 clean (or every finding suppressed)
+ *   2 usage error / cannot resolve source
+ *   3 unsuppressed findings
+ */
+async function handleLintConsistencyVerb({ rest, parsed, cwd, stdout, stderr }) {
+  if (rest.length === 0) {
+    stderr.write('[error] blueprint lint-consistency: missing <source>\n');
+    return 2;
+  }
+  const rawSource = rest[0];
+  // Reuse the shipping shelf resolver so a bare slug (edge-cloudflare-turnstile)
+  // or a @stock/<slug> reference resolves to the packaged shelf, and a
+  // path resolves relative to cwd.
+  const resolved = await resolveBlueprintSource(rawSource, { projectRoot: cwd });
+  if (isRcfError(resolved)) {
+    stderr.write(`[error] blueprint lint-consistency: ${resolved.message}\n`);
+    return 2;
+  }
+  const sourcePath = resolved.resolved;
+  const loaded = await loadForLint(sourcePath);
+  if ('error' in loaded) {
+    stderr.write(`[error] blueprint lint-consistency: ${loaded.error}\n`);
+    return 2;
+  }
+  const suppressions = await loadSuppressions(sourcePath);
+  const result = runLint(loaded, suppressions);
+  const asJson = parsed.values.json === true;
+  if (asJson) {
+    stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  } else {
+    stdout.write(`[blueprint] lint-consistency '${result.blueprint}': ${result.verdict} `
+      + `(pass1=${result.passCounts.pass1}, pass2=${result.passCounts.pass2}, `
+      + `suppressed=${result.passCounts.suppressed})\n`);
+    for (const f of result.findings) {
+      const tag = f.suppressed ? '[suppressed]' : '[finding]';
+      stdout.write(`  ${tag} ${f.id} (${f.pass}, ${f.kind}): ${f.message}\n`);
+      if (f.suppressed && f.suppressionReason) stdout.write(`     reason: ${f.suppressionReason}\n`);
+    }
+  }
+  return result.verdict === 'pass' ? 0 : 3;
+}
+
 async function createCustomAuthReadLine({ stdin, stdout }) {
   const { createInterface } = await import('node:readline');
   const rl = createInterface({ input: stdin, output: stdout, terminal: true });

package/src/setup/identity-seed.js

@@ -57,6 +57,24 @@ _(how you like to work: casual or formal register, verbose or terse
 responses, willingness to be pushed back on, anything the agent should
 know before choosing its default posture)_
 
+## Register
+
+_(how the agent should frame decisions when it needs your ruling. One
+of the three values below on a single line; a line that reads only
+\`unstated\` is fine and reads as productOwner on the first
+escalation.)_
+
+- \`productOwner\`: escalations arrive as one plain-English sentence
+  naming the decision and its consequences, then two or three named
+  choices with what each costs. No method vocabulary, no document ids.
+- \`engineer\`: escalations name the AC id, quote the seed's assertion,
+  quote the project convention that conflicts, and ask a direct
+  question. Fluent in the method vocabulary.
+- \`unstated\`: the agent asks you which register on the first
+  exchange after init and holds \`productOwner\` in the meantime.
+
+unstated
+
 ## Project-scoped notes
 
 _(anything specific to this project that would be useful for the agent