@renzrollon/interlock 1.5.1 → 1.6.0

package/lib/run.mjs

@@ -22,7 +22,7 @@
 // through `ctx.deps` rather than being written a second time here.
 
 import { createHash } from 'node:crypto'
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 
 import { LIMITS, EFFORT, RUNTIME } from './limits.mjs'
@@ -53,7 +53,7 @@ import {
   summaryHeadline,
   tailFromManifest
 } from './receipt.mjs'
-import { detectUnarchived } from './drift.mjs'
+import { detectUnarchived, livingSpecEdges, readGraphAt } from './drift.mjs'
 import { projectSlug } from './project-slug.mjs'
 import { composeCloseMessage, postNtfy, readNotifyConfig } from './notify.mjs'
 import {
@@ -64,11 +64,22 @@ import {
   planVerification,
   judgeVerification
 } from './verify.mjs'
-import { resolveReview, readReviewPolicy } from './review-core.mjs'
+import {
+  REVIEW_POLICY_FILE,
+  composePolicy,
+  parseReviewPolicy,
+  readReviewPolicy,
+  resolveReview
+} from './review-core.mjs'
+import { applyToleranceBand, carriesFindingsList } from './findings.mjs'
+import { canonicalizePath } from './risk.mjs'
+import { capabilityOf, parseSpec } from './spec-text.mjs'
 import { writeReviewMetrics } from './metrics.mjs'
 import { planRemediation } from './remediate.mjs'
 import { classifySurface } from './surface.mjs'
-import { buildChecklist } from './conformance.mjs'
+import { buildChecklist, buildLivingChecklist } from './conformance.mjs'
+import { assessMergeConfidence, combineSignals, mergeConfidenceHeadline } from './merge-confidence.mjs'
+import { buildRunEvidence, gatherMergeEvidence } from './merge-evidence.mjs'
 import { record as recordAutonomy } from './autonomy.mjs'
 import { writeResumeCard } from './resume-card.mjs'
 import { summarizePlan } from './plan-summary.mjs'
@@ -88,6 +99,7 @@ import {
 } from './waves.mjs'
 import {
   assembleCommitPrompt,
+  assembleDomainContext,
   assembleHandoffPrompt,
   assembleImplementerPrompt,
   assemblePlannerPrompt,
@@ -97,7 +109,8 @@ import {
   assembleVerdictPrompt,
   assembleVerifyPrompt,
   publishStageLine,
-  selectDimensions
+  selectDimensions,
+  selectDomainCapabilities
 } from './prompts/index.mjs'
 import {
   COMMIT_SCHEMA,
@@ -299,6 +312,13 @@ export function newManifest({ change, flags, host, hostCapabilities }) {
     // this is where the CLI reads it back, because the driver returns only
     // results and the wave state has no such field.
     mergeBase: null,
+    // The commit the run started on, recorded once at `run start` and never
+    // moved. The enforced `REVIEW.md` lists and the living requirements the
+    // `domain` review judges against are read from it, so a change cannot edit
+    // the copy that is applied to it. Null in a repository with no commit, and
+    // absent on a manifest written before this field existed: both read the
+    // working tree and say so (`REVIEW BASE NOT PINNED`).
+    startSha: null,
     // The inter-wave verification budget's own clock (`interWaveVerifyBudgetMs`).
     // Every `run` subcommand is a fresh process running BETWEEN agent turns, so
     // the interval a verify agent spends is only measurable across two
@@ -991,7 +1011,7 @@ export const GRAPH_UNAVAILABLE_BANNER =
   'GRAPH UNAVAILABLE: never built — implementer and reviewer agents fall back to grep and will be slower'
 
 /** Root first, then the home, never written: the inputs a worktree run reads through. */
-function locateInput(root, home, relative) {
+export function locateInput(root, home, relative) {
   const atRoot = resolve(root, relative)
   if (existsSync(atRoot)) return { path: atRoot, source: 'root' }
   const atHome = resolve(home, relative)
@@ -1519,6 +1539,248 @@ function rejectedReportsOfRun(root) {
   }
 }
 
+// --- the base a review is judged against (judge-against-base-and-living-specs, D3, D4) ---
+//
+// Two inputs a review reads are enforced, not advisory: the `REVIEW.md` path
+// lists and the living requirements the `domain` dimension judges against. A
+// change must not be able to edit the copy that is applied to it, so a run reads
+// both from the commit it started on (`manifest.startSha`). The policy PROSE
+// stays the working tree's: it is advice that cannot relax the gate, and an
+// uncommitted edit to it reaching a reviewer is a feature. A run with no start
+// commit reads everything from the working tree and says so.
+
+/** The short form of a commit, as banners name it. */
+const shortSha = sha => String(sha).slice(0, 7)
+
+/** HEAD when the run starts, or null — never a guess, and never a crash. */
+function readStartSha(ctx) {
+  try {
+    const sha = ctx.deps && typeof ctx.deps.headCommit === 'function' ? ctx.deps.headCommit(ctx.root) : null
+    return typeof sha === 'string' && sha ? sha : null
+  } catch {
+    return null
+  }
+}
+
+/** The start commit this run pinned, or null (none recorded, or an older manifest). */
+function pinnedSha(manifest) {
+  return manifest && typeof manifest.startSha === 'string' && manifest.startSha ? manifest.startSha : null
+}
+
+/**
+ * One repository file, from `ref` or — when `ref` is null — the working tree.
+ * `{ text }`, `{ absent: true }`, `{ tooLarge: true, size }` or `{ error }`; it
+ * never throws, because the caller decides how each outcome degrades.
+ */
+function readFileAt(ctx, ref, relative, { maxBytes } = {}) {
+  if (ref === null) {
+    const path = join(ctx.root, relative)
+    try {
+      if (!existsSync(path)) return { absent: true }
+      const size = statSync(path).size
+      if (Number.isFinite(maxBytes) && size > maxBytes) return { tooLarge: true, size }
+      return { text: readFileSync(path, 'utf8') }
+    } catch (err) {
+      return { error: (err && err.message) || String(err) }
+    }
+  }
+  if (!ctx.deps || typeof ctx.deps.readAtRef !== 'function') {
+    return { error: 'this host supplies no reader for a commit' }
+  }
+  try {
+    const read = ctx.deps.readAtRef(ctx.root, ref, relative, { maxBytes })
+    return read && typeof read === 'object' ? read : { error: 'the reader returned nothing' }
+  } catch (err) {
+    return { error: (err && err.message) || String(err) }
+  }
+}
+
+/** Push a banner onto the manifest unless one with the same label is already there. */
+function raiseOnce(manifest, banner) {
+  if (!Array.isArray(manifest.banners)) manifest.banners = []
+  const label = banner.slice(0, banner.indexOf(':') + 1)
+  if (!manifest.banners.some(b => typeof b === 'string' && b.startsWith(label))) manifest.banners.push(banner)
+}
+
+/** The working tree's `REVIEW.md` as text plus its parsed policy, or null when absent. */
+function readWorkingPolicy(root) {
+  const path = join(root, REVIEW_POLICY_FILE)
+  if (!existsSync(path)) return null
+  let text = ''
+  try {
+    if (statSync(path).size <= LIMITS.maxReviewPolicyBytes) text = readFileSync(path, 'utf8')
+  } catch {
+    // The policy reader below reports an unreadable file as a problem.
+  }
+  return { text, policy: readReviewPolicy(root) }
+}
+
+/**
+ * The policy a review is adjudicated by: prose and owner from the working tree,
+ * both enforced path lists from the start commit (`composePolicy`).
+ *
+ * With no start commit the working tree supplies everything, unchanged from
+ * before; `reviewStep` has already said so (`REVIEW BASE NOT PINNED`). A start
+ * commit that cannot be read degrades the same way and says so here. A working
+ * copy that differs from the start commit's raises `POLICY DIFFERS FROM BASE`.
+ *
+ * @returns {{ policy: object, banners: string[] }}
+ */
+function policyForAdjudication(ctx, manifest) {
+  const sha = pinnedSha(manifest)
+  if (!sha) return { policy: readReviewPolicy(ctx.root), banners: [] }
+
+  const short = shortSha(sha)
+  const read = readFileAt(ctx, sha, REVIEW_POLICY_FILE, { maxBytes: LIMITS.maxReviewPolicyBytes })
+  if (read.error !== undefined) {
+    return {
+      policy: readReviewPolicy(ctx.root),
+      banners: [
+        `REVIEW BASE NOT PINNED: start commit ${short} could not be read (${read.error}); ` +
+          `read from the working tree: ${REVIEW_POLICY_FILE} lists`
+      ]
+    }
+  }
+
+  let base = null
+  if (typeof read.text === 'string') {
+    base = { text: read.text, policy: parseReviewPolicy(read.text) }
+  } else if (read.tooLarge) {
+    base = {
+      text: '',
+      policy: {
+        prose: '',
+        excludePaths: [],
+        humanPaths: [],
+        owner: null,
+        problems: [
+          `${REVIEW_POLICY_FILE} is ${read.size} bytes, over the ${LIMITS.maxReviewPolicyBytes}-byte scan ` +
+            `cap — not parsed; review proceeds under default policy`
+        ]
+      }
+    }
+  }
+
+  const policy = composePolicy({ working: readWorkingPolicy(ctx.root), base, ref: short })
+  const banners = []
+  if (policy.differsFromBase) {
+    banners.push(
+      `POLICY DIFFERS FROM BASE: ${REVIEW_POLICY_FILE} differs from ${short}; ` +
+        `its Do Not Report paths were read from ${short}`
+    )
+  }
+  return { policy, banners }
+}
+
+const SPEC_CITATION_PATH = /^openspec\/specs\/.+\/spec\.md$/
+
+/**
+ * What `resolveReview` needs to check requirement citations: for every spec a
+ * finding cites, that spec's requirement keys at the base (the start commit, or
+ * the working tree for an unpinned run), or `{ unreadable }` when it could not
+ * be read. Only canonical `openspec/specs/**\/spec.md` paths are read, so a
+ * citation cannot make the run read an arbitrary file.
+ */
+function requirementHeadingsFor(ctx, manifest, findings) {
+  const ref = pinnedSha(manifest)
+  const where = ref ? `at ${shortSha(ref)}` : 'in the working tree'
+  const headings = new Map()
+  for (const finding of applyToleranceBand(findings, null).reportable) {
+    const cited = finding && typeof finding.requirement === 'string' ? finding.requirement : ''
+    const hash = cited.indexOf('#')
+    if (hash === -1) continue
+    const path = canonicalizePath(cited.slice(0, hash).trim())
+    if (!path || !SPEC_CITATION_PATH.test(path) || headings.has(path)) continue
+    const read = readFileAt(ctx, ref, path)
+    if (typeof read.text === 'string') {
+      headings.set(path, parseSpec(read.text).requirements.map(r => r.key))
+    } else if (read.absent) {
+      headings.set(path, { unreadable: `${path} does not exist ${where}` })
+    } else {
+      headings.set(path, { unreadable: read.error || 'unreadable' })
+    }
+  }
+  return headings
+}
+
+/** Where a capability's living spec and a change's delta spec live. */
+const livingSpecPathOf = capability => `openspec/specs/${capability}/spec.md`
+const deltaSpecPathOf = (change, capability) => `openspec/changes/${change}/specs/${capability}/spec.md`
+
+/**
+ * The text of the given capabilities' requirements, read from `ref` (null = the
+ * working tree), and the change's own delta specs, which are always the working
+ * tree's: they ARE the change. `readErrors` names every file that could not be
+ * read, so a degraded assembly says why.
+ */
+function assembleDomainFor(ctx, manifest, capabilities, ref, living = {}) {
+  const deltas = {}
+  const readErrors = []
+  for (const { capability } of capabilities) {
+    if (!(capability in living)) {
+      const read = readFileAt(ctx, ref, livingSpecPathOf(capability))
+      if (typeof read.text === 'string') living[capability] = read.text
+      else if (read.error) readErrors.push(`${livingSpecPathOf(capability)}: ${read.error}`)
+    }
+    const delta = readFileAt(ctx, null, deltaSpecPathOf(manifest.change, capability))
+    if (typeof delta.text === 'string') deltas[capability] = delta.text
+  }
+  const assembled = assembleDomainContext({ capabilities, living, deltas, ref })
+  return { assembled, readErrors }
+}
+
+/**
+ * Decide whether `domain` runs and what it is given (design D4).
+ *
+ * Capabilities are selected from the run's graph (`manifest.graphPath`) and from
+ * the capabilities the change's delta specs declare it modifies, the latter only
+ * where a living spec exists at the base. The text is assembled from the start
+ * commit. Nothing here is silent: a missing graph is `partial` or `skipped`,
+ * a graph that links no changed path is recorded as `notSelected` and nothing
+ * else (an unlinked file is a coverage gap, not a degraded review).
+ */
+function gatherDomain(ctx, manifest, changedPaths) {
+  const ref = pinnedSha(manifest)
+  const graph = manifest.graphPath
+    ? readGraphAt(manifest.graphPath)
+    : { links: null, reason: 'no graph has been built — run /interlock:bootstrap once' }
+  const edges = Array.isArray(graph.links) ? livingSpecEdges(graph) : null
+
+  const living = {}
+  let specFiles = []
+  try {
+    specFiles = inspectChange(ctx.root, manifest.change).specFiles
+  } catch {
+    // A change that cannot be inspected declares nothing; the run's own checks say why.
+  }
+  const declared = []
+  for (const rel of specFiles) {
+    const capability = capabilityOf(rel)
+    if (!capability || declared.includes(capability)) continue
+    const read = readFileAt(ctx, ref, livingSpecPathOf(capability))
+    if (typeof read.text === 'string') {
+      living[capability] = read.text
+      declared.push(capability)
+    }
+  }
+
+  const selection = selectDomainCapabilities({ changedPaths, edges, graphReason: graph.reason, declared })
+  let assembled = null
+  let skipped = selection.skipped
+  let readErrors = []
+  if (selection.capabilities.length) {
+    const result = assembleDomainFor(ctx, manifest, selection.capabilities, ref, living)
+    assembled = result.assembled
+    readErrors = result.readErrors
+    if (assembled.skipped) {
+      skipped = result.readErrors.length
+        ? `${assembled.skipped} (${result.readErrors.join('; ')})`
+        : assembled.skipped
+    }
+  }
+  return { selection, assembled, skipped, readErrors, runs: Boolean(assembled) && !assembled.skipped }
+}
+
 /**
  * The review step: one worker, every selected dimension fanned out inside it,
  * two skeptics per finding (design D1, D3, D4, D8).
@@ -1532,7 +1794,10 @@ function reviewStep(ctx, manifest, carried = {}) {
   const { root } = ctx
   const change = manifest.change
   const changedPaths = ctx.deps.observedChangedPaths(root)
-  const { dimensions: names, reasons } = selectDimensions(changedPaths)
+  const domain = gatherDomain(ctx, manifest, changedPaths)
+  const { dimensions: names, reasons } = selectDimensions(changedPaths, {
+    domain: domain.runs ? domain.selection : null
+  })
   const dimensions = resolveDimensionRubrics(names)
   const policy = readReviewPolicy(root)
 
@@ -1543,10 +1808,83 @@ function reviewStep(ctx, manifest, carried = {}) {
     }
   }
 
+  // What the review reads from the working tree because there is no start
+  // commit to read it from, named once (design D3). The lists are always read;
+  // the living requirements only when `domain` runs.
+  const raised = []
+  if (!pinnedSha(manifest)) {
+    const unpinned = [`${REVIEW_POLICY_FILE} lists`, ...(domain.runs ? ['living requirements'] : [])]
+    raised.push(
+      `REVIEW BASE NOT PINNED: this run recorded no start commit; read from the working tree: ${unpinned.join(', ')}`
+    )
+  }
+  if (domain.skipped) {
+    raised.push(`DOMAIN REVIEW SKIPPED: ${domain.skipped}`)
+  } else if (domain.runs) {
+    // Two ways the reviewer is given less than the whole: a selection made
+    // without a graph, and a text the size bound cut. `raiseOnce` keeps one
+    // banner per label, so when both hold one line states both (design D20 of
+    // label-and-harden-the-merge-verdict). The limit is cited by its key, never
+    // restated.
+    const partial = []
+    if (domain.selection.partial) partial.push(domain.selection.partial)
+    const omitted = Array.isArray(domain.assembled.omitted) ? domain.assembled.omitted.length : 0
+    if (omitted > 0) {
+      partial.push(
+        `${omitted} requirement(s) were left out of the domain reviewer's text by the size bound ` +
+          `(LIMITS.maxDomainSpecChars, printed by \`interlock limits\`)`
+      )
+    }
+    if (partial.length) raised.push(`DOMAIN REVIEW PARTIAL: ${partial.join('; ')}`)
+  }
+
+  // A run adjudicates only what THIS review wrote (design D24). The work files
+  // sit in a directory no run clears, so a review that writes nothing would
+  // otherwise be adjudicated from whatever an earlier run left there. Removed
+  // once, when the step is first emitted: `manifest.reviewDimensions` is set a
+  // few lines below, and a step derived again by `run next` finds it set and
+  // removes nothing, since by then the reviewer may already be writing.
+  if (!manifest.reviewDimensions) {
+    for (const path of [FINDINGS_PATH, VERDICTS_PATH]) {
+      try {
+        rmSync(join(root, path), { force: true })
+      } catch (err) {
+        raised.push(
+          `REVIEW WORK FILE NOT CLEARED: ${path} could not be removed (${(err && err.message) || err}) — ` +
+            `what an earlier run left there may be adjudicated as this review's`
+        )
+      }
+    }
+  }
+  for (const banner of raised) {
+    raiseOnce(manifest, banner)
+    banners.push(banner)
+  }
+
   // Carried across every later `run reviewed`/`run remediated` call in this
   // run, each its own process: what the CLI selected, and why, so an agent-
   // added dimension can be told apart from one the CLI asked for (design D4).
+  // `skipped`, `notSelected` and `domain` are recorded only when they apply, so
+  // a record without them says `domain` was neither refused nor unlinked.
   manifest.reviewDimensions = { selected: names, reasons }
+  // A selected dimension whose criteria could not be read was dispatched on its
+  // name alone. The banner above says so once; the record keeps it, because the
+  // merge verdict asks which dimensions ran WITH their rubric (design D4 of
+  // complete-and-record-the-merge-verdict).
+  const unavailable = dimensions.filter(d => d.rubric === null).map(d => d.name)
+  if (unavailable.length) manifest.reviewDimensions.unavailable = unavailable
+  if (domain.skipped) manifest.reviewDimensions.skipped = [{ name: 'domain', reason: domain.skipped }]
+  if (domain.selection.notSelected) manifest.reviewDimensions.notSelected = domain.selection.notSelected
+  if (domain.runs) {
+    const { superseded, omitted, specifiedByChange, ref } = domain.assembled
+    manifest.reviewDimensions.domain = {
+      capabilities: domain.selection.capabilities,
+      ref,
+      superseded,
+      omitted,
+      specifiedByChange
+    }
+  }
 
   // Tasks recorded as done whose handoff packet was rejected. A later wave was
   // told about its predecessor's; the last wave's had nobody to tell. The review
@@ -1574,6 +1912,7 @@ function reviewStep(ctx, manifest, carried = {}) {
           change,
           dimensions,
           policyProse: policy.prose,
+          domainContext: domain.runs ? domain.assembled.text : undefined,
           rejectedReports,
           findingsPath: FINDINGS_PATH,
           verdictsPath: VERDICTS_PATH,
@@ -1615,6 +1954,22 @@ function remediateStep(ctx, manifest, plan, extra = {}) {
 
   const dimensions = resolveDimensionRubrics(plan.reReviewDimensions)
   const policyProse = readReviewPolicy(root).prose
+  // A re-review of `domain` is handed the text the first pass was, re-assembled
+  // from the capabilities and the ref it recorded — not re-selected, so the
+  // reviewer judges the fix against the same requirements.
+  const recordedDomain = manifest.reviewDimensions && manifest.reviewDimensions.domain
+  const domainContext =
+    plan.reReviewDimensions.includes('domain') &&
+    recordedDomain &&
+    Array.isArray(recordedDomain.capabilities) &&
+    recordedDomain.capabilities.length
+      ? assembleDomainFor(
+          ctx,
+          manifest,
+          recordedDomain.capabilities,
+          typeof recordedDomain.ref === 'string' && recordedDomain.ref ? recordedDomain.ref : null
+        ).assembled.text
+      : undefined
   const stageLine = publishStageLine('remediation', change, ++manifest.stageIndex)
   return makeStep({
     action: 'remediate',
@@ -1628,7 +1983,17 @@ function remediateStep(ctx, manifest, plan, extra = {}) {
         model: null,
         effort: EFFORT.skeptic,
         schema: REMEDIATE_RESULT_SCHEMA,
-        prompt: assembleRemediatePrompt({ change, round: plan.round, plan, dimensions, policyProse, stageLine })
+        prompt: assembleRemediatePrompt({
+          change,
+          round: plan.round,
+          plan,
+          dimensions,
+          policyProse,
+          domainContext,
+          findingsPath: FINDINGS_PATH,
+          verdictsPath: VERDICTS_PATH,
+          stageLine
+        })
       })
     ]
   })
@@ -1666,21 +2031,98 @@ function stageMarkerBanners(results) {
 }
 
 /**
- * Re-adjudicate the work files a review or fixer just wrote, write `review.json`
- * and the metrics file exactly as `interlock review --metrics <change>` would,
- * and record the counts on the manifest (design D2, D7).
+ * The dimension record `review.json` carries (design D4 of
+ * complete-and-record-the-merge-verdict), read off the manifest so every
+ * adjudication of one run writes the same one:
+ *
+ *   selected     what the CLI selected
+ *   unavailable  selected dimensions whose rubric could not be read
+ *   completed    whether the review worker's result was usable and `ok`
+ *   ran          selected minus unavailable, plus any dimension the reviewer
+ *                added, when the review completed; nothing otherwise
+ *   skipped      dimensions refused with a reason (`domain`, for want of a graph)
+ *
+ * The CLI never watches one dimension run: the worker fans them out in its own
+ * context and reports `ok`. So `ran` means "dispatched with its rubric in a
+ * review the worker reported complete", and nothing stronger.
+ */
+function dimensionRecord(manifest) {
+  const recorded =
+    manifest.reviewDimensions && typeof manifest.reviewDimensions === 'object' ? manifest.reviewDimensions : {}
+  const names = value => (Array.isArray(value) ? value.filter(name => typeof name === 'string' && name) : [])
+  const selected = names(recorded.selected)
+  const unavailable = names(recorded.unavailable).filter(name => selected.includes(name))
+  const completed = recorded.completed === true
+  const added = names((Array.isArray(recorded.added) ? recorded.added : []).map(d => d && d.name)).filter(
+    name => !selected.includes(name)
+  )
+  return {
+    selected,
+    ran: completed ? [...selected.filter(name => !unavailable.includes(name)), ...new Set(added)] : [],
+    unavailable,
+    completed,
+    skipped: Array.isArray(recorded.skipped) ? recorded.skipped : []
+  }
+}
+
+/** Where every adjudication of a run writes its result, and a later round reads the last one back. */
+const REVIEW_RECORD = 'review.json'
+const REVIEW_RECORD_PATH = join(WORK_DIR, REVIEW_RECORD)
+
+/**
+ * The findings work file as a review or a fixer left it: `{ findings }`, or
+ * `{ missing }` saying why it carries no findings list. An absent file, one that
+ * is not JSON and one holding none of the accepted shapes are the same fact to
+ * an adjudication: there is no list this agent wrote (design D10 of
+ * label-and-harden-the-merge-verdict). An empty list is a list.
+ */
+function readFindingsWork(root) {
+  let raw
+  try {
+    raw = readFileSync(join(root, FINDINGS_PATH), 'utf8')
+  } catch (err) {
+    return { missing: err && err.code === 'ENOENT' ? 'the file is absent' : `the file could not be read (${(err && err.code) || err})` }
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return { missing: 'the file is not valid JSON' }
+  }
+  if (!carriesFindingsList(parsed)) return { missing: 'it holds none of the shapes a findings list takes' }
+  return { findings: parsed }
+}
+
+/** The reason a findings work file could not be adjudicated, as a note or a halt states it. */
+const noFindingsList = missing => `${FINDINGS_PATH} carries no findings list (${missing})`
+
+/**
+ * Adjudicate the findings a review or fixer just wrote against the verdicts
+ * work file, write `review.json` and the metrics file exactly as `interlock
+ * review --metrics <change>` would, and record the counts on the manifest
+ * (design D2, D7). Every adjudication rewrites `review.json`, so every one
+ * writes the dimension record with it. The caller reads the findings work file
+ * and decides what a missing list means; this is handed a list.
  */
-function adjudicateReview(ctx, manifest) {
+function adjudicateReview(ctx, manifest, findings) {
   const { root } = ctx
-  const findings = readJson(join(root, FINDINGS_PATH))
   const verdicts = readJson(join(root, VERDICTS_PATH))
   const changedPaths = ctx.deps.observedChangedPaths(root)
-  const policy = readReviewPolicy(root)
+  const { policy, banners: policyBanners } = policyForAdjudication(ctx, manifest)
 
-  const result = resolveReview(findings, verdicts, { changedPaths, excludePaths: policy.excludePaths })
-  writeWork(root, 'review.json', result)
+  const result = resolveReview(findings, verdicts, {
+    changedPaths,
+    excludePaths: policy.excludePaths,
+    requirementHeadings: requirementHeadingsFor(ctx, manifest, findings)
+  })
+  writeWork(root, REVIEW_RECORD, { ...result, dimensions: dimensionRecord(manifest) })
 
-  const banners = []
+  // Once per run: a later round adjudicates the same policy against the same
+  // base, and `manifest.banners` already holds what the first said.
+  const recorded = Array.isArray(manifest.banners) ? manifest.banners : []
+  const banners = policyBanners.filter(
+    b => !recorded.some(r => typeof r === 'string' && r.startsWith(b.slice(0, b.indexOf(':') + 1)))
+  )
   const metrics = writeReviewMetrics(stateHomeOf(ctx, manifest), { change: manifest.change, counts: result.counts })
   if (!metrics.written) {
     banners.push(`REVIEW METRICS NOT WRITTEN: ${metrics.reason}`)
@@ -1710,19 +2152,30 @@ export function runReviewed(ctx, { results, hostRecords }) {
     return finishStep(ctx, manifest, trajectoryHaltStep('agent-result', observed.failure))
   }
 
-  const { result, banners } = adjudicateReview(ctx, manifest)
-  banners.push(...stageMarkerBanners(results))
-
   // A review step that reported nothing usable still adjudicates — the files
   // are read either way — but "the review did not complete" is a different
   // fact from "the review found nothing", and the summary must not blur them
   // (workflow-host spec, edge case: an agent that returns no findings file).
   const report = results && results[0] && typeof results[0] === 'object' ? results[0] : null
-  if (!report || report.ok !== true) {
+  const reported = Boolean(report) && report.ok === true
+  if (!reported) {
     manifest.notes.push(
       `review did not complete: ${(report && report.detail) || 'the step returned no usable result'}`
     )
   }
+  // Whatever the step reported about itself, a review that left no findings
+  // list did not complete: the work files were removed when the step was
+  // emitted, so an absent, unparseable or list-less file is this review's own
+  // silence, never a clean result (design D10, D24 of
+  // label-and-harden-the-merge-verdict). The run goes on, as it does for a
+  // step that returned nothing usable, and adjudicates as with no findings.
+  const work = readFindingsWork(root)
+  if (work.missing) {
+    manifest.notes.push(
+      `review did not complete: ${noFindingsList(work.missing)}, so there is nothing this review wrote to adjudicate`
+    )
+  }
+  const reviewCompleted = reported && !work.missing
 
   // A dimension the reviewer added beyond the CLI's selection (design D4).
   // The CLI cannot know why; the one-line reason is the agent's own report,
@@ -1731,10 +2184,19 @@ export function runReviewed(ctx, { results, hostRecords }) {
   const added = Array.isArray(report && report.addedDimensions)
     ? report.addedDimensions.filter(d => d && typeof d.name === 'string' && !selected.has(d.name))
     : []
-  if (added.length) {
-    manifest.reviewDimensions = { ...(manifest.reviewDimensions || { selected: [], reasons: {} }), added }
+  // Whether the worker reported that it completed, recorded for every later
+  // adjudication of this run: the dimension record on `review.json` reads it,
+  // and a fixing round must not turn "did not complete" into "ran".
+  manifest.reviewDimensions = {
+    ...(manifest.reviewDimensions || { selected: [], reasons: {} }),
+    ...(added.length ? { added } : {}),
+    completed: reviewCompleted
   }
 
+  // After the two facts above, because the adjudication writes them on `review.json`.
+  const { result, banners } = adjudicateReview(ctx, manifest, work.missing ? [] : work.findings)
+  banners.push(...stageMarkerBanners(results))
+
   manifest.banners.push(...banners)
 
   const { plan, error } = planRemediationRound(result.surviving, 1)
@@ -1797,7 +2259,36 @@ export function runRemediated(ctx, { round, results, hostRecords }) {
     ))
   }
 
-  const { result, banners } = adjudicateReview(ctx, manifest)
+  // A round that leaves no findings list has cleared nothing (design D10 of
+  // label-and-harden-the-merge-verdict). Read as an empty review it would
+  // clear the very blockers it was asked to fix, and at the verdict round the
+  // run would commit. So the round is adjudicated from the surviving findings
+  // of the last adjudication, unchanged: `review.json`, which every
+  // adjudication of this run writes, read here before anything rewrites it and
+  // left as it is. When that cannot be read back either there is nothing to
+  // stand on, and the run halts: the one outcome that cannot clear a blocker.
+  const work = readFindingsWork(root)
+  let result
+  let banners
+  if (work.missing) {
+    const last = readJson(join(root, REVIEW_RECORD_PATH))
+    if (!last || typeof last !== 'object' || !Array.isArray(last.surviving)) {
+      return finishStep(ctx, manifest, haltStep(
+        `round ${completedRound} left no findings to adjudicate and the last adjudication cannot be read back: ` +
+          `${noFindingsList(work.missing)}, and ${REVIEW_RECORD_PATH} is absent, unparseable or without its ` +
+          `surviving list — nothing here can say a blocker was cleared`,
+        { banners: stageMarkerBanners(results) }
+      ))
+    }
+    manifest.notes.push(
+      `round ${completedRound} was not re-reviewed: ${noFindingsList(work.missing)}; the ${last.surviving.length} ` +
+        `finding(s) that survived the last adjudication stand unchanged`
+    )
+    result = last
+    banners = []
+  } else {
+    ;({ result, banners } = adjudicateReview(ctx, manifest, work.findings))
+  }
   banners.push(...stageMarkerBanners(results))
 
   if (completedRound === roundCap + 1) {
@@ -2487,6 +2978,7 @@ function speakInterruptedNotes(root, manifest) {
 export function runStart(ctx, { change, flags, host, hostCapabilities, hostEnv, stateHome }) {
   const { root } = ctx
   const manifest = newManifest({ change, flags, host, hostCapabilities })
+  manifest.startSha = readStartSha(ctx)
   // Where this run's corpora go, decided once and recorded (ship/state-home):
   // every later subcommand reads it back off the manifest and never resolves
   // again, so one run uses one home even if git state changes under it.
@@ -3366,6 +3858,7 @@ export function runJudge(ctx, { context, results, hostRecords }) {
     }
     verdict = judgeVerification(plan, reportedSteps, { context })
     for (const banner of verdict.banners || []) banners.push(banner)
+    if (context === 'final') recordFinalVerdict(root, manifest, verdict, banners)
     const exitFailure = logCliExit(ctx, manifest, 'verify judge', verdict.halt ? 1 : 0)
     if (exitFailure) {
       // The judgement happened; the record of it did not. Halting here is what
@@ -3388,6 +3881,25 @@ export function runJudge(ctx, { context, results, hostRecords }) {
     }
   } else {
     banners.push(`VERIFICATION SKIPPED: reason=${reason}`)
+    // Nothing ran, so there is no verdict; what the close reads instead is a
+    // verdict-shaped record of WHY, one band per skip reason (design D3 of
+    // complete-and-record-the-merge-verdict). Each kind is null, not absent:
+    // it did not run.
+    if (context === 'final') {
+      recordFinalVerdict(
+        root,
+        manifest,
+        {
+          context: 'final',
+          skipped: plan && Array.isArray(plan.skipped) ? plan.skipped : [],
+          unit: null,
+          e2e: null,
+          coverage: null,
+          typecheck: null
+        },
+        banners
+      )
+    }
   }
 
   if (context === 'inter-wave') {
@@ -3449,6 +3961,30 @@ export function runJudge(ctx, { context, results, hostRecords }) {
   return finishStep(ctx, manifest, commitStep(ctx, manifest, banners))
 }
 
+/** The final verdict the run acted on, where the close reads it back. */
+const VERIFY_FINAL_FILE = 'verify-final.json'
+
+/**
+ * Persist the final verification verdict, stamped with this run's id (design
+ * D3, D18 of complete-and-record-the-merge-verdict). It used to be a local of
+ * `runJudge`; the close assesses merge confidence from it, in another process.
+ * The id is what makes it THIS run's: the working directory is not cleared
+ * between runs, and a verdict an earlier run left must not be read as ours.
+ *
+ * A write that fails loses evidence, not the run: it is spoken and the judge
+ * goes on, and the close then reads the verification signals as unobserved.
+ */
+function recordFinalVerdict(root, manifest, verdict, banners) {
+  try {
+    writeWork(root, VERIFY_FINAL_FILE, { ...verdict, runId: manifest.runId ?? null })
+  } catch (err) {
+    banners.push(
+      `MERGE EVIDENCE UNAVAILABLE: the final verification verdict — it could not be recorded ` +
+        `(${(err && err.message) || String(err)})`
+    )
+  }
+}
+
 /**
  * The handoff step: the manual-test-plan decision and the conformance
  * checklist, computed here and inlined (design D5).
@@ -3480,6 +4016,11 @@ function handoffStep(ctx, manifest, banners = []) {
   }
 
   let scenarios = null
+  // The living requirements the change is asked to confirm (design D5 of
+  // complete-and-record-the-merge-verdict), and how many: `null` when
+  // conformance is off, or when no list could be built at all.
+  let living = null
+  let livingCount = null
   const extra = [...banners]
   if (manifest.flags.conformance === true) {
     const checklist = buildChecklist(root, change, { changed: changedPaths })
@@ -3492,6 +4033,30 @@ function handoffStep(ctx, manifest, banners = []) {
     } else {
       scenarios = checklist.scenarios
     }
+
+    // The same selection, base and bound the review step gives the `domain`
+    // reviewer, so the two can never disagree about which requirements are in
+    // force. Skipped and partial are each said once per run, as the two
+    // `DOMAIN REVIEW` banners are; a graph that links nothing is an empty list
+    // and says nothing. A living spec the base could not be read for is a list
+    // nobody could build, and is said as a skip rather than counted as zero.
+    const domain = gatherDomain(ctx, manifest, changedPaths)
+    const list = buildLivingChecklist({ selection: domain.selection, assembled: domain.assembled })
+    const unread = domain.readErrors.length ? `a living spec could not be read (${domain.readErrors.join('; ')})` : null
+    const skipReason = list.skipped || unread
+    if (skipReason) {
+      const banner = `LIVING CONFORMANCE SKIPPED: ${skipReason}`
+      raiseOnce(manifest, banner)
+      extra.push(banner)
+    } else {
+      living = list.requirements
+      livingCount = list.requirementsRequired
+      if (list.partial) {
+        const banner = `LIVING CONFORMANCE PARTIAL: ${list.partial}`
+        raiseOnce(manifest, banner)
+        extra.push(banner)
+      }
+    }
   }
 
   return makeStep({
@@ -3499,6 +4064,7 @@ function handoffStep(ctx, manifest, banners = []) {
     banners: extra,
     needsManualTestPlan,
     scenarios: scenarios ? scenarios.length : null,
+    living: livingCount,
     then: { argv: ['run', 'commit'] },
     spawns: [
       spawn(root, {
@@ -3513,7 +4079,8 @@ function handoffStep(ctx, manifest, banners = []) {
           needsManualTestPlan,
           testPlanReason,
           conformance: scenarios,
-          learnings: manifest.flags.handoff === true
+          learnings: manifest.flags.handoff === true,
+          ...(living ? { living } : {})
         })
       })
     ]
@@ -3581,7 +4148,12 @@ export function runCommit(ctx, { results, hostRecords }) {
         skipReason: typeof reported.skipReason === 'string' ? reported.skipReason : undefined,
         learnings: count(reported.learnings),
         scenariosChecked: count(reported.scenariosChecked),
-        scenariosUnconfirmed: count(reported.scenariosUnconfirmed)
+        scenariosUnconfirmed: count(reported.scenariosUnconfirmed),
+        // The living requirements, beside the scenarios (design D5 of
+        // complete-and-record-the-merge-verdict). Absent stays absent: a count
+        // nobody reported is not a count of zero.
+        requirementsChecked: count(reported.requirementsChecked),
+        requirementsUnconfirmed: count(reported.requirementsUnconfirmed)
       }
     : null
   if (!manifest.handoff) {
@@ -3803,6 +4375,182 @@ function recordDispatched(manifest, step) {
   }
 }
 
+// --- merge confidence at close (complete-and-record-the-merge-verdict) -------
+//
+// A completed run states its merge verdict once, from facts it observed: the
+// input is gathered by the function the `merge-confidence` command calls
+// (`lib/merge-evidence.mjs`), so the two cannot assemble it differently. The
+// verdict is reported — in the summary, the receipt, the outcome record and an
+// evidence file — and never enforced: nothing here touches the exit code.
+
+/** The run's evidence file, beside `review.json` in the working root (design D9). */
+const MERGE_EVIDENCE_FILE = 'merge-confidence.json'
+
+const isRecord = value => Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+
+/** One thing the gather could not read, as the degradation block says it (design D1). */
+function mergeEvidenceBanner(note) {
+  if (typeof note === 'string') return `MERGE EVIDENCE UNAVAILABLE: ${note}`
+  const what = note && typeof note.what === 'string' && note.what ? note.what : 'a fact'
+  const reason = note && typeof note.reason === 'string' && note.reason ? note.reason : 'no reason was given'
+  return `MERGE EVIDENCE UNAVAILABLE: ${what} — ${reason}`
+}
+
+/**
+ * Assess one gathered input. With no start commit the run has no base, and the
+ * module's readers say so in the command's words: the `--base` input was not
+ * given. A run has no flags, so the close adds what that means here — the base
+ * a ship run reads is its start commit, and this one recorded none (design D2).
+ * Evidence only: recombining the same bands and flags yields the same verdict
+ * and score.
+ */
+function assessForRun(input, base) {
+  const assessed = assessMergeConfidence(input)
+  if (base) return assessed
+  const line = 'a ship run reads its base from its start commit, and this run recorded no start commit'
+  return combineSignals(
+    assessed.signals.map(signal =>
+      /--base\b/.test(signal.reason) ? { ...signal, evidence: [...signal.evidence, line] } : signal
+    )
+  )
+}
+
+/**
+ * Gather and assess at close (design D2). Throws when the gather or the module
+ * does; the caller speaks that as `MERGE CONFIDENCE NOT ASSESSED`.
+ *
+ * What the run hands in is only what THIS run observed (design D18): the
+ * working directory is not cleared between runs, so `review.json` is read only
+ * when this run adjudicated a review, and `verify-final.json` only when it
+ * carries this run's id. No pipeline input, ever: the run is offline and no
+ * platform has seen the commit it just made.
+ *
+ * @returns {{ input: object, assessment: object, notes: Array, base: string|null, headSha: string|null,
+ *   committed: boolean, evidence: { review: any, verify: any, handoff: any, coverage: any, run: object } }}
+ */
+function assessAtClose(ctx, manifest, { touchedPaths, run }) {
+  const { root } = ctx
+  const deps = ctx.deps && typeof ctx.deps === 'object' ? ctx.deps : {}
+  const has = name => typeof deps[name] === 'function'
+  const notes = []
+  const base = pinnedSha(manifest)
+
+  // The commit the run made. The step reports the sha; HEAD, where this host
+  // can read it, supplies the full form of the same commit. A run told not to
+  // commit, and one whose commit step failed, are still on their start commit.
+  const commit = manifest.commit && manifest.commit.ok === true ? manifest.commit : null
+  const committed = Boolean(commit)
+  const reported = commit && typeof commit.sha === 'string' && commit.sha ? commit.sha : null
+  let head = null
+  try {
+    head = has('headCommit') ? deps.headCommit(root) : null
+  } catch {
+    head = null
+  }
+  if (typeof head !== 'string' || !head) head = null
+  const headSha = committed ? (reported && head && head.startsWith(reported) ? head : reported || head) : head || base
+
+  // The commit's own touched paths; the working tree's changed paths when the
+  // run made no commit or its commit could not be read (design D14).
+  let changedPaths = Array.isArray(touchedPaths) ? touchedPaths : null
+  if (!changedPaths) {
+    try {
+      const observed = has('observedChangedPaths') ? deps.observedChangedPaths(root) : []
+      changedPaths = Array.isArray(observed) ? observed : []
+    } catch {
+      changedPaths = []
+    }
+  }
+
+  let review = null
+  if (manifest.review) {
+    review = readJson(join(root, WORK_DIR, 'review.json'))
+    if (!isRecord(review)) {
+      review = null
+      notes.push({
+        what: 'the review record',
+        reason: `this run adjudicated a review and ${join(WORK_DIR, 'review.json')} could not be read back`
+      })
+    }
+  }
+
+  let verify = null
+  const recorded = readJson(join(root, WORK_DIR, VERIFY_FINAL_FILE))
+  if (isRecord(recorded) && typeof manifest.runId === 'string' && manifest.runId && recorded.runId === manifest.runId) {
+    const { runId: _stamp, ...verdict } = recorded
+    verify = verdict
+  }
+
+  // Coverage figures, computed where the verdict says the coverage command ran,
+  // so the report read is this run's (design D3). A reason is a note; the
+  // signal's own fallbacks then apply.
+  let coverage = null
+  if (verify && isRecord(verify.coverage)) {
+    const unavailable = reason => notes.push({ what: 'the coverage figures', reason })
+    if (!base) {
+      unavailable('this run recorded no start commit to compute them against')
+    } else if (!has('coverageInput')) {
+      unavailable('no coverageInput function was supplied, so this host has no means of computing them')
+    } else {
+      try {
+        const answer = deps.coverageInput(root, { base })
+        if (isRecord(answer) && isRecord(answer.input)) coverage = answer.input
+        else {
+          unavailable(
+            isRecord(answer) && typeof answer.reason === 'string' && answer.reason
+              ? answer.reason
+              : 'the computation returned neither figures nor a reason'
+          )
+        }
+      } catch (err) {
+        unavailable((err && err.message) || String(err))
+      }
+    }
+  }
+
+  // Git, as this host supplies it. A missing function is the gather's to note.
+  const git = {}
+  for (const name of ['diffShape', 'nameStatus', 'listFiles', 'readAtRef']) {
+    if (has(name)) git[name] = deps[name]
+  }
+  if (!committed && base) {
+    // The head is still the start commit, so the diff is empty by construction
+    // and says nothing about the change (design D14). Said in the run's terms.
+    git.diffShape = () => ({
+      base,
+      paths: [],
+      nothingToDiff:
+        `the run made no commit, so ${shortSha(base)}...HEAD is empty by construction and says nothing about the change`
+    })
+  }
+
+  const evidence = { review, verify, handoff: isRecord(manifest.handoff) ? manifest.handoff : null, coverage, run }
+  const gather = has('gatherMergeEvidence') ? deps.gatherMergeEvidence : gatherMergeEvidence
+  const gathered = gather(root, {
+    change: manifest.change,
+    changedPaths,
+    base,
+    headSha,
+    supplied: { ...evidence, pipeline: null },
+    deps: git,
+    // The graph the run selected living requirements from at the handoff, so
+    // the close recounts the same denominator (design D16).
+    ...(typeof manifest.graphPath === 'string' && manifest.graphPath ? { graphPath: manifest.graphPath } : {})
+  })
+  if (!isRecord(gathered) || !isRecord(gathered.input)) throw new Error('the gather returned no input to assess')
+  if (Array.isArray(gathered.notes)) notes.push(...gathered.notes)
+
+  return {
+    input: gathered.input,
+    assessment: assessForRun(gathered.input, base),
+    notes,
+    base,
+    headSha,
+    committed,
+    evidence
+  }
+}
+
 // --- run close (design D10) -------------------------------------------------
 
 /**
@@ -4068,12 +4816,42 @@ export async function runClose(
   const runnerCounts = manifest.agentCounts && typeof manifest.agentCounts === 'object' ? manifest.agentCounts : null
   const observedAny = Boolean(runnerCounts) || joined.present
   const count = (value = 0) => (observedAny ? value : undefined)
+
+  // Merge confidence, once, on a completed run only (design D2): a diff that
+  // stopped part-way is not a candidate for merging, and "never assessed" must
+  // stay distinguishable from a low score. Before the receipt, which carries
+  // the verdict. A failed assessment is spoken and changes no exit code
+  // (design D17): it is the outcome-corpus class of failure.
+  let merge = null
+  if (!haltReason) {
+    try {
+      merge = assessAtClose(ctx, manifest, {
+        touchedPaths: summary.paths.touchedPaths,
+        run: {
+          halted: false,
+          trajectoryComplete: !committerObserved.failure,
+          stageMarkerGaps: degradations.filter(b => typeof b === 'string' && b.startsWith('STAGE MARKER NOT PUBLISHED'))
+            .length,
+          rejectedReports: rejectedReportsOfRun(root).length,
+          permissionPrompts: count(closeObserved.permissionPrompts) ?? null,
+          autoModeDenials: count(closeObserved.autoModeDenials) ?? null,
+          leftoverTasks: leftoverTaskIds.length
+        }
+      })
+      for (const note of merge.notes) degradations.push(mergeEvidenceBanner(note))
+    } catch (err) {
+      merge = null
+      degradations.push(`MERGE CONFIDENCE NOT ASSESSED: ${(err && err.message) || String(err)}`)
+    }
+  }
+
   const receipt = buildReceipt({
     change: manifest.change,
     summary,
     degradations,
     planFingerprint,
     leftoverTaskIds,
+    mergeConfidence: merge ? merge.assessment : undefined,
     lanesStoppedByHost: count(runnerCounts ? runnerCounts.lanesStoppedByHost : 0),
     schemaResultsMissing: count(runnerCounts ? runnerCounts.schemaResultsMissing : 0),
     toolsDeniedInLanes: count(runnerCounts ? runnerCounts.toolsDeniedInLanes : 0),
@@ -4168,6 +4946,59 @@ export async function runClose(
     }
   }
 
+  // The assessment's last word (design D15). The receipt was built before its
+  // own append, so it could not know whether that append, the terminal event or
+  // the check above would fail. When one did, the run record's
+  // `trajectoryComplete` is no longer true: the close reassesses from the SAME
+  // gathered input with that one field changed, and the evidence file and the
+  // summary carry the result. The receipt keeps what it was built with. In the
+  // ordinary case nothing is computed twice.
+  let mergeSummary = null
+  if (merge) {
+    let assessed = merge.assessment
+    let runRecord = merge.evidence.run
+    const complete = trajectoryComplete && reconstructable
+    if (runRecord.trajectoryComplete !== complete) {
+      runRecord = { ...runRecord, trajectoryComplete: complete }
+      try {
+        assessed = assessForRun({ ...merge.input, run: runRecord }, merge.base)
+      } catch (err) {
+        assessed = null
+        degradations.push(`MERGE CONFIDENCE NOT ASSESSED: ${(err && err.message) || String(err)}`)
+      }
+    }
+    if (assessed) {
+      // Per-run working state, so it goes to the working root and never the
+      // state home. A file that cannot be written is spoken and is not named.
+      let assessmentPath = null
+      try {
+        writeWork(
+          root,
+          MERGE_EVIDENCE_FILE,
+          buildRunEvidence({
+            change: manifest.change,
+            runId: manifest.runId,
+            base: merge.base,
+            headSha: merge.headSha,
+            committed: merge.committed,
+            evidence: { ...merge.evidence, run: runRecord },
+            result: assessed
+          })
+        )
+        assessmentPath = [...WORK_DIR.split(/[\\/]/), MERGE_EVIDENCE_FILE].join('/')
+      } catch (err) {
+        degradations.push(`MERGE CONFIDENCE NOT WRITTEN: ${(err && err.message) || String(err)}`)
+      }
+      const driven = kind => assessed.driving.filter(d => d.kind === kind).map(d => d.id)
+      mergeSummary = {
+        headline: mergeConfidenceHeadline(assessed),
+        groups: { fix: driven('finding'), person: driven('person'), evidence: driven('evidence') },
+        flags: assessed.flags,
+        assessmentPath
+      }
+    }
+  }
+
   // The autonomy ladder's record for this run's review (design D6). It used to
   // ride on the commit prompt, which asked the party being assessed to write
   // the assessment's input — the exact provenance rule
@@ -4245,7 +5076,8 @@ export async function runClose(
       projectSlug: slug,
       push,
       unarchived,
-      resumeCard
+      resumeCard,
+      mergeConfidence: mergeSummary
     })
   }
 }