@entrorove/skill 0.1.23 → 0.1.25

package/local-merge-authority.mjs

@@ -0,0 +1,89 @@
+import { createPublicKey, sign, verify, randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { canonical, sha256, fail, identifier, paths } from './local-merge-storage.mjs';
+import { loadTaskHandoffSigner } from './local-task-handoff-observation.mjs';
+
+export const MERGE_LEASE_FIELDS = ['schemaVersion', 'mergeId', 'taskId', 'flowId', 'stepId', 'ownerId', 'taskDigest', 'chainDigest',
+  'chainRevision', 'planId', 'planDigest', 'runnerId', 'runnerKeyId', 'repositoryId', 'repositoryDigest', 'scopeBindingDigest',
+  'scopeArtifactDigest', 'scopeContractDigest', 'scopeContractArtifactDigest', 'architectureContractDigest', 'architectureLedgerDigest', 'baselineRef', 'paths',
+  'scopePaths', 'mappings', 'mappingDigest', 'mappingProof',
+  'leaseId', 'generation', 'epoch', 'issuedAt', 'expiresAt', 'nonce', 'keyId', 'signature'];
+
+export function pinnedKey(encoded) {
+  try {
+    const bytes = Buffer.from(encoded ?? '', 'base64'), key = createPublicKey({ key: bytes, type: 'spki', format: 'der' });
+    if (bytes.toString('base64') !== encoded || key.asymmetricKeyType !== 'ed25519') throw new Error();
+    return { key, keyId: sha256(bytes) };
+  } catch { fail('MERGE_AUTHORITY_KEY', 'Independent pinned Ed25519 authority is unavailable or invalid'); }
+}
+export function inspectSigned(value, schemaVersion, encoded, now = Date.now()) {
+  if (!value || value.schemaVersion !== schemaVersion || typeof value.signature !== 'string') fail('MERGE_AUTHORITY_SCHEMA', 'Signed merge authority schema is invalid');
+  const { signature, ...payload } = value, trusted = pinnedKey(encoded);
+  const bytes = Buffer.from(signature, 'base64url'), issued = Date.parse(value.issuedAt), expires = Date.parse(value.expiresAt);
+  identifier(value.nonce);
+  if (value.keyId !== trusted.keyId || bytes.length !== 64 || bytes.toString('base64url') !== signature
+    || !Number.isFinite(issued) || !Number.isFinite(expires) || issued > now || expires <= now || expires <= issued || expires - issued > 300_000
+    || !verify(null, Buffer.from(canonical(payload)), trusted.key, bytes)) fail('MERGE_AUTHORITY_INVALID', 'Merge authority signature, lifetime or independent identity is invalid');
+  return { payload, keyId: trusted.keyId, digest: sha256(canonical(value)) };
+}
+export async function signMergeReceipt(input, payload) {
+  const file = input.runnerSignerConfigPath;
+  if (typeof file !== 'string' || !path.isAbsolute(file)) fail('MERGE_RUNNER_SIGNER_REQUIRED', 'Merge requires an independently pinned configured runner signer');
+  const trusted = pinnedKey(process.env.ENTROROVE_TASK_HANDOFF_RUNNER_PUBLIC_KEY);
+  const signer = await loadTaskHandoffSigner({ root: input.repositoryRoot }, file, trusted.keyId);
+  const value = { ...payload, issuedAt: new Date().toISOString(), expiresAt: new Date(Date.now() + signer.config.receiptTtlMs).toISOString(), nonce: randomUUID(), keyId: trusted.keyId };
+  return { ...value, signature: sign(null, Buffer.from(canonical(value)), signer.privateKey).toString('base64url') };
+}
+export function match(value, expected, fields, code = 'MERGE_AUTHORITY_BINDING') {
+  if (fields.some(field => canonical(value[field] ?? null) !== canonical(expected[field] ?? null))) fail(code, 'Merge authority changed its frozen task, refs, scope or artifact binding');
+}
+export function inspectMergeLease(lease, ctx, state, registration) {
+  inspectSigned(lease, 'entrorove.merge-lease/1.0', process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY);
+  if (Object.keys(lease).sort().join('|') !== [...MERGE_LEASE_FIELDS].sort().join('|')) fail('MERGE_LEASE_SCHEMA', 'Merge lease must preserve its exact signed protocol fields');
+  match(lease, registration, ['taskId', 'flowId', 'ownerId', 'taskDigest', 'chainDigest', 'runnerKeyId']);
+  match(lease, { repositoryDigest: ctx.repo, flowId: ctx.flowId, stepId: ctx.stepId, epoch: state.epoch }, ['repositoryDigest', 'flowId', 'stepId', 'epoch']);
+  if (canonical(paths(lease.paths)) !== canonical(lease.paths) || !Number.isSafeInteger(lease.generation) || lease.generation < 1
+    || !Number.isSafeInteger(lease.chainRevision) || lease.chainRevision < 1 || typeof lease.baselineRef !== 'string' || !lease.baselineRef.trim()) {
+    fail('MERGE_LEASE_BINDING', 'Merge lease paths, baseline, generation or chain revision is invalid');
+  }
+  for (const field of ['mergeId', 'leaseId', 'planId', 'runnerId', 'repositoryId']) identifier(lease[field]);
+  for (const field of ['planDigest', 'scopeBindingDigest', 'scopeArtifactDigest', 'scopeContractDigest', 'scopeContractArtifactDigest', 'architectureContractDigest', 'architectureLedgerDigest']) {
+    if (!/^[0-9a-f]{64}$/.test(lease[field] ?? '')) fail('MERGE_LEASE_BINDING', 'Merge lease requires original frozen authority digests');
+  }
+  const proof = lease.mappingProof;
+  if (!Array.isArray(lease.mappings) || !lease.mappings.length || !proof || proof.schemaVersion !== 'entrorove.merge-artifact-mapping/1.0'
+    || lease.mappingDigest !== sha256(canonical(proof)) || !Array.isArray(proof.entries)
+    || canonical(paths(lease.mappings.map(item => item.targetPath))) !== canonical(lease.mappings.map(item => item.targetPath))) fail('MERGE_MAPPING_BINDING', 'Merge mapping must retain its actual immutable plan-bound digest');
+  match(proof, lease, ['flowId', 'ownerId', 'planId', 'planDigest', 'taskDigest', 'chainDigest']);
+  if (Object.keys(proof).sort().join('|') !== 'blueprintBinding|chainDigest|entries|flowId|ownerId|planDigest|planId|schemaVersion|scopeArtifactDigest|taskDigest'
+    || !proof.blueprintBinding || typeof proof.blueprintBinding !== 'object' || Array.isArray(proof.blueprintBinding)
+    || !Object.keys(proof.blueprintBinding).length) fail('MERGE_MAPPING_BINDING', 'Mapping proof must retain its exact original native Blueprint shape');
+  const proofTargets = paths(proof.entries.map(entry => entry.targetPath)); paths(proof.entries.map(entry => entry.sourcePath));
+  if (canonical(proofTargets) !== canonical(proof.entries.map(entry => entry.targetPath))) fail('MERGE_MAPPING_BINDING', 'Original mapping proof must have unique sorted target entries');
+  for (const entry of proof.entries) {
+    if (Object.keys(entry).sort().join('|') !== 'producerNodeRef|producerStepId|sha256|sourcePath|stepId|targetPath'
+      || !/^[0-9a-f]{64}$/.test(entry.sha256 ?? '')) fail('MERGE_MAPPING_BINDING', 'Mapping entry must retain its exact actual native producer identity');
+    for (const field of ['producerNodeRef', 'producerStepId', 'stepId']) identifier(entry[field]);
+  }
+  if (proof.scopeArtifactDigest !== lease.scopeContractArtifactDigest || canonical(paths(lease.scopePaths)) !== canonical(lease.scopePaths)) fail('MERGE_MAPPING_BINDING', 'Native artifact mapping lost its original frozen task, chain or scope');
+  paths(lease.mappings.map(item => item.sourcePath));
+  for (const mapping of lease.mappings) {
+    if (Object.keys(mapping).sort().join('|') !== 'sourcePath|targetPath' || !lease.scopePaths.includes(mapping.sourcePath) || !lease.scopePaths.includes(mapping.targetPath)
+      || !proof.entries.some(entry => entry.sourcePath === mapping.sourcePath && entry.targetPath === mapping.targetPath && /^[0-9a-f]{64}$/.test(entry.sha256))) {
+      fail('MERGE_MAPPING_SCOPE', 'Every actual source origin and target path must remain in the original frozen scope');
+    }
+  }
+  if (canonical(lease.paths) !== canonical(lease.mappings.map(item => item.targetPath))) fail('MERGE_MAPPING_SCOPE', 'Merge lease paths must be exactly its authorized mapping targets');
+  return lease;
+}
+export function inspectMergeContract(contract, ctx, preparation, preflight, evidence) {
+  const checked = inspectSigned(contract, 'entrorove.merge-contract/1.0', process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY);
+  match(contract, preparation, ['repositoryDigest', 'flowId', 'stepId', 'baselineRef', 'sourceRef', 'targetRef', 'paths', 'scopePaths', 'sourceFiles', 'targetFiles', 'afterManifest', 'beforeFullManifest', 'mappings', 'mappingDigest', 'mappingProof', 'mergedArtifactSha256', 'snapshotDigest', 'architectureContractDigest']);
+  match(contract, { preparationDigest: sha256(canonical(preparation)), archguardPreflightDigest: sha256(canonical(preflight)),
+    evidenceDigests: evidence.map(item => sha256(canonical(item))).sort() }, ['preparationDigest', 'archguardPreflightDigest', 'evidenceDigests']);
+  match(contract, { repositoryDigest: ctx.repo, flowId: ctx.flowId, stepId: ctx.stepId }, ['repositoryDigest', 'flowId', 'stepId']);
+  for (const field of ['contractId', 'ownerId', 'leaseId']) identifier(contract[field]);
+  if (!Number.isSafeInteger(contract.generation) || contract.generation < 1 || !/^[0-9a-f]{64}$/.test(contract.taskDigest ?? '')
+    || !/^[0-9a-f]{64}$/.test(contract.chainDigest ?? '')) fail('MERGE_AUTHORITY_BINDING', 'Merge contract requires the original owner, task, chain and live lease');
+  return checked;
+}

package/local-merge-contracts.mjs

@@ -0,0 +1,56 @@
+import { array, evidenceArray, integer, ledgerIdentifier as id, nullable, object, paths,
+  record, relativePath, sha256, text } from './local-contract-types.mjs';
+
+const exact = properties => object(properties, Object.keys(properties));
+const bounded = (items, maximum = 512) => ({ ...array(items, 1), maxItems: maximum });
+const reference = exact({ kind: { const: 'snapshot' }, artifactId: id, manifestDigest: sha256 });
+const stored = exact({ path: relativePath, exists: { type: 'boolean' }, sha256, mode: nullable(integer(0, 0o777)) });
+const source = exact({ path: relativePath, sourcePath: relativePath, sha256, mode: integer(0, 0o777) });
+const native = exact({ path: relativePath, sha256 });
+const mappings = bounded(exact({ sourcePath: relativePath, targetPath: relativePath }));
+const mappingProof = exact({ schemaVersion: { const: 'entrorove.merge-artifact-mapping/1.0' }, flowId: id,
+  ownerId: id, taskDigest: sha256, chainDigest: sha256, planId: id, planDigest: sha256,
+  blueprintBinding: record, scopeArtifactDigest: sha256,
+  entries: bounded(exact({ sourcePath: relativePath, targetPath: relativePath, sha256, producerNodeRef: id, producerStepId: id, stepId: id })) });
+const signature = { issuedAt: text, expiresAt: text, nonce: id, keyId: sha256, signature: { ...text, pattern: '^[A-Za-z0-9_-]{86}$' } };
+const identity = { mergeId: id, taskId: id, flowId: id, stepId: id, ownerId: id, taskDigest: sha256, chainDigest: sha256,
+  leaseId: id, generation: integer(1), epoch: integer(0), repositoryDigest: { ...text, pattern: '^[0-9a-f]{32}$' } };
+const lease = { ...identity, chainRevision: integer(1), planId: id, planDigest: sha256, runnerId: id, runnerKeyId: sha256,
+  repositoryId: id, scopeBindingDigest: sha256, scopeArtifactDigest: sha256, scopeContractDigest: sha256,
+  scopeContractArtifactDigest: sha256, architectureContractDigest: sha256, architectureLedgerDigest: sha256,
+  baselineRef: text, paths, scopePaths: paths, mappings, mappingProof, mappingDigest: sha256, ...signature };
+export const MERGE_LEASE_SCHEMA = exact({ schemaVersion: { const: 'entrorove.merge-lease/1.0' }, ...lease });
+const artifacts = { sourceRef: reference, targetRef: reference, sourceFiles: bounded(source), targetFiles: bounded(stored),
+  afterManifest: bounded(native), beforeFullManifest: bounded(stored), mergedArtifactSha256: sha256,
+  snapshotDigest: sha256, snapshotReceiptDigest: sha256, mergeLeaseDigest: sha256 };
+export const MERGE_PREPARATION_SCHEMA = exact({ schemaVersion: { const: 'entrorove.merge-preparation-receipt/1.0' },
+  ...identity, baselineRef: text, paths, scopePaths: paths, mappings, mappingProof, mappingDigest: sha256,
+  architectureContractDigest: sha256, architectureLedgerDigest: sha256, ...artifacts, ...signature });
+export const MERGE_CONTRACT_SCHEMA = exact({ schemaVersion: { const: 'entrorove.merge-contract/1.0' }, ...lease,
+  ...artifacts, contractId: id, preparationDigest: sha256, archguardPreflightDigest: sha256,
+  evidenceDigests: bounded(sha256, 128), evidenceBindings: bounded(exact({ evidenceDigest: sha256, subjectDigest: sha256,
+    flowId: id, stepId: id, snapshotDigest: sha256, contractDigest: sha256, artifactSha256: sha256 }), 128) });
+export const MERGE_ROLLBACK_AUTHORIZATION_SCHEMA = exact({ schemaVersion: { const: 'entrorove.merge-rollback-authorization/1.0' }, ...lease,
+  transactionId: id, originalStepId: id, originalLeaseId: id, originalGeneration: integer(1), originalContractDigest: sha256,
+  originalResultDigest: sha256, expectedJournalDigest: sha256, headReceiptDigest: sha256, contractRawDigest: sha256,
+  nativeLedgerHeadDigest: sha256, sourceRef: reference, targetRef: reference, beforeFiles: bounded(stored), restoreFiles: bounded(stored) });
+const base = { repositoryRoot: text, home: text, flowId: id, stepId: id, taskId: id };
+const actual = { ...base, runnerSignerConfigPath: text, mergeLease: MERGE_LEASE_SCHEMA, preparation: MERGE_PREPARATION_SCHEMA };
+const freeze = object({ ...base, sourceRoot: text, snapshotReceipt: record, mergeLease: MERGE_LEASE_SCHEMA,
+  runnerSignerConfigPath: text }, ['repositoryRoot', 'flowId', 'stepId', 'snapshotReceipt', 'mergeLease', 'runnerSignerConfigPath']);
+const preflight = object(actual, ['repositoryRoot', 'flowId', 'stepId', 'taskId', 'mergeLease', 'preparation']);
+const verified = object({ ...actual, contract: MERGE_CONTRACT_SCHEMA, sourceRef: reference, targetRef: reference,
+  preflight: record, evidence: evidenceArray, gatePassPath: text, executionAttemptNonce: id,
+  generation: integer(1), leaseId: id, workerId: id,
+  changes: bounded(object({ targetPath: relativePath, gatePassPath: text, content: {}, expectedSha256: nullable(sha256) }, ['targetPath'])) },
+['repositoryRoot', 'flowId', 'stepId', 'taskId', 'runnerSignerConfigPath', 'mergeLease', 'preparation', 'contract', 'preflight', 'evidence', 'gatePassPath', 'changes']);
+const rollback = { oneOf: [
+  object({ ...base, transactionId: id, rollbackAuthorization: MERGE_ROLLBACK_AUTHORIZATION_SCHEMA, gatePassPath: text, runnerSignerConfigPath: text,
+    executionAttemptNonce: id, generation: integer(1), leaseId: id },
+  ['repositoryRoot', 'flowId', 'stepId', 'transactionId', 'rollbackAuthorization', 'gatePassPath', 'runnerSignerConfigPath']),
+  object({ ...base, snapshotId: id, gatePassPath: text, runnerSignerConfigPath: text, executionAttemptNonce: id,
+    generation: integer(1), leaseId: id }, ['repositoryRoot', 'flowId', 'snapshotId', 'gatePassPath', 'runnerSignerConfigPath']),
+] };
+export const MERGE_LOCAL_OPERATION_SCHEMAS = Object.freeze({ 'merge-freeze': freeze, 'merge-preflight': preflight,
+  'merge-verified': verified, rollback, 'merge-journal-head': object({ ...base, transactionId: id, runnerSignerConfigPath: text },
+    ['repositoryRoot', 'flowId', 'stepId', 'transactionId', 'runnerSignerConfigPath']) });

package/local-merge-controller.mjs

@@ -0,0 +1,170 @@
+import path from 'node:path';
+import { verifyTestEvidence } from './local-evidence-verification.mjs';
+import { inspectMergePreparation, inspectMergeArchguardPreflight, mergePreflightBinding } from './local-merge-archguard-verification.mjs';
+import { canonical, sha256, context, withMergeFence, fail, read } from './local-merge-storage.mjs';
+import { inspectMergeContract, inspectMergeLease, inspectSigned, match, signMergeReceipt } from './local-merge-authority.mjs';
+import { readFrozenMergeArtifact } from './local-merge-artifacts.mjs';
+import { applyFileBatch, assertBatchImage, metadata } from './local-merge-transaction.mjs';
+import { readMergeJournal, saveMergeJournal, appendMergeEvent, reserveMergeNonces, mergeNonceKeys, verifyPersistentMergeSignature,
+  assertNoMergeFailure, recordMergeFailure } from './local-merge-journal.mjs';
+import { requireMergeMutationBridge, requireMergeOwnershipBridge, requireMergeArchguardBridge, verifyMergeMutationPass, verifyMergeMutationReceipt } from './local-merge-mutation.mjs';
+import { inspectStoredMergeSuccess } from './local-merge-head.mjs';
+export { rollbackMerge } from './local-merge-rollback.mjs';
+
+const SCHEMA = 'entrorove.local-execution/1.0';
+function reject(error) { return { schemaVersion: SCHEMA, status: 'blocked', merged: false, code: error.code ?? 'MERGE_BLOCKED', reason: error.message }; }
+function requireVerified(value, label) { if (!value.verified) fail('MERGE_UNVERIFIED', `${label}: ${value.reason ?? 'independent authority is required'}`); }
+function validateEvidence(input, preparation, contract) {
+  if (!Array.isArray(input.evidence) || !input.evidence.length || input.evidence.length > 128) fail('MERGE_EVIDENCE_REQUIRED', 'Merge requires complete independently trusted execution evidence');
+  if (!Array.isArray(contract.evidenceBindings) || contract.evidenceBindings.length !== input.evidence.length) fail('MERGE_EVIDENCE_BINDING', 'Frozen contract must bind every original verified business receipt');
+  const covered = new Set();
+  const checks = input.evidence.map(evidence => {
+    const binding = contract.evidenceBindings.find(item => item.evidenceDigest === sha256(canonical(evidence)));
+    if (!binding || Object.keys(binding).sort().join('|') !== 'artifactSha256|contractDigest|evidenceDigest|flowId|snapshotDigest|stepId|subjectDigest') fail('MERGE_EVIDENCE_BINDING', 'Evidence differs from its original independently frozen business binding');
+    const checked = verifyTestEvidence(evidence, { publicKey: process.env.ENTROROVE_VALIDATOR_RECEIPT_PUBLIC_KEY, binding, requireBinding: true });
+    if (!checked.verified || !checked.successful) fail('MERGE_EVIDENCE_UNVERIFIED', 'Every merge receipt must independently prove successful actual execution');
+    for (const file of preparation.sourceFiles) {
+      const entry = preparation.mappingProof.entries.find(item => item.sourcePath === file.sourcePath && item.targetPath === file.path && item.sha256 === file.sha256);
+      if (entry?.stepId === binding.stepId && evidence.subject.files.some(actual => actual.path === file.sourcePath && actual.sha256 === file.sha256)) covered.add(file.path);
+    }
+    return checked;
+  });
+  if (new Set(input.evidence.map(item => item.evidenceId)).size !== checks.length) fail('MERGE_EVIDENCE_DUPLICATE', 'Merge evidence identities must be unique');
+  if (covered.size !== preparation.sourceFiles.length) fail('MERGE_EVIDENCE_COVERAGE', 'Original trusted business evidence does not cover every native-mapped actual source output');
+  return checks;
+}
+async function validateAuthority(ctx, input, state, registration, verifyTargets = true) {
+  inspectMergeLease(input.mergeLease, ctx, state, registration);
+  const prepared = inspectMergePreparation(input.preparation, {}, { publicKey: process.env.ENTROROVE_TASK_HANDOFF_RUNNER_PUBLIC_KEY });
+  requireVerified(prepared, 'Frozen actual preparation');
+  for (const field of ['sourceRef', 'targetRef']) {
+    if (input[field] !== undefined && canonical(input[field]) !== canonical(input.preparation[field])) fail('MERGE_REF_BINDING', 'Explicit merge reference differs from its actual frozen preparation');
+  }
+  match(input.preparation, input.mergeLease, ['mergeId', 'taskId', 'ownerId', 'taskDigest', 'chainDigest', 'leaseId', 'generation', 'epoch', 'mappings', 'mappingDigest']);
+  const preflight = inspectMergeArchguardPreflight(input.preflight, mergePreflightBinding(input.preparation),
+    { preparation: input.preparation, mergeLease: input.mergeLease });
+  requireVerified(preflight, 'Independent actual Archguard preflight');
+  const checked = inspectMergeContract(input.contract, ctx, input.preparation, input.preflight, input.evidence);
+  validateEvidence(input, input.preparation, input.contract);
+  match(input.contract, input.mergeLease, ['mergeId', 'taskId', 'ownerId', 'taskDigest', 'chainDigest', 'leaseId', 'generation', 'epoch', 'mappings', 'mappingDigest', 'mappingProof', 'scopePaths']);
+  const source = await readFrozenMergeArtifact(ctx.input, input.preparation.sourceRef), target = await readFrozenMergeArtifact(ctx.input, input.preparation.targetRef);
+  if (source.manifest.role !== 'source' || target.manifest.role !== 'target'
+    || canonical(source.manifest.files.map(({ exists, ...file }) => file)) !== canonical(input.preparation.sourceFiles)
+    || canonical(target.manifest.files) !== canonical(input.preparation.beforeFullManifest)
+    || canonical(target.manifest.files.filter(file => input.mergeLease.paths.includes(file.path))) !== canonical(input.preparation.targetFiles)) fail('MERGE_ARTIFACT_BINDING', 'Frozen merge source or target differs from its authority');
+  const changes = input.changes;
+  if (!Array.isArray(changes) || !changes.length || canonical(changes.map(change => change.targetPath).sort()) !== canonical(input.preparation.paths)) fail('MERGE_CHANGES_REQUIRED', 'Merge changes must exactly cover its nonempty actual frozen differences');
+  for (const change of changes) {
+    const file = source.files.find(item => item.path === change.targetPath);
+    if (change.gatePassPath !== undefined && change.gatePassPath !== input.gatePassPath) fail('MERGE_PASS_BINDING', 'Explicit path gate cannot replace its original atomic batch gate');
+    const baseline = target.files.find(item => item.path === change.targetPath);
+    if (change.expectedSha256 !== undefined && change.expectedSha256 !== (baseline.exists ? baseline.sha256 : null)) {
+      fail('MERGE_TARGET_CAS', 'Caller baseline must retain the actual frozen target, including its original absence');
+    }
+    if (change.content !== undefined && (!Buffer.from(typeof change.content === 'string' ? change.content : JSON.stringify(change.content)).equals(file.bytes))) fail('MERGE_CONTENT_BINDING', 'Caller content cannot replace frozen actual source bytes');
+  }
+  if (verifyTargets) await assertBatchImage(ctx.input, target.files);
+  const mutation = verifyTargets ? await verifyMergeMutationPass(ctx, input, input.preparation.paths, target.files) : null;
+  const afterWide = target.files.map(file => source.files.find(item => item.path === file.path) ?? file);
+  return { checked, source, target, afterWide, mutation };
+}
+async function commit(ctx, input, state, registration, images, assertCurrent) {
+  const bridge = await requireMergeMutationBridge(), ownershipGuard = await requireMergeOwnershipBridge();
+  const transactionId = input.contract.mergeId, contractDigest = sha256(canonical(input.contract));
+  let token = null, startedAt;
+  const binding = { ...resultBinding(input), transactionId, contractDigest, ...images.mutation };
+  const writes = input.preparation.sourceFiles.filter(file => input.preparation.paths.includes(file.path))
+    .map(file => ({ path: file.path, status: 'written', contentDigest: file.sha256 }));
+  let journal = { transactionId, operation: 'merge', status: 'pending', contractDigest, contract: input.contract,
+    preparation: input.preparation, mergeLease: input.mergeLease, before: images.target.files.map(metadata), after: images.afterWide.map(metadata),
+    touched: [], createdParents: [], receipt: null, mutationPass: images.mutation.pass,
+    nonceKeys: mergeNonceKeys(input.contract, input.preparation, input.preflight, input.evidence) };
+  const outcome = await ownershipGuard({ ...ctx.input, paths: input.preparation.paths }, images.mutation.pass, () => applyFileBatch(ctx.input, images.target.files, images.afterWide, {
+    prepare: async () => { startedAt = new Date().toISOString(); journal.startedAt = startedAt; await saveMergeJournal(ctx, journal);
+      await reserveMergeNonces(ctx, transactionId, journal.nonceKeys, contractDigest);
+      token = await bridge.beginMutationBatch14({ ...ctx.input, signerConfigPath: input.runnerSignerConfigPath }, {
+        mutationPass: images.mutation.pass, contract: input.contract, contractDigest, transactionId,
+        beforeFiles: journal.before.filter(file => input.preparation.paths.includes(file.path)),
+        afterFiles: journal.after.filter(file => input.preparation.paths.includes(file.path)) }); },
+    progress: async progress => { journal = { ...journal, ...progress }; await saveMergeJournal(ctx, journal); },
+    finish: async () => {
+      await validateAuthority(ctx, input, state, registration, false);
+      await assertCurrent();
+      const mutationBatchReceipt = verifyMergeMutationReceipt(await bridge.finishMutationBatch14(token), binding, writes, true,
+        { files: journal.after.filter(file => input.preparation.paths.includes(file.path)) });
+      await appendMergeEvent(ctx, transactionId, 'files-applied-reported', { contractDigest });
+      const receipt = await signMergeReceipt(ctx.input, { schemaVersion: 'entrorove.merge-result-receipt/1.0', operation: 'merge',
+        status: 'verified', transactionId, contractDigest, ...resultBinding(input), beforeFiles: journal.before, afterFiles: journal.after,
+        ...mutationReceiptFields(images.mutation), mutationBatchReceipt, startedAt,
+        rollbackOutcome: 'retained', recoveryRequired: false });
+      assertMergeDeadline(input, state, images.mutation, mutationBatchReceipt, receipt);
+      journal = await saveMergeJournal(ctx, { ...journal, status: 'verified', receipt });
+      await assertCurrent();
+      assertMergeDeadline(input, state, images.mutation, mutationBatchReceipt, receipt); return receipt;
+    },
+    failed: async failure => {
+      await recordMergeFailure(ctx, transactionId, contractDigest, failure); let receipt = null, proofFailure = null;
+      try {
+        if (!token) fail('MERGE_CONSUMPTION_UNRESOLVED', 'Begin did not return an original mutation token; consumption cannot be fabricated');
+        const afterFiles = await Promise.all(journal.before.map(async file => metadata({ path: file.path, ...await read(path.join(ctx.root, file.path), ctx.input, file.path, true) })));
+        const current = afterFiles.filter(file => input.preparation.paths.includes(file.path));
+        const mutationBatchReceipt = verifyMergeMutationReceipt(await bridge.failMutationBatch14(token, {
+          code: /^[A-Z][A-Z0-9_]{0,127}$/.test(failure.code) ? failure.code : 'MERGE_BATCH_FAILED', rollbackOutcome: failure.rollbackOutcome }), binding,
+          current.map(file => ({ path: file.path, status: 'failed', contentDigest: file.sha256 })), false, { files: current });
+        receipt = await signMergeReceipt(ctx.input, { schemaVersion: 'entrorove.merge-result-receipt/1.0', operation: 'merge', status: 'failed',
+          transactionId, contractDigest, ...resultBinding(input), beforeFiles: journal.before, afterFiles,
+          ...mutationReceiptFields(images.mutation), mutationBatchReceipt, startedAt, rollbackOutcome: failure.rollbackOutcome, recoveryRequired: failure.recoveryRequired });
+      } catch (error) { proofFailure = { code: error.code ?? 'MERGE_FAILURE_PROOF', reason: error.message }; }
+      journal = await saveMergeJournal(ctx, { ...journal, status: 'failed', failure, receipt, proofFailure });
+      await appendMergeEvent(ctx, transactionId, 'failed', { contractDigest, failure, proofFailure });
+      if (proofFailure) throw Object.assign(new Error(proofFailure.reason), { code: proofFailure.code });
+    },
+  }));
+  return outcome.applied ? { schemaVersion: SCHEMA, status: 'verified', merged: true, transactionId, changes: input.preparation.paths.length, receipt: outcome.result }
+    : { schemaVersion: SCHEMA, status: 'failed', merged: false, transactionId, receipt: journal.receipt, ...outcome };
+}
+function mutationReceiptFields(value) {
+  return Object.fromEntries(['mutationPassDigest', 'mutationSnapshotDigest', 'executionAuthorityDigest', 'executionAttemptNonce'].map(field => [field, value[field]]));
+}
+function assertMergeDeadline(input, state, mutation, proof, receipt) {
+  const attempt = state.executionAttempts.find(value => value.authority.leaseId === mutation.pass.leaseId
+    && value.authority.generation === mutation.pass.generation);
+  const authorities = [input.contract, input.mergeLease, input.preparation, input.preflight, mutation.pass, proof, receipt,
+    attempt?.authority, ...input.evidence.map(value => value.receipt)];
+  if (authorities.some(value => !value || !Number.isFinite(Date.parse(value.expiresAt)) || Date.parse(value.expiresAt) <= Date.now())) {
+    fail('MERGE_AUTHORITY_EXPIRED', 'Whole merge must finish inside every original live lease, execution, pass, preparation, preflight and evidence lifetime');
+  }
+}
+function resultBinding(input) {
+  const value = input.contract;
+  return Object.fromEntries(['mergeId', 'taskId', 'flowId', 'stepId', 'ownerId', 'taskDigest', 'chainDigest', 'leaseId', 'generation', 'epoch',
+    'repositoryDigest', 'sourceRef', 'targetRef', 'paths', 'mergedArtifactSha256', 'mappingDigest', 'afterManifest'].map(field => [field, value[field]]));
+}
+export async function mergeVerified(input) {
+  try {
+    const ctx = await context(input);
+    return await withMergeFence(ctx, async (state, registration) => {
+      if (input.contract?.mergeId) await assertNoMergeFailure(ctx, input.contract.mergeId);
+      const previous = input.contract?.mergeId ? await readMergeJournal(ctx, input.contract.mergeId, true) : null;
+      if (previous) {
+        if (previous.contractDigest !== sha256(canonical(input.contract))) fail('MERGE_TRANSACTION_CONFLICT', 'An existing transaction cannot change its original frozen contract');
+        if (previous.status !== 'verified') fail('MERGE_RECOVERY_REQUIRED', 'A pending or failed transaction requires explicit authorized recovery');
+        await inspectStoredMergeSuccess(ctx, previous, registration);
+        match(previous.contract, { ...registration, epoch: state.epoch }, ['ownerId', 'taskDigest', 'chainDigest', 'taskId', 'epoch']);
+        if (Date.parse(previous.contract.expiresAt) <= Date.now()) return { schemaVersion: SCHEMA, status: 'reported', merged: false, historicalResult: previous.receipt, code: 'MERGE_HISTORICAL_RESULT' };
+        const archguard = await requireMergeArchguardBridge();
+        return archguard(ctx.input, input.preflight, async assertCurrent => {
+          await validateAuthority(ctx, input, state, registration, false); await assertCurrent();
+          inspectSigned(previous.receipt, 'entrorove.merge-result-receipt/1.0', process.env.ENTROROVE_TASK_HANDOFF_RUNNER_PUBLIC_KEY);
+          inspectSigned(previous.receipt.mutationBatchReceipt, 'entrorove.mutation-batch-consumption-receipt/1.0', process.env.ENTROROVE_TASK_HANDOFF_RUNNER_PUBLIC_KEY);
+          return { schemaVersion: SCHEMA, status: 'verified', merged: true, transactionId: previous.transactionId, recoveredResult: true, receipt: previous.receipt };
+        });
+      }
+      const archguard = await requireMergeArchguardBridge();
+      return archguard(ctx.input, input.preflight, async assertCurrent => {
+        const images = await validateAuthority(ctx, input, state, registration);
+        return commit(ctx, input, state, registration, images, assertCurrent);
+      });
+    });
+  } catch (error) { return reject(error); }
+}

package/local-merge-head.mjs

@@ -0,0 +1,56 @@
+import { canonical, sha256, context, withMergeFence, fail } from './local-merge-storage.mjs';
+import { inspectSigned, match, signMergeReceipt } from './local-merge-authority.mjs';
+import { readMergeJournal, assertNoMergeFailure, assertMergeTransactionLedger, verifyPersistentMergeSignature } from './local-merge-journal.mjs';
+import { readFrozenMergeArtifact } from './local-merge-artifacts.mjs';
+import { assertBatchImage, metadata } from './local-merge-transaction.mjs';
+import { verifyMergeMutationReceipt, inspectMergeMutationHistory } from './local-merge-mutation.mjs';
+
+export async function inspectStoredMergeSuccess(ctx, journal, registration) {
+  const contract = journal.contract, result = journal.receipt;
+  if (journal.status !== 'verified' || journal.operation !== 'merge' || !result || result.status !== 'verified'
+    || result.operation !== 'merge' || result.rollbackOutcome !== 'retained' || result.recoveryRequired) {
+    fail('MERGE_JOURNAL_NOT_SUCCESSFUL', 'Rollback head requires the original actual successful merge transaction');
+  }
+  inspectSigned(contract, 'entrorove.merge-contract/1.0', process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY, Date.parse(contract.issuedAt));
+  verifyPersistentMergeSignature(result, 'entrorove.merge-result-receipt/1.0', ctx.repo);
+  match(contract, registration, ['ownerId', 'taskId', 'taskDigest', 'chainDigest', 'flowId', 'runnerKeyId']);
+  match(result, { ...contract, transactionId: journal.transactionId, contractDigest: journal.contractDigest },
+    ['transactionId', 'contractDigest', 'flowId', 'stepId', 'ownerId', 'taskId', 'taskDigest', 'chainDigest',
+      'sourceRef', 'targetRef', 'mappingDigest', 'afterManifest', 'paths']);
+  if (journal.contractDigest !== sha256(canonical(contract))) fail('MERGE_JOURNAL_BINDING', 'Original merge contract bytes changed');
+  const proof = result.mutationBatchReceipt;
+  const writes = contract.sourceFiles.filter(file => contract.paths.includes(file.path)).map(file => ({ path: file.path, status: 'written', contentDigest: file.sha256 }));
+  verifyMergeMutationReceipt(proof, result, writes, true,
+    { now: Date.parse(proof?.issuedAt), files: result.afterFiles.filter(file => contract.paths.includes(file.path)) });
+  await inspectMergeMutationHistory(ctx.input, journal.mutationPass, proof,
+    result.beforeFiles.filter(file => contract.paths.includes(file.path)), result.afterFiles.filter(file => contract.paths.includes(file.path)));
+  await assertNoMergeFailure(ctx, journal.transactionId); await assertMergeTransactionLedger(ctx, journal);
+  const originalInput = { ...ctx.input, stepId: contract.stepId };
+  const source = await readFrozenMergeArtifact(originalInput, contract.sourceRef), target = await readFrozenMergeArtifact(originalInput, contract.targetRef);
+  if (canonical(target.manifest.files) !== canonical(contract.beforeFullManifest)) fail('MERGE_JOURNAL_BINDING', 'Original wide target artifact changed');
+  const after = target.files.map(file => source.files.find(item => item.path === file.path) ?? file);
+  if (canonical(journal.before) !== canonical(target.files.map(metadata)) || canonical(journal.after) !== canonical(after.map(metadata))
+    || canonical(result.beforeFiles) !== canonical(journal.before) || canonical(result.afterFiles) !== canonical(journal.after)) {
+    fail('MERGE_JOURNAL_BINDING', 'Original actual full-batch result differs from its immutable bytes');
+  }
+  await assertBatchImage(ctx.input, after); return { source, target, after };
+}
+export async function produceMergeJournalHead(input) {
+  const ctx = await context(input);
+  return withMergeFence(ctx, async (state, registration) => {
+    const journal = await readMergeJournal(ctx, input.transactionId);
+    if (ctx.stepId !== journal.contract.stepId) fail('MERGE_JOURNAL_BINDING', 'Journal head locator must retain its original merge step');
+    const contract = journal.contract;
+    const native = await import('./local-merge-archguard.mjs');
+    if (typeof native.withMergeArchguardStateFence !== 'function') fail('MERGE_ARCH_CURRENT_UNAVAILABLE', 'Fresh journal head requires the actual architecture and native history fence');
+    return native.withMergeArchguardStateFence(ctx.input, { architectureContractDigest: contract.architectureContractDigest }, async (assertCurrent, current) => {
+      await inspectStoredMergeSuccess(ctx, journal, registration); await assertCurrent();
+      const head = await signMergeReceipt(ctx.input, { schemaVersion: 'entrorove.merge-journal-head-receipt/1.0', transactionId: journal.transactionId,
+        mergeId: contract.mergeId, flowId: ctx.flowId, stepId: contract.stepId, repositoryDigest: ctx.repo, epoch: state.epoch,
+        ...Object.fromEntries(['ownerId', 'taskId', 'taskDigest', 'chainDigest', 'sourceRef', 'targetRef', 'paths', 'scopePaths'].map(field => [field, contract[field]])),
+        contractDigest: journal.contractDigest, originalResultDigest: sha256(canonical(journal.receipt)), journalDigest: sha256(canonical(journal)),
+        beforeFiles: journal.before, afterFiles: journal.after, ...current });
+      await assertCurrent(); return head;
+    });
+  });
+}

package/local-merge-journal.mjs

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { verify } from 'node:crypto';
+import { canonical, sha256, identifier, json, writeJson, fail } from './local-merge-storage.mjs';
+import { pinnedKey, signMergeReceipt } from './local-merge-authority.mjs';
+
+export function verifyPersistentMergeSignature(value, schema, repo) {
+  const { signature, ...payload } = value ?? {}, trusted = pinnedKey(process.env.ENTROROVE_TASK_HANDOFF_RUNNER_PUBLIC_KEY);
+  if (value?.schemaVersion !== schema || value.repositoryDigest !== repo || value.keyId !== trusted.keyId
+    || typeof signature !== 'string' || Buffer.from(signature, 'base64url').length !== 64
+    || Buffer.from(signature, 'base64url').toString('base64url') !== signature
+    || !verify(null, Buffer.from(canonical(payload)), trusted.key, Buffer.from(signature, 'base64url'))) {
+    fail('MERGE_JOURNAL_TAMPERED', 'Durable merge state lost its original independently pinned runner signature');
+  }
+  return value;
+}
+export const journalFile = (ctx, transactionId) => path.join(ctx.state, 'transactions', identifier(transactionId), 'journal.json');
+const failureFile = (ctx, transactionId) => path.join(ctx.state, 'transactions', identifier(transactionId), 'failure.json');
+export async function assertNoMergeFailure(ctx, transactionId) {
+  try { await json(failureFile(ctx, transactionId)); }
+  catch (error) { if (error.code === 'ENOENT') return; throw error; }
+  fail('MERGE_RECOVERY_REQUIRED', 'An actual failed transaction remains permanently recorded and cannot be replayed as a new green merge');
+}
+export async function recordMergeFailure(ctx, transactionId, contractDigest, failure) {
+  await writeJson(failureFile(ctx, transactionId), { schemaVersion: 'entrorove.merge-failure-marker/1.0', status: 'failed',
+    repositoryDigest: ctx.repo, flowId: ctx.flowId, stepId: ctx.stepId, transactionId, contractDigest, failure,
+    at: new Date().toISOString(), authority: 'blocking-local-audit' });
+}
+export async function readMergeJournal(ctx, transactionId, optional = false) {
+  try {
+    const value = verifyPersistentMergeSignature(await json(journalFile(ctx, transactionId)), 'entrorove.merge-journal/1.0', ctx.repo);
+    if (value.transactionId !== transactionId || value.flowId !== ctx.flowId || value.stepId !== value.contract?.stepId) fail('MERGE_JOURNAL_BINDING', 'Merge journal belongs to another actual task or original transaction step');
+    return value;
+  } catch (error) { if (optional && error.code === 'ENOENT') return null; throw error; }
+}
+export async function saveMergeJournal(ctx, value) {
+  const signed = await signMergeReceipt(ctx.input, { ...value, schemaVersion: 'entrorove.merge-journal/1.0',
+    repositoryDigest: ctx.repo, flowId: ctx.flowId, stepId: value.contract?.stepId ?? ctx.stepId, operationStepId: ctx.stepId });
+  await writeJson(journalFile(ctx, value.transactionId), signed); return signed;
+}
+export function mergeNonceKeys(contract, preparation, preflight, evidence) {
+  return [contract, preparation, preflight, ...evidence.map(item => item.receipt)].map(value => `${value.keyId}:${value.nonce}`).sort();
+}
+async function readLedger(ctx) {
+  const file = path.join(ctx.home, '.entrorove', 'merges', ctx.repo, 'ledger.json'); let state;
+  try { state = verifyPersistentMergeSignature(await json(file), 'entrorove.merge-local-ledger/1.0', ctx.repo); }
+  catch (error) { if (error.code !== 'ENOENT') throw error;
+    state = { schemaVersion: 'entrorove.merge-local-ledger/1.0', repositoryDigest: ctx.repo, entries: [] }; }
+  if (!Array.isArray(state.entries) || state.entries.length > 50000) fail('MERGE_LEDGER_INVALID', 'Merge ledger must be bounded and append-only');
+  for (const [index, entry] of state.entries.entries()) {
+    const { entryDigest, ...body } = entry;
+    if (entry.sequence !== index + 1 || entry.previousDigest !== (state.entries[index - 1]?.entryDigest ?? null)
+      || entryDigest !== sha256(canonical(body))) fail('MERGE_LEDGER_TAMPERED', 'Merge ledger hash chain changed');
+  }
+  return { file, state };
+}
+export async function assertMergeTransactionLedger(ctx, journal) {
+  const { state } = await readLedger(ctx), entries = state.entries.filter(entry => entry.transactionId === journal.transactionId);
+  const pending = entries.find(entry => entry.event === 'pending');
+  if (!pending || pending.details.contractDigest !== journal.contractDigest
+    || canonical(pending.details.nonceKeys) !== canonical(journal.nonceKeys)
+    || !entries.some(entry => entry.event === 'files-applied-reported') || entries.some(entry => entry.event === 'failed')) {
+    fail('MERGE_LEDGER_BINDING', 'A cached merge requires its original signed append-only consumption and actual file-report history');
+  }
+}
+export async function appendMergeEvent(ctx, transactionId, event, details = {}) {
+  const { file, state } = await readLedger(ctx), entries = state.entries;
+  const body = { sequence: entries.length + 1, previousDigest: entries.at(-1)?.entryDigest ?? null,
+    transactionId, flowId: ctx.flowId, stepId: ctx.stepId, event, details, at: new Date().toISOString() };
+  entries.push({ ...body, entryDigest: sha256(canonical(body)) });
+  await writeJson(file, await signMergeReceipt(ctx.input, { schemaVersion: state.schemaVersion, repositoryDigest: ctx.repo, entries }));
+}
+export async function reserveMergeNonces(ctx, transactionId, nonceKeys, contractDigest) {
+  if (new Set(nonceKeys).size !== nonceKeys.length || nonceKeys.some(key => !/^[0-9a-f]{64}:[A-Za-z0-9._:-]+$/.test(key))) fail('MERGE_REPLAY', 'Duplicate or unknown signed evidence nonce cannot authorize a merge');
+  const { state } = await readLedger(ctx);
+  if (state.entries.some(entry => entry.details.nonceKeys?.some(key => nonceKeys.includes(key)))) fail('MERGE_REPLAY', 'A merge authority or execution receipt nonce has already been consumed');
+  await appendMergeEvent(ctx, transactionId, 'pending', { contractDigest, nonceKeys });
+}

package/local-merge-mutation.mjs

@@ -0,0 +1,97 @@
+import path from 'node:path';
+import { canonical, sha256, fail, identifier, paths, MISSING_SHA256, noLinks } from './local-merge-storage.mjs';
+import { match, inspectSigned } from './local-merge-authority.mjs';
+import { metadata } from './local-merge-transaction.mjs';
+
+export async function requireMergeMutationBridge() {
+  let bridge;
+  try { bridge = await import('./local-mutation-batch.mjs'); }
+  catch (error) {
+    if (error.code !== 'ERR_MODULE_NOT_FOUND') throw error;
+    fail('MERGE_MUTATION_BATCH_UNAVAILABLE', 'Real merge requires the original mutation authority batch-consumption implementation');
+  }
+  for (const name of ['beginMutationBatch14', 'finishMutationBatch14', 'failMutationBatch14']) {
+    if (typeof bridge[name] !== 'function') fail('MERGE_MUTATION_BATCH_UNAVAILABLE', 'Mutation authority has no complete original batch-consumption interface');
+  }
+  return bridge;
+}
+export async function requireMergeOwnershipBridge() {
+  const bridge = await import('./local-swarm-mutation.mjs');
+  if (typeof bridge.withSwarmMutationBatchLease !== 'function') {
+    fail('MERGE_SWARM_BATCH_UNAVAILABLE', 'Real merge requires the original cross-flow ownership guard to protect every batch path under one physical ownership lock');
+  }
+  return bridge.withSwarmMutationBatchLease;
+}
+export async function requireMergeArchguardBridge() {
+  const bridge = await import('./local-merge-archguard.mjs');
+  if (typeof bridge.withMergeArchguardFence !== 'function') fail('MERGE_ARCH_CURRENT_UNAVAILABLE', 'Actual merge requires the original architecture contract and native ledger locks throughout its whole batch');
+  return bridge.withMergeArchguardFence;
+}
+export async function verifyMergeMutationPass(ctx, input, names, beforeFiles) {
+  const { verifyMutationPass } = await import('./local-execution.mjs');
+  const { snapshotAuthority14 } = await import('./local-mutation-snapshot.mjs');
+  let original;
+  for (const targetPath of names) {
+    const change = input.changes?.find(item => item.targetPath === targetPath);
+    const checked = await verifyMutationPass({ ...ctx.input, gatePassPath: change?.gatePassPath ?? input.gatePassPath, targetPath });
+    const pass = checked.pass;
+    if (original && canonical(pass) !== canonical(original)) fail('MERGE_PASS_BINDING', 'One atomic batch must use one original mutation pass');
+    match(pass, input.contract, ['taskId', 'ownerId', 'taskDigest', 'chainDigest', 'leaseId', 'generation', 'epoch', 'repositoryDigest', 'flowId', 'stepId']);
+    if (canonical(pass.paths) !== canonical(names) || pass.executionPlanSha256 !== sha256(canonical(input.contract))) {
+      fail('MERGE_PASS_BINDING', 'Actual mutation pass must bind the exact frozen merge contract and changed subset');
+    }
+    original = pass;
+  }
+  const snapshot = await snapshotAuthority14(ctx.input, ctx.root, original.snapshotReceipt);
+  if (canonical(snapshot.manifest.files) !== canonical(beforeFiles.filter(file => names.includes(file.path)).map(metadata))) {
+    fail('MERGE_PASS_BINDING', 'Actual mutation snapshot must retain the exact frozen before subset');
+  }
+  return { pass: original, mutationPassDigest: sha256(canonical(original)), mutationSnapshotDigest: original.snapshotDigest,
+    executionAuthorityDigest: original.executionAuthorityDigest, executionAttemptNonce: original.executionAttemptNonce };
+}
+export function verifyMergeMutationReceipt(receipt, binding, writes, successful, options = {}) {
+  inspectSigned(receipt, 'entrorove.mutation-batch-consumption-receipt/1.0', process.env.ENTROROVE_TASK_HANDOFF_RUNNER_PUBLIC_KEY, options.now ?? Date.now());
+  match(receipt, { ...binding, passDigest: binding.mutationPassDigest }, ['flowId', 'taskId', 'stepId', 'leaseId', 'generation',
+    'passDigest', 'contractDigest', 'transactionId', 'executionAuthorityDigest', 'executionAttemptNonce', 'paths']);
+  const common = ['schemaVersion', 'status', 'consumed', 'batchId', 'flowId', 'taskId', 'stepId', 'leaseId', 'generation',
+    'passDigest', 'contractDigest', 'transactionId', 'executionAuthorityDigest', 'executionAttemptNonce', 'paths', 'writes',
+    'keyId', 'nonce', 'issuedAt', 'expiresAt', 'signature'];
+  const extra = successful ? ['afterFiles'] : ['currentFiles', 'code', ...(receipt.reportedRollbackOutcome === undefined ? [] : ['reportedRollbackOutcome'])];
+  const files = successful ? receipt.afterFiles : receipt.currentFiles, status = successful ? 'written' : 'failed';
+  if (receipt.consumed !== true || receipt.status !== status || Object.keys(receipt).sort().join('|') !== [...common, ...extra].sort().join('|')
+    || !Array.isArray(files) || canonical(paths(files.map(file => file?.path))) !== canonical(receipt.paths)
+    || files.some(file => !file || Object.keys(file).sort().join('|') !== 'exists|mode|path|sha256' || typeof file.exists !== 'boolean'
+      || !/^[0-9a-f]{64}$/.test(file.sha256 ?? '') || (file.exists ? !Number.isInteger(file.mode) || file.mode < 0 || file.mode > 0o777
+        : file.sha256 !== MISSING_SHA256 || file.mode !== null))
+    || canonical(receipt.writes) !== canonical(files.map(file => ({ path: file.path, status, contentDigest: file.sha256 })))
+    || canonical(receipt.writes) !== canonical(writes) || !options.files || canonical(files) !== canonical(options.files)) {
+    fail('MERGE_MUTATION_CONSUMPTION', 'Original consumed batch proof must preserve every exact signed actual file and completed or failed write');
+  }
+  identifier(receipt.batchId);
+  if (!successful && (!/^[A-Z][A-Z0-9_]{0,127}$/.test(receipt.code ?? '') || receipt.reportedRollbackOutcome !== undefined
+    && !['retained', 'restored', 'restoration-failed'].includes(receipt.reportedRollbackOutcome))) {
+    fail('MERGE_MUTATION_CONSUMPTION', 'Original failed consumption requires its real explicit failure and recovery outcome');
+  }
+  return receipt;
+}
+export async function inspectMergeMutationHistory(input, originalPass, receipt, beforeFiles, afterFiles) {
+  const { mutationPass14 } = await import('./local-mutation-wire.mjs');
+  const { readMutationConsumption14 } = await import('./local-mutation-pass-store.mjs');
+  const pass = mutationPass14(originalPass, { live: false }), passDigest = sha256(canonical(pass));
+  match(pass, { ...receipt, executionPlanSha256: receipt.contractDigest }, ['flowId', 'taskId', 'stepId', 'leaseId', 'generation',
+    'executionAuthorityDigest', 'executionAttemptNonce', 'paths', 'executionPlanSha256']);
+  if (passDigest !== receipt.passDigest) fail('MERGE_MUTATION_CONSUMPTION', 'Historical proof lost its original cloud-signed pass');
+  const file = path.join(process.env.ENTROROVE_TASK_HANDOFF_STATE_DIRECTORY, 'mutations', pass.repositoryDigest, pass.flowId, `${identifier(pass.passId)}.json`);
+  await noLinks(file);
+  const ledger = await readMutationConsumption14(pass, { consumptionPath: file, executionHome: input.home });
+  const beforeDigest = sha256(canonical(beforeFiles)), afterDigest = sha256(canonical(afterFiles));
+  const batchDigest = sha256(canonical({ passDigest, beforeDigest, afterDigest, batchId: receipt.batchId }));
+  for (const after of afterFiles) {
+    const entry = ledger.writes[after.path];
+    if (!entry || entry.status !== 'written' || entry.contentDigest !== after.sha256 || entry.batchId !== receipt.batchId
+      || entry.batchDigest !== batchDigest || entry.beforeDigest !== beforeDigest || entry.afterDigest !== afterDigest) {
+      fail('MERGE_MUTATION_CONSUMPTION', 'Historical result differs from its actual durable completed original batch consumption');
+    }
+  }
+  return ledger;
+}