@entrorove/skill 0.1.52 → 0.1.54

package/local-delegated-modify-analysis.mjs

@@ -0,0 +1,232 @@
+import ts from 'typescript';
+import { parse as parseVue, parseCache } from '@vue/compiler-sfc';
+import { canonical } from './local-integrity.mjs';
+import { createScopeImportResolver } from './local-scope-import-expressions.mjs';
+import { isDynamicFunctionReference, isTypeOnlyReference } from './local-typescript-function-reference.mjs';
+
+const fail = () => { throw Object.assign(new Error('Preserved modification changed an existing definition, public contract, dependency, or unsupported source boundary'),
+  { code: 'ENTROROVE_MUTATION_DELEGATION_CHANGE' }); };
+const printer = ts.createPrinter({ removeComments: true });
+const print = node => node ? printer.printNode(ts.EmitHint.Unspecified, node, node.getSourceFile()) : null;
+function unwrap(node) {
+  while (node && (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)
+    || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node))) node = node.expression;
+  return node;
+}
+function names(node) {
+  if (!node) return [];
+  if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isPrivateIdentifier(node)) return [node.text];
+  if (ts.isObjectBindingPattern(node) || ts.isArrayBindingPattern(node)) return node.elements.flatMap(item => ts.isBindingElement(item) ? names(item.name) : []);
+  return [print(node)];
+}
+function owner(node) {
+  if (node.name) return names(node.name).join(',');
+  if (node.parent?.name && (ts.isVariableDeclaration(node.parent) || ts.isPropertyAssignment(node.parent))) return names(node.parent.name).join(',');
+  return '<anonymous>';
+}
+function scope(node) {
+  const parts = [];
+  for (let parent = node.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
+    if (ts.isFunctionLike(parent) || ts.isClassLike(parent) || ts.isModuleDeclaration(parent)) parts.unshift(`${parent.kind}:${owner(parent)}`);
+  }
+  return parts.join('/');
+}
+const modifiers = node => node.modifiers?.map(value => value.kind) ?? [];
+function signature(node) {
+  return { kind: node.kind, name: node.name ? print(node.name) : null, modifiers: modifiers(node), optional: Boolean(node.questionToken),
+    generator: Boolean(node.asteriskToken), types: node.typeParameters?.map(print) ?? [], type: print(node.type),
+    parameters: node.parameters?.map(print) ?? [] };
+}
+function exported(node, exportNames) {
+  if (names(node.name).some(name => exportNames.has(name))) return true;
+  for (let current = node; current && !ts.isSourceFile(current); current = current.parent) {
+    if (current !== node && ts.isFunctionLike(current)) return false;
+    if (current.modifiers?.some(value => [ts.SyntaxKind.ExportKeyword, ts.SyntaxKind.DefaultKeyword].includes(value.kind))
+      || ts.isExportAssignment(current)) return true;
+  }
+  return false;
+}
+function exportedNames(source) {
+  const result = new Set();
+  for (const node of source.statements) {
+    if (ts.isExportDeclaration(node) && !node.moduleSpecifier && node.exportClause && ts.isNamedExports(node.exportClause)) {
+      for (const item of node.exportClause.elements) result.add((item.propertyName ?? item.name).text);
+    }
+    if (ts.isExportAssignment(node) && ts.isIdentifier(unwrap(node.expression))) result.add(unwrap(node.expression).text);
+  }
+  const common = node => {
+    if (commonJs(node)) {
+      const value = unwrap(node.right);
+      if (ts.isIdentifier(value)) result.add(value.text);
+      if (ts.isObjectLiteralExpression(value)) for (const property of value.properties) {
+        if (ts.isShorthandPropertyAssignment(property)) result.add(property.name.text);
+        if (ts.isPropertyAssignment(property) && ts.isIdentifier(unwrap(property.initializer))) result.add(unwrap(property.initializer).text);
+      }
+    }
+    ts.forEachChild(node, common);
+  };
+  common(source);
+  return result;
+}
+function isDefinition(node) {
+  return ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)
+    || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isEnumMember(node)
+    || ts.isPropertySignature(node) || ts.isMethodSignature(node) || ts.isPropertyDeclaration(node) || ts.isMethodDeclaration(node)
+    || ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node) || ts.isGetAccessorDeclaration(node)
+    || ts.isSetAccessorDeclaration(node) || ts.isModuleDeclaration(node) || ts.isImportSpecifier(node) || ts.isImportClause(node)
+    || ts.isNamespaceImport(node) || ts.isImportEqualsDeclaration(node) || ts.isTypeParameterDeclaration(node);
+}
+const increment = (map, key) => map.set(key, (map.get(key) ?? 0) + 1);
+function variableContract(node) {
+  const value = unwrap(node.initializer);
+  return { ...signature(node), binding: node.parent.flags & (ts.NodeFlags.Const | ts.NodeFlags.Let),
+    callable: value && ts.isFunctionLike(value) ? signature(value) : null,
+    alias: value && (ts.isIdentifier(value) || ts.isPropertyAccessExpression(value) || ts.isElementAccessExpression(value)) ? print(value) : null };
+}
+function isDependency(node) {
+  return ts.isImportDeclaration(node) || ts.isExportDeclaration(node) || ts.isImportEqualsDeclaration(node) || ts.isImportTypeNode(node)
+    || ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword
+      || ts.isIdentifier(node.expression) && node.expression.text === 'require');
+}
+function dependency(node, source, resolve) {
+  const call = ts.isCallExpression(node);
+  return { syntax: print(node), alternatives: call ? resolve(node.arguments[0]) : null,
+    comments: source.text.slice(node.getStart(source), node.end).match(/\/\*[\s\S]*?\*\//g) ?? [] };
+}
+function commonJs(node) {
+  return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken
+    && /^(?:module\.exports|exports)(?:\.[A-Za-z_$][\w$]*|\[[\s\S]+\])?$/.test(print(node.left) ?? '');
+}
+function sourceChecker(source) {
+  const filename = `/${source.fileName.replace(/^\/+/, '')}`;
+  const matches = value => `/${value.replace(/^\/+/, '')}` === filename;
+  return ts.createProgram([filename], { noLib: true, noResolve: true, allowJs: true }, {
+    getSourceFile: value => matches(value) ? source : undefined, getDefaultLibFileName: () => '/none.d.ts', writeFile: () => {},
+    getCurrentDirectory: () => '/', getDirectories: () => [], fileExists: matches,
+    readFile: value => matches(value) ? source.text : undefined, getCanonicalFileName: value => value,
+    useCaseSensitiveFileNames: () => true, getNewLine: () => '\n',
+  }).getTypeChecker();
+}
+function exportedObject(value) {
+  return value.properties.map(property => {
+    const initializer = ts.isPropertyAssignment(property) ? unwrap(property.initializer) : property;
+    return { name: print(property.name), kind: property.kind,
+      alias: ts.isIdentifier(initializer) || ts.isPropertyAccessExpression(initializer) ? print(initializer) : null,
+      callable: ts.isFunctionLike(initializer) ? signature(initializer) : null };
+  });
+}
+function unknownReference(node, context) {
+  if (isTypeOnlyReference(node)) return false;
+  if (ts.isIdentifier(node) && (['eval', 'createRequire'].includes(node.text) || isDynamicFunctionReference(node, context))) return true;
+  if (ts.isIdentifier(node) && node.text === 'require' && !(ts.isCallExpression(node.parent) && node.parent.expression === node)
+    && !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node)) return true;
+  if (ts.isElementAccessExpression(node) && (!ts.isStringLiteralLike(node.argumentExpression)
+    || ['Function', 'eval', 'require', 'createRequire'].includes(node.argumentExpression.text))) return true;
+  return ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression)
+    && ['Object', 'Reflect'].includes(node.expression.expression.text) && ['get', 'set', 'defineProperty'].includes(node.expression.name.text);
+}
+function scriptProjection(part) {
+  const kind = /\.[jt]sx$/i.test(part.path) ? ts.ScriptKind.TSX : /\.[cm]?js$/i.test(part.path) ? ts.ScriptKind.JS : ts.ScriptKind.TS;
+  const source = ts.createSourceFile(part.path, part.content, ts.ScriptTarget.Latest, true, kind);
+  if (source.parseDiagnostics.length) fail();
+  const result = { dependencies: [], definitions: new Map(), signatures: new Map(), public: [], unknown: new Map() };
+  const exports = exportedNames(source), resolve = createScopeImportResolver(source);
+  let visited = 0, checker;
+  const inferred = node => {
+    checker ??= sourceChecker(source);
+    return checker.typeToString(checker.getTypeAtLocation(node), node, ts.TypeFormatFlags.NoTruncation);
+  };
+  const visit = node => {
+    if (++visited > 200_000) fail();
+    const key = `${scope(node)}/${node.kind}:${names(node.name).join(',')}`;
+    if (isDependency(node)) result.dependencies.push(dependency(node, source, resolve));
+    if (isDefinition(node)) for (const name of names(node.name)) increment(result.definitions, `${scope(node)}/${node.kind}:${name}`);
+    if (ts.isClassExpression(node)) increment(result.definitions, `${scope(node)}/${node.kind}:${owner(node)}`);
+    if (ts.isFunctionLike(node)) increment(result.signatures, canonical({ scope: scope(node), signature: signature(node) }));
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) increment(result.signatures, canonical({ key, contract: print(node) }));
+    if (exported(node, exports) && isDefinition(node)) {
+      const contract = ts.isVariableDeclaration(node) ? variableContract(node) : signature(node);
+      result.public.push({ key, contract });
+      if (ts.isFunctionLike(node) || ts.isVariableDeclaration(node) && (contract.callable || contract.alias)) {
+        result.public.push({ key, inferred: inferred(node) });
+      }
+      if (ts.isPropertyAssignment(node) && ['props', 'emits'].includes(names(node.name)[0])) result.public.push({ key, metadata: print(node.initializer) });
+      if (ts.isClassDeclaration(node)) result.public.push({ key, heritage: node.heritageClauses?.map(print) ?? [] });
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)
+      && ['defineProps', 'defineEmits', 'defineSlots', 'defineModel', 'withDefaults'].includes(node.expression.text)) {
+      result.public.push({ macro: print(node) });
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'defineExpose') {
+      result.public.push({ expose: node.arguments.map(value => ts.isObjectLiteralExpression(value) ? exportedObject(value) : print(value)) });
+    }
+    if (ts.isExportAssignment(node) && ![ts.SyntaxKind.ObjectLiteralExpression, ts.SyntaxKind.CallExpression,
+      ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ClassExpression, ts.SyntaxKind.ArrowFunction].includes(unwrap(node.expression).kind)) {
+      result.public.push({ defaultAlias: print(node.expression), equals: node.isExportEquals });
+    }
+    if (commonJs(node)) result.public.push({ commonJs: print(node.left), contract: ts.isFunctionLike(unwrap(node.right))
+      ? { signature: signature(unwrap(node.right)), inferred: inferred(unwrap(node.right)) }
+      : ts.isObjectLiteralExpression(unwrap(node.right)) ? exportedObject(unwrap(node.right)) : print(node.right) });
+    if (unknownReference(node, part.context)) increment(result.unknown, print(node));
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return result;
+}
+function templateParts(root, path) {
+  const parts = [], seen = new WeakSet();
+  const walk = node => {
+    if (!node || typeof node !== 'object' || seen.has(node)) return;
+    seen.add(node);
+    if (node.type === 7 && ['on', 'for'].includes(node.name) && node.exp?.content) {
+      parts.push({ path: `${path}.ts`, content: node.name === 'for' ? `for (${node.exp.content}) {}` : node.exp.content });
+      seen.add(node.exp);
+    }
+    if (node.type === 4 && !node.isStatic && node.content) parts.push({ path: `${path}.ts`, content: `void (${node.content});` });
+    for (const [key, child] of Object.entries(node)) if (!['loc', 'ast', 'parent', 'codegenNode'].includes(key)) {
+      if (Array.isArray(child)) child.forEach(walk); else walk(child);
+    }
+  };
+  walk(root);
+  return parts;
+}
+function parts(path, content) {
+  if (!/\.vue$/i.test(path)) {
+    if (!/\.[cm]?[jt]sx?$/i.test(path)) fail();
+    return { metadata: [], scripts: [{ path, content }] };
+  }
+  const parsed = parseVue(content, { filename: path, sourceMap: false, templateParseOptions: { expressionPlugins: ['typescript'] } });
+  parseCache.clear();
+  if (parsed.errors.length) fail();
+  const value = parsed.descriptor, scripts = [];
+  const metadata = [value.template?.attrs ?? null, value.styles.map(block => ({ attrs: block.attrs, content: block.content })),
+    value.customBlocks.map(block => ({ type: block.type, attrs: block.attrs, content: block.content }))];
+  if (value.template?.lang) fail();
+  for (const [index, block] of [value.script, value.scriptSetup].entries()) {
+    metadata.push(block?.attrs ?? null);
+    if (!block) continue;
+    const extension = { javascript: 'js', typescript: 'ts' }[block.lang] ?? block.lang ?? 'js';
+    if (!['js', 'ts', 'jsx', 'tsx'].includes(extension)) fail();
+    scripts.push({ path: `${path}.${index}.${extension}`, content: block.src ? `import ${JSON.stringify(block.src)};` : block.content,
+      context: { vueComponent: true, vueSetup: block === value.scriptSetup } });
+  }
+  scripts.push(...templateParts(value.template?.ast, path));
+  return { metadata, scripts };
+}
+function retained(before, after) {
+  for (const [key, count] of before) if ((after.get(key) ?? 0) < count) fail();
+}
+export function assertDelegatedSourceModification(input) {
+  const { path, before, after } = input ?? {};
+  if (typeof path !== 'string' || typeof before !== 'string' || typeof after !== 'string'
+    || Buffer.byteLength(before) > 1_048_576 || Buffer.byteLength(after) > 1_048_576) fail();
+  try {
+    const original = parts(path, before), candidate = parts(path, after);
+    if (canonical(original.metadata) !== canonical(candidate.metadata) || original.scripts.length !== candidate.scripts.length) fail();
+    for (let index = 0; index < original.scripts.length; index++) {
+      const a = scriptProjection(original.scripts[index]), b = scriptProjection(candidate.scripts[index]);
+      if (canonical(a.dependencies) !== canonical(b.dependencies) || canonical(a.public) !== canonical(b.public)) fail();
+      retained(a.definitions, b.definitions); retained(a.signatures, b.signatures); retained(b.unknown, a.unknown);
+    }
+  } catch { fail(); }
+}

