pincer-workflow 0.5.0 → 0.7.0

package/template/scripts/pincer-runtime/migrate.cjs

@@ -1,45 +1,68 @@
 'use strict';
 // PINCER runtime — migration (docs/runtime-contracts.md, "Migration and
-// rollback"). Preview is read-only; apply backs up every authored file it
-// changes, strips legacy receipts into the binding's legacy_receipts (history,
-// never runtime evidence), ignores .pincer/, and writes the binding last.
-// Conflicts fail closed before the first write; repeated apply is a no-op.
+// rollback"). Preview is read-only; apply is one transaction that backs up every
+// authored file it changes, strips legacy receipts into the change record's
+// `legacy.receipts` (history, never runtime evidence), converts a v0.5.0 schema 1
+// binding into a schema 2 record (same id, base and registration; the free-text
+// authorization retained as unvalidated history), rewrites the local candidate
+// pointers that no longer resolve, ignores .pincer/, and selects the change in
+// this worktree. The migrated change is planned with no authorization; existing
+// attempts and evaluations stay history until verified again. Conflicts fail
+// closed before the first write; repeated apply is a no-op.
 const fs = require('node:fs');
 const path = require('node:path');
 const parse = require('./parse.cjs');
 const identity = require('./identity.cjs');
+const changes = require('./changes.cjs');
 const statusModule = require('./status.cjs');
+const state = require('./state.cjs');
+const transaction = require('./transaction.cjs');
 const { fmUnset } = require('./lifecycle.cjs');
-const { nowIso, atomicWrite } = require('./fsutil.cjs');
+const { nowIso, readJson } = require('./fsutil.cjs');
 
 const IGNORE_LINE = '.pincer/';
+const gitignoreHas = root => changes.gitignoreHas(fs.existsSync(path.join(root, '.gitignore')) ? fs.readFileSync(path.join(root, '.gitignore'), 'utf8') : '');
+const OLD_CANDIDATE_KEY = /^candidate:([0-9a-f]{40}):(C-[0-9]{2,6})$/;
 
