@entrorove/skill 0.1.22 → 0.1.24

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;
+}

package/local-merge-rollback.mjs

@@ -0,0 +1,126 @@
+import path from 'node:path';
+import { context, withMergeFence, canonical, sha256, fail, paths, read, identifier } from './local-merge-storage.mjs';
+import { MERGE_LEASE_FIELDS, inspectSigned, match, signMergeReceipt } from './local-merge-authority.mjs';
+import { readMergeJournal, saveMergeJournal, appendMergeEvent, reserveMergeNonces, recordMergeFailure } from './local-merge-journal.mjs';
+import { inspectStoredMergeSuccess } from './local-merge-head.mjs';
+import { rollbackFileBatch, metadata } from './local-merge-transaction.mjs';
+import { atomicSnapshotRollback } from './local-merge-snapshot-rollback.mjs';
+import { requireMergeMutationBridge, requireMergeOwnershipBridge, verifyMergeMutationPass, verifyMergeMutationReceipt } from './local-merge-mutation.mjs';
+
+const SCHEMA = 'entrorove.local-execution/1.0';
+const AUTH_SCHEMA = 'entrorove.merge-rollback-authorization/1.0';
+const extraFields = ['transactionId', 'originalStepId', 'originalLeaseId', 'originalGeneration', 'originalContractDigest',
+  'originalResultDigest', 'expectedJournalDigest', 'headReceiptDigest', 'contractRawDigest', 'nativeLedgerHeadDigest',
+  'sourceRef', 'targetRef', 'beforeFiles', 'restoreFiles'];
+function inspectRollbackAuthorization(ctx, auth, journal, state, registration) {
+  inspectSigned(auth, AUTH_SCHEMA, process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY);
+  if (Object.keys(auth).sort().join('|') !== [...MERGE_LEASE_FIELDS, ...extraFields].sort().join('|')) fail('MERGE_ROLLBACK_SCHEMA', 'Rollback requires its exact independently signed original transaction and fresh operation contract');
+  match(auth, registration, ['ownerId', 'taskDigest', 'chainDigest', 'taskId', 'flowId', 'runnerKeyId']);
+  match(auth, { repositoryDigest: ctx.repo, flowId: ctx.flowId, stepId: ctx.stepId, epoch: state.epoch }, ['repositoryDigest', 'flowId', 'stepId', 'epoch']);
+  match(auth, { ...journal.contract, transactionId: journal.transactionId, originalStepId: journal.contract.stepId,
+    originalLeaseId: journal.contract.leaseId, originalGeneration: journal.contract.generation, originalContractDigest: journal.contractDigest,
+    originalResultDigest: sha256(canonical(journal.receipt)), expectedJournalDigest: sha256(canonical(journal)),
+    beforeFiles: journal.after, restoreFiles: journal.before },
+  ['transactionId', 'mergeId', 'originalStepId', 'originalLeaseId', 'originalGeneration', 'originalContractDigest',
+    'originalResultDigest', 'expectedJournalDigest', 'sourceRef', 'targetRef', 'paths', 'scopePaths', 'mappings', 'mappingProof',
+    'mappingDigest', 'planId', 'planDigest', 'baselineRef', 'architectureContractDigest', 'beforeFiles', 'restoreFiles']);
+  if (auth.stepId === auth.originalStepId || auth.leaseId === auth.originalLeaseId || !Number.isSafeInteger(auth.generation)
+    || auth.generation < 1 || canonical(paths(auth.paths)) !== canonical(auth.paths)
+    || canonical(paths(auth.scopePaths)) !== canonical(auth.scopePaths)
+    || !['headReceiptDigest', 'contractRawDigest', 'nativeLedgerHeadDigest'].every(field => /^[0-9a-f]{64}$/.test(auth[field] ?? ''))) {
+    fail('MERGE_ROLLBACK_BINDING', 'Rollback must use its fresh independent node, lease, current native state and immutable original images');
+  }
+  for (const field of ['transactionId', 'mergeId', 'leaseId', 'originalLeaseId', 'originalStepId']) identifier(auth[field]);
+  return auth;
+}
+function resultBinding(auth) {
+  const afterManifest = auth.restoreFiles.filter(file => auth.paths.includes(file.path)).map(({ path: filePath, sha256: digest }) => ({ path: filePath, sha256: digest }));
+  return { ...Object.fromEntries(['mergeId', 'taskId', 'flowId', 'stepId', 'ownerId', 'taskDigest', 'chainDigest', 'leaseId', 'generation',
+    'epoch', 'repositoryDigest', 'sourceRef', 'targetRef', 'paths', 'mappingDigest', 'originalContractDigest'].map(field => [field, auth[field]])),
+    transactionId: auth.transactionId, contractDigest: sha256(canonical(auth)), rollbackAuthorizationDigest: sha256(canonical(auth)),
+    afterManifest, mergedArtifactSha256: sha256(`validator.file-manifest/1.0\n${afterManifest.map(file => `${file.path}\0${file.sha256}`).join('\n')}`) };
+}
+function mutationFields(value) {
+  return Object.fromEntries(['mutationPassDigest', 'mutationSnapshotDigest', 'executionAuthorityDigest', 'executionAttemptNonce'].map(field => [field, value[field]]));
+}
+function assertDeadline(auth, state, mutation, proof, receipt) {
+  inspectSigned(auth, AUTH_SCHEMA, process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY);
+  const attempt = state.executionAttempts.find(value => value.authority.leaseId === auth.leaseId && value.authority.generation === auth.generation);
+  if ([auth, mutation.pass, proof, receipt, attempt?.authority].some(value => !value || Date.parse(value.expiresAt) <= Date.now()
+    || !Number.isFinite(Date.parse(value.expiresAt)))) fail('MERGE_AUTHORITY_EXPIRED', 'Rollback must finish inside its actual fresh contract, execution, mutation and receipt lifetimes');
+}
+async function actualWide(ctx, names) {
+  return Promise.all(names.map(async filePath => metadata({ path: filePath, ...await read(path.join(ctx.root, filePath), ctx.input, filePath, true) })));
+}
+async function rollbackCommit(ctx, input, state, journal, images, assertCurrent) {
+  const auth = input.rollbackAuthorization, bridge = await requireMergeMutationBridge(), guard = await requireMergeOwnershipBridge();
+  const binding = { ...resultBinding(auth), ...images.mutation }, auditId = `rollback-${sha256(canonical(auth)).slice(0, 48)}`;
+  const before = images.after, after = images.target.files, selected = files => files.filter(file => auth.paths.includes(file.path)).map(metadata);
+  let token = null, startedAt, latest = journal;
+  let attempt = { status: 'pending', authorization: auth, authorizationDigest: binding.contractDigest, touched: [], createdParents: [], receipt: null };
+  const outcome = await guard({ ...ctx.input, paths: auth.paths }, images.mutation.pass, () => rollbackFileBatch(ctx.input, before, after, journal.createdParents, {
+    prepare: async () => {
+      startedAt = new Date().toISOString(); attempt.startedAt = startedAt;
+      await reserveMergeNonces(ctx, auditId, [`${auth.keyId}:${auth.nonce}`], binding.contractDigest);
+      latest = await saveMergeJournal(ctx, { ...journal, rollback: attempt });
+      token = await bridge.beginMutationBatch14({ ...ctx.input, signerConfigPath: input.runnerSignerConfigPath }, {
+        mutationPass: images.mutation.pass, contract: auth, contractDigest: binding.contractDigest, transactionId: auth.transactionId,
+        beforeFiles: selected(before), afterFiles: selected(after) });
+    },
+    progress: async progress => { attempt = { ...attempt, ...progress }; latest = await saveMergeJournal(ctx, { ...journal, rollback: attempt }); },
+    finish: async () => {
+      await assertCurrent(); inspectSigned(auth, AUTH_SCHEMA, process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY);
+      const proof = verifyMergeMutationReceipt(await bridge.finishMutationBatch14(token), binding,
+        selected(after).map(file => ({ path: file.path, status: 'written', contentDigest: file.sha256 })), true, { files: selected(after) });
+      await appendMergeEvent(ctx, auditId, 'rollback-files-restored-reported', { authorizationDigest: binding.contractDigest });
+      const receipt = await signMergeReceipt(ctx.input, { schemaVersion: 'entrorove.merge-result-receipt/1.0', operation: 'rollback', status: 'verified',
+        ...resultBinding(auth), ...mutationFields(images.mutation), mutationBatchReceipt: proof, startedAt,
+        beforeFiles: before.map(metadata), afterFiles: after.map(metadata), rollbackOutcome: 'restored', recoveryRequired: false });
+      assertDeadline(auth, state, images.mutation, proof, receipt);
+      attempt = { ...attempt, status: 'verified', receipt, mutationPass: images.mutation.pass };
+      latest = await saveMergeJournal(ctx, { ...journal, status: 'restored', rollback: attempt });
+      await assertCurrent(); assertDeadline(auth, state, images.mutation, proof, receipt); return receipt;
+    },
+    failed: async failure => {
+      await recordMergeFailure(ctx, auditId, binding.contractDigest, failure);
+      let receipt = null, proofFailure = null;
+      try {
+        if (!token) fail('MERGE_CONSUMPTION_UNRESOLVED', 'Rollback begin returned no original token; failure proof cannot be fabricated');
+        const afterFiles = await actualWide(ctx, auth.scopePaths), current = afterFiles.filter(file => auth.paths.includes(file.path));
+        const proof = verifyMergeMutationReceipt(await bridge.failMutationBatch14(token, { code: /^[A-Z][A-Z0-9_]{0,127}$/.test(failure.code) ? failure.code : 'MERGE_ROLLBACK_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: 'rollback', status: 'failed',
+          ...resultBinding(auth), ...mutationFields(images.mutation), mutationBatchReceipt: proof, startedAt,
+          beforeFiles: before.map(metadata), afterFiles, rollbackOutcome: failure.rollbackOutcome === 'restored' ? 'retained' : 'restoration-failed', recoveryRequired: failure.recoveryRequired });
+      } catch (error) { proofFailure = { code: error.code ?? 'MERGE_FAILURE_PROOF', reason: error.message }; }
+      attempt = { ...attempt, status: 'failed', failure, receipt, proofFailure };
+      latest = await saveMergeJournal(ctx, { ...journal, status: failure.recoveryRequired ? 'failed' : 'verified', rollback: attempt });
+      await appendMergeEvent(ctx, auditId, 'rollback-failed', { failure, proofFailure });
+      if (proofFailure) throw Object.assign(new Error(proofFailure.reason), { code: proofFailure.code });
+    },
+  }));
+  if (!outcome.applied && outcome.restoredParents) {
+    try { await saveMergeJournal(ctx, { ...latest, createdParents: outcome.restoredParents }); }
+    catch (error) { outcome.recoveryRequired = true;
+      outcome.journalAuditFailure = { code: error.code ?? 'MERGE_AUDIT_IO', reason: error.message }; }
+  }
+  return { schemaVersion: SCHEMA, ...outcome, status: outcome.applied ? 'verified' : 'failed', rolledBack: outcome.applied,
+    transactionId: auth.transactionId, receipt: outcome.applied ? outcome.result : attempt.receipt,
+    rollbackOutcome: outcome.applied ? 'restored' : outcome.rollbackOutcome === 'restored' ? 'retained' : 'restoration-failed' };
+}
+export async function rollbackMerge(input) {
+  try {
+    if (!input.transactionId) return await atomicSnapshotRollback(input);
+    const ctx = await context(input);
+    return await withMergeFence(ctx, async (state, registration) => {
+      const journal = await readMergeJournal(ctx, input.transactionId), auth = inspectRollbackAuthorization(ctx, input.rollbackAuthorization, journal, state, registration);
+      const native = await import('./local-merge-archguard.mjs');
+      if (typeof native.withMergeArchguardStateFence !== 'function') fail('MERGE_ARCH_CURRENT_UNAVAILABLE', 'Rollback requires the original actual native architecture state fence');
+      return native.withMergeArchguardStateFence(ctx.input, auth, async assertCurrent => {
+        const images = await inspectStoredMergeSuccess(ctx, journal, registration);
+        const mutation = await verifyMergeMutationPass(ctx, { ...input, contract: auth }, auth.paths, images.after);
+        return rollbackCommit(ctx, input, state, journal, { ...images, mutation }, assertCurrent);
+      });
+    });
+  } catch (error) { return { schemaVersion: SCHEMA, status: 'blocked', rolledBack: false, code: error.code ?? 'MERGE_ROLLBACK_BLOCKED', reason: error.message }; }
+}