package/local-discipline-actions.mjs

@@ -11,6 +11,7 @@ import { auditMutation14, withMutationAudit14 } from './local-mutation-audit.mjs
 import { mutationFail14, removeMutationProjectFile14, moveMutationProjectFile14 } from './local-mutation-files.mjs';
 
 function actionIntent(input, value, kind, review) {
+  if (value.pass.writeDelegation) mutationFail14('ENTROROVE_MUTATION_DELEGATION_CHANGE', 'Preserved mutation forbids structural file actions');
   if (!value.pass.disciplinePolicy) mutationFail14('ENTROROVE_DISCIPLINE_NEEDS_HUMAN', `${kind} needs a separately approved original change declaration`);
   const policy = disciplineApprovedPolicy(value.pass.disciplinePolicy), intent = policy.writes.find(write => write.targetPath === value.target);
   const { usageReviewDigest, ...supplied } = input.declaration ?? {};
@@ -63,6 +64,7 @@ async function perform(input, kind, original, state) {
 async function guardedAction(input, kind) {
   return withMutationAudit14(input, `guarded-${kind}`, async () => {
     const value = await checkedPass(input), pass = value.pass;
+    if (pass.writeDelegation) mutationFail14('ENTROROVE_MUTATION_DELEGATION_CHANGE', 'Preserved mutation forbids structural file actions');
     return withStateLock(value.locations.consumptionPath, () => withTaskHandoffWriteFence({ ...input,
       epoch: pass.epoch, passId: pass.passId, leaseId: pass.leaseId }, state => perform(input, kind, value, state)));
   });

package/local-discipline-gate.mjs

@@ -5,6 +5,7 @@ import { disciplineDuplicateMappings, disciplineFormattingLines } from './local-
 import { disciplineRepositoryObservation, assertDisciplineRepository } from './local-discipline-repository.mjs';
 import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
 import { readSnapshotCopy14 } from './local-mutation-snapshot.mjs';
+import { assertDelegatedSourceModification } from './local-delegated-modify-analysis.mjs';
 
 const needs = message => mutationFail14('ENTROROVE_DISCIPLINE_NEEDS_HUMAN', message);
 function declaredWrite(input, pass, baseline) {
@@ -73,11 +74,12 @@ export async function disciplineWritePreflight(input, value, content) {
   const review = await readDisciplineSnapshot(snapshot), baseline = snapshot.manifest.files.find(file => file.path === target);
   await assertDisciplineRepository(input, binding.root, review, ledger);
   const intent = declaredWrite(input, pass, baseline);
+  const original = baseline.exists ? (await readSnapshotCopy14(input, snapshot.snapshotRoot, snapshot.manifest, target)).content.toString('utf8') : '';
+  if (pass.writeDelegation) assertDelegatedSourceModification({ path: target, before: original, after: content });
   const candidate = await disciplineRepositoryObservation(input, binding.root, { analyze: true, overrides: new Map([[target, content]]) });
   const removed = checkRemoved(review, candidate.analysis, target, intent, snapshot.manifest.disciplineReviewDigest, input.declaration);
   checkContracts(review, candidate.analysis, target, intent);
   const reuse = checkReuse(review, candidate.analysis, target, intent, pass.parallelPaths);
-  const original = baseline.exists ? (await readSnapshotCopy14(input, snapshot.snapshotRoot, snapshot.manifest, target)).content.toString('utf8') : '';
   const formatting = baseline.exists ? disciplineFormattingLines(original, content, target) : [];
   if (formatting.length) mutationFail14('ENTROROVE_DISCIPLINE_FORMAT_SCOPE', `Formatting touches lines without functional changes: ${target}:${formatting.join(',')}`);
   return { reviewDigest: snapshot.manifest.disciplineReviewDigest, declaredKind: baseline.exists ? 'modify' : 'create', removed, reuse,

package/local-error.mjs

@@ -13,6 +13,8 @@ export const LOCAL_ERROR_CODE_CATALOG = Object.freeze({
   ENTROROVE_DISCIPLINE_USAGE_UNKNOWN: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
   ENTROROVE_DISCIPLINE_REVIEW_REQUIRED: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
   ENTROROVE_DISCIPLINE_DATA_SNAPSHOT_REQUIRED: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
+  ENTROROVE_MUTATION_DELEGATION_CHANGE: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
+  ENTROROVE_MUTATION_DELEGATION_INVALID: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
   ENTROROVE_IDE_GUARD_REQUIRED: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
   ENTROROVE_IDE_GUARD_UNSUPPORTED: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
 });
@@ -25,6 +27,7 @@ const BLOCKED_CODES = new Set([
   'ENTROROVE_GIT_UNAVAILABLE',
   'ENTROROVE_MUTATE_NOT_ACCEPTED', 'ENTROROVE_MUTATION_AUTHORITY_REQUIRED',
   'ENTROROVE_MUTATION_PASS_INVALID', 'ENTROROVE_MUTATION_PASS_EXPIRED',
+  'ENTROROVE_MUTATION_DELEGATION_CHANGE', 'ENTROROVE_MUTATION_DELEGATION_INVALID',
   'ENTROROVE_BUDGET_LEASE_EXPIRED', 'ENTROROVE_BUDGET_AUTHORITY_REQUIRED',
   'ENTROROVE_SWARM_AUTHORITY_INVALID', 'ENTROROVE_SWARM_CLOUD_AUTHORITY_REQUIRED',
   'ENTROROVE_HANDOFF_FENCE', 'ENTROROVE_HANDOFF_WRITE_REVOKED',

package/local-execution.mjs

@@ -277,7 +277,7 @@ export async function finalGate(input) {
 }
 
 const LOCAL_OPERATION_GROUPS = Object.freeze(['core', 'budget', 'scope', 'merge', 'chain', 'handoff', 'archguard', 'calctool', 'swarm', 'validator', 'formula', 'evidence']);
-const PASS_REQUIRED_OPERATIONS = new Set(['mutation-snapshot-attest', 'mutate-gate', 'gate-issue', 'gate-verify', 'guarded-write',
+const PASS_REQUIRED_OPERATIONS = new Set(['mutation-snapshot-attest', 'mutation-consumption-attest', 'mutate-gate', 'gate-issue', 'gate-verify', 'guarded-write',
   'discipline-review', 'discipline-check', 'guarded-delete', 'guarded-move',
   'merge-verified', 'rollback', 'archguard-contract-create', 'archguard-contract-update', 'archguard-checkpoint', 'archguard-scope-request',
   'budget-handoff', 'budget-transition', 'spawn-bind', 'peer-complete', 'complete']);

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]))) {