-function gitignoreHas(root) {
-  const file = path.join(root, '.gitignore');
-  if (!fs.existsSync(file)) return false;
-  return fs.readFileSync(file, 'utf8').split('\n').map(l => l.trim()).some(l => l === IGNORE_LINE || l === '/.pincer/' || l === '.pincer');
-}
-
-// Compute the plan. Returns { prd, change, conflicts: [{code, detail}], binding:
-// { file, exists, action }, tickets: [{file, id, verified, last_check}],
-// gitignore: boolean (needs the line), alreadyMigrated }.
+// Compute the plan. Returns { prd, change, source: 'legacy' | 'binding' | 'record',
+// conflicts, binding: { file, existing, action }, tickets, gitignore, index,
+// selection, alreadyMigrated, partial, authorization }.
 function plan(root, { prd, change, authorization = null } = {}) {
   const conflicts = [];
   const conflict = (code, detail) => conflicts.push({ code, detail });
   const prdResult = parse.validatePrd(root, prd);
   if (!prdResult.ok) { conflict('INPUT_INVALID', `${prdResult.file || prd}: ${prdResult.problems[0]}`); return { prd, conflicts }; }
-  const id = change || `prd-v${prd.match(parse.PRD_REF)[1]}`;
-  if (!identity.CHANGE_ID.test(id)) conflict('INPUT_INVALID', `change ID must match [a-z0-9][a-z0-9-]{0,63}: ${id}`);
+  let id = change || `prd-v${prd.match(parse.PRD_REF)[1]}`;
+  if (!changes.CHANGE_ID.test(id)) conflict('INPUT_INVALID', `change ID must match [a-z0-9][a-z0-9-]{0,63}: ${id}`);
   if (!identity.head(root)) conflict('UNSUPPORTED_INPUT', 'migration needs a git repository with at least one commit');
-  const bindings = identity.listBindings(root);
-  let existing = null;
-  if (bindings.length > 1) conflict('AMBIGUOUS', `several change bindings under .prd/changes/ (${bindings.map(b => path.basename(b)).join(', ')}); keep exactly one`);
-  else if (bindings.length === 1) {
-    const loaded = identity.loadBinding(root, { prd });
-    if (loaded.code && loaded.code !== 'REVISION_CHANGED' && !loaded.other) conflict(loaded.code === 'UNSUPPORTED_SCHEMA' ? 'UNSUPPORTED_SCHEMA' : 'INPUT_INVALID', loaded.problem);
-    else if (loaded.other) conflict('AMBIGUOUS', `${loaded.file} binds ${loaded.binding.prd}, not ${prd}; one change per worktree — register --replace or remove it first`);
-    else if (loaded.binding && loaded.binding.change !== id) conflict('AMBIGUOUS', `${loaded.file} already binds ${prd} as change "${loaded.binding.change}"; pass --change ${loaded.binding.change}`);
-    else existing = loaded.binding || null;
+  const scan = changes.scan(root);
+  let source = 'legacy', binding = null, existing = null, bindingFile = null;
+  if (scan.mode === 'invalid') for (const p of scan.problems) conflict(p.code, p.detail);
+  else if (scan.mode === 'migrated') {
+    const bindings = scan.entries.filter(e => e.schema === 1);
+    const bad = scan.entries.filter(e => e.code);
+    if (bindings.length > 1 || bad.length) conflict('AMBIGUOUS', `several files under .prd/changes/ (${scan.entries.map(e => path.basename(e.file)).join(', ')}); keep exactly one v0.5.0 binding`);
+    else {
+      const b = bindings[0].doc;
+      const invalid = identity.validateBinding(b);
+      if (invalid) conflict(/schema|runtime contract/.test(invalid) ? 'UNSUPPORTED_SCHEMA' : 'INPUT_INVALID', `${bindings[0].file}: ${invalid}`);
+      else if (path.basename(bindings[0].file, '.json') !== b.change) conflict('INPUT_INVALID', `${bindings[0].file}: filename does not match change "${b.change}"`);
+      else if (b.prd !== prd) conflict('AMBIGUOUS', `${bindings[0].file} binds ${b.prd}, not ${prd}; a v0.5.0 binding is converted first — migrate it with: node scripts/pincer-runtime.cjs migrate --preview --prd ${b.prd}, then register ${prd}`);
+      else if (change && change !== b.change) conflict('AMBIGUOUS', `${bindings[0].file} already binds ${prd} as change "${b.change}"; pass --change ${b.change}`);
+      else { id = b.change; source = 'binding'; binding = b; bindingFile = bindings[0].file; }
+    }
+  } else if (scan.mode === 'changes') {
+    const loaded = changes.loadRecords(root);
+    for (const p of loaded.problems) conflict(p.code, p.detail);
+    if (!loaded.problems.length) {
+      const owner = changes.ownerOf(loaded, prd);
+      if (owner && owner[0] !== id) conflict('INPUT_INVALID', `${prd} is owned by change "${owner[0]}" (${owner[1].file}); pass --change ${owner[0]}`);
+      else {
+        const rec = loaded.records.get(id);
+        if (rec && rec.record.prd !== prd) conflict('INPUT_INVALID', `${rec.file} names change "${id}" for ${rec.record.prd}; choose another --change ID for ${prd}`);
+        else if (rec) { existing = rec; source = 'record'; }
+      }
+    }
   }
   const set = parse.validateTicketSet(root);
   if (!set.ok) conflict('INPUT_INVALID', `pincer-ticket: ${set.file ? `${set.file}: ` : ''}${set.problems[0]}`);
@@ -55,9 +78,26 @@ function plan(root, { prd, change, authorization = null } = {}) {
     }
   }
   const gitignore = !gitignoreHas(root);
-  const alreadyMigrated = Boolean(existing) && tickets.length === 0 && !gitignore;
-  const partial = Boolean(existing) && tickets.length > 0;
-  return { prd, change: id, authorization, conflicts, binding: { file: `.prd/changes/${id}.json`, exists: Boolean(existing), existing, action: existing ? (partial ? 'complete' : 'keep') : 'register' }, tickets, gitignore, alreadyMigrated, partial };
+  // Local pointers of a converted binding: candidate keys gain the change segment.
+  let index = null;
+  if (source === 'binding' && state.exists(root)) {
+    const read = state.readIndex(root);
+    if (read.error) conflict('INPUT_INVALID', read.error);
+    else {
+      const stale = Object.keys(read.index.current).filter(k => OLD_CANDIDATE_KEY.test(k));
+      if (stale.length) index = { stale, doc: read.index };
+    }
+  }
+  const sel = changes.readSelection(root);
+  const selection = sel.code || sel.change !== id ? id : null;
+  const alreadyMigrated = source === 'record' && tickets.length === 0 && !gitignore;
+  const partial = source === 'record' && tickets.length > 0;
+  return {
+    prd, change: id, source, authorization, conflicts, bindingFile,
+    binding: { file: changes.recordFile(id), existing: existing ? existing.record : binding, bindingFile, action: source === 'binding' ? 'convert' : source === 'record' ? (partial ? 'complete' : 'keep') : 'register' },
+    tickets, gitignore, index, selection, alreadyMigrated, partial,
+    historical: { attempts: state.exists(root) ? state.listAttempts(root).filter(a => a.schema === 1).length : 0 },
+  };
 }
 
 function renderPlan(p) {
@@ -68,23 +108,33 @@ function renderPlan(p) {
     return lines.join('\n') + '\n';
   }
   lines.push(`migration plan for ${p.prd} (change ${p.change})`);
-  if (p.alreadyMigrated) { lines.push('  already migrated: binding present, no legacy receipts remain, .pincer/ ignored'); return lines.join('\n') + '\n'; }
-  if (p.partial) lines.push('  note      an earlier migration was partially applied (binding present, receipts remain); apply completes it');
-  lines.push(`  binding   ${p.binding.file} (${p.binding.exists ? 'present, legacy_receipts extended' : 'new; base = HEAD'})`);
-  for (const t of p.tickets) lines.push(`  ticket    ${t.file}: remove ${[t.verified ? 'verified' : null, t.last_check ? 'last_check' : null].filter(Boolean).join(', ')} → legacy_receipts[${t.id}] (history, not runtime evidence)`);
+  if (p.alreadyMigrated) { lines.push('  already migrated: change record present, no legacy receipts remain, .pincer/ ignored'); if (p.selection) lines.push(`  selection .pincer/runtime/selection.json → ${p.change} is not set in this worktree; select with: node scripts/pincer-runtime.cjs change select ${p.change}`); return lines.join('\n') + '\n'; }
+  if (p.source === 'binding') {
+    const b = p.binding.existing;
+    lines.push(`  binding   ${p.bindingFile || p.binding.file} (v0.5.0, schema 1) → change record (schema 2) at the same path: change ${b.change}, base ${b.base.slice(0, 7)} and registration ${b.registered} kept; ${Object.keys(b.legacy_receipts).length} receipt(s) already imported carried over`);
+    if (b.authorization) lines.push(`  note      the binding's authorization text "${b.authorization}" is retained as legacy.authorization_text (unvalidated history); it never authorizes execution`);
+  } else if (p.source === 'record') lines.push(`  record    ${p.binding.file} (present; ${p.tickets.length} receipt(s) imported into legacy.receipts by a migrate event)`);
+  else lines.push(`  record    ${p.binding.file} (new schema 2 record; base = HEAD; planned)`);
+  if (p.partial) lines.push('  note      an earlier migration was partially applied (record present, receipts remain); apply completes it');
+  for (const t of p.tickets) lines.push(`  ticket    ${t.file}: remove ${[t.verified ? 'verified' : null, t.last_check ? 'last_check' : null].filter(Boolean).join(', ')} → legacy.receipts[${t.id}] (history, not runtime evidence)`);
   if (!p.tickets.length) lines.push('  tickets   no legacy receipts to import');
   lines.push(p.gitignore ? `  gitignore add \`${IGNORE_LINE}\`` : '  gitignore already ignores .pincer/');
-  lines.push(`  backups   .pincer/backups/<timestamp>/ for every changed authored file`);
-  if (!p.authorization) lines.push('  note      no --authorization given; registration does not prove human approval');
+  if (p.index) lines.push(`  index     .pincer/runtime/index.json: ${p.index.stale.length} candidate pointer(s) dropped — a v0.5.0 attempt record cannot satisfy the change-scoped key, so its check is run again (attempt records untouched, kept as history)`);
+  lines.push(`  history   ${p.historical.attempts} existing attempt(s) and any saved evaluation stay history (HISTORICAL_EVIDENCE) until verified again; the change is planned with no authorization`);
+  if (p.selection) lines.push(`  selection .pincer/runtime/selection.json → ${p.change} (this worktree only; a fresh clone selects explicitly)`);
+  lines.push('  backups   .pincer/backups/<timestamp>/ for every changed authored file (tickets, .gitignore, the binding, the local index)');
+  if (p.authorization) lines.push(`  note      --authorization "${p.authorization}" is retained as legacy.authorization_text (unvalidated history); record the user's actual instruction afterwards with: node scripts/pincer-runtime.cjs change authorize ${p.change} --agreement <digest> --reference <text> --excerpt <text>`);
+  else if (!(p.source === 'binding' && p.binding.existing.authorization)) lines.push(`  note      no --authorization given; migration grants no authorization — record the user's instruction afterwards with: node scripts/pincer-runtime.cjs change authorize ${p.change} …`);
   lines.push(`apply with: node scripts/pincer-runtime.cjs migrate --apply --prd ${p.prd}${p.change !== `prd-v${p.prd.match(parse.PRD_REF)[1]}` ? ` --change ${p.change}` : ''}`);
   return lines.join('\n') + '\n';
 }
 
