create-agdf 0.14.5 → 0.20.1

package/runtime/core/lib/control-state/run-operations.js

@@ -0,0 +1,80 @@
+import { validDecisionMaterial, decisionMaterialVersion } from './decision-material-contract.js';
+import { TextDecoder } from 'node:util';
+import { canonicalJson, digest, COOPERATIVE_ASSURANCE, DIGEST_PATTERN, exactObject } from './approval-command-contract.js';
+import { REVISION_ID_PATTERN, RUN_ID_PATTERN, APPROVAL_GATES } from './run-identity.js';
+import { isSafeControlRelativePath } from './contained-file.js';
+
+const fields = ['schema_version', 'kind', 'operation_id', 'request_digest', 'target_id', 'run_id', 'expected_revision_id', 'created_at', 'producer', 'assurance', 'effect'];
+export const RUN_OPERATION_KINDS = Object.freeze(['step.record', 'presentation_decision.record', 'prd_revision.reopen', 'closeout.record']);
+const uuid = value => typeof value === 'string' && REVISION_ID_PATTERN.test(value);
+const hash = value => typeof value === 'string' && DIGEST_PATTERN.test(value);
+const text = (value, max = 8192) => typeof value === 'string' && value.length <= max && !/\0/u.test(value);
+const source = (value, runId) => exactObject(value, ['path', 'digest']) && isSafeControlRelativePath(value.path)
+  && value.path.startsWith(`.agdf/control/artefacts/${runId}/`) && hash(value.digest);
+function validRecord(receipt) {
+  const r = receipt.effect.record;
+  if (receipt.kind === 'step.record') return exactObject(r, ['step', 'source', 'status', 'covers', 'source_set_digest'])
+    && ['ur', 'route', 'review', 'evidence', 'Brownfield Review', 'UX Intent Definition', 'Brownfield Analysis', 'CD+Tests', 'TP Review', 'Clean Implementation Review', 'CR'].includes(r.step)
+    && source(r.source, receipt.run_id) && ['done', 'revise', 'block', 'not_applicable'].includes(r.status)
+    && text(r.covers, 1024) && hash(r.source_set_digest);
+  if (receipt.kind === 'presentation_decision.record') return exactObject(r, ['gate', 'presentation_id', 'presentation_digest', 'material_version', 'material_sources', 'action', 'comment', 'owner', 'artefact_digest'])
+    && APPROVAL_GATES.includes(r.gate) && uuid(r.presentation_id) && hash(r.presentation_digest) && hash(r.material_version)
+    && validDecisionMaterial(r.material_sources, receipt.run_id) && r.material_version === decisionMaterialVersion(receipt.run_id, r.gate, r.material_sources) && ['request_change', 'reject'].includes(r.action) && text(r.comment) && Buffer.byteLength(r.comment) <= 8192 && (r.action !== 'request_change' || r.comment.trim())
+    && text(r.owner, 128) && r.owner.trim() && (r.gate === 'UAT' ? r.artefact_digest === null : hash(r.artefact_digest));
+  if (receipt.kind === 'closeout.record') return exactObject(r, ['or', 'lifecycle', 'context_evidence_digest', 'confirmation_digest'])
+    && source(r.or, receipt.run_id) && r.or.path === `.agdf/control/artefacts/${receipt.run_id}/OR.md`
+    && r.lifecycle === 'completed' && hash(r.context_evidence_digest) && hash(r.confirmation_digest);
+  if (receipt.kind === 'prd_revision.reopen') return exactObject(r, ['prd', 'archive', 'confirmation_digest']) && source(r.prd, receipt.run_id)
+    && r.prd.path === `.agdf/control/artefacts/${receipt.run_id}/PRD.md`
+    && exactObject(r.archive, ['path', 'digest']) && r.archive.path === `.agdf/control/runs/${receipt.run_id}/revisions/${receipt.operation_id}/manifest.json`
+    && hash(r.archive.digest) && hash(r.confirmation_digest)
+    && r.confirmation_digest === digest(earlyPrdConfirmation(receipt.run_id, receipt.expected_revision_id, receipt.operation_id, r.prd.digest));
+  return false;
+}
+export const earlyPrdConfirmation = (runId, revisionId, operationId, prdDigest) => `Reopen PRD: ${runId} ${revisionId} ${operationId} ${prdDigest}`;
+export function validRunOperation(receipt) {
+  return exactObject(receipt, fields) && receipt.schema_version === '1' && RUN_OPERATION_KINDS.includes(receipt.kind)
+    && uuid(receipt.operation_id) && hash(receipt.request_digest) && hash(receipt.target_id) && RUN_ID_PATTERN.test(receipt.run_id ?? '')
+    && uuid(receipt.expected_revision_id) && exactObject(receipt.effect, ['previous_revision_id', 'resulting_revision_id', 'revision', 'record'])
+    && receipt.effect.previous_revision_id === receipt.expected_revision_id && uuid(receipt.effect.resulting_revision_id)
+    && receipt.effect.resulting_revision_id !== receipt.expected_revision_id && Number.isSafeInteger(receipt.effect.revision) && receipt.effect.revision >= 2
+    && exactObject(receipt.producer, ['contract', 'package_version']) && receipt.producer.contract === 'run-command/1' && text(receipt.producer.package_version, 128) && receipt.producer.package_version
+    && canonicalJson(receipt.assurance) === canonicalJson(COOPERATIVE_ASSURANCE)
+    && typeof receipt.created_at === 'string' && /^\d{4}-\d{2}-\d{2}T.*Z$/u.test(receipt.created_at) && Number.isFinite(Date.parse(receipt.created_at)) && Boolean(validRecord(receipt));
+}
+export function readRunOperations(content) {
+  const lines = String(content).replace(/\r\n?/gu, '\n').split('\n');
+  const starts = lines.flatMap((line, i) => /^## Run Operations\s*$/u.test(line) ? [i] : []);
+  if (!starts.length) return { present: false, valid: true, receipts: [] };
+  const invalid = () => ({ present: true, valid: false, receipts: [], reason: 'run_operations_invalid' });
+  if (starts.length !== 1) return invalid();
+  const start = starts[0]; let end = start + 1;
+  while (end < lines.length && !/^#{1,2} /u.test(lines[end])) end++;
+  const body = lines.slice(start + 1, end).map(line => line.trim()).filter(Boolean);
+  if (body[0] !== '- schema_version: 1' || body[1] !== '| operation_id | request_digest | receipt |' || !/^\|[-:|\s]+\|$/u.test(body[2] ?? '')) return invalid();
+  const receipts = [], ids = new Set(), revisions = new Set(); let revision = 1;
+  for (const line of body.slice(3)) {
+    const cells = line.match(/^\| ([^|]+) \| ([^|]+) \| ([A-Za-z0-9_-]+) \|$/u);
+    if (!cells || cells[3].length > 131072) return invalid();
+    try {
+      const bytes = Buffer.from(cells[3], 'base64url'), json = new TextDecoder('utf-8', { fatal: true }).decode(bytes), r = JSON.parse(json);
+      if (bytes.toString('base64url') !== cells[3] || canonicalJson(r) !== json || !validRunOperation(r)
+        || r.operation_id !== cells[1] || r.request_digest !== cells[2] || ids.has(r.operation_id) || revisions.has(r.effect.resulting_revision_id) || r.effect.revision <= revision) return invalid();
+      receipts.push(r); ids.add(r.operation_id); revisions.add(r.effect.resulting_revision_id); revision = r.effect.revision;
+    } catch { return invalid(); }
+  }
+  return receipts.length ? { present: true, valid: true, receipts, start, end } : invalid();
+}
+export function appendRunOperation(content, receipt) {
+  const before = readRunOperations(content); if (!before.valid || !validRunOperation(receipt)) throw Error('AGDF_RUN_OPERATIONS_INVALID');
+  const block = ['## Run Operations', '', '- schema_version: 1', '', '| operation_id | request_digest | receipt |', '|---|---|---|',
+    ...[...before.receipts, receipt].map(r => `| ${r.operation_id} | ${r.request_digest} | ${Buffer.from(canonicalJson(r)).toString('base64url')} |`), ''];
+  const lines = String(content).split('\n');
+  const result = before.present ? [...lines.slice(0, before.start), ...block, ...lines.slice(before.end)].join('\n') : `${String(content).trimEnd()}\n\n${block.join('\n')}`;
+  if (!readRunOperations(result).valid) throw Error('AGDF_RUN_OPERATIONS_INVALID'); return result;
+}
+export function assertRunOperationsChange(current, candidate, appended) {
+  const before = readRunOperations(current), after = readRunOperations(candidate);
+  if (!before.valid || !after.valid || after.present !== (before.present || Boolean(appended))
+    || canonicalJson(after.receipts) !== canonicalJson(appended ? [...before.receipts, appended] : before.receipts)) throw Error('AGDF_RUN_OPERATIONS_CHANGED');
+}

package/runtime/core/lib/control-state/run-owned-outputs.js

@@ -0,0 +1,59 @@
+import { join } from 'node:path';
+import { existsSync, lstatSync, readFileSync, unlinkSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { exactObject } from './approval-command-contract.js';
+import { hasSymlinkComponent } from './contained-file.js';
+import { atomicWrite, fsyncDirectory } from './run-state-writer.js';
+
+export const INTERNAL_STEP_FILES = Object.freeze({
+  'Brownfield Review': 'BROWNFIELD_REVIEW.md', 'UX Intent Definition': 'UX_INTENT_DEFINITION.md',
+  'Brownfield Analysis': 'BROWNFIELD_ANALYSIS.md', 'CD+Tests': 'CD_TESTS.md', 'TP Review': 'TP_REVIEW.md',
+  'Clean Implementation Review': 'CLEAN_IMPLEMENTATION_REVIEW.md', CR: 'CODE_REVIEW.md',
+});
+const permitted = new Set(['UR.md', 'OR.md', ...Object.values(INTERNAL_STEP_FILES)]);
+export const outputBytesDigest = text => text === null ? null : 'sha256:' + createHash('sha256').update(text, 'utf8').digest('hex');
+export function ownedOutputPath(root, runId, path) {
+  const prefix = `.agdf/control/artefacts/${runId}/`;
+  if (typeof path !== 'string' || !path.startsWith(prefix) || !permitted.has(path.slice(prefix.length)) || hasSymlinkComponent(root, path)) throw Error('AGDF_RUN_STEP_RECOVERY_REQUIRED');
+  return join(root, path);
+}
+export function ownedOutputText(root, runId, path) {
+  const file = ownedOutputPath(root, runId, path);
+  if (!existsSync(file)) return null;
+  const stat = lstatSync(file); if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 131072) throw Error('AGDF_RUN_STEP_RECOVERY_REQUIRED');
+  return new TextDecoder('utf-8', { fatal: true }).decode(readFileSync(file));
+}
+export function validOwnedOutputs(runId, outputs) {
+  const prefix = `.agdf/control/artefacts/${runId}/`;
+  return Array.isArray(outputs) && outputs.length <= 2 && new Set(outputs.map(row => row?.path)).size === outputs.length
+    && outputs.every(row => exactObject(row, ['path', 'old', 'next', 'old_digest', 'next_digest'])
+      && typeof row.path === 'string' && row.path.startsWith(prefix) && permitted.has(row.path.slice(prefix.length))
+      && (row.old === null || typeof row.old === 'string') && typeof row.next === 'string'
+      && Buffer.byteLength(row.next) <= 131072 && (row.old === null || Buffer.byteLength(row.old) <= 131072)
+      && row.old_digest === outputBytesDigest(row.old) && row.next_digest === outputBytesDigest(row.next));
+}
+export function prepareOwnedOutput(root, runId, path, next) {
+  const old = ownedOutputText(root, runId, path), row = { path, old, next, old_digest: outputBytesDigest(old), next_digest: outputBytesDigest(next) };
+  if (!validOwnedOutputs(runId, [row])) throw Error('AGDF_RUN_STEP_RECOVERY_REQUIRED'); return row;
+}
+export function publishOwnedOutputs(root, journal, checkpoint) {
+  for (const row of journal.outputs) {
+    if (ownedOutputText(root, journal.run_id, row.path) !== row.old) throw Error('AGDF_RUN_STEP_RECOVERY_REQUIRED');
+    atomicWrite(ownedOutputPath(root, journal.run_id, row.path), row.next, { checkpoint: stage => checkpoint(`output_${stage}`) });
+    checkpoint('output');
+  }
+}
+export function recoverOwnedOutputs(root, journal, committed) {
+  for (const row of journal.outputs) {
+    const text = ownedOutputText(root, journal.run_id, row.path);
+    if (committed) { if (text !== row.next) throw Error('AGDF_RUN_STEP_RECOVERY_REQUIRED'); }
+    else {
+      if (text !== row.old && text !== row.next) throw Error('AGDF_RUN_STEP_RECOVERY_REQUIRED');
+      if (text !== row.old) {
+        const file = ownedOutputPath(root, journal.run_id, row.path);
+        if (row.old === null) { unlinkSync(file); fsyncDirectory(join(root, `.agdf/control/artefacts/${journal.run_id}`)); }
+        else atomicWrite(file, row.old);
+      }
+    }
+  }
+}

package/runtime/core/lib/control-state/run-presentation-envelope.js

@@ -0,0 +1,36 @@
+// Immutable envelope validation is shared by live and archived proofs.
+import { digest as hash, exactObject, DIGEST_PATTERN } from "./approval-command-contract.js";
+import { validPreviewSnapshot } from "./preview-snapshot.js";
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+const recovery = "Run run-present for the current run/gate/revision, show its exact presentation, then wait for a NEW deliberate user response. Never bind an earlier reply retroactively.";
+
+export { UUID as PRESENTATION_ID_PATTERN, recovery as PRESENTATION_RECOVERY };
+
+// Rechecks the immutable presentation envelope without evaluating a Run hidden by its
+// own pending journal. Full policy/binding validation must precede transaction intent.
+// Pure record check is also consumed inside captured read-only observations.
+export function validateRunPresentationEnvelope(envelope, { runId, gate, revisionId, presentationId }) {
+  const { record, digest } = envelope ?? {};
+  if (!record || ![1, 2, 3, 4, 5].includes(record.schema_version) || record.presentation_id !== presentationId
+      || record.run_id !== runId || record.gate !== gate || record.revision_id !== revisionId
+      || digest !== hash(JSON.stringify(record)) || !Number.isFinite(Date.parse(record.created_at))) {
+    return { reason: "presentation_binding_invalid", recovery };
+  }
+  if (record.schema_version === 2 && (!exactObject(envelope, ['record', 'digest'])
+    || !exactObject(record, ['schema_version', 'presentation_id', 'operation_id', 'request_digest', 'created_at', 'run_id', 'gate', 'revision_id', 'content_digest', 'artefact_digest', 'summary_digest', 'presentation_language', 'presentation_digest'])
+    || record.operation_id !== presentationId || !UUID.test(record.operation_id) || !DIGEST_PATTERN.test(record.request_digest ?? ''))) return { reason: 'presentation_binding_invalid', recovery };
+  if ([3, 4, 5].includes(record.schema_version) && (!exactObject(envelope, ['record', 'digest'])
+    || !exactObject(record, ['schema_version', 'presentation_id', ...(record.operation_id ? ['operation_id', 'request_digest'] : []),
+      'created_at', 'run_id', 'gate', 'revision_id', 'content_digest', 'artefact_digest', 'summary_digest', 'presentation_language',
+      'presentation_digest', 'document_digest', 'document_bytes', 'document_language', ...(record.schema_version === 4 ? ['qa_acceptance'] : []), ...(record.schema_version === 5 ? ['preview_review'] : [])])
+    || record.operation_id && (record.operation_id !== presentationId || !UUID.test(record.operation_id) || !DIGEST_PATTERN.test(record.request_digest ?? ''))
+    || !/^[a-z]{2}(?:-[A-Za-z0-9]{2,8})*$/u.test(record.document_language ?? '')
+    || !DIGEST_PATTERN.test(record.document_digest ?? '') || !Number.isInteger(record.document_bytes)
+    || record.document_bytes < 1 || record.document_bytes > 131072)) return { reason: 'presentation_binding_invalid', recovery };
+  if (record.schema_version === 4 && (gate !== 'QA' || !exactObject(record.qa_acceptance, ['kind', 'digest'])
+    || record.qa_acceptance.kind !== 'accepted_with_deviations' || !DIGEST_PATTERN.test(record.qa_acceptance.digest ?? ''))) return { reason: 'presentation_binding_invalid', recovery };
+  if (record.schema_version === 5 && (gate !== 'PRD' || !validPreviewSnapshot(record.preview_review, runId, presentationId))) return { reason: 'presentation_binding_invalid', recovery };
+  return { presentationId, digest, record };
+}
+

package/runtime/core/lib/control-state/run-presentation-render.js

@@ -0,0 +1,443 @@
+import { readAcceptanceCriteria } from "../control-evaluation/traceability-readiness.js";
+import { createHash } from "node:crypto";
+import { readFileSync } from "../control-read/fs.js";
+import { basename } from "node:path";
+import { TextDecoder } from "node:util";
+import { resolvedArtefactFile } from "../control-evaluation/run-state.js";
+import { interactionLocales, resolveArtifactPresentationLanguages } from "../resources/context.js";
+import { localePack, resolvePresentationLocale, resolveHumanRunTitle } from "../interaction-presentation.js";
+import { readSourceRevisions, SOURCE_GATES } from './run-source-revisions.js';
+import { readRunOperations } from './run-operations.js';
+import { qaDeviationPresentation } from './qa-deviation-acceptance.js';
+import { observeDecisionContent, decisionContentRecovery, localizedDecisionFields } from '../control-evaluation/decision-content-readiness.js';
+import { readReportDecision } from '../control-evaluation/report-decision.js';
+import { previewForState } from './preview-review.js';
+import { readValidatedRevisionArchive, validateRevisionHistory, validateEarlyPrdHistory, earlyPrdHistoryReference, byteDigest } from './run-revision-history.js';
+
+// Compare only an actual immutable prior version from the existing archive owner.
+// A current file or an unbound historical Evidence row is never a previous version.
+export function presentationVersionComparison(root, state, gate, currentDigest) {
+  const unavailable = reason => ({ state: 'unavailable', reason });
+  if (!SOURCE_GATES.includes(gate)) return unavailable('no_verified_prior_applicable_version');
+  const history = readSourceRevisions(state.content), operations = readRunOperations(state.content);
+  if (!history.valid || !operations.valid) return unavailable('historical_source_unconfirmed');
+  const candidates = [
+    ...history.receipts.filter(row => SOURCE_GATES.indexOf(row.source_gate) <= SOURCE_GATES.indexOf(gate)).map(row => ({ revision: row.revision, row, early: false })),
+    ...operations.receipts.filter(row => row.kind === 'prd_revision.reopen' && gate === 'PRD').map(row => ({ revision: row.effect.revision, row, early: true })),
+  ].sort((a, b) => b.revision - a.revision);
+  if (!candidates.length) return unavailable('no_verified_prior_applicable_version');
+  const candidate = candidates[0];
+  try {
+    if (!(candidate.early ? validateEarlyPrdHistory(root, candidate.row) : validateRevisionHistory(root, candidate.row))) return unavailable('historical_source_unconfirmed');
+    const archive = readValidatedRevisionArchive(root, candidate.early ? earlyPrdHistoryReference(candidate.row) : candidate.row);
+    const previous = archive?.control.artefacts.get(gate), bytes = previous?.path && archive.archived.get(previous.path);
+    if (!bytes || bytes.length > 131072 || !['draft', 'approved'].includes(previous.status)) return unavailable('no_verified_prior_applicable_version');
+    const previousText = new TextDecoder('utf-8', { fatal: true }).decode(bytes), previousDigest = byteDigest(bytes);
+    return { state: 'available', previous_revision_id: archive.parsed.meta.revision_id,
+      previous_digest: previousDigest, current_digest: currentDigest, unchanged: previousDigest === currentDigest, previous_text: previousText };
+  } catch { return unavailable('historical_source_unconfirmed'); }
+}
+
+// Read-only approval rendering. gate-check (and with it the MCP dispatcher) imports this module;
+// writing presentation records stays in run-presentation.js.
+const MAX_APPROVAL_ARTEFACT_BYTES = 131072;
+const MAX_LOCALIZED_SUMMARY_ITEM_CHARS = 1200;
+const MAX_LOCALIZED_SUMMARY_CHARS = 24000;
+const SUMMARY_SECTIONS = Object.freeze({
+  UR: [
+    ["Problem", /problem|need|anlass/iu], ["Ziel", /goal|objective|ziel/iu],
+    ["Umfang", /scope|umfang/iu], ["Abnahme", /acceptance|abnahme|success signal/iu],
+    ["Offen", /risk|unknown|open question|offen/iu],
+  ],
+  PRD: [
+    ["Nutzerziel", /ux intent and success|user intent/iu, /^primary_user_intent\s*:/iu],
+    ["Erfolg", /ux intent and success|user intent/iu, /^success_signal\s*:/iu],
+    ["Produktumfang", /product scope|umfang/iu],
+    ["Abnahme", /acceptance criteria|abnahmekriterien/iu], ["Abgrenzung", /non-goal|out of scope|nichtumfang/iu],
+    ["Offen", /risk|open question|offen/iu],
+  ],
+  SD: [
+    ["Lösung", /solution overview|lösung/iu], ["Verantwortung", /ownership|source of truth|verantwortung|so?t/iu],
+    ["Entscheidungen", /architecture decision|design decision|architekturentscheidung/iu],
+    ["Integration", /integration point|integration/iu], ["Offen", /risk|open question|offen/iu],
+  ],
+  TP: [
+    ["Aufgaben", /task list|aufgaben/iu], ["Tests", /test plan|tests?/iu],
+    ["Abgrenzung", /out of scope|nichtumfang/iu], ["Risiken", /risk|blocker|risik|blocker/iu],
+  ],
+  QA: [
+    ['Ergebnis', /tp coverage/iu, /^delivered_result:/iu],
+    ["Entscheidung", /qa decision|entscheidung/iu], ["TP-Abdeckung", /tp coverage|abdeckung/iu, /^(?!delivered_result:)/iu],
+    ["Belege", /evidence|belege/iu], ["Fehlt", /missing evidence|fehlende belege/iu],
+    ["Risiken", /risk|risik/iu], ["Nächster Schritt", /required next step|next step|nächster schritt/iu],
+  ],
+});
+const SUMMARY_LABELS_EN = Object.freeze({
+  Problem: "Problem", Ziel: "Goal", Umfang: "Scope", Abnahme: "Acceptance", Offen: "Open questions",
+  Produktumfang: "Product scope", Nutzerziel: "User intent", Erfolg: "Success", "Abgrenzung": "Non-goals", Lösung: "Solution",
+  Verantwortung: "Ownership", Entscheidungen: "Design decisions", Integration: "Integration",
+  Aufgaben: "Tasks", Tests: "Tests", Risiken: "Risks", Entscheidung: "Decision",
+  "TP-Abdeckung": "Task plan coverage", Belege: "Evidence", Fehlt: "Missing evidence", "Nächster Schritt": "Next step",
+  Ergebnis: 'Delivered result',
+});
+export const hash = (value) => `sha256:${createHash("sha256").update(value).digest("hex")}`;
+
+function compactSummaryText(value) {
+  return value.replace(/\[([^\]]+)\]\([^)]*\)/gu, "$1").replace(/`([^`]+)`/gu, "$1")
+    .replace(/<[^>]+>/gu, "").replace(/\s+/gu, " ").trim();
+}
+
+function userFacingSummaryText(value) {
+  const text = compactSummaryText(value);
+  const content = text.match(/^(?:delivered_result|qualification_limits|delivery_risks):\s*(.+)$/iu);
+  if (content) return content[1];
+  const intent = text.match(/^(?:primary_user_intent|success_signal)\s*:\s*(.+)$/iu);
+  if (intent) return capitalizeSummary(intent[1].trim());
+  if (/^(?:ui_ux_impact|ux_intent_definition|primary_decision_or_action)\s*:/iu.test(text)) return "";
+  if (!/^criterion_id\s*:/iu.test(text)) return text;
+  const clauses = text.split(/;\s*/u);
+  for (const field of ["visible feedback", "observable success", "expected effective state"]) {
+    const clause = clauses.find((item) => item.match(new RegExp(`^${field}\\s*:`, "iu")));
+    if (clause) return capitalizeSummary(clause.replace(new RegExp(`^${field}\\s*:\\s*`, "iu"), "").trim());
+  }
+  return "";
+}
+
+function capitalizeSummary(value) {
+  return value.replace(/^\p{Ll}/u, (letter) => letter.toUpperCase());
+}
+
+function substantiveMarkdown(markdown) {
+  return markdown.replace(/^## AGDF Approval Summary \([^\r\n]*\)\s*\r?\n[\s\S]*?(?=^#{1,2}\s|(?![\s\S]))/gmu, "");
+}
+
+function criterionEntries(markdown) {
+  const parsed = readAcceptanceCriteria(substantiveMarkdown(markdown));
+  if (parsed.diagnostics.length) throw Object.assign(new Error("approval_summary_source_criteria_invalid"), { diagnostics: parsed.diagnostics });
+  return parsed.entries;
+}
+
+function criterionDescription(entry) {
+  for (const field of ["observable_success", "visible_feedback", "expected_effective_state"]) {
+    const value = String(entry.fields[field] ?? "").trim();
+    if (value) return capitalizeSummary(compactSummaryText(value));
+  }
+  return "";
+}
+
+function approvalDecisionEntries(markdown) {
+  const source = substantiveMarkdown(markdown);
+  const section = source.split(/^## Approval Decisions\s*$/mu)[1]?.split(/^## /mu)[0] ?? "";
+  return section.split(/\r?\n/u).filter((line) => line.trim().startsWith("|"))
+    .map((line) => line.split("|").slice(1, -1).map((cell) => compactSummaryText(cell.trim())))
+    .filter((cells) => cells.length >= 4 && cells[0] && cells[0] !== "Decision" && !/^[-:]+$/u.test(cells[0]))
+    .map((cells) => ({ id: cells[0], timing: cells[1] ?? "", status: cells[2] ?? "", resolution: cells[3] ?? "" }));
+}
+
+function localizedSummaryBlocks(markdown) {
+  const source = markdown.replace(/\r\n?/gu, "\n");
+  const matches = [...source.matchAll(/^## AGDF Approval Summary \(([^;\n]+);\s*source=([A-Za-z][A-Za-z0-9-]*)\)\s*\n([\s\S]*?)(?=^#{1,2}\s|(?![\s\S]))/gmu)];
+  return matches.map((match) => ({ locale: match[1].trim(), source: match[2].trim().toLowerCase(), body: match[3].trim() }));
+}
+
+function validateLocalizedSummaryBlock(gate, block, sourceMarkdown, sourceLanguage) {
+  if (!block || !block.body) throw new Error("approval_summary_locale_missing");
+  if (block.source !== sourceLanguage) throw new Error("approval_summary_source_language_mismatch");
+  if (block.body.length > MAX_LOCALIZED_SUMMARY_CHARS || /(?:…|\.\.\.)/u.test(block.body))
+    throw new Error("approval_summary_truncated_or_overlong");
+  const lines = block.body.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+  if (lines.some((line) => line.length > MAX_LOCALIZED_SUMMARY_ITEM_CHARS))
+    throw new Error("approval_summary_field_overlong");
+  if (gate === "PRD") {
+    const sourceIds = criterionEntries(sourceMarkdown).map((entry) => entry.id);
+    const summaryIds = lines.flatMap((line) => [...line.matchAll(/^\s*[-*]\s*([A-Z][A-Z0-9]*(?:-[A-Z0-9]+)+)\s*:/giu)].map((match) => match[1]));
+    if (!sourceIds.length) throw new Error("approval_summary_criteria_missing");
+    if (new Set(sourceIds).size !== sourceIds.length) throw new Error("approval_summary_source_criteria_duplicate");
+    if (new Set(summaryIds).size !== summaryIds.length) throw new Error("approval_summary_criteria_duplicate");
+    const sourceSet = new Set(sourceIds);
+    if (summaryIds.some((id) => !sourceSet.has(id))) throw new Error("approval_summary_criteria_unknown");
+    if (summaryIds.length !== sourceIds.length || sourceIds.some((id) => !summaryIds.includes(id)))
+      throw new Error("approval_summary_criteria_incomplete");
+    if (!lines.some((line) => /^(?:[-*]\s*)?(?:Nutzerziel|User intent|Ziel|Goal)\s*:/iu.test(line)))
+      throw new Error("approval_summary_user_goal_missing");
+    if (!lines.some((line) => /^(?:[-*]\s*)?(?:Umfang|Scope|Produktumfang|Product scope)\s*:/iu.test(line)))
+      throw new Error("approval_summary_scope_missing");
+    const decisions = approvalDecisionEntries(sourceMarkdown);
+    if (decisions.length && !lines.some((line) => /^(?:[-*]\s*)?(?:Entscheidungen|Decisions|Geklärte Entscheidungen|Resolved decisions|Offene Entscheidungen|Open decisions)\s*:/iu.test(line)))
+      throw new Error("approval_summary_decisions_missing");
+  }
+}
+
+function requiredLocalizedSummary(gate, markdown, languages, { path } = {}) {
+  if (!languages.approval_summary_required) return null;
+  const blocks = localizedSummaryBlocks(markdown).filter(block => block.locale === languages.presentation_language);
+  if (blocks.length !== 1) throw new Error(blocks.length ? "approval_summary_locale_duplicate" : "approval_summary_locale_missing");
+  const block = blocks[0];
+  validateLocalizedSummaryBlock(gate, block, substantiveMarkdown(markdown), languages.artifact_language);
+  // UAT reads these fields later with the same owner and the same locale choice.
+  const locale = String(languages.presentation_language ?? "").toLowerCase().startsWith("de") ? "de" : "en";
+  const { gaps } = localizedDecisionFields(gate, markdown, { locale, sourceLanguage: languages.artifact_language, path });
+  if (gaps.length) throw Object.assign(new Error("approval_summary_field_unreadable"),
+    { diagnostics: gaps.map(({ field, expected }) => ({ field, expected })) });
+  return block;
+}
+
+// Reuse the presentation validator before authoring is considered complete.
+export function evaluateApprovalSummaryReadiness(gate, markdown, languages, { path } = {}) {
+  try {
+    requiredLocalizedSummary(gate, markdown, languages, { path });
+    return Object.freeze({ ready: true, required_heading: languages.approval_summary_heading, reason: null });
+  } catch (error) {
+    if (!String(error.message).startsWith("approval_summary_")) throw error;
+    return Object.freeze({ ready: false, required_heading: languages.approval_summary_heading, reason: error.message, ...(error.diagnostics ? { diagnostics: error.diagnostics } : {}) });
+  }
+}
+
+// Diagnosis shares the validator's owner. It describes a failed constraint, never relaxes it.
+export function renderApprovalSummaryIssue(summary, { path, presentationLanguage }) {
+  const locale = resolvePresentationLocale(interactionLocales, presentationLanguage);
+  const pack = localePack(interactionLocales, locale), german = locale.split("-")[0] === "de";
+  const expected = {
+    approval_summary_user_goal_missing: german ? "- Ziel:" : "- Goal:",
+    approval_summary_scope_missing: german ? "- Umfang:" : "- Scope:",
+    approval_summary_decisions_missing: german ? "- Entscheidungen:" : "- Decisions:",
+    approval_summary_field_unreadable: summary.diagnostics?.map(row => row.expected).join("` · `") || undefined,
+  }[summary.reason] ?? summary.required_heading;
+  return [
+    `${pack.statusCard.summaryRecovery}: \`${path}\``,
+    `${pack.statusCard.summaryReason}: \`${summary.reason}\``,
+    `${pack.statusCard.summaryExpected}: \`${expected}\`${expected !== summary.required_heading ? ` · \`${summary.required_heading}\`` : ""}`,
+  ].join("\n");
+}
+
+function sectionBody(markdown, pattern, contentPattern = null, maxItems = 3) {
+  const lines = markdown.replace(/\r\n?/gu, "\n").split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const heading = lines[index].match(/^(#{2,6})\s+(?:\d+\.\s*)?(.+?)\s*#*\s*$/u);
+    if (!heading || !pattern.test(heading[2])) continue;
+    const body = [];
+    const level = heading[1].length;
+    let inTable = false;
+    for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+      const nextHeading = lines[cursor].match(/^(#{2,6})\s+/u);
+      if (nextHeading && nextHeading[1].length <= level) break;
+      let line = lines[cursor].trim();
+      if (!line) { inTable = false; continue; }
+      if (/^\|/u.test(line)) {
+        if (!inTable) { inTable = true; continue; }
+        if (/^\|?[\s:|-]+\|?$/u.test(line)) continue;
+        line = line.replace(/^\||\|$/gu, "").split("|").map((cell) => cell.trim()).filter(Boolean).join(" — ");
+      } else {
+        inTable = false;
+        line = line.replace(/^(?:[-*+]\s+|\d+[.)]\s+)/u, "");
+      }
+      if (contentPattern && !contentPattern.test(line)) continue;
+      const cleaned = userFacingSummaryText(line);
+      if (!cleaned || /^(?:what|which|how|who|every field|specify|decision:|status:|gate:|date:|owner:)/iu.test(cleaned)
+          || /^(?:ui_ux_impact|ux_intent_definition|primary_user_intent|success_signal|primary_decision_or_action):/iu.test(cleaned)) continue;
+      body.push(cleaned);
+      if (body.length >= maxItems) break;
+    }
+    if (body.length) return body;
+  }
+  return [];
+}
+
+function artifactSummary(gate, markdown, { runId, revisionId, language, sourceLanguage, artefactPath }) {
+  const locale = resolvePresentationLocale(interactionLocales, language);
+  const pack = localePack(interactionLocales, locale);
+  const german = locale.split("-")[0] === "de";
+  const source = substantiveMarkdown(markdown);
+  const presentationLanguage = locale.split("-")[0];
+  const sourceLanguageNote = sourceLanguage !== presentationLanguage
+    ? `- ${pack.statusCard.sourceLanguage}: ${pack.statusCard[{ en: "languageEnglish", de: "languageGerman" }[sourceLanguage]] ?? sourceLanguage} · ${pack.statusCard.originalLanguageExcerpts}`
+    : "";
+  const items = [];
+  if (sourceLanguage !== presentationLanguage) {
+    const block = requiredLocalizedSummary(gate, markdown, {
+      approval_summary_required: true, presentation_language: locale, artifact_language: sourceLanguage,
+    }, { path: artefactPath });
+    const summary = [sourceLanguageNote, block.body].filter(Boolean).join("\n");
+    return { markdown: summary, digest: hash(summary) };
+  }
+
+  for (const [label, pattern, contentPattern] of SUMMARY_SECTIONS[gate] ?? []) {
+    if (gate === "PRD" && label === "Abnahme") continue;
+    if (gate === "PRD" && label === "Offen") continue;
+    const maxItems = gate === "TP" && label === "Aufgaben" ? Number.POSITIVE_INFINITY : 1;
+    const values = sectionBody(source, pattern, contentPattern, maxItems);
+    if (!values.length) continue;
+    const displayLabel = german ? label : (SUMMARY_LABELS_EN[label] ?? label);
+    items.push(`- ${displayLabel}: ${values.join("; ")}`);
+  }
+  if (gate === 'QA') {
+    const decision = readReportDecision(markdown);
+    if (decision) items.unshift(`- ${german ? 'Entscheidung' : 'Decision'}: ${decision}`);
+  }
+  if (gate === "PRD") {
+    const criteria = criterionEntries(source);
+    if (!criteria.length) throw new Error("approval_summary_criteria_missing");
+    if (new Set(criteria.map((entry) => entry.id)).size !== criteria.length) throw new Error("approval_summary_source_criteria_duplicate");
+    const criterionRows = criteria.map((entry) => {
+      const description = criterionDescription(entry);
+      if (!description) throw new Error("approval_summary_criterion_content_missing");
+      return `  - ${entry.id}: ${description}`;
+    });
+    items.push(`- ${german ? "Abnahmekriterien" : "Acceptance criteria"}:\n${criterionRows.join("\n")}`);
+    const decisions = approvalDecisionEntries(source);
+    if (decisions.length) {
+      const rows = decisions.map((decision) => {
+        const state = german
+          ? ({ resolved: "geklärt", open: "offen" }[decision.status] ?? decision.status)
+          : decision.status;
+        return `  - ${decision.id} (${state}): ${decision.resolution}`;
+      });
+      items.push(`- ${german ? "Entscheidungen" : "Decisions"}:\n${rows.join("\n")}`);
+    }
+  }
+  if (!items.length) throw new Error("approval_summary_content_missing");
+  const summary = [sourceLanguageNote, ...items].filter(Boolean).join("\n");
+  return { markdown: summary, digest: hash(summary) };
+}
+
+// A compact decision brief is a projection of the already validated, source-
+// authored summary. Missing authored fields stay absent; no agent/UI paraphrase.
+export function decisionBriefFromSummary(summary, language) {
+  const german = String(language).toLowerCase().startsWith('de');
+  const fields = [
+    [german ? 'Ziel' : 'Goal', /^(?:Ziel|Goal|Nutzerziel|User intent):\s*(.+)$/iu],
+    [german ? 'Vorschlag' : 'Proposal', /^(?:Vorschlag|Proposal|Umfang|Scope|Produktumfang|Product scope|Lösung|Solution):\s*(.+)$/iu],
+    [german ? 'Änderungen' : 'Changes', /^(?:Änderungen|Changes):\s*(.+)$/iu],
+    [german ? 'Risiken und offene Punkte' : 'Risks and open questions', /^(?:Risiken|Risks|Offen|Open questions):\s*(.+)$/iu],
+  ];
+  const lines = summary.split(/\r?\n/u).map(line => line.replace(/^\s*[-*]\s+/u, '').trim());
+  return fields.flatMap(([label, pattern]) => { const matched = lines.map(line => line.match(pattern)).find(Boolean);
+    return matched ? [`- ${label}: ${matched[1]}`] : []; }).join('\n');
+}
+
+export function renderReviewableApproval(root, report, { runId, gate, revisionId }, runState) {
+  const p = report.approval_presentation;
+  if (!p) return null;
+  const german = String(p.presentation_language ?? "").toLowerCase().startsWith("de");
+  let artifactSection;
+  let artefactDigest;
+  let summaryDigest;
+  let documentContent;
+  let summaryMarkdown;
+  let decisionMarkdown;
+  let documentLanguage = p.presentation_language;
+  let documentHeading;
+  const qaAcceptance = gate === 'QA' ? qaDeviationPresentation(runState?.qa_acceptance, p.presentation_language) : null;
+  if (gate === "UAT") {
+    const observation = observeDecisionContent(root, runState, { gate, locale: german ? 'de' : 'en',
+      sourceLanguage: resolveArtifactPresentationLanguages(root, p.presentation_language).artifact_language });
+    if (!observation.ready) throw Object.assign(Error('AGDF_DECISION_CONTENT_INCOMPLETE'), {
+      recovery: decisionContentRecovery(observation, { locale: german ? 'de' : 'en', state: runState }),
+    });
+    const projection = runState?.evidence_applicability;
+    const evidence = projection ? projection.current.map(row => ({ evidence: row.step, source: row.report.path, covers: row.sources.map(s => s.type).join(', '), strength: 'exact cooperative association' })) : [];
+    const other = projection ? [...projection.superseded.map(row => ({ evidence: row.step, source: row.report.path, covers: row.reason, strength: german ? 'ersetzt' : 'superseded' })),
+      ...projection.applicability_unknown.map(row => ({ evidence: row.step ?? row.evidence, source: row.report?.path ?? row.source, covers: row.reason, strength: german ? 'Zuordnung unbekannt' : 'applicability unknown' }))] : runState?.evidence_refs ?? [];
+    const allEvidence = [...evidence, ...other];
+    if (allEvidence.length === 0) return null;
+    const labels = german ? ['Ziel', 'Geliefertes Ergebnis', 'Technische QA', 'Nachweisgrenzen', 'Risiken und offene Punkte', 'Freigabewirkung']
+      : ['Intended outcome', 'Delivered result', 'Technical QA', 'Qualification limits', 'Risks and open issues', 'Approval effect'];
+    const { goal, result, qa, limits, risks } = observation.groups;
+    const pack = localePack(interactionLocales, resolvePresentationLocale(interactionLocales, p.presentation_language));
+    const brief = [goal, result, qa, limits, risks, pack.primary.afterApproval.UAT].map((value, index) => `- ${labels[index]}: ${value}`).join('\n');
+    decisionMarkdown = brief;
+    const summaryLines = evidence.map((item) => `- ${item.evidence} · ${item.covers} (${item.strength})`);
+    if (!evidence.length) summaryLines.push(german ? 'Keine aktuell exakt zugeordneten Nachweise; historische Zuordnung bleibt ausdrücklich unbekannt.' : 'No currently exact associated evidence; historical applicability remains explicitly unknown.');
+    summaryLines.push(`- ${german ? 'Ersetzte oder nicht zugeordnete Nachweise' : 'Superseded or unassociated evidence'}: ${other.length}`);
+    const attribution = observation.sources.map(s => `- ${s.type}: ${s.path} · ${s.digest}`).join('\n');
+    const summaryText = brief + '\n\n' + summaryLines.join("\n") + '\n\n' + attribution;
+    summaryDigest = hash(summaryText);
+    summaryMarkdown = summaryText;
+    artefactDigest = hash(JSON.stringify({ groups: observation.groups, sources: observation.sources, evidence: allEvidence }));
+    artifactSection = `## ${german ? "Kurzfassung" : "Review summary"} · ${gate}\n\nRun: \`${runId}\` · Gate: \`${gate}\` · Revision: \`${revisionId}\`\n\n${summaryText}\n\n## ${german ? "Vorliegende UAT-Evidenz" : "Available UAT evidence"}\n\n${allEvidence.map((item) => `- ${item.evidence} · Quelle: ${item.source} · Deckt ab: ${item.covers} · Stärke: ${item.strength}`).join("\n")}`;
+    documentContent = artifactSection;
+    if (runState?.qa_acceptance?.accepted) {
+      const accepted = qaDeviationPresentation(runState.qa_acceptance, p.presentation_language);
+      summaryMarkdown += `\n\n${accepted.summary}`;
+      decisionMarkdown += `\n\n${accepted.summary}`;
+      summaryDigest = hash(summaryMarkdown);
+      documentContent += `\n\n${accepted.summary}`;
+    }
+  } else {
+    const artefact = runState?.artefacts?.get(gate);
+    const path = resolvedArtefactFile(root, artefact?.path);
+    if (!path) return null;
+    if (/[<>\r\n]/u.test(path)) throw new Error("approval_artefact_path_invalid");
+    const content = readFileSync(path);
+    if (content.byteLength > MAX_APPROVAL_ARTEFACT_BYTES) throw new Error("approval_artefact_too_large");
+    artefactDigest = hash(content);
+    let contentText;
+    try { contentText = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(content); }
+    catch { throw new Error("approval_artefact_encoding_invalid"); }
+    let summary;
+    const languages = resolveArtifactPresentationLanguages(root, p.presentation_language);
+    const sourceLanguage = languages.artifact_language;
+    documentLanguage = sourceLanguage;
+    try {
+      summary = artifactSummary(gate, contentText, { runId, revisionId, language: p.presentation_language, sourceLanguage,
+        artefactPath: String(artefact?.path ?? "").replace(/^`|`$/gu, "") });
+    } catch (error) {
+      if (String(error?.message ?? "").startsWith("approval_summary_")) {
+        const locale = resolvePresentationLocale(interactionLocales, p.presentation_language);
+        const pack = localePack(interactionLocales, locale);
+        const languageName = pack.statusCard[locale.split("-")[0] === "de" ? "languageGerman" : "languageEnglish"];
+        const artifactLabel = german ? "Artefakt" : "Artefact";
+        const requiredHeading = languages.approval_summary_heading ?? `AGDF Approval Summary (${locale}; source=${sourceLanguage})`;
+        error.recovery = [
+          `## ${pack.statusCard.summaryRecovery}`,
+          `Run: \`${runId}\` · Gate: \`${gate}\` · Revision: \`${revisionId}\``,
+          renderApprovalSummaryIssue({ reason: error.message, required_heading: requiredHeading, diagnostics: error.diagnostics }, {
+            path, presentationLanguage: p.presentation_language,
+          }),
+          pack.operationalValues.approvalSummaryRecovery.replace("{language}", languageName),
+          `${german ? "Erforderlicher Abschnitt" : "Required section"}: \`${requiredHeading}\``,
+          `${artifactLabel}: [${basename(path)}](<${path}>)`,
+          pack.operationalValues.completeMissingApprovalSummary,
+        ].join("\n\n");
+      }
+      throw error;
+    }
+    if (!summary) return null;
+    documentContent = contentText;
+    documentHeading = contentText.match(/^#\s+(.+)$/mu)?.[1];
+    summaryDigest = summary.digest;
+    summaryMarkdown = summary.markdown;
+    artifactSection = `${summary.markdown}\n\n## ${german ? "Prüfartefakt" : "Review artefact"} · ${gate}\n\nRun: \`${runId}\` · Gate: \`${gate}\` · Revision: \`${revisionId}\`\n\n${german ? "Artefakt" : "Artefact"}: [${basename(path)}](<${path}>)\n\nSHA-256: \`${artefactDigest}\`\n\n${german ? "Bitte öffne die verlinkte Fassung vor deiner Entscheidung." : "Open the linked version before deciding."}`;
+  }
+  const pack = localePack(interactionLocales, resolvePresentationLocale(interactionLocales, p.presentation_language));
+  if (gate === 'PRD') {
+    const preview = previewForState(root, runState);
+    if (preview) {
+      const d = preview.descriptor, label = pack.decisionCard;
+      const inert = value => String(value).replace(/[\\`*_{}\[\]()<>#!|]/gu, '\\$&');
+      const review = [`**${label.previewTask} · ${inert(d.version)}**`, inert(d.review_task),
+        `${label.previewScenarios}: ${d.scenarios.map(inert).join(' · ')}`,
+        `${label.previewCriteria}: ${d.criterion_ids.join(', ')}`, label.previewIllustrative,
+        ...(d.open_questions.length ? [d.open_questions.map(inert).join('\n')] : [])].join('\n\n');
+      summaryMarkdown += `\n\n${review}`; summaryDigest = hash(summaryMarkdown);
+      decisionMarkdown = (decisionMarkdown || decisionBriefFromSummary(summaryMarkdown, p.presentation_language) || '') + `\n\n${review}`;
+    }
+  }
+  // One source-authored summary and one decision moment. Provenance remains
+  // available without duplicating the status, transition and approval prompts.
+  if (qaAcceptance) { summaryMarkdown = qaAcceptance.summary; summaryDigest = hash(summaryMarkdown); }
+  const parts = [`## ${qaAcceptance ? pack.decisionCard.deviationAcceptanceIntro : pack.gateActionTitles[gate]}`, resolveHumanRunTitle({ currentArtefactHeading: documentHeading, runContent: runState?.content, runId }),
+    qaAcceptance?.summary || decisionMarkdown || decisionBriefFromSummary(summaryMarkdown, p.presentation_language) || summaryMarkdown, qaAcceptance?.effect || pack.primary.afterApproval[gate],
+    german ? 'Antworte „Dokument lesen“, um diese Fassung vollständig im Chat zu lesen. Fragen und Änderungswünsche kannst du hier besprechen. Ohne deine Freigabe bleibt dieser Schritt offen.'
+      : 'Reply “Read document” to read this complete version in Chat. Discuss questions and requested changes here. This step remains open until you approve.',
+    pack.decisionCard.chatApprovalHint.replace('{gate}', gate),
+    `<details><summary>${german ? 'Details und Nachweise' : 'Details and evidence'}</summary>\n\n${summaryMarkdown}\n\n</details>`,
+    `<details><summary>${german ? 'Fassung und Quellen' : 'Version and sources'}</summary>\n\nRun: \`${runId}\` · ${pack.gateTitles[gate]} · Revision: \`${revisionId}\`\n\nSHA-256: \`${artefactDigest}\`\n\n</details>`];
+  return parts.every((part) => typeof part === "string" && part.trim())
+    ? { markdown: parts.join("\n\n"), companion_markdown: [german
+          ? `Die AGDF-Karte ist geöffnet. Du kannst dort „${qaAcceptance?.approve_label || 'Freigeben'}“ klicken oder hier \`Approval: ${gate}\` eingeben. Beide Wege entscheiden dieselbe vorgelegte Fassung einmal.`
+          : `The AGDF card is open. Click “${qaAcceptance?.approve_label || 'Approve'}” there or enter \`Approval: ${gate}\` here. Both paths decide the same presented version once.`, ...parts].join("\n\n"), preview_markdown: artifactSection,
+        artefact_digest: artefactDigest, summary_digest: summaryDigest, summary_markdown: summaryMarkdown,
+        document_content: documentContent, document_language: documentLanguage,
+        ...(qaAcceptance ? { qa_acceptance: { kind: qaAcceptance.kind, digest: qaAcceptance.digest } } : {}) } : null;
+}