@entrorove/skill 0.1.51 → 0.1.53

package/local-mutation-authority.mjs

@@ -14,6 +14,8 @@ import { withSwarmMutationLease } from './local-swarm-mutation.mjs';
 import { disciplineWritePreflight } from './local-discipline-gate.mjs';
 import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
 import { assertDisciplineRepository } from './local-discipline-repository.mjs';
+import { withPreservedMutationFence } from './local-preserved-mutation-state.mjs';
+import { assertPreservedMutationProtection } from './local-preserved-mutation-protection.mjs';
 export { beginMutationBatch14, finishMutationBatch14, failMutationBatch14 } from './local-mutation-batch.mjs';
 
 const SCHEMA = 'entrorove.local-execution/1.0';
@@ -25,7 +27,8 @@ export async function mutateGate14(input) {
   return withMutationAudit14(input, 'mutate-gate', async () => {
     const pass = suppliedPass(input), binding = await mutationOriginalBinding14(input, pass);
     const snapshot = await mutationSnapshotBinding14(input, pass, { allSources: true });
-    assertTaskHandoffSnapshotBinding(binding.state, pass.snapshotReceipt);
+    if (!pass.writeDelegation) assertTaskHandoffSnapshotBinding(binding.state, pass.snapshotReceipt);
+    else await assertPreservedMutationProtection(input, binding.root, pass);
     return { schemaVersion: SCHEMA, status: 'verified', allowed: true, snapshotId: snapshot.manifest.snapshotId,
       receiptDigest: pass.snapshotReceiptDigest, paths: [...pass.paths], coordinationRequired: false };
   });
@@ -33,6 +36,18 @@ export async function mutateGate14(input) {
 export async function issueMutationPass14(input) {
   return withMutationAudit14(input, 'mutation-pass-issue', async () => {
     const pass = suppliedPass(input);
+    if (pass.writeDelegation) {
+      const binding = await mutationOriginalBinding14(input, pass);
+      await mutationSnapshotBinding14(input, pass, { allSources: true });
+      await assertPreservedMutationProtection(input, binding.root, pass);
+      mutationLifetime14(pass);
+      const locations = await installMutationPass14(input, binding, pass);
+      await withPreservedMutationFence(input, pass, async () => {
+        await assertPreservedMutationProtection(input, binding.root, pass);
+        await auditMutation14(input, 'mutation-pass-issued', { passId: pass.passId, leaseId: pass.leaseId, generation: pass.generation });
+      }, { issue: true });
+      return { schemaVersion: SCHEMA, gatePassPath: locations.gatePassPath, pass };
+    }
     return withTaskHandoffIssueFence(input, async state => {
       const binding = await mutationOriginalBinding14(input, pass, state);
       await mutationSnapshotBinding14(input, pass, { allSources: true });
@@ -50,7 +65,8 @@ export async function checkedPass(input, state, { allowTargetDrift = false } = {
   if (!pass.paths.includes(target)) mutationFail14('ENTROROVE_MUTATION_WRITE_SCOPE', 'Guarded writing is outside the cloud pass path set');
   const binding = await mutationOriginalBinding14(input, pass, state);
   const snapshot = await mutationSnapshotBinding14(input, pass, { targetPath: target, allowTargetDrift });
-  assertTaskHandoffSnapshotBinding(binding.state, pass.snapshotReceipt);
+  if (!pass.writeDelegation) assertTaskHandoffSnapshotBinding(binding.state, pass.snapshotReceipt);
+  else await assertPreservedMutationProtection(input, binding.root, pass);
   const locations = await mutationPassLocations14(input, binding, pass);
   const ledger = await readMutationConsumption14(pass, locations);
   const consumedWrite = ledger.writes[target];
@@ -92,9 +108,10 @@ async function performWrite(input, state, value) {
       disciplineReviewDigest: discipline.reviewDigest, declaredKind: discipline.declaredKind });
     mutationLifetime14(pass);
     const written = await writeMutationProjectFile14(input, binding.root, target, content, baseline);
-    const completed = { ...ledger, writes: { ...ledger.writes, [target]: { ...entry, status: 'written' } } };
+    const completed = { ...ledger, writes: { ...ledger.writes, [target]: { ...entry, status: 'written', writtenAt: new Date().toISOString() } } };
     await saveMutationConsumption14(locations, completed);
     await assertDisciplineRepository(input, binding.root, await readDisciplineSnapshot(snapshot), completed);
+    if (pass.writeDelegation) await assertPreservedMutationProtection(input, binding.root, pass);
     await auditMutation14(input, 'guarded-write', { passId: pass.passId, sha256: written.sha256 });
     const stateRoot = await mutationStateRoot14(input);
     await privateMutationDirectory14(path.join(stateRoot, 'ledgers', pass.repositoryDigest), { privateFrom: stateRoot });
@@ -106,7 +123,8 @@ async function performWrite(input, state, value) {
 export async function guardedWrite14(input) {
   return withMutationAudit14(input, 'guarded-write', async () => {
     const value = await checkedPass(input), pass = value.pass;
-    return withStateLock(value.locations.consumptionPath, () => withTaskHandoffWriteFence({ ...input,
-      epoch: pass.epoch, passId: pass.passId, leaseId: pass.leaseId }, state => performWrite(input, state, value)));
+    return withStateLock(value.locations.consumptionPath, () => pass.writeDelegation
+      ? withPreservedMutationFence(input, pass, state => performWrite(input, state, value))
+      : withTaskHandoffWriteFence({ ...input, epoch: pass.epoch, passId: pass.passId, leaseId: pass.leaseId }, state => performWrite(input, state, value)));
   });
 }

package/local-mutation-batch.mjs

@@ -41,6 +41,7 @@ function tokenState(token, permitted) {
 }
 async function authority(input, supplied) {
   const pass = await readStoredMutationPass14(input);
+  if (pass.writeDelegation) mutationFail14('ENTROROVE_MUTATION_DELEGATION_CHANGE', 'Preserved mutation requires individual existing-file modification');
   for (const value of [supplied, input.mutationPass]) if (value !== undefined && canonical(mutationPass14(value)) !== canonical(pass)) {
     mutationFail14('ENTROROVE_MUTATION_PASS_CHANGED', 'Batch cannot replace its stored original signed pass');
   }

package/local-mutation-binding.mjs

@@ -7,8 +7,12 @@ import { mutationFail14, mutationHome14, mutationRoot14, mutationStateRoot14 } f
 import { snapshotAuthority14, snapshotVerify14, verifySnapshotSources14 } from './local-mutation-snapshot.mjs';
 import { mutationChallenge14, mutationPass14 } from './local-mutation-wire.mjs';
 import { withMutationAudit14 } from './local-mutation-audit.mjs';
+import { preservedMutationOriginalBinding, withPreservedMutationFence } from './local-preserved-mutation-state.mjs';
+import { loadPreservedMutationSigner } from './local-preserved-mutation-signer.mjs';
+import { capturePreservedMutationProtection } from './local-preserved-mutation-protection.mjs';
 
 export async function mutationOriginalBinding14(input, authority, state) {
+  if (authority.writeDelegation) return preservedMutationOriginalBinding(input, authority);
   const root = await mutationRoot14(input.repositoryRoot), home = await mutationHome14(input.home);
   await mutationStateRoot14(input);
   const ctx = await context({ ...input, repositoryRoot: root });
@@ -67,23 +71,28 @@ export async function attestMutationSnapshot14(input) {
     if (input.snapshotId !== challenge.snapshotId) mutationFail14('ENTROROVE_MUTATION_SNAPSHOT_BINDING', 'Snapshot attestation requires the cloud-assigned original snapshot identifier');
     const verified = await snapshotVerify14(input);
     const snapshot = await snapshotAuthority14(input, binding.root, verified.receipt);
-    assertTaskHandoffSnapshotBinding(binding.state, verified.receipt);
+    if (!challenge.writeDelegation) assertTaskHandoffSnapshotBinding(binding.state, verified.receipt);
     if (snapshot.manifest.contractDigest !== challenge.scopeContractDigest
       || canonical(snapshot.manifest.paths) !== canonical(challenge.paths)
       || snapshot.manifest.files.some(file => !file.exists && !challenge.newFilePaths.includes(file.path))) {
       mutationFail14('ENTROROVE_MUTATION_SNAPSHOT_BINDING', 'Snapshot attestation differs from its original cloud scope challenge');
     }
-    const signer = await loadTaskHandoffSigner(binding.context, input.signerConfigPath, challenge.runnerKeyId);
+    const signer = challenge.writeDelegation
+      ? await loadPreservedMutationSigner(input, input.signerConfigPath, challenge.writeDelegation.mutationKeyId)
+      : await loadTaskHandoffSigner(binding.context, input.signerConfigPath, challenge.runnerKeyId);
     const now = Date.now(), expires = Math.min(now + signer.config.receiptTtlMs, Date.parse(challenge.expiresAt));
     if (expires <= now) mutationFail14('ENTROROVE_MUTATION_AUTHORITY_EXPIRED', 'Snapshot challenge expired before runner attestation');
     const payload = { schemaVersion: 'entrorove.mutation-snapshot-attestation/1.0', challengeId: challenge.challengeId,
       challengeDigest: sha256(canonical(challenge)), nonce: challenge.nonce, runnerId: challenge.runnerId,
-      keyId: challenge.runnerKeyId, flowId: challenge.flowId, taskId: challenge.taskId, ownerId: challenge.ownerId,
+      keyId: signer.config.keyId, flowId: challenge.flowId, taskId: challenge.taskId, ownerId: challenge.ownerId,
       stepId: challenge.stepId, leaseId: challenge.leaseId, generation: challenge.generation,
       repositoryId: challenge.repositoryId, repositoryDigest: challenge.repositoryDigest, snapshotId: challenge.snapshotId,
       paths: [...challenge.paths], manifest: snapshot.manifest, receipt: verified.receipt,
       issuedAt: new Date(now).toISOString(), expiresAt: new Date(expires).toISOString() };
-    return { schemaVersion: 'entrorove.local-execution/1.0', verified: true,
-      attestation: { ...payload, signature: sign(null, Buffer.from(canonical(payload)), signer.privateKey).toString('base64url') } };
+    const output = () => ({ schemaVersion: 'entrorove.local-execution/1.0', verified: true,
+      attestation: { ...payload, signature: sign(null, Buffer.from(canonical(payload)), signer.privateKey).toString('base64url') } });
+    if (!challenge.writeDelegation) return output();
+    const protectedFiles = await capturePreservedMutationProtection(input, binding.root, challenge, snapshot);
+    return withPreservedMutationFence(input, challenge, output, { attest: true, protectedFiles });
   });
 }

package/local-mutation-consumption.mjs

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import { randomUUID, sign, verify } from 'node:crypto';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { mutationFail14, mutationRead14, readMutationJson14, atomicMutationJson14, privateMutationDirectory14 } from './local-mutation-files.mjs';
+import { readStoredMutationPass14, readMutationConsumption14, mutationPassLocations14 } from './local-mutation-pass-store.mjs';
+import { assertPreservedMutationIssued } from './local-preserved-mutation-state.mjs';
+import { loadPreservedMutationSigner } from './local-preserved-mutation-signer.mjs';
+import { preservedMutationPublicKey } from './local-preserved-mutation-wire.mjs';
+import { assertPreservedMutationProtection } from './local-preserved-mutation-protection.mjs';
+import { snapshotAuthority14, readSnapshotCopy14 } from './local-mutation-snapshot.mjs';
+import { assertDelegatedSourceModification } from './local-delegated-modify-analysis.mjs';
+import { assertDisciplineRepository } from './local-discipline-repository.mjs';
+import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
+
+const fail = () => mutationFail14('ENTROROVE_MUTATION_CONSUMPTION_INVALID', 'Mutation consumption requires its actual completed original writes, unchanged protection and separate M signer');
+const iso = value => typeof value === 'string' && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+export async function preservedMutationConsumptionState(input) {
+  const pass = await readStoredMutationPass14(input, { live: false });
+  if (!pass.writeDelegation) fail();
+  const binding = await assertPreservedMutationIssued(input, pass), locations = await mutationPassLocations14(input, binding, pass);
+  const ledger = await readMutationConsumption14(pass, locations);
+  return { pass, binding, locations, ledger, complete: pass.paths.every(target => ledger.writes[target]?.status === 'written') };
+}
+async function actualWrites(input, state) {
+  const { pass, binding, ledger } = state;
+  if (!state.complete || Object.keys(ledger.writes).length !== pass.paths.length) fail();
+  const snapshot = await snapshotAuthority14(input, binding.root, pass.snapshotReceipt);
+  if (sha256(canonical(snapshot.manifest)) !== pass.snapshotManifestDigest || snapshot.manifest.snapshotDigest !== pass.snapshotDigest) fail();
+  const writes = [];
+  for (const target of pass.paths) {
+    const completed = ledger.writes[target], before = snapshot.manifest.files.find(file => file.path === target);
+    if (!iso(completed.writtenAt)) mutationFail14('ENTROROVE_MUTATION_CONSUMPTION_WRITE_TIME', 'Original write has no verifiable completion timestamp; its old receipt cannot authorize another mutation');
+    if (!before?.exists || completed.kind && completed.kind !== 'modify' || !iso(completed.at)
+      || Date.parse(completed.writtenAt) < Date.parse(pass.issuedAt) || Date.parse(completed.writtenAt) >= Date.parse(pass.expiresAt)
+      || Date.parse(completed.writtenAt) < Date.parse(completed.at) || Date.parse(completed.writtenAt) > Date.now()) fail();
+    const current = await mutationRead14(input, binding.root, target), copy = await readSnapshotCopy14(input, snapshot.snapshotRoot, snapshot.manifest, target);
+    if (current.sha256 !== completed.contentDigest || current.mode !== completed.mode || current.mode !== before.mode) fail();
+    assertDelegatedSourceModification({ path: target, before: copy.content.toString('utf8'), after: current.content.toString('utf8') });
+    writes.push({ path: target, beforeSha256: before.sha256, beforeMode: before.mode,
+      afterSha256: current.sha256, afterMode: current.mode, writtenAt: completed.writtenAt });
+  }
+  await assertDisciplineRepository(input, binding.root, await readDisciplineSnapshot(snapshot), ledger);
+  await assertPreservedMutationProtection(input, binding.root, pass);
+  return writes;
+}
+function receiptCore(pass, writes) {
+  return { schemaVersion: 'entrorove.preserved-mutation-consumption/1.0', purpose: 'preserved-existing-modify-consumption',
+    keyId: pass.writeDelegation.mutationKeyId, ownerId: pass.ownerId, taskId: pass.taskId, flowId: pass.flowId, stepId: pass.stepId,
+    leaseId: pass.leaseId, generation: pass.generation, epoch: pass.epoch, passId: pass.passId, passDigest: sha256(canonical(pass)),
+    challengeId: pass.challengeId, challengeNonce: pass.challengeNonce, passNonce: pass.nonce,
+    snapshotId: pass.snapshotId, snapshotDigest: pass.snapshotDigest,
+    protectedFilesDigest: sha256(canonical(pass.writeDelegation.protectedFiles)), writes };
+}
+function cachedReceipt(value, pass, core) {
+  const { signature, issuedAt, expiresAt, nonce, ...actual } = value;
+  const unsigned = { ...actual, issuedAt, expiresAt, nonce }, bytes = typeof signature === 'string' ? Buffer.from(signature, 'base64url') : Buffer.alloc(0);
+  if (canonical(actual) !== canonical(core) || !iso(issuedAt) || !iso(expiresAt) || Date.parse(issuedAt) > Date.now()
+    || Date.parse(expiresAt) <= Date.parse(issuedAt) || Date.parse(expiresAt) - Date.parse(issuedAt) > 300_000
+    || !/^[0-9a-f-]{36}$/.test(nonce) || bytes.length !== 64 || bytes.toString('base64url') !== signature
+    || !verify(null, Buffer.from(canonical(unsigned)), preservedMutationPublicKey(pass.writeDelegation.mutationPublicKey).key, bytes)) fail();
+  return value;
+}
+async function consumptionReceipt(input, state, { renewExpired = false, allowExpiredReplay = false } = {}) {
+  const writes = await actualWrites(input, state), core = receiptCore(state.pass, writes);
+  const directory = path.join(state.binding.directory, 'consumption-receipts'), file = path.join(directory, `${state.pass.passId}.json`);
+  await privateMutationDirectory14(directory, { privateFrom: state.binding.stateRoot });
+  let previous;
+  try { previous = cachedReceipt(await readMutationJson14(file), state.pass, core); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+  if (previous && Date.parse(previous.expiresAt) > Date.now()) return previous;
+  if (previous && allowExpiredReplay && !renewExpired) return previous;
+  if (previous && !renewExpired) mutationFail14('ENTROROVE_MUTATION_CONSUMPTION_EXPIRED', 'Original M consumption receipt expired; recover any pending request before a proven zero-effect renewal');
+  const signer = await loadPreservedMutationSigner(input, state.binding.signerConfigPath, core.keyId), now = Date.now();
+  const unsigned = { ...core, issuedAt: new Date(now).toISOString(), expiresAt: new Date(now + 300_000).toISOString(), nonce: randomUUID() };
+  const result = { ...unsigned, signature: sign(null, Buffer.from(canonical(unsigned)), signer.privateKey).toString('base64url') };
+  if (previous) {
+    const archive = `${file}.${previous.nonce}.expired`;
+    try { if (canonical(await readMutationJson14(archive)) !== canonical(previous)) fail(); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; await atomicMutationJson14(archive, previous, { privateFrom: state.binding.stateRoot }); }
+  }
+  await atomicMutationJson14(file, result, { privateFrom: state.binding.stateRoot, replace: Boolean(previous) });
+  return result;
+}
+export async function attestMutationConsumption14(input, options = {}) {
+  const original = await preservedMutationConsumptionState(input);
+  return withStateLock(original.locations.consumptionPath, async () => {
+    const state = await preservedMutationConsumptionState(input), receipt = await consumptionReceipt(input, state, options);
+    return { schemaVersion: 'entrorove.local-execution/1.0', status: 'reported', consumptionReceipt: receipt,
+      claimsVerifiedExecution: false, claimsCompletion: false,
+      nextAction: { operation: 'mutation-pass-settle', input: { passId: state.pass.passId, consumptionReceipt: receipt } } };
+  });
+}

package/local-mutation-pass-store.mjs

@@ -4,22 +4,24 @@ import { withStateLock } from './local-state-lock.mjs';
 import { atomicMutationJson14, mutationFail14, mutationRoot14, mutationStateRoot14, mutationTarget14,
   privateMutationDirectory14, readMutationJson14 } from './local-mutation-files.mjs';
 import { mutationPass14 } from './local-mutation-wire.mjs';
+import { assertPreservedMutationIssued } from './local-preserved-mutation-state.mjs';
 
 const SCHEMA = 'entrorove.mutation-consumption/1.0';
-export async function readStoredMutationPass14(input) {
+export async function readStoredMutationPass14(input, { live = true } = {}) {
   const root = await mutationRoot14(input.repositoryRoot), stateRoot = await mutationStateRoot14(input);
   if (typeof input.gatePassPath !== 'string' || !path.isAbsolute(input.gatePassPath)) {
     mutationFail14('ENTROROVE_MUTATION_AUTHORITY_REQUIRED', 'Guarded writing requires its stored original cloud pass');
   }
-  const pass = mutationPass14(await readMutationJson14(input.gatePassPath));
+  const pass = mutationPass14(await readMutationJson14(input.gatePassPath), { live });
   const expected = path.join(stateRoot, 'gates', sha256(root).slice(0, 32), input.flowId, `${pass.passId}.json`);
   if (input.gatePassPath !== expected) mutationFail14('ENTROROVE_MUTATION_PASS_LOCATION', 'Mutation pass is outside its original repository and flow storage');
+  if (pass.writeDelegation) await assertPreservedMutationIssued(input, pass);
   return pass;
 }
 export async function mutationPassLocations14(input, binding, pass) {
   const stateRoot = await mutationStateRoot14(input);
   const gates = path.join(stateRoot, 'gates', pass.repositoryDigest, pass.flowId);
-  const anchor = process.env.ENTROROVE_TASK_HANDOFF_STATE_DIRECTORY;
+  const anchor = pass.writeDelegation ? binding.directory : process.env.ENTROROVE_TASK_HANDOFF_STATE_DIRECTORY;
   const consumption = path.join(anchor, 'mutations', pass.repositoryDigest, pass.flowId);
   await privateMutationDirectory14(gates, { privateFrom: stateRoot });
   await privateMutationDirectory14(consumption, { privateFrom: anchor });
@@ -28,7 +30,7 @@ export async function mutationPassLocations14(input, binding, pass) {
 }
 function initial(pass, locations) {
   return { schemaVersion: SCHEMA, passId: pass.passId, passDigest: sha256(canonical(pass)), flowId: pass.flowId,
-    stepId: pass.stepId, executionAttemptNonce: pass.executionAttemptNonce, executionHome: locations.executionHome,
+    stepId: pass.stepId, ...(pass.writeDelegation ? { delegationNonce: pass.challengeNonce } : { executionAttemptNonce: pass.executionAttemptNonce }), executionHome: locations.executionHome,
     paths: [...pass.paths], writes: {} };
 }
 export async function readMutationConsumption14(pass, locations) {

package/local-mutation-wire.mjs

@@ -4,6 +4,7 @@ import { canonicalHandoffSignature } from './local-task-handoff-overlay-wire.mjs
 import { mutationFail14, mutationPaths14 } from './local-mutation-files.mjs';
 import { disciplineApprovedPolicy } from './local-discipline-contracts.mjs';
 import { validatorParallelDeclarationsValid } from './runtime/validator-runtime-v7.0.44.mjs';
+import { preservedMutationDelegation } from './local-preserved-mutation-wire.mjs';
 
 export const MUTATION_IDENTITY_FIELDS14 = ['flowId', 'taskId', 'ownerId', 'taskDigest', 'chainDigest', 'chainRevision',
   'acceptanceReceiptId', 'acceptanceDigest', 'routeDigest', 'receiver', 'receiverDigest', 'stepId', 'leaseId', 'leaseDigest',
@@ -38,13 +39,18 @@ function pinnedAuthority() {
   } catch { mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Pinned cloud mutation authority is unavailable or invalid'); }
 }
 function identity(payload) {
+  if (Object.hasOwn(payload, 'previousPassId') && (!ID.test(payload.previousPassId) || payload.previousPassId === payload.passId)) {
+    mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Mutation continuation must retain a distinct original settled predecessor');
+  }
   const ids = ['flowId', 'taskId', 'acceptanceReceiptId', 'stepId', 'leaseId', 'planId', 'executionAuthorityId',
     'executionAttemptNonce', 'runnerId', 'repositoryId', 'snapshotId', 'nonce', 'challengeId'];
   const digests = ['taskDigest', 'chainDigest', 'acceptanceDigest', 'routeDigest', 'receiverDigest', 'leaseDigest',
     'planDigest', 'executionPlanSha256', 'executionAuthorityDigest', 'runnerKeyId', 'scopeBindingDigest',
     'scopeArtifactDigest', 'scopeContractDigest'];
-  if (ids.some(field => typeof payload[field] !== 'string' || !ID.test(payload[field]))
-    || digests.some(field => typeof payload[field] !== 'string' || !SHA.test(payload[field]))
+  const delegated = Object.hasOwn(payload, 'writeDelegation');
+  const execution = new Set(['executionAuthorityId', 'executionAuthorityDigest', 'executionAttemptNonce']);
+  if (ids.filter(field => !delegated || !execution.has(field)).some(field => typeof payload[field] !== 'string' || !ID.test(payload[field]))
+    || digests.filter(field => !delegated || !execution.has(field)).some(field => typeof payload[field] !== 'string' || !SHA.test(payload[field]))
     || !/^[0-9a-f]{32}$/.test(payload.repositoryDigest) || !/^[0-9a-f-]{36}$/.test(payload.ownerId)
     || !Number.isSafeInteger(payload.epoch) || payload.epoch < 0
     || ['generation', 'chainRevision'].some(field => !Number.isSafeInteger(payload[field]) || payload[field] < 1)) {
@@ -63,6 +69,7 @@ function identity(payload) {
     || ['projectId', 'hostId', 'threadId'].some(field => !ID.test(String(payload.receiver[field])))) {
     mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Mutation authority lost its original cloud receiver');
   }
+  if (delegated) preservedMutationDelegation(payload);
 }
 function authority(value, fields, schema, options) {
   exact(value, [...fields, 'authorityReceipt']);
@@ -79,12 +86,22 @@ function authority(value, fields, schema, options) {
   identity(payload); mutationLifetime14(payload, options); return value;
 }
 export function mutationChallenge14(value, options) {
-  return authority(value, CHALLENGE_FIELDS, 'entrorove.mutation-snapshot-challenge/1.0', options);
+  return authority(value, authorityFields(value, CHALLENGE_FIELDS), 'entrorove.mutation-snapshot-challenge/1.0', options);
+}
+function authorityFields(value, fields) {
+  const original = Object.hasOwn(value ?? {}, 'writeDelegation') ? [...fields.filter(field =>
+    !['executionAuthorityId', 'executionAuthorityDigest', 'executionAttemptNonce'].includes(field)), 'writeDelegation'] : fields;
+  return [...original, ...['previousPassId'].filter(field => Object.hasOwn(value ?? {}, field))];
 }
 export function mutationPass14(value, options) {
-  const fields = [...PASS_FIELDS, ...['disciplinePolicy', 'parallelPaths'].filter(key => Object.hasOwn(value ?? {}, key))];
+  const fields = [...authorityFields(value, PASS_FIELDS), ...['disciplinePolicy', 'parallelPaths'].filter(key => Object.hasOwn(value ?? {}, key))];
   const pass = authority(value, fields, 'entrorove.mutation-pass/1.0', options);
   if (pass.disciplinePolicy) disciplineApprovedPolicy(pass.disciplinePolicy);
+  if (pass.writeDelegation && (!pass.disciplinePolicy || pass.parallelPaths || pass.disciplinePolicy.dataOperations?.length
+    || pass.paths.some(target => { const write = pass.disciplinePolicy.writes.find(item => item.targetPath === target);
+      return !write || write.kind !== 'modify' || write.deletedSymbols?.length || write.exceptions?.length; }))) {
+    mutationFail14('ENTROROVE_MUTATION_DELEGATION_INVALID', 'Preserved mutation permits only the exact existing modification policy');
+  }
   if (pass.parallelPaths && !validatorParallelDeclarationsValid(pass.parallelPaths)) mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Parallel paths must match the frozen equivalence contract');
   if (!ID.test(pass.passId) || !ID.test(pass.challengeNonce) || pass.handoffEpoch !== pass.epoch || pass.coordinationRequired !== false
     || ['challengeDigest', 'snapshotDigest', 'snapshotReceiptDigest', 'snapshotManifestDigest', 'attestationDigest'].some(field => !SHA.test(pass[field]))) {

package/local-preserved-mutation-protection.mjs

@@ -0,0 +1,51 @@
+import { promises as fs } from 'node:fs';
+import { canonical } from './local-integrity.mjs';
+import { scopeRead, scopeTarget } from './local-scope-files.mjs';
+import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
+import { preservedMutationDelegation, preservedMutationFail } from './local-preserved-mutation-wire.mjs';
+import { preservedMutationProtectedFiles } from './local-preserved-mutation-state.mjs';
+import { scopeCandidateImports } from './local-scope-repository.mjs';
+
+function unknownTarget(path, site) {
+  const reason = typeof site?.reason === 'string' && /^[a-z-]+$/.test(site.reason) ? site.reason : 'unknown-import-source';
+  throw Object.assign(new Error(`Preserved mutation cannot modify unknown dependency source ${JSON.stringify(path)}: ${reason}`),
+    { code: 'ENTROROVE_MUTATION_DELEGATION_INVALID', path, reason });
+}
+
+async function observe(input, root, expected) {
+  const before = await scopeTarget(root, expected.path, false, true), resolvedPath = await fs.realpath(before.target);
+  const read = await scopeRead(root, expected.path, input), after = await scopeTarget(root, expected.path, false, true);
+  if (read.sha256 !== expected.sha256 || before.stat.dev !== after.stat.dev || before.stat.ino !== after.stat.ino
+    || before.stat.mode !== after.stat.mode || resolvedPath !== await fs.realpath(after.target)) {
+    preservedMutationFail(`Preserved mutation dependency ${JSON.stringify(expected.path)} changed bytes, permissions or physical identity`);
+  }
+  return { ...expected, mode: after.stat.mode & 0o777, resolvedPath };
+}
+export async function capturePreservedMutationProtection(input, root, authority, snapshot) {
+  const delegation = preservedMutationDelegation(authority), review = await readDisciplineSnapshot(snapshot);
+  for (const expected of delegation.targetFiles) {
+    const file = snapshot.manifest.files.find(item => item.path === expected.path);
+    if (!file?.exists || file.sha256 !== expected.sha256) preservedMutationFail('Preserved mutation target must retain its exact existing gate baseline');
+    const imports = await scopeCandidateImports(root, { path: expected.path,
+      content: (await scopeRead(root, expected.path, input)).content.toString('utf8') }, input);
+    const declared = delegation.targetImports.find(item => item.path === expected.path);
+    if (imports.dynamic) unknownTarget(expected.path, imports.unresolvedImports?.[0]);
+    if (canonical([...new Set(imports.edges.map(edge => edge.specifier))].sort()) !== canonical(declared.specifiers)) {
+      preservedMutationFail('Preserved mutation targets cannot contain unknown or changed imports');
+    }
+  }
+  const unknown = review.analysis.unresolved.find(item => authority.paths.includes(item.path) && /(?:^import-|dynamic-import|dynamic-reference)/.test(item.reason));
+  if (unknown) unknownTarget(unknown.path, unknown);
+  const result = [];
+  for (const expected of delegation.protectedFiles) result.push(await observe(input, root, expected));
+  return result;
+}
+export async function assertPreservedMutationProtection(input, root, authority) {
+  const delegation = preservedMutationDelegation(authority), original = await preservedMutationProtectedFiles(input, authority);
+  if (canonical(original.map(({ path, sha256 }) => ({ path, sha256 }))) !== canonical(delegation.protectedFiles)) {
+    preservedMutationFail('Preserved mutation protected file manifest differs from its signed delegation');
+  }
+  for (const expected of original) {
+    if (canonical(await observe(input, root, expected)) !== canonical(expected)) preservedMutationFail(`Preserved mutation dependency ${JSON.stringify(expected.path)} changed permissions or physical identity`);
+  }
+}

package/local-preserved-mutation-signer.mjs

@@ -0,0 +1,81 @@
+import { createPrivateKey, createPublicKey, generateKeyPairSync, randomUUID, sign } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationHome14, mutationRoot14, mutationStateRoot14, mutationId14, privateMutationDirectory14,
+  readMutationJson14, atomicMutationJson14, mutationTarget14 } from './local-mutation-files.mjs';
+import { preservedMutationFail, preservedMutationPublicKey } from './local-preserved-mutation-wire.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { regular } from './local-task-handoff-storage.mjs';
+
+export async function preservedMutationLocation(input) {
+  const root = await mutationRoot14(input.repositoryRoot), home = await mutationHome14(input.home);
+  const relative = path.relative(root, home);
+  if (!relative || relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)) {
+    preservedMutationFail('Preserved mutation signer home must be outside the repository');
+  }
+  const stateRoot = await mutationStateRoot14({ ...input, home });
+  const repositoryDigest = sha256(root).slice(0, 32), flowId = mutationId14(input.flowId, 'flowId');
+  const directory = path.join(stateRoot, 'mutation-delegates', repositoryDigest, flowId);
+  await privateMutationDirectory14(directory, { privateFrom: stateRoot });
+  return { root, home, stateRoot, repositoryDigest, flowId, directory, bindingPath: path.join(directory, 'binding.json'),
+    signerConfigPath: path.join(directory, 'signer.json'), fencePath: path.join(directory, 'fence.json') };
+}
+export async function readPreservedMutationBinding(input) {
+  const location = await preservedMutationLocation(input), binding = await readMutationJson14(location.bindingPath);
+  const publicKey = preservedMutationPublicKey(binding.publicKey);
+  if (canonical(Object.keys(binding).sort()) !== canonical(['schemaVersion', 'flowId', 'repositoryDigest', 'home', 'keyId', 'publicKey'].sort())
+    || binding.schemaVersion !== 'entrorove.mutation-delegate-binding/1.0' || binding.flowId !== location.flowId
+    || binding.repositoryDigest !== location.repositoryDigest || binding.home !== location.home || binding.keyId !== publicKey.keyId) {
+    preservedMutationFail('Preserved mutation signer lost its original repository, home or flow binding');
+  }
+  return { ...location, binding };
+}
+export async function preparePreservedMutationSigner(input) {
+  const location = await preservedMutationLocation(input);
+  return withStateLock(path.join(location.directory, 'prepare'), () => prepareSigner(input, location));
+}
+async function prepareSigner(input, location) {
+  try { await mutationTarget14(location.directory, 'binding.json'); }
+  catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    const pair = generateKeyPairSync('ed25519'), publicKey = pair.publicKey.export({ format: 'der', type: 'spki' }).toString('base64');
+    const stage = path.join(location.directory, `.prepare-${randomUUID()}`);
+    await privateMutationDirectory14(stage, { exclusive: true, privateFrom: location.stateRoot });
+    const privateKeyPath = path.join(location.directory, 'private.pem');
+    try {
+      await fs.writeFile(path.join(stage, 'private.pem'), pair.privateKey.export({ format: 'pem', type: 'pkcs8' }), { flag: 'wx', mode: 0o600 });
+      await atomicMutationJson14(path.join(stage, 'signer.json'), { schemaVersion: 'entrorove.mutation-delegate-signer/1.0',
+        privateKeyPath, keyId: sha256(Buffer.from(publicKey, 'base64')), receiptTtlMs: 60_000 }, { privateFrom: location.stateRoot });
+      await atomicMutationJson14(path.join(stage, 'binding.json'), { schemaVersion: 'entrorove.mutation-delegate-binding/1.0',
+        flowId: location.flowId, repositoryDigest: location.repositoryDigest, home: location.home,
+        publicKey, keyId: sha256(Buffer.from(publicKey, 'base64')) }, { privateFrom: location.stateRoot });
+      const fence = { schemaVersion: 'entrorove.preserved-mutation-fence/1.0', epoch: 0, identity: null, grants: [] };
+      await atomicMutationJson14(path.join(stage, 'fence.json'), { ...fence,
+        signature: sign(null, Buffer.from(canonical(fence)), pair.privateKey).toString('base64url') }, { privateFrom: location.stateRoot });
+      for (const file of ['private.pem', 'signer.json', 'binding.json', 'fence.json']) await fs.link(path.join(stage, file), path.join(location.directory, file));
+    } finally { await fs.rm(stage, { recursive: true, force: true }); }
+  }
+  const actual = await readPreservedMutationBinding(input);
+  await mutationTarget14(actual.directory, 'fence.json');
+  await loadPreservedMutationSigner(input, actual.signerConfigPath, actual.binding.keyId);
+  return { schemaVersion: 'entrorove.local-execution/1.0', status: 'reported', purpose: 'preserved-existing-modify',
+    mutationPublicKey: actual.binding.publicKey, mutationKeyId: actual.binding.keyId, keyId: actual.binding.keyId, signerConfigPath: actual.signerConfigPath };
+}
+export async function loadPreservedMutationSigner(input, file, keyId) {
+  const location = await readPreservedMutationBinding(input);
+  if (file !== location.signerConfigPath || location.binding.keyId !== keyId) preservedMutationFail('Preserved mutation signer differs from the delegated physical key');
+  const config = await readMutationJson14(file);
+  if (canonical(Object.keys(config).sort()) !== canonical(['schemaVersion', 'privateKeyPath', 'keyId', 'receiptTtlMs'].sort())
+    || config.schemaVersion !== 'entrorove.mutation-delegate-signer/1.0' || config.keyId !== keyId
+    || config.privateKeyPath !== path.join(location.directory, 'private.pem') || !Number.isSafeInteger(config.receiptTtlMs)
+    || config.receiptTtlMs < 1 || config.receiptTtlMs > 90_000) preservedMutationFail('Preserved mutation signer configuration is invalid');
+  const target = await mutationTarget14(location.directory, 'private.pem'), { bytes, stat } = await regular(target.target, 16 * 1024);
+  try {
+    if (stat.nlink !== 1 || process.platform !== 'win32' && (stat.mode & 0o077)
+      || process.getuid && stat.uid !== process.getuid()) preservedMutationFail('Preserved mutation signer must be an owned private file');
+    const privateKey = createPrivateKey(bytes), der = createPublicKey(privateKey).export({ format: 'der', type: 'spki' });
+    if (privateKey.asymmetricKeyType !== 'ed25519' || sha256(der) !== keyId) preservedMutationFail('Preserved mutation signer key fingerprint is invalid');
+    return { privateKey, config };
+  } finally { bytes.fill(0); }
+}

package/local-preserved-mutation-state.mjs

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { sign, verify } from 'node:crypto';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { readMutationJson14, atomicMutationJson14 } from './local-mutation-files.mjs';
+import { readPreservedMutationBinding, loadPreservedMutationSigner } from './local-preserved-mutation-signer.mjs';
+import { preservedMutationDelegation, preservedMutationFail, preservedMutationPublicKey } from './local-preserved-mutation-wire.mjs';
+
+const identity = authority => Object.fromEntries(['flowId', 'taskId', 'ownerId', 'taskDigest', 'chainDigest',
+  'repositoryDigest', 'runnerKeyId', 'runnerId', 'repositoryId', 'receiverDigest'].map(field => [field, authority[field]]));
+async function rejectGenericHistory(location) {
+  const anchor = process.env.ENTROROVE_TASK_HANDOFF_STATE_DIRECTORY;
+  if (!anchor) return;
+  const file = path.join(anchor, 'flows', location.repositoryDigest, location.flowId, 'fence.json');
+  try {
+    await fs.lstat(file);
+    preservedMutationFail('Preserved mutation cannot replace an existing generic task execution or handoff history');
+  } catch (error) { if (error.code !== 'ENOENT') throw error; }
+}
+export async function preservedMutationOriginalBinding(input, authority) {
+  const location = await readPreservedMutationBinding(input), delegation = preservedMutationDelegation(authority);
+  if (authority.flowId !== input.flowId || authority.stepId !== input.stepId || authority.repositoryDigest !== location.repositoryDigest
+    || input.taskId !== undefined && input.taskId !== authority.taskId || input.generation !== undefined && input.generation !== authority.generation
+    || input.leaseId !== undefined && input.leaseId !== authority.leaseId || input.executionAttemptNonce !== undefined
+    || delegation.mutationKeyId !== location.binding.keyId || delegation.mutationPublicKey !== location.binding.publicKey) {
+    preservedMutationFail('Preserved mutation lost its original physical signer, task, lease or repository binding');
+  }
+  await rejectGenericHistory(location);
+  let state;
+  try { state = await readMutationJson14(location.fencePath); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; preservedMutationFail('Preserved mutation fence history is missing; automatic reinitialization is forbidden'); }
+  if (state) {
+    const { signature, ...core } = state, bytes = typeof signature === 'string' ? Buffer.from(signature, 'base64url') : Buffer.alloc(0);
+    if (bytes.length !== 64 || bytes.toString('base64url') !== signature
+      || !verify(null, Buffer.from(canonical(core)), preservedMutationPublicKey(location.binding.publicKey).key, bytes)) {
+      preservedMutationFail('Preserved mutation fence integrity is invalid');
+    }
+  }
+  if (state.schemaVersion !== 'entrorove.preserved-mutation-fence/1.0' || state.epoch !== 0
+    || state.identity !== null && canonical(state.identity) !== canonical(identity(authority))
+    || !Array.isArray(state.grants) || state.grants.length > 10000 || state.identity === null && state.grants.length) {
+    preservedMutationFail('Preserved mutation fence cannot replace original task identity or epoch history');
+  }
+  return { ...location, context: null, state: { epoch: 0, status: 'active' }, preservedState: state };
+}
+function grantFor(state, authority) {
+  const grant = state.grants.find(item => item.challengeId === authority.challengeId);
+  const nonce = authority.passId ? authority.challengeNonce : authority.nonce;
+  const digest = authority.passId ? authority.challengeDigest : sha256(canonical(authority));
+  if (state.grants.some(item => item.nonce === nonce && item !== grant)
+    || grant && (grant.nonce !== nonce || grant.challengeDigest !== digest || grant.leaseId !== authority.leaseId
+      || grant.generation !== authority.generation || grant.stepId !== authority.stepId)) {
+    preservedMutationFail('Preserved mutation nonce cannot replace its original challenge or lease');
+  }
+  return grant;
+}
+export async function assertPreservedMutationIssued(input, pass) {
+  const binding = await preservedMutationOriginalBinding(input, pass), grant = grantFor(binding.preservedState, pass);
+  if (!grant || grant.passDigest !== sha256(canonical(pass))) preservedMutationFail('Preserved mutation requires its original issued pass and nonce fence');
+  return binding;
+}
+export async function preservedMutationProtectedFiles(input, authority) {
+  const binding = await preservedMutationOriginalBinding(input, authority), grant = grantFor(binding.preservedState, authority);
+  if (!grant?.protectedFiles) preservedMutationFail('Preserved mutation requires its original protected file observations');
+  return grant.protectedFiles;
+}
+async function persist(input, binding, state) {
+  const { signature: previous, ...core } = state;
+  const signer = await loadPreservedMutationSigner(input, binding.signerConfigPath, binding.binding.keyId);
+  const signature = sign(null, Buffer.from(canonical(core)), signer.privateKey).toString('base64url');
+  await atomicMutationJson14(binding.fencePath, { ...core, signature }, { privateFrom: binding.stateRoot, replace: true });
+}
+export async function withPreservedMutationFence(input, authority, action, { attest = false, issue = false, protectedFiles } = {}) {
+  const original = await preservedMutationOriginalBinding(input, authority);
+  return withStateLock(original.fencePath, async () => {
+    const binding = await preservedMutationOriginalBinding(input, authority), state = binding.preservedState;
+    if (state.identity === null) state.identity = identity(authority);
+    let grant = grantFor(state, authority);
+    if (!grant) {
+      if (!attest || authority.passId) preservedMutationFail('Preserved mutation has no original attested challenge');
+      grant = { challengeId: authority.challengeId, nonce: authority.nonce, challengeDigest: sha256(canonical(authority)),
+        leaseId: authority.leaseId, generation: authority.generation, stepId: authority.stepId, passDigest: null, protectedFiles };
+      state.grants.push(grant);
+    }
+    if (attest && canonical(grant.protectedFiles) !== canonical(protectedFiles)) preservedMutationFail('Preserved mutation protected baseline changed during attestation');
+    if (authority.passId) {
+      const passDigest = sha256(canonical(authority));
+      if (grant.passDigest !== passDigest && (!issue || grant.passDigest !== null)) preservedMutationFail('Preserved mutation challenge was already bound to another pass');
+      if (issue) grant.passDigest = passDigest;
+      else if (!grant.passDigest) preservedMutationFail('Preserved mutation pass is not issued');
+    }
+    await persist(input, binding, state);
+    return action(binding.state);
+  });
+}

package/local-preserved-mutation-wire.mjs

@@ -0,0 +1,49 @@
+import { createPublicKey } from 'node:crypto';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationFail14, mutationPath14 } from './local-mutation-files.mjs';
+
+export const preservedMutationFail = message => mutationFail14('ENTROROVE_MUTATION_DELEGATION_INVALID', message);
+function exact(value, names) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || canonical(Object.keys(value).sort()) !== canonical([...names].sort())) preservedMutationFail('Preserved mutation delegation fields are invalid');
+}
+export function preservedMutationPublicKey(encoded) {
+  try {
+    const bytes = Buffer.from(encoded, 'base64'), key = createPublicKey({ key: bytes, format: 'der', type: 'spki' });
+    if (typeof encoded !== 'string' || bytes.toString('base64') !== encoded || key.asymmetricKeyType !== 'ed25519'
+      || key.export({ format: 'der', type: 'spki' }).toString('base64') !== encoded) throw new Error();
+    return { key, keyId: sha256(bytes) };
+  } catch { preservedMutationFail('Preserved mutation requires a canonical Ed25519 public key'); }
+}
+function files(values) {
+  if (!Array.isArray(values) || values.length > 2000) preservedMutationFail('Preserved mutation file manifest is invalid');
+  for (const [index, file] of values.entries()) {
+    exact(file, ['path', 'sha256']); mutationPath14(file.path);
+    if (!/^[0-9a-f]{64}$/.test(file.sha256) || index && values[index - 1].path >= file.path) {
+      preservedMutationFail('Preserved mutation file manifest must be sorted and unique');
+    }
+  }
+  return values;
+}
+export function preservedMutationDelegation(authority) {
+  const value = authority.writeDelegation;
+  exact(value, ['schemaVersion', 'purpose', 'scopeKeyId', 'mutationKeyId', 'mutationPublicKey',
+    'gateEvidenceDigest', 'importGraphDigest', 'protectedFiles', 'targetFiles', 'targetImports']);
+  const publicKey = preservedMutationPublicKey(value.mutationPublicKey);
+  if (value.schemaVersion !== 'entrorove.preserved-write-delegation/1.0' || value.purpose !== 'preserved-existing-modify'
+    || ['scopeKeyId', 'mutationKeyId', 'gateEvidenceDigest', 'importGraphDigest'].some(field => !/^[0-9a-f]{64}$/.test(value[field]))
+    || publicKey.keyId !== value.mutationKeyId || new Set([authority.runnerKeyId, value.scopeKeyId, value.mutationKeyId]).size !== 3
+    || authority.epoch !== 0 || authority.newFilePaths.length !== 0) preservedMutationFail('Preserved mutation role or original epoch is invalid');
+  files(value.protectedFiles); files(value.targetFiles);
+  if (canonical(value.targetFiles.map(file => file.path)) !== canonical(authority.paths)
+    || value.protectedFiles.some(file => authority.paths.includes(file.path))
+    || !Array.isArray(value.targetImports) || canonical(value.targetImports.map(file => file?.path)) !== canonical(authority.paths)) {
+    preservedMutationFail('Preserved mutation must retain its exact existing target and protected path sets');
+  }
+  for (const file of value.targetImports) {
+    exact(file, ['path', 'specifiers']);
+    if (!Array.isArray(file.specifiers) || file.specifiers.some(item => typeof item !== 'string' || !item || /[\u0000-\u001f\u007f]/.test(item))
+      || canonical([...new Set(file.specifiers)].sort()) !== canonical(file.specifiers)) preservedMutationFail('Preserved mutation import manifest is invalid');
+  }
+  return value;
+}