-// Apply the plan: backups, tickets, .gitignore, then the binding last.
+// Apply the plan as one transaction: backups first (copies of the originals),
+// then tickets, .gitignore, the record, the index and the selection together.
 function apply(root, options) {
-  const p = plan(root, options);
-  if (p.conflicts.length) return { plan: p, applied: false };
-  if (p.alreadyMigrated) return { plan: p, applied: false, already: true };
+  const first = plan(root, options);
+  if (first.conflicts.length) return { plan: first, applied: false };
+  if (first.alreadyMigrated) return { plan: first, applied: false, already: true };
   const stamp = nowIso().replace(/[-:]/g, '');
   const backupDir = path.join(root, '.pincer', 'backups', stamp);
   const backups = [];
@@ -96,32 +146,59 @@ function apply(root, options) {
     fs.copyFileSync(src, dest);
     backups.push(`.pincer/backups/${stamp}/${rel}`);
   };
-  const receipts = {};
-  for (const t of p.tickets) {
-    backup(t.file);
-    receipts[t.id] = { verified: t.verified, last_check: t.last_check };
-    let text = fmUnset(t.text, 'verified');
-    text = fmUnset(text, 'last_check');
-    atomicWrite(path.join(root, t.file), text);
-  }
-  if (p.gitignore) {
-    backup('.gitignore');
-    const file = path.join(root, '.gitignore');
-    const existing = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-    const lead = existing && !existing.endsWith('\n') ? '\n' : '';
-    fs.appendFileSync(file, `${lead}${existing ? '\n' : ''}# pincer runtime state (added by migrate)\n${IGNORE_LINE}\n`);
-  }
-  let binding;
-  if (p.binding.existing) {
-    binding = { ...p.binding.existing, legacy_receipts: { ...p.binding.existing.legacy_receipts, ...receipts } };
-    if (options.authorization) binding.authorization = options.authorization;
-  } else {
-    const registered = identity.register(root, { prd: p.prd, change: p.change, authorization: options.authorization || null });
-    if (registered.code) return { plan: p, applied: false, error: registered.problem, backups };
-    binding = { ...registered.binding, legacy_receipts: receipts };
+  try {
+    const out = transaction.run(root, { command: `migrate --apply ${options.prd}`, hooks: options.hooks || null }, ctx => {
+      const p = plan(root, options);
+      if (p.conflicts.length) ctx.refuse(p.conflicts[0].code, p.conflicts[0].detail);
+      if (p.alreadyMigrated) return { plan: p, already: true };
+      for (const t of p.tickets) backup(t.file);
+      if (p.gitignore) backup('.gitignore');
+      if (p.source === 'binding') backup(p.bindingFile);
+      if (p.index) backup(`${state.RUNTIME_DIR}/index.json`);
+      const receipts = {};
+      for (const t of p.tickets) {
+        receipts[t.id] = { verified: t.verified, last_check: t.last_check };
+        ctx.write(t.file, fmUnset(fmUnset(t.text, 'verified'), 'last_check'));
+      }
+      if (p.gitignore) {
+        const existing = ctx.text('.gitignore') || '';
+        const lead = existing && !existing.endsWith('\n') ? '\n' : '';
+        ctx.write('.gitignore', `${existing}${lead}${existing ? '\n' : ''}# pincer runtime state (added by migrate)\n${IGNORE_LINE}\n`);
+      }
+      let record;
+      if (p.source === 'record') {
+        record = JSON.parse(JSON.stringify(p.binding.existing));
+        record.legacy.receipts = { ...record.legacy.receipts, ...receipts };
+        if (options.authorization) record.legacy.authorization_text = options.authorization;
+        const sequence = record.sequence + 1;
+        record.events.push({ sequence, kind: 'migrate', from: record.lifecycle.state, to: record.lifecycle.state, at: ctx.now, reason: null, agreement: null, authorization: null, decision: null, replacement: null, note: `${Object.keys(receipts).length} legacy receipt(s) imported` });
+        record.sequence = sequence;
+      } else if (p.source === 'binding') {
+        const b = p.binding.existing;
+        record = changes.newRecord({ change: b.change, prd: b.prd, base: b.base, now: ctx.now, kind: 'migrate', legacy: { receipts: { ...b.legacy_receipts, ...receipts }, authorization_text: options.authorization || b.authorization || null, migrated_from: 'binding', migrated: ctx.now } });
+        record.registered = b.registered;
+        record.events[0].note = `converted from the v0.5.0 binding (registered ${b.registered})`;
+      } else {
+        record = changes.newRecord({ change: p.change, prd: p.prd, base: identity.head(root), now: ctx.now, kind: 'migrate', legacy: { receipts, authorization_text: options.authorization || null, migrated_from: 'legacy', migrated: ctx.now } });
+      }
+      const invalid = changes.validateRecord(record, p.binding.file);
+      if (invalid) ctx.refuse(invalid.code, invalid.problem);
+      ctx.write(p.binding.file, record);
+      if (p.index) {
+        const doc = p.index.doc;
+        for (const key of p.index.stale) delete doc.current[key];
+        ctx.write(`${state.RUNTIME_DIR}/index.json`, doc);
+      }
+      if (p.selection) ctx.write(changes.SELECTION_FILE, { schema: 1, change: p.change, selected: ctx.now });
+      return { plan: p, record };
+    });
+    if (out.result.already) return { plan: out.result.plan, applied: false, already: true };
+    return { plan: out.result.plan, applied: true, record: out.result.record, backups, backupDir: backups.length ? `.pincer/backups/${stamp}/` : null };
+  } catch (error) {
+    if (error.refusal) return { plan: first, applied: false, error: error.message, code: error.code, backups };
+    if (error.code === 'STATE_BUSY') return { plan: first, applied: false, error: error.message, code: 'STATE_BUSY', backups };
+    throw error;
   }
-  identity.writeBinding(root, binding);
-  return { plan: p, applied: true, binding, backups, backupDir: backups.length ? `.pincer/backups/${stamp}/` : null };
 }
 
 module.exports = { plan, renderPlan, apply, IGNORE_LINE, gitignoreHas };

package/template/scripts/pincer-runtime/parse.cjs

@@ -252,6 +252,25 @@ function normalizePrd(text) {
   }
   return `${out.join('\n')}\n`;
 }
+// Split a ticket text into the parts the structural agreement difference names:
+// the frontmatter, the Acceptance Criteria section, the Verification section and
+// everything else (headings inside fenced blocks are ignored, as elsewhere).
+function ticketSections(text) {
+  const rows = lines(text);
+  const parts = { frontmatter: [], acceptance: [], verification: [], other: [] };
+  let inFront = rows[0] === '---', section = 'other', fence = false;
+  for (let i = 0; i < rows.length; i++) {
+    const line = rows[i];
+    if (inFront) { parts.frontmatter.push(line); if (i > 0 && line === '---') inFront = false; continue; }
+    if (fence) { parts[section].push(line); if (/^[ \t]*```/.test(line)) fence = false; continue; }
+    if (/^[ \t]*```/.test(line)) { fence = true; parts[section].push(line); continue; }
+    if (/^## Acceptance Criteria[ \t]*$/.test(line)) section = 'acceptance';
+    else if (/^## Verification[ \t]*$/.test(line)) section = 'verification';
+    else if (/^## /.test(line)) section = 'other';
+    parts[section].push(line);
+  }
+  return Object.fromEntries(Object.entries(parts).map(([k, v]) => [k, v.join('\n')]));
+}
 const ticketDigest = text => sha256(normalizeTicket(text));
 const prdDigest = text => sha256(normalizePrd(text));
 const checkDigest = (text, timeoutSeconds = DEFAULT_TIMEOUT) => sha256(`${blockText(text)}timeout=${timeoutSeconds}\n`);
@@ -292,6 +311,6 @@ module.exports = {
   sha256, lines, normalizeId, canonicalId, parseFrontmatter, frontmatterField,
   verificationCommands, blockText, legacyBlockHash, unticked, effectiveTimeout,
   validateTicket, dependencies, validateMetadata, validatePrd,
-  normalizeTicket, normalizePrd, ticketDigest, prdDigest, checkDigest,
+  normalizeTicket, normalizePrd, ticketDigest, prdDigest, checkDigest, ticketSections,
   ticketFiles, ticketFile, validateTicketSet,
 };

package/template/scripts/pincer-runtime/phases.cjs

@@ -0,0 +1,245 @@
+'use strict';
+// PINCER runtime — phase-specific coverage (docs/runtime-contracts.md, "Strict
+// coverage" → "Phase-specific coverage"). One pure computation over the validated
+// graph, consumed by `coverage`, `change complete`, `evidence export`, `ready`,
+// status and resume: `structure` (every obligation linked or authorized as not
+// delivered, nothing missing from the baseline), `implementation` (structure plus
+// every ticket done and ready under the v5 rules) and `candidate` (the evaluated
+// candidate's reconciled evidence). The three are separate fields; none implies
+// another, and a linked check, a done ticket or a passing syntax check never
+// becomes a delivery or adequacy verdict. A change without the capability is
+// labeled `unverified`. Nothing here writes, launches or judges semantics.
+const changes = require('./changes.cjs');
+const routing = require('./routing.cjs');
+const agreement = require('./agreement.cjs');
+const authorization = require('./authorization.cjs');
+const coverage = require('./coverage.cjs');
+const dispositions = require('./dispositions.cjs');
+const requirements = require('./requirements.cjs');
+const locator = require('./locator.cjs');
+const state = require('./state.cjs');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const STRUCTURE_ORDER = ['INPUT_INVALID', 'INVENTORY_INVALID', 'COVERAGE_INVALID', 'COVERAGE_INCOMPLETE', 'SCOPE_UNAUTHORIZED', 'OBLIGATION_MISSING'];
+const byOrder = (a, b) => STRUCTURE_ORDER.indexOf(a.code) - STRUCTURE_ORDER.indexOf(b.code);
+
+const unverified = reason => ({ strict: false, label: 'unverified', reason, inventory: null, map: null, graph: null, scope: [], structure: null, implementation: null, candidate: null, blockers: [] });
+
+// compute(root, record, { gathered, verdict }) — `gathered` is status.render(...).gathered
+// for the record (computed here when absent); `verdict` the authorization verdict.
+function compute(root, record, { gathered = null, verdict = null } = {}) {
+  if (!record) return unverified('no change record');
+  if (!changes.isStrict(record)) return unverified(`strict coverage not adopted (node scripts/pincer-runtime.cjs coverage adopt --preview --change ${record.change})`);
+  const out = { strict: true, label: 'strict', reason: null, inventory: null, map: null, graph: null, scope: [], structure: { complete: false, problems: [] }, implementation: { complete: false, scenarios: {}, problems: [] }, candidate: { evaluated: false, candidate: null, manifest: null, delivery: null, adequacy: null, scenarios: {}, problems: [] }, blockers: [] };
+  const priorInventory = gid => agreement.inventoryOf(root, record, record.agreements.find(g => g.id === gid) || null);
+  const cov = coverage.load(root, record, { priorInventory });
+  out.inventory = cov.inventory ? { digest: cov.inventory.digest, requirements: Object.fromEntries(Object.entries(cov.inventory.requirements).map(([id, r]) => [id, { title: r.title, line: r.line, end: r.end, scenarios: r.scenarios }])), scenarios: Object.fromEntries(Object.entries(cov.inventory.scenarios).map(([id, s]) => [id, { requirement: s.requirement, line: s.line, end: s.end }])) } : null;
+  out.map = cov.map ? { path: cov.map.file, digest: cov.map.digest, checks: Object.fromEntries(Object.entries(cov.map.map.checks).map(([id, c]) => [id, { kind: c.kind, required: c.required, declared: coverage.definitionDigest(c) }])) } : null;
+  if (cov.code && cov.code !== 'COVERAGE_INCOMPLETE') {
+    out.structure.problems = cov.problems.map(detail => ({ code: cov.code, detail, ids: [] }));
+    out.blockers = out.structure.problems.map(p => ({ code: p.code, detail: p.detail }));
+    return out;
+  }
+  out.graph = cov.graph;
+  const v = verdict || authorization.verdict(root, record);
+  const scope = dispositions.scopeProblems(record, cov.graph, v);
+  out.scope = scope.resolved;
+  const problems = [...cov.graph.problems, ...scope.problems, ...dispositions.obligationProblems(dispositions.baseline(root, record), cov.inventory, cov.map.map)].sort(byOrder);
+  out.structure = { complete: problems.length === 0, problems };
+  // Implementation: every in-scope scenario's tickets done and ready; every ticket of the change done and ready.
+  const g = gathered || require('./status.cjs').render(root, { change: record.change }).gathered;
+  // A fresh clone (no local attempt history) of a completed change validates the saved
+  // candidate record only: a done ticket's missing local attempt is its stated limit, not
+  // unfinished work. Before completion the v5 rule holds: a fresh clone must verify.
+  const localUnavailable = !state.hasIndex(root) && record.lifecycle.state === 'completed';
+  out.implementation.limitations = localUnavailable ? ['local verification history unavailable; done tickets rely on the saved candidate evidence until verified here'] : [];
+  const ticketState = id => {
+    const t = g && g.tickets ? g.tickets.find(x => x.fields.ticket === id) : null;
+    if (!t) return { id, status: null, ready: false, code: 'EVIDENCE_MISSING', detail: 'no ticket file' };
+    const r = g.computeReadiness(t);
+    if (localUnavailable && t.fields.status === 'done' && !r.ready && r.reasons[0].code === 'EVIDENCE_MISSING') return { id, status: 'done', ready: true, code: null, detail: null, limitation: 'no local attempt history' };
+    return { id, status: t.fields.status, ready: r.ready, code: r.ready ? null : r.reasons[0].code, detail: r.ready ? null : `${r.reasons[0].detail} — ${r.reasons[0].next}` };
+  };
+  const implProblems = [];
+  const seen = new Set();
+  for (const id of requirements.sortIds(Object.keys(cov.graph.scenarios))) {
+    const s = cov.graph.scenarios[id];
+    const tickets = s.tickets.map(ticketState);
+    const unfinished = tickets.find(t => t.status !== 'done');
+    const unverifiedT = tickets.find(t => t.status === 'done' && !t.ready);
+    const state = unfinished ? 'unfinished' : unverifiedT ? 'unverified' : 'complete';
+    const detail = unfinished ? `${unfinished.id} is ${unfinished.status || 'missing'}, not done` : unverifiedT ? `${unverifiedT.id} ${unverifiedT.code}: ${unverifiedT.detail}` : null;
+    out.implementation.scenarios[id] = { scope: 'in-scope', requirement: s.requirement, implementation: state, tickets, checks: s.checks, detail };
+    if (state !== 'complete' && !seen.has(detail)) { seen.add(detail); implProblems.push({ code: unfinished ? 'LIFECYCLE_BLOCKED' : unverifiedT.code, detail: `${id}: ${detail}`, ids: [id, (unfinished || unverifiedT).id] }); }
+  }
+  for (const id of requirements.sortIds(Object.keys(cov.graph.scope))) {
+    const s = cov.graph.scope[id];
+    out.implementation.scenarios[id] = { scope: s.disposition, requirement: s.requirement, implementation: 'not applicable', tickets: [], checks: [], detail: `${s.disposition} by decision ${s.decision}` };
+  }
+  // Enabling tickets and any other ticket of the change must be done and ready too.
+  for (const id of Object.keys(cov.tickets || {})) {
+    const t = ticketState(id);
+    if (t.status === 'done' && t.ready) continue;
+    const detail = t.status !== 'done' ? `${id} is ${t.status}, not done` : `${id} ${t.code}: ${t.detail}`;
+    if (!implProblems.some(p => p.ids.includes(id))) implProblems.push({ code: t.status !== 'done' ? 'LIFECYCLE_BLOCKED' : t.code, detail, ids: [id] });
+  }
+  out.implementation.problems = implProblems;
+  out.implementation.complete = out.structure.complete && implProblems.length === 0;
+  candidateCoverage(root, record, out.candidate);
+  // A missing or stale evaluation blocks only a completed change: before completion no candidate is expected.
+  out.blockers = [...out.structure.problems, ...implProblems, ...(record.lifecycle.state === 'completed' ? out.candidate.problems : [])].map(p => ({ code: p.code, detail: p.detail }));
+  return out;
+}
+
+// Candidate coverage: the change's latest evaluation (schema 3) reconciled by the
+// locator, with per-scenario dispositions and the codes that block release.
+function candidateCoverage(root, record, out) {
+  const loc = locator.current(root, record);
+  if (loc.state === 'missing') { out.problems = [{ code: 'EVIDENCE_MISSING', detail: 'candidate: not evaluated', ids: [] }]; return; }
+  out.evaluated = true; out.candidate = loc.candidate || null; out.manifest = loc.manifest || null;
+  let m = null;
+  try { m = JSON.parse(fs.readFileSync(path.join(root, loc.manifest), 'utf8')); } catch { m = null; }
+  const problems = [];
+  if (loc.state === 'stale') problems.push({ code: 'CANDIDATE_STALE', detail: loc.text, ids: [] });
+  if (!m || m.schema !== 3) { problems.push({ code: 'EVIDENCE_MISSING', detail: `candidate evidence is ${m && m.schema ? `schema ${m.schema}` : 'unreadable'}, not the strict schema 3; evaluate again`, ids: [] }); out.problems = problems; return; }
+  const checkOf = Object.fromEntries((m.checks || []).filter(c => c && c.id).map(c => [c.id, c]));
+  for (const row of m.scenarios || []) {
+    if (!row || !row.id) continue;
+    const checks = (row.checks || []).map(id => { const c = checkOf[id] || {}; return { id, kind: c.kind || null, required: c.required ?? null, result: c.result || null }; });
+    const failing = checks.filter(c => c.required && c.result !== 'passed');
+    out.scenarios[row.id] = { disposition: row.disposition, checks, detail: row.disposition === 'blocked' ? `blocked by ${failing.map(c => `${c.id} (${c.kind} ${c.result || 'missing'})`).join(', ') || 'a missing check'}` : row.disposition === 'delivered' ? 'every required check passed' : `${row.disposition} by decision ${row.decision} (${row.authorization || 'unauthorized'})` };
+    for (const c of failing) problems.push({ code: c.kind === 'command' ? ({ failed: 'CHECK_FAILED', unverified: 'ATTEMPT_ERROR' }[c.result] || 'CHECK_FAILED') : 'REVIEW_MISSING', detail: `${row.id}: ${c.id} (${c.kind}) is ${c.result || 'missing'}`, ids: [row.id, c.id] });
+  }
+  out.delivery = m.delivery || null;
+  out.adequacy = m.adequacy || null;
+  if (!m.adequacy || m.adequacy.verdict !== 'adequate') problems.push({ code: 'ADEQUACY_REQUIRED', detail: m.adequacy ? `the reviewer judged the checks inadequate: ${m.adequacy.note}` : 'no adequacy judgment recorded', ids: [] });
+  out.problems = problems;
+}
+
+// The first blocking problem for a phase, in the contract's order, or null.
+function firstBlocker(report, phase) {
+  if (!report.strict) return null;
+  if (report.structure.problems.length) return report.structure.problems[0];
+  if (phase === 'structure') return null;
+  if (report.implementation.problems.length) return report.implementation.problems[0];
+  if (phase === 'implementation') return null;
+  return report.candidate.problems[0] || null;
+}
+
+// --- The coverage report (docs/runtime-contracts.md, "Coverage and impact commands") ------
+const RUNTIME_CMD = 'node scripts/pincer-runtime.cjs';
+// One ordered next action for a strict change: the first blocking code, else the
+// phase that is due (verify/start/complete/evaluate/release), or nothing to do.
+function nextAction(report, record, { verdict = null, running = [], selected = true } = {}) {
+  const cmd = (action, command, extra = {}) => ({ action, command, ticket: null, check: null, decision: null, ...extra });
+  if (!report.strict) return cmd('adopt strict coverage when wanted', `${RUNTIME_CMD} coverage adopt --preview --change ${record.change}`);
+  const id = record.change;
+  // Rules 2 and 3 outrank everything below, including the agreement verdict: a
+  // historical change is never routed to execution or to authorization, and a
+  // running attempt is waited for rather than raced.
+  const ahead = routing.preface({ id, lifecycle: record.lifecycle, base: record.base, running });
+  if (ahead) return { ...cmd(ahead.action, ahead.command), ...ahead };
+  if (verdict && verdict.verdict !== 'current') {
+    if (verdict.verdict === 'DECISION_REQUIRED') return cmd("record the user's decision", `${RUNTIME_CMD} change decide ${id} --resolve ${verdict.open[0]} --reference <text> --excerpt <text>`, { decision: verdict.open[0] });
+    if (['AUTHORIZATION_REQUIRED', 'AGREEMENT_CHANGED'].includes(verdict.verdict)) return cmd("record the user's authorization of the current agreement", `${RUNTIME_CMD} change authorize ${id} --agreement ${verdict.current} --reference <text> --excerpt <text>`);
+    if (verdict.verdict === 'COVERAGE_INVALID') return cmd('repair the coverage map', verdict.detail);
+    if (verdict.verdict === 'INVENTORY_INVALID') return cmd('repair the PRD definitions', verdict.detail);
+    return cmd('repair the agreement inputs', `${verdict.verdict}: ${verdict.detail}`);
+  }
+  const p = report.structure.problems[0];
+  if (p) {
+    if (p.code === 'INVENTORY_INVALID') return cmd('repair the PRD definitions', p.detail);
+    if (p.code === 'COVERAGE_INVALID') return cmd('repair the coverage map', p.detail);
+    if (p.code === 'COVERAGE_INCOMPLETE') return cmd('author the missing coverage rows, then authorize', `edit .prd/coverage/${id}.json: ${p.detail}; then ${RUNTIME_CMD} change authorize ${id} --agreement <digest> …`);
+    if (p.code === 'SCOPE_UNAUTHORIZED') return cmd('record the scope decision and its user authorization', `${RUNTIME_CMD} change decide ${id} --summary <text> / --resolve D-NN …, then change authorize ${id} --agreement <digest> --decision D-NN …`, { decision: p.decision || null });
+    if (p.code === 'OBLIGATION_MISSING') return cmd('restore the obligation, or record the decision and the removed tombstone', p.detail);
+    return cmd('repair the coverage inputs', `${p.code}: ${p.detail}`);
+  }
+  const staged = routing.lifecycleAction({ id, lifecycle: record.lifecycle });
+  if (staged) return { ...cmd(staged.action, staged.command), ...staged };
+  const i = report.implementation.problems[0];
+  if (i) {
+    const ticket = i.ids.find(x => /^T-/.test(x)) || null;
+    if (i.code === 'LIFECYCLE_BLOCKED' && ticket) return cmd(`finish ${ticket}`, `scripts/pincer-ticket.sh start ${ticket} → verify ${ticket} → done ${ticket}`, { ticket });
+    if (ticket) return cmd(`re-verify ${ticket} (${i.code})`, `scripts/pincer-ticket.sh verify ${ticket}`, { ticket });
+    return cmd('finish the mapped work', i.detail);
+  }
+  if (record.lifecycle.state === 'active') return cmd('complete the change', `${RUNTIME_CMD} change complete ${id}`);
+  const c = report.candidate.problems[0];
+  if (c) {
+    const check = c.ids.find(x => /^C-/.test(x)) || null;
+    if (c.code === 'EVIDENCE_MISSING' && !report.candidate.evaluated) return cmd('evaluate the candidate', '/pincer-evaluate (declare the candidate, run every declared check, record the reviews and the adequacy judgment, export)');
+    if (['CHECK_FAILED', 'ATTEMPT_ERROR'].includes(c.code) && check) return cmd(`re-run ${check} and re-evaluate`, `${RUNTIME_CMD} check ${check} --candidate <sha>, then /pincer-evaluate`, { check });
+    if (c.code === 'REVIEW_MISSING' && check) return cmd(`perform and record the review ${check}`, `record ${check} with its candidate-bound artifact in the draft, then /pincer-evaluate`, { check });
+    if (c.code === 'ADEQUACY_REQUIRED') return cmd("record the reviewer's adequacy judgment", '/pincer-evaluate with adequacy { verdict, note } in the draft');
+    return cmd('evaluate the candidate again', `${c.code}: ${c.detail}`);
+  }
+  return cmd('read-only release audit', '/pincer-release');
+}
+
+// report(root, record, { gathered, verdict, generated }) → coverage JSON schema 1.
+function report(root, record, { gathered = null, verdict = null, generated = null, selected = true } = {}) {
+  const authorization = require('./authorization.cjs');
+  const running = record ? require('./transaction.cjs').runningAttempts(root, record.change) : [];
+  const v = verdict || (record ? authorization.verdict(root, record) : null);
+  const r = compute(root, record, { gathered, verdict: v });
+  const reviewed = v && v.authorized && record ? (() => { const g = record.agreements.find(x => x.id === v.authorized.agreement); return g ? { agreement: g.id, authorization: v.authorized.id, digest: g.digest } : null; })() : null;
+  const base = record && r.strict ? require('./dispositions.cjs').baseline(root, record) : null;
+  const out = {
+    schema: 1, runtime: changes.RUNTIME_STRICT, generated: generated || require('./fsutil.cjs').nowIso(), root, mode: 'changes', change: record ? record.change : null,
+    strict: r.strict, label: r.label, reason: r.reason,
+    inventory: r.inventory ? { digest: r.inventory.digest, requirements: Object.entries(r.inventory.requirements).map(([id, x]) => ({ id, title: x.title, line: x.line, end: x.end, scenarios: x.scenarios })), scenarios: Object.entries(r.inventory.scenarios).map(([id, x]) => ({ id, requirement: x.requirement, line: x.line, end: x.end })) } : null,
+    map: r.map ? { path: r.map.path, digest: r.map.digest, checks: Object.entries(r.map.checks).map(([id, c]) => ({ id, ...c })) } : null,
+    agreement: { current: v && v.current ? v.current : null, reviewed, verdict: v ? v.verdict : null },
+    baseline: base ? { agreements: base.agreements, scenarios: Object.keys(base.scenarios) } : null,
+    structure: r.structure, implementation: r.implementation, candidate: r.candidate, scope: r.scope,
+    blockers: [
+      ...(running.length ? [{ code: 'ATTEMPT_RUNNING', detail: `attempt ${running[0].id} of change ${record.change} is running${running[0].alive === false ? ' (its owner is no longer running)' : ''}` }] : []),
+      ...(v && v.verdict !== 'current' ? [{ code: v.verdict, detail: v.detail }] : []), ...r.blockers],
+    next: routing.qualify(nextAction(r, record, { verdict: v, running, selected }), { id: record ? record.change : null, selected }),
+  };
+  return out;
+}
+
+function render(j) {
+  const lines = [];
+  const short = s => (typeof s === 'string' ? s.slice(0, 12) : '—');
+  lines.push(`PINCER coverage · ${j.generated} · ${j.root}`);
+  lines.push(`Change     ${j.change || 'none'} · coverage ${j.label}${j.reason ? ` (${j.reason})` : ''}`);
+  if (j.strict) {
+    lines.push(`Agreement  current ${short(j.agreement.current)} · reviewed ${j.agreement.reviewed ? `${j.agreement.reviewed.agreement} (${j.agreement.reviewed.authorization}, ${short(j.agreement.reviewed.digest)})` : 'none'} · verdict ${j.agreement.verdict}`);
+    lines.push(`Inventory  ${j.inventory ? `${j.inventory.requirements.length} requirement(s), ${j.inventory.scenarios.length} scenario(s) · ${short(j.inventory.digest)}` : 'unreadable'}`);
+    lines.push(`Map        ${j.map ? `${j.map.path} · ${short(j.map.digest)} · checks ${j.map.checks.map(c => `${c.id} (${c.kind}${c.required ? ', required' : ''})`).join(', ')}` : 'unreadable'}`);
+    lines.push(`Structure  ${j.structure.complete ? 'complete' : `incomplete: ${j.structure.problems.map(p => `${p.code} ${p.detail}`).join('; ')}`}`);
+    const sc = Object.entries(j.implementation.scenarios);
+    lines.push(`Implementation ${j.implementation.complete ? 'complete' : 'incomplete'} · ${sc.filter(([, s]) => s.implementation === 'complete').length}/${sc.filter(([, s]) => s.scope === 'in-scope').length} in-scope scenario(s) complete${sc.some(([, s]) => s.scope !== 'in-scope') ? ` · ${sc.filter(([, s]) => s.scope !== 'in-scope').map(([id, s]) => `${id} ${s.scope}`).join(', ')}` : ''}`);
+    for (const [id, s] of sc) lines.push(`  ${id.padEnd(6)} ${s.scope === 'in-scope' ? s.implementation.padEnd(14) : s.scope.padEnd(14)} ${s.scope === 'in-scope' ? `tickets ${s.tickets.map(t => `${t.id} ${t.status || 'missing'}${t.ready ? '' : t.code ? ` (${t.code})` : ''}`).join(', ')} · checks ${s.checks.join(', ')}` : s.detail}${j.candidate.scenarios[id] ? ` · candidate ${j.candidate.scenarios[id].disposition}` : ''}`);
+    const c = j.candidate;
+    lines.push(`Candidate  ${c.evaluated ? `${c.candidate ? c.candidate.slice(0, 7) : '?'} · delivery original ${c.delivery ? c.delivery.original : '?'}, agreed ${c.delivery ? c.delivery.agreed : '?'} · adequacy ${c.adequacy ? `${c.adequacy.verdict} ("${c.adequacy.note}")` : 'not recorded'}` : 'not evaluated · adequacy: not recorded'}${c.problems.length ? ` · ${c.problems.map(p => `${p.code} ${p.detail}`).join('; ')}` : ''}`);
+    if (j.scope.length) lines.push(`Scope      ${j.scope.map(s => `${s.id} ${s.disposition} by ${s.decision} (${s.authorization}; reviewer judgment: "${s.excerpt}" must support it)`).join('; ')}`);
+  }
+  lines.push(`Blockers   ${j.blockers.length ? j.blockers.map(b => `${b.code} ${b.detail}`).join('\n           ') : 'none'}`);
+  lines.push(`Next       ${j.next.action}: ${j.next.command}`);
+  return `${lines.join('\n')}\n`;
+}
+
+// A one-line summary for status and resume.
+function summary(r) {
+  if (!r.strict) return { strict: false, label: 'unverified', reason: r.reason, structure: null, implementation: null, candidate: null };
+  const sc = Object.values(r.implementation.scenarios);
+  return {
+    strict: true, label: 'strict', reason: null,
+    structure: { complete: r.structure.complete, problems: r.structure.problems.map(p => ({ code: p.code, detail: p.detail })) },
+    implementation: { complete: r.implementation.complete, scenarios: { total: sc.length, complete: sc.filter(s => s.implementation === 'complete').length, unfinished: sc.filter(s => s.implementation === 'unfinished').length, unverified: sc.filter(s => s.implementation === 'unverified').length, dispositioned: sc.filter(s => s.scope !== 'in-scope').length } },
+    candidate: r.candidate.evaluated ? { evaluated: true, delivery: r.candidate.delivery, adequacy: r.candidate.adequacy ? r.candidate.adequacy.verdict : null } : { evaluated: false, delivery: null, adequacy: null },
+  };
+}
+function summaryLine(r, record) {
+  if (!r.strict) return `Coverage unverified · ${r.reason}`;
+  const s = summary(r);
+  const reviewed = record && record.authorizations.length ? `${record.authorizations.at(-1).agreement} (${record.authorizations.at(-1).id})` : 'none';
+  return `Coverage strict · agreement ${reviewed} · structure ${s.structure.complete ? 'complete' : `incomplete (${s.structure.problems[0].code})`} · implementation ${s.implementation.scenarios.complete}/${s.implementation.scenarios.total - s.implementation.scenarios.dispositioned} scenarios${s.implementation.scenarios.dispositioned ? ` (${s.implementation.scenarios.dispositioned} dispositioned)` : ''} · candidate ${s.candidate.evaluated ? `${s.candidate.delivery ? `delivery original ${s.candidate.delivery.original}, agreed ${s.candidate.delivery.agreed}` : 'delivery not recorded (evidence predates strict coverage)'}, adequacy ${s.candidate.adequacy || 'not recorded'}` : 'not evaluated'}`;
+}
+
+module.exports = { STRUCTURE_ORDER, compute, firstBlocker, nextAction, report, render, summary, summaryLine };

package/template/scripts/pincer-runtime/readiness.cjs

@@ -39,7 +39,7 @@ function legacyTicketReadiness(text, fields) {
 // `contextKey` is the key the attempt was read for and `pointedId` the id the
 // index names for it (the record must match both); the attempt's artifacts
 // carry `missing`/`altered` from state.inspectArtifacts.
-function migratedTicketReadiness({ text, fields, timeout, attempt, legacyReceipt, current, sourceProblems = [], changedPaths = [], contextKey = null, pointedId = null }) {
+function migratedTicketReadiness({ text, fields, timeout, attempt, legacyReceipt, current, sourceProblems = [], changedPaths = [], contextKey = null, pointedId = null, mode = 'migrated', strict = false }) {
   const reasons = [];
   for (const p of sourceProblems) reasons.push(reason(p.code, p.detail, p.code === 'SECRET_PATH' ? 'remove or ignore the secret file' : 'remove the input or change the configuration'));
   if (reasons.length) return { ready: false, reasons };
@@ -52,6 +52,14 @@ function migratedTicketReadiness({ text, fields, timeout, attempt, legacyReceipt
   // outcome is honored: a stripped or foreign record is never a pass.
   const invalid = validateAttempt(attempt, contextKey, pointedId);
   if (invalid) return { ready: false, reasons: [reason('ATTEMPT_ERROR', `attempt ${id} ${invalid}`, 'verify')] };
+  // A record written before the migration to change records keeps its identity
+  // as history; it never becomes current evidence for the new change context.
+  if (mode === 'changes' && attempt.schema === 1) return { ready: false, reasons: [reason('HISTORICAL_EVIDENCE', `attempt ${id} was recorded under schema ${attempt.schema} (before this project used change records) and is history, not current evidence`, 'verify')] };
+  // Strict coverage (schema 3 attempts): an attempt recorded before adoption is history;
+  // a strict attempt read for a change without the capability is never evidence.
+  if (mode === 'changes' && strict && attempt.schema !== 3) return { ready: false, reasons: [reason('HISTORICAL_EVIDENCE', `attempt ${id} was recorded under schema ${attempt.schema} (before this change adopted strict coverage) and is history, not current evidence`, 'verify')] };
+  if (mode === 'changes' && !strict && attempt.schema === 3) return { ready: false, reasons: [reason('ATTEMPT_ERROR', `attempt ${id} is a strict-coverage (schema 3) attempt; this change has not adopted strict coverage`, 'verify')] };
+  if (mode !== 'changes' && attempt.schema !== 1) return { ready: false, reasons: [reason('ATTEMPT_ERROR', `attempt ${id} is a change-record (schema ${attempt.schema}) attempt; this project is not in changes mode`, 'verify')] };
   switch (attempt.outcome) {
     case 'running': return { ready: false, reasons: [reason('ATTEMPT_RUNNING', `attempt ${id} is running`, 'wait, or run recover if its owner died')] };
     case 'interrupted': return { ready: false, reasons: [reason('ATTEMPT_INTERRUPTED', `attempt ${id} was interrupted`, 'verify')] };
@@ -62,7 +70,12 @@ function migratedTicketReadiness({ text, fields, timeout, attempt, legacyReceipt
     default: return { ready: false, reasons: [reason('ATTEMPT_ERROR', `attempt ${id} has unknown outcome ${JSON.stringify(attempt.outcome)}`, 'verify')] };
   }
   if (current.prdRevision && attempt.context && attempt.context.prd_revision !== current.prdRevision) {
-    reasons.push(reason('REVISION_CHANGED', 'the PRD revision changed since the passing attempt', 'register --rebind, then verify'));
+    // The remedy is mode-specific. `register --rebind` is the v0.4.1/v0.5.0 repair and
+    // changes mode refuses it outright (AGREEMENT_CHANGED: "--rebind is not supported
+    // for change records"), so naming it there sends the reader to a command the
+    // runtime will not run — the defect class T-80 closed for the coverage report.
+    reasons.push(reason('REVISION_CHANGED', 'the PRD revision changed since the passing attempt',
+      mode === 'changes' ? 'change revise, record its authorization, then verify' : 'register --rebind, then verify'));
   }
   if (attempt.check && attempt.check.digest !== parse.checkDigest(text, timeout)) {
     reasons.push(reason('CHECK_CHANGED', 'the Verification block or timeout changed since the passing attempt', 'verify'));