@entrorove/skill 0.1.61 → 0.1.64

package/local-mutation-wire.mjs

@@ -39,6 +39,21 @@ function pinnedAuthority() {
     return { key, keyId: sha256(der) };
   } catch { mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Pinned cloud mutation authority is unavailable or invalid'); }
 }
+function originalReceiver(payload) {
+  const receiver = payload.receiver;
+  const original = receiver?.schemaVersion === 'entrorove.original-task-mutation-receiver/1.0';
+  exact(receiver, original ? ['schemaVersion', 'taskId', 'ownerId', 'flowId', 'originalRequestId', 'taskDigest',
+    'routeDigest', 'acceptanceReceiptId', 'acceptanceDigest']
+    : ['taskId', 'ownerId', 'projectId', 'hostId', 'threadId', 'descriptionDigest', 'taskDigest']);
+  if (receiver.taskId !== payload.taskId || receiver.ownerId !== payload.ownerId || receiver.taskDigest !== payload.taskDigest
+    || sha256(canonical(receiver)) !== payload.receiverDigest || (original
+      ? typeof receiver.originalRequestId !== 'string' || !ID.test(receiver.originalRequestId)
+        || ['flowId', 'routeDigest', 'acceptanceReceiptId', 'acceptanceDigest']
+        .some(field => receiver[field] !== payload[field])
+      : !SHA.test(receiver.descriptionDigest) || ['projectId', 'hostId', 'threadId'].some(field => !ID.test(String(receiver[field]))))) {
+    mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Mutation authority lost its original accepted receiver');
+  }
+}
 function identity(payload) {
   if (Object.hasOwn(payload, 'scopeRevisionDigest') && !SHA.test(payload.scopeRevisionDigest)) {
     mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Mutation authority scope revision is invalid');
@@ -74,13 +89,7 @@ function identity(payload) {
     || canonical([...payload.newFilePaths].sort()) !== canonical(payload.newFilePaths)) {
     mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Mutation authority path set is invalid');
   }
-  exact(payload.receiver, ['taskId', 'ownerId', 'projectId', 'hostId', 'threadId', 'descriptionDigest', 'taskDigest']);
-  if (payload.receiver.taskId !== payload.taskId || payload.receiver.ownerId !== payload.ownerId
-    || payload.receiver.taskDigest !== payload.taskDigest || !SHA.test(payload.receiver.descriptionDigest)
-    || sha256(canonical(payload.receiver)) !== payload.receiverDigest
-    || ['projectId', 'hostId', 'threadId'].some(field => !ID.test(String(payload.receiver[field])))) {
-    mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Mutation authority lost its original cloud receiver');
-  }
+  originalReceiver(payload);
   if (delegated) preservedMutationDelegation(payload);
 }
 function authority(value, fields, schema, options) {
@@ -101,7 +110,16 @@ function authority(value, fields, schema, options) {
   identity(payload); mutationLifetime14(payload, options); return value;
 }
 export function mutationChallenge14(value, options) {
-  return authority(value, authorityFields(value, CHALLENGE_FIELDS), 'entrorove.mutation-snapshot-challenge/1.0', options);
+  const fields = authorityFields(value, CHALLENGE_FIELDS);
+  if (Object.hasOwn(value ?? {}, 'previousChallenge')) {
+    exact(value.previousChallenge, ['challengeId', 'challengeDigest']);
+    if (!ID.test(value.previousChallenge.challengeId) || !SHA.test(value.previousChallenge.challengeDigest)
+      || value.verificationMode !== 'member-local' || !value.writeDelegation) {
+      mutationFail14('ENTROROVE_MUTATION_AUTHORITY_INVALID', 'Expired challenge predecessor requires its exact member-local binding');
+    }
+    fields.push('previousChallenge');
+  }
+  return authority(value, fields, 'entrorove.mutation-snapshot-challenge/1.0', options);
 }
 function authorityFields(value, fields) {
   const original = Object.hasOwn(value ?? {}, 'writeDelegation') ? [...fields.filter(field =>
@@ -114,7 +132,8 @@ export function mutationPass14(value, 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; }))) {
+      return !write || write.kind !== (pass.writeDelegation.purpose !== 'preserved-existing-modify' ? 'create' : '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');

package/local-preserved-mutation-protection.mjs

@@ -25,7 +25,14 @@ export async function capturePreservedMutationProtection(input, root, authority,
   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 (delegation.purpose === 'planned-file-create') {
+      if (!file || file.exists !== false || file.sha256 !== expected.sha256 || file.mode !== null) {
+        preservedMutationFail('Planned creation requires an actual absent target in the original M snapshot');
+      }
+      continue;
+    }
     if (!file?.exists || file.sha256 !== expected.sha256) preservedMutationFail('Preserved mutation target must retain its exact existing gate baseline');
+    if (delegation.purpose === 'planned-file-modify') continue;
     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);
@@ -35,7 +42,7 @@ export async function capturePreservedMutationProtection(input, root, authority,
     }
   }
   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);
+  if (unknown && delegation.purpose === 'preserved-existing-modify') unknownTarget(unknown.path, unknown);
   const result = [];
   for (const expected of delegation.protectedFiles) result.push(await observe(input, root, expected));
   return result;

package/local-preserved-mutation-wire.mjs

@@ -37,14 +37,18 @@ export function preservedMutationDelegation(authority) {
     || !local && authority.runnerKeyId === authority.authorityReceipt?.keyId) {
     preservedMutationFail('Preserved mutation cannot promote scope, mutation or workflow signing keys to independent validation');
   }
-  if (value.schemaVersion !== 'entrorove.preserved-write-delegation/1.0' || value.purpose !== 'preserved-existing-modify'
+  const create = value.purpose === 'planned-file-create';
+  if (value.schemaVersion !== 'entrorove.preserved-write-delegation/1.0' || !['preserved-existing-modify', 'planned-file-create', 'planned-file-modify'].includes(value.purpose)
     || ['scopeKeyId', 'mutationKeyId', 'gateEvidenceDigest', 'importGraphDigest'].some(field => !/^[0-9a-f]{64}$/.test(value[field]))
     || publicKey.keyId !== value.mutationKeyId || new Set(roleKeys).size !== roleKeys.length
-    || authority.epoch !== 0 || authority.newFilePaths.length !== 0) preservedMutationFail('Preserved mutation role or original epoch is invalid');
+    || authority.epoch !== 0 || (create ? canonical(authority.newFilePaths) !== canonical(authority.paths)
+      || value.targetFiles.some(file => file.sha256 !== sha256('entrorove.missing-file/1.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)) {
+    || !Array.isArray(value.targetImports) || (value.purpose !== 'preserved-existing-modify' ? value.targetImports.length !== 0
+      : 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) {

package/local-scope-files.mjs

@@ -2,6 +2,8 @@ import { constants, promises as fs } from 'node:fs';
 import path from 'node:path';
 import { canonical, sha256 } from './local-integrity.mjs';
 import { readBudgetedProjectFile } from './local-budget-reads.mjs';
+import { verifiedSfnt } from './local-scope-font.mjs';
+import { verifiedZip } from './local-scope-zip.mjs';
 
 export function scopeFail(code, message) { throw Object.assign(new Error(message), { code }); }
 export function observedScopeRisk(files) {
@@ -135,7 +137,7 @@ export async function scopeFiles(root, requested, knownFiles = []) {
   return [...found].sort();
 }
 export function lineCount(content) {
-  if (!content.length) return 0;
+  if (!content.length || verifiedSfnt(content) || verifiedZip(content)) return 0;
   return content.toString('utf8').split(/\r\n|\n|\r/).length - (/[\r\n]$/.test(content.toString('utf8')) ? 1 : 0);
 }
 export async function packageBoundary(root, relative, input = { repositoryRoot: root }) {

package/local-scope-font.mjs

@@ -0,0 +1,45 @@
+function checksum(bytes, start, length, adjustment = -1) {
+  let sum = 0;
+  for (let offset = start; offset < start + length; offset += 4) {
+    let word = 0;
+    for (let i = 0; i < 4; i++) word = word * 256 + (offset + i < start + length ? bytes[offset + i] : 0);
+    if (offset !== adjustment) sum = (sum + word) >>> 0;
+  }
+  return sum;
+}
+// Recognize an sfnt container from its complete bytes, never its name. Unknown
+// or damaged data keeps the conservative text count; a magic prefix is no proof.
+export function verifiedSfnt(bytes) {
+  if (bytes.length < 28 || ![0x4f54544f, 0x00010000].includes(bytes.readUInt32BE(0))) return false;
+  const count = bytes.readUInt16BE(4), end = 12 + count * 16;
+  if (!count || count > 4096 || end > bytes.length) return false;
+  const selector = Math.floor(Math.log2(count)), search = 16 * 2 ** selector;
+  if (bytes.readUInt16BE(6) !== search || bytes.readUInt16BE(8) !== selector
+    || bytes.readUInt16BE(10) !== count * 16 - search) return false;
+  const tables = []; let previous = ''; let head;
+  for (let index = 12; index < end; index += 16) {
+    if (bytes.subarray(index, index + 4).some(byte => byte < 0x20 || byte > 0x7e)) return false;
+    const tag = bytes.toString('ascii', index, index + 4);
+    if (!/^[\x20-\x7e]{4}$/.test(tag) || tag <= previous) return false;
+    previous = tag;
+    const offset = bytes.readUInt32BE(index + 8), length = bytes.readUInt32BE(index + 12);
+    if (offset % 4 || offset < end || offset + length > bytes.length) return false;
+    const adjustment = tag === 'head' ? offset + 8 : -1;
+    if (tag === 'head') {
+      if (length !== 54 || bytes.readUInt32BE(offset) !== 0x00010000
+        || bytes.readUInt32BE(offset + 12) !== 0x5f0f3cf5) return false;
+      head = offset;
+    }
+    if (checksum(bytes, offset, length, adjustment) !== bytes.readUInt32BE(index + 4)) return false;
+    tables.push({ offset, length });
+  }
+  if (head === undefined || checksum(bytes, 0, bytes.length) !== 0xb1b0afba) return false;
+  let covered = end;
+  for (const table of tables.sort((a, b) => a.offset - b.offset)) {
+    if (table.offset < covered) return false;
+    for (; covered < table.offset; covered++) if (bytes[covered] !== 0) return false;
+    covered = table.offset + table.length;
+  }
+  for (; covered < bytes.length; covered++) if (bytes[covered] !== 0) return false;
+  return true;
+}

package/local-scope-repository.mjs

@@ -264,17 +264,20 @@ async function configMetadata(root, relative, input) {
 async function resolveLocalImport(root, relative, required = true) {
   if (relative.startsWith('../') || relative === '..') scopeFail('ENTROROVE_PATH_UNSAFE', 'local import escapes the repository');
   const replacements = /\.js$/.test(relative) ? [relative.replace(/\.js$/, '.ts'), relative.replace(/\.js$/, '.tsx')] : [];
-  for (const candidate of [relative, ...replacements, ...['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue', '.json', '.d.ts', '.d.mts', '.d.cts', '/index.js', '/index.ts', '/index.d.ts'].map(ext => relative + ext)]) {
+  const candidates = [relative, ...replacements, ...['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx', '.vue', '.json', '.d.ts', '.d.mts', '.d.cts', '/index.js', '/index.ts', '/index.d.ts'].map(ext => relative + ext)];
+  for (const candidate of candidates) {
     const item = await scopeProbeTarget(root, candidate, dependencyReference(candidate));
     if (item.exists && item.stat.isFile()) return candidate;
   }
-  if (required) scopeFail('ENTROROVE_IMPORT_UNRESOLVED', 'a local import has no resolvable source file');
+  if (required) throw Object.assign(new Error('a local import has no resolvable source file'),
+    { code: 'ENTROROVE_IMPORT_UNRESOLVED', missingCandidates: candidates });
   return null;
 }
 export async function importGraph(root, originals, input = { repositoryRoot: root }, limits = {}) {
   const pending = originals.filter(file => file.exists !== false).map(file => file.path); const visited = new Map(); const edges = []; let dynamic = false;
   let sourceBytes = 0;
   const dynamicSources = [], unresolvedImports = [];
+  const pendingCreates = new Set(originals.filter(file => file.exists === false && input.scopeCreatePaths?.includes(file.path)).map(file => file.path));
   const workspace = await workspaceIndex(root, input);
   const metadata = new Map(workspace.metadata.map(item => [item.path, item]));
   while (pending.length) {
@@ -300,7 +303,17 @@ export async function importGraph(root, originals, input = { repositoryRoot: roo
     unresolvedImports.push(...imports.unresolvedImports.map(site => ({ path: relative, ...site })));
     if (imports.dynamic) dynamicSources.push({ path: relative, sha256: read.sha256 });
     for (const specifier of imports.specifiers.sort()) {
-      const target = await resolveImport(root, relative, specifier, workspace, input, aliases, configPath, declarations);
+      let target;
+      try { target = await resolveImport(root, relative, specifier, workspace, input, aliases, configPath, declarations); }
+      catch (error) {
+        const missing = error.code === 'ENTROROVE_IMPORT_UNRESOLVED' && specifier.startsWith('.')
+          ? error.missingCandidates?.filter(candidate => pendingCreates.has(candidate)) : null;
+        if (!missing?.length) throw error;
+        unresolvedImports.push({ path: relative, specifier, reason: 'approved-create-not-present', candidatePaths: missing });
+        dynamic = true;
+        if (!dynamicSources.some(source => source.path === relative)) dynamicSources.push({ path: relative, sha256: read.sha256 });
+        continue;
+      }
       edges.push({ from: relative, to: target, external: target === null, specifier,
         ...(declarations.has(specifier) ? { declarationOnly: true, declarationPath: relative } : {}) });
       if (target !== null && !visited.has(target)) pending.push(target);

package/local-scope-zip.mjs

@@ -0,0 +1,93 @@
+import { inflateRawSync } from 'node:zlib';
+
+const MAX_ENTRY_BYTES = 16 * 1024 * 1024, MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const crcTable = Uint32Array.from({ length: 256 }, (_, value) => {
+  for (let bit = 0; bit < 8; bit++) value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+  return value >>> 0;
+});
+function crc32(bytes) {
+  let value = 0xffffffff;
+  for (const byte of bytes) value = crcTable[(value ^ byte) & 255] ^ (value >>> 8);
+  return (value ^ 0xffffffff) >>> 0;
+}
+function plainExtra(bytes) {
+  let offset = 0;
+  while (offset + 4 <= bytes.length) {
+    const kind = bytes.readUInt16LE(offset), size = bytes.readUInt16LE(offset + 2);
+    if ([1, 0x9901].includes(kind) || offset + 4 + size > bytes.length) return false;
+    offset += 4 + size;
+  }
+  return offset === bytes.length;
+}
+function directory(bytes) {
+  const floor = Math.max(0, bytes.length - 65557); let end = bytes.length - 22;
+  for (; end >= floor; end--) {
+    if (bytes.readUInt32LE(end) === 0x06054b50 && end + 22 + bytes.readUInt16LE(end + 20) === bytes.length) break;
+  }
+  if (end < floor || bytes.readUInt16LE(end + 4) || bytes.readUInt16LE(end + 6)) return null;
+  const count = bytes.readUInt16LE(end + 10), offset = bytes.readUInt32LE(end + 16), size = bytes.readUInt32LE(end + 12);
+  if (count > 10_000 || count !== bytes.readUInt16LE(end + 8) || offset + size !== end) return null;
+  const entries = []; let cursor = offset, total = 0;
+  for (let index = 0; index < count; index++) {
+    if (cursor + 46 > end || bytes.readUInt32LE(cursor) !== 0x02014b50) return null;
+    const nameLength = bytes.readUInt16LE(cursor + 28), extraLength = bytes.readUInt16LE(cursor + 30);
+    const next = cursor + 46 + nameLength + extraLength + bytes.readUInt16LE(cursor + 32);
+    const flags = bytes.readUInt16LE(cursor + 8), method = bytes.readUInt16LE(cursor + 10);
+    const compressed = bytes.readUInt32LE(cursor + 20), expanded = bytes.readUInt32LE(cursor + 24);
+    if (!nameLength || next > end || flags & ~0x080e || ![0, 8].includes(method) || bytes.readUInt16LE(cursor + 34)
+      || compressed === 0xffffffff || expanded > MAX_ENTRY_BYTES || (total += expanded) > MAX_TOTAL_BYTES
+      || !plainExtra(bytes.subarray(cursor + 46 + nameLength, cursor + 46 + nameLength + extraLength))) return null;
+    entries.push({ central: cursor, local: bytes.readUInt32LE(cursor + 42), flags, method, compressed, expanded,
+      crc: bytes.readUInt32LE(cursor + 16), name: bytes.subarray(cursor + 46, cursor + 46 + nameLength) });
+    cursor = next;
+  }
+  return cursor === end ? { entries, offset } : null;
+}
+function descriptorEnd(bytes, offset, entry, limit) {
+  for (const length of [16, 12]) {
+    const start = offset + length - 12;
+    if (offset + length > limit || length === 16 && bytes.readUInt32LE(offset) !== 0x08074b50) continue;
+    if (bytes.readUInt32LE(start) === entry.crc && bytes.readUInt32LE(start + 4) === entry.compressed
+      && bytes.readUInt32LE(start + 8) === entry.expanded) return offset + length;
+  }
+  return -1;
+}
+function entryEnd(bytes, entry, limit) {
+  const start = entry.local;
+  if (start + 30 > limit || bytes.readUInt32LE(start) !== 0x04034b50) return -1;
+  const nameLength = bytes.readUInt16LE(start + 26), extraLength = bytes.readUInt16LE(start + 28);
+  const data = start + 30 + nameLength + extraLength, end = data + entry.compressed;
+  if (end > limit || !bytes.subarray(start + 30, start + 30 + nameLength).equals(entry.name)
+    || !plainExtra(bytes.subarray(start + 30 + nameLength, data))) return -1;
+  for (const [local, central] of [[4, 6], [6, 8], [8, 10], [10, 12], [12, 14]]) {
+    if (bytes.readUInt16LE(start + local) !== bytes.readUInt16LE(entry.central + central)) return -1;
+  }
+  for (const [field, expected] of [[14, entry.crc], [18, entry.compressed], [22, entry.expanded]]) {
+    const actual = bytes.readUInt32LE(start + field);
+    if (actual !== expected && (!(entry.flags & 8) || actual !== 0)) return -1;
+  }
+  const compressed = bytes.subarray(data, end); let expanded;
+  if (entry.method === 0) expanded = compressed;
+  else {
+    try {
+      const result = inflateRawSync(compressed, { maxOutputLength: Math.max(1, entry.expanded), info: true });
+      if (result.engine.bytesWritten !== compressed.length) return -1;
+      expanded = result.buffer;
+    } catch { return -1; }
+  }
+  if (expanded.length !== entry.expanded || crc32(expanded) !== entry.crc) return -1;
+  return entry.flags & 8 ? descriptorEnd(bytes, end, entry, limit) : end;
+}
+// PKWARE APPNOTE 6.3.10, 4.3: verify complete ordinary ZIP records and CRCs
+// in bounded memory. Never extract, execute entries or grant their paths access.
+export function verifiedZip(bytes) {
+  if (bytes.length < 22 || ![0x04034b50, 0x06054b50].includes(bytes.readUInt32LE(0))) return false;
+  const found = directory(bytes); if (!found) return false;
+  let covered = 0;
+  for (const entry of found.entries.sort((a, b) => a.local - b.local)) {
+    if (entry.local !== covered) return false;
+    covered = entryEnd(bytes, entry, found.offset);
+    if (covered < 0) return false;
+  }
+  return covered === found.offset;
+}

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "entrorove.skill-manifest/1.0",
   "name": "entrorove",
-  "version": "0.1.61",
+  "version": "0.1.64",
   "endpoint": "https://entrorove.com",
   "requestSchemaVersion": "entrorove.skill.request/2.0",
   "supportedRequestSchemaVersions": [

package/member-producer-repair-authority.mjs

@@ -0,0 +1,48 @@
+import { canonical } from './local-integrity.mjs';
+import { observationAuthoritySignature } from './workflow-observation-wire.mjs';
+
+const keys = ['schemaVersion', 'repairId', 'flowId', 'ownerId', 'taskId', 'stepId', 'leaseId', 'generation', 'leaseDigest',
+  'planId', 'planDigest', 'executionPlanSha256', 'failedObservationId', 'failureResultDigest', 'previousAcceptanceDigest',
+  'kind', 'paths', 'dependencyRepairDigest', 'failureStepId', 'baselineSettlementId', 'baselineSettlementDigest',
+  'grantId', 'sequence', 'previousGrantDigest', 'scopeDigest', 'requestId', 'issuedAt', 'expiresAt', 'authorityReceipt'];
+const identity = ['flowId', 'ownerId', 'taskId', 'stepId', 'leaseId', 'generation', 'planId', 'planDigest', 'executionPlanSha256'];
+const shas = ['leaseDigest', 'planDigest', 'executionPlanSha256', 'failureResultDigest', 'previousAcceptanceDigest', 'scopeDigest', 'requestId'];
+export function memberProducerRepairStepMatches(status, authority, { settledPass = false } = {}) {
+  try {
+    const values = status?.producerRepairAuthorities;
+    if (!Array.isArray(values) || values.length > 128) return false;
+    const matching = values.filter(p => p.stepId === authority.stepId);
+    if (matching.length !== 1) return false;
+    const p = matching[0], expected = [...keys, ...(Object.hasOwn(p, 'scopeRevisionDigest') ? ['scopeRevisionDigest'] : [])];
+    if (canonical(Object.keys(p).sort()) !== canonical(expected.sort())) return false;
+    observationAuthoritySignature(p);
+    const start = Date.parse(p.issuedAt), end = Date.parse(p.expiresAt), at = Date.parse(authority.issuedAt);
+    if (p.schemaVersion !== 'entrorove.member-producer-repair/1.0' || identity.some(k => p[k] !== authority[k])
+      || status.flow?.stepId !== p.failureStepId || status.flow.ownerId !== p.ownerId
+      || status.flow.flowId !== p.flowId || status.flow.status !== 'running' || status.workflow?.phase !== 'execute'
+      || status.workflow.terminalAt || ['pending', 'declined'].includes(status.workflow.authorization)
+      || !['producer-correction', 'dependency-revalidation'].includes(p.kind)
+      || shas.some(k => !/^[a-f0-9]{64}$/.test(p[k])) || authority.leaseDigest && authority.leaseDigest !== p.leaseDigest
+      || !Array.isArray(p.paths) || p.paths.length > 512 || new Set(p.paths).size !== p.paths.length
+      || canonical(p.paths) !== canonical([...p.paths].sort()) || (p.kind === 'producer-correction') !== (p.paths.length > 0)
+      || p.paths.some(path => typeof path !== 'string' || !path || path.startsWith('/') || /[\\:\u0000-\u001f\u007f]/.test(path)
+        || path.split('/').some(part => !part || part === '.' || part === '..'))
+      || !Number.isSafeInteger(p.sequence) || p.sequence < 1 || !Number.isSafeInteger(p.generation) || p.generation < 1
+      || ['grantId', 'repairId', 'failedObservationId', 'failureStepId'].some(k => typeof p[k] !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(p[k]))
+      || (p.sequence === 1 ? p.previousGrantDigest !== null : !/^[a-f0-9]{64}$/.test(p.previousGrantDigest))
+      || !Number.isFinite(start) || !Number.isFinite(end) || start > Date.now() || end <= start || end - start > 600000
+      || !Number.isFinite(at) || at < start || at >= end || Date.parse(authority.expiresAt) > end
+      || !settledPass && end <= Date.now()
+      || (p.dependencyRepairDigest !== null && !/^[a-f0-9]{64}$/.test(p.dependencyRepairDigest))
+      || (Object.hasOwn(p, 'scopeRevisionDigest') && p.scopeRevisionDigest !== authority.scopeRevisionDigest
+        && Object.hasOwn(authority, 'scopeRevisionDigest'))) return false;
+    if (settledPass && (authority.verificationMode !== 'member-local' || authority.runnerKeyId !== null
+      || !authority.writeDelegation || p.kind !== 'producer-correction' || !Array.isArray(authority.paths)
+      || !authority.paths.length || authority.paths.some(path => !p.paths.includes(path)))) return false;
+    return true;
+  } catch { return false; }
+}
+export function memberProducerRepairDependency(status, pass) {
+  if (!memberProducerRepairStepMatches(status, pass, { settledPass: true })) return null;
+  return status.producerRepairAuthorities.find(p => p.stepId === pass.stepId).dependencyRepairDigest;
+}

package/model-images.d.mts

@@ -0,0 +1,9 @@
+export type ModelImageInput = { url: string; detail?: 'auto'|'low'|'high'|'original' };
+export type ModelImageMetadata = { sha256: string; mimeType: string; bytes: number; detail: 'auto'|'low'|'high'|'original' };
+export type ModelImage = ModelImageInput & ModelImageMetadata;
+export const MODEL_IMAGE_LIMITS: Readonly<{count: number; perImageBytes: number; totalBytes: number; requestBytes: number; maxSide: number}>;
+export function inspectModelImage(bytes: Buffer): Omit<ModelImageMetadata,'detail'>;
+export function normalizeModelImages(value?: unknown): ModelImage[];
+export function modelImageManifest(images: readonly ModelImage[]): ModelImageMetadata[];
+export function modelUserContent(goal: string, images: readonly ModelImage[]): string | Array<
+  { type: 'text'; text: string } | { type: 'image_url'; image_url: { url: string; detail: ModelImageMetadata['detail'] } }>;

package/model-images.mjs

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+
+export const MODEL_IMAGE_LIMITS = Object.freeze({ count: 4, perImageBytes: 2 * 1024 * 1024,
+  totalBytes: 8 * 1024 * 1024, requestBytes: 12 * 1024 * 1024, maxSide: 8192 });
+const DETAILS = new Set(['auto', 'low', 'high', 'original']);
+const invalid = () => new Error('Images require bounded JPEG, PNG, GIF or WebP content with valid dimensions');
+
+function jpegSize(bytes) {
+  let offset = 2;
+  while (offset + 4 <= bytes.length) {
+    if (bytes[offset++] !== 255) throw invalid();
+    while (bytes[offset] === 255) offset++;
+    if (offset + 3 > bytes.length) throw invalid();
+    const marker = bytes[offset++];
+    if (marker === 0xda || marker === 0xd9) break;
+    const length = bytes.readUInt16BE(offset);
+    if (length < 2 || offset + length > bytes.length) throw invalid();
+    if ([0xc0,0xc1,0xc2,0xc3,0xc5,0xc6,0xc7,0xc9,0xca,0xcb,0xcd,0xce,0xcf].includes(marker)) {
+      if (length < 8) throw invalid();
+      return [bytes.readUInt16BE(offset + 5), bytes.readUInt16BE(offset + 3)];
+    }
+    offset += length;
+  }
+  throw invalid();
+}
+
+function webpSize(bytes) {
+  if (bytes.length < 30 || bytes.readUInt32LE(4) + 8 !== bytes.length) throw invalid();
+  const chunk = bytes.toString('ascii', 12, 16), length = bytes.readUInt32LE(16);
+  if (20 + length + (length % 2) > bytes.length) throw invalid();
+  if (chunk === 'VP8X' && length === 10) return [bytes.readUIntLE(24, 3) + 1, bytes.readUIntLE(27, 3) + 1];
+  if (chunk === 'VP8 ' && length >= 10 && bytes.subarray(23,26).equals(Buffer.from([0x9d,1,0x2a]))) {
+    return [bytes.readUInt16LE(26) & 0x3fff, bytes.readUInt16LE(28) & 0x3fff];
+  }
+  if (chunk === 'VP8L' && length >= 5 && bytes[20] === 0x2f) {
+    const packed = bytes.readUInt32LE(21);
+    return [(packed & 0x3fff) + 1, ((packed >>> 14) & 0x3fff) + 1];
+  }
+  throw invalid();
+}
+
+/** Inspect content headers and dimensions; the provider still decodes the actual image. */
+export function inspectModelImage(bytes) {
+  if (!Buffer.isBuffer(bytes) || bytes.length < 26 || bytes.length > MODEL_IMAGE_LIMITS.perImageBytes) throw invalid();
+  let mimeType, size;
+  if (bytes.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10]))
+    && bytes.readUInt32BE(8) === 13 && bytes.toString('ascii',12,16) === 'IHDR') {
+    mimeType = 'image/png'; size = [bytes.readUInt32BE(16), bytes.readUInt32BE(20)];
+  } else if (bytes[0] === 255 && bytes[1] === 216) {
+    mimeType = 'image/jpeg'; size = jpegSize(bytes);
+  } else if (['GIF87a','GIF89a'].includes(bytes.toString('ascii',0,6))) {
+    mimeType = 'image/gif'; size = [bytes.readUInt16LE(6), bytes.readUInt16LE(8)];
+  } else if (bytes.toString('ascii',0,4) === 'RIFF' && bytes.toString('ascii',8,12) === 'WEBP') {
+    mimeType = 'image/webp'; size = webpSize(bytes);
+  } else throw invalid();
+  if (size.some(value => !Number.isInteger(value) || value < 1 || value > MODEL_IMAGE_LIMITS.maxSide)) throw invalid();
+  return { mimeType, bytes: bytes.length, sha256: createHash('sha256').update(bytes).digest('hex') };
+}
+
+export function normalizeModelImages(value = []) {
+  if (!Array.isArray(value) || value.length > MODEL_IMAGE_LIMITS.count) throw new Error('At most four input images are supported');
+  let total = 0;
+  return value.map(image => {
+    if (!image || typeof image !== 'object' || Array.isArray(image)
+      || Object.keys(image).some(key => !['url','detail'].includes(key))
+      || typeof image.url !== 'string' || !DETAILS.has(image.detail ?? 'auto')) throw invalid();
+    if (image.url.length > Math.ceil(MODEL_IMAGE_LIMITS.perImageBytes / 3) * 4 + 64) throw invalid();
+    const match = /^data:(image\/(?:jpeg|png|gif|webp));base64,([A-Za-z0-9+/]+={0,2})$/.exec(image.url);
+    if (!match) throw new Error('Input images must use inline base64 data URLs; remote URLs are not fetched');
+    const bytes = Buffer.from(match[2], 'base64');
+    if (bytes.toString('base64') !== match[2]) throw invalid();
+    const metadata = inspectModelImage(bytes);
+    if (metadata.mimeType !== match[1]) throw new Error('Image media type differs from its actual content');
+    total += bytes.length;
+    if (total > MODEL_IMAGE_LIMITS.totalBytes) throw new Error('Input images exceed the total byte limit');
+    return Object.freeze({ url: image.url, detail: image.detail ?? 'auto', ...metadata });
+  });
+}
+
+export function modelImageManifest(images) {
+  return images.map(({ sha256, mimeType, bytes, detail }) => ({ sha256, mimeType, bytes, detail }));
+}
+
+export function modelUserContent(goal, images) {
+  return images.length ? [{ type: 'text', text: goal }, ...images.map(image => ({ type: 'image_url',
+    image_url: { url: image.url, detail: image.detail } }))] : goal;
+}

package/mutation-challenge-refresh.mjs

@@ -0,0 +1,51 @@
+import { canonical, sha256 } from './local-integrity.mjs';
+import { buildInvocation } from './remote-client.mjs';
+import { mutationFail14 } from './local-mutation-files.mjs';
+
+const fail = message => mutationFail14('ENTROROVE_MUTATION_CHALLENGE_REFRESH', message);
+export async function refreshExpiredMutationChallenge(context, callbacks) {
+  const { state, identity, mutator, location, dependencies, fields } = context;
+  const { remote, save, challengeBinding } = callbacks, old = state.challenged.challenge;
+  if (state.issued || state.gatePassPath || Date.parse(old.expiresAt) > Date.now()) return state.challenged;
+  challengeBinding(old, identity, mutator, { live: false });
+  if (old.verificationMode !== 'member-local' || !old.writeDelegation || old.runnerKeyId !== null) {
+    fail('Expired challenge recovery requires the original member-local editing authority');
+  }
+  if (!state.refreshOriginal && state.attestation) {
+    const input = { challengeId: old.challengeId, attestation: state.attestation };
+    if (!state.pending) {
+      state.pending = { stage: 'issued', operation: 'mutation-pass-issue', input,
+        requestId: buildInvocation('mutation-pass-issue', input).requestId };
+      await save(location, state);
+    }
+    if (state.pending.stage === 'issued') {
+      try { await remote('issued', 'mutation-pass-issue', input, state, location, dependencies); }
+      catch (error) {
+        if (state.pending || error.output?.status !== 'blocked'
+          || !['ENTROROVE_MUTATION_LEASE', 'ENTROROVE_MUTATION_EXPIRED'].includes(error.output.code)
+          || state.feedback?.acknowledgement?.stored !== true) throw error;
+      }
+      if (state.issued) return state.challenged;
+    }
+  }
+  if (state.pending && state.pending.stage !== 'refreshed') fail('Recover only the original pending mutation request before challenge refresh');
+  if (!Array.isArray(state.attempts ?? []) || (state.attempts?.length ?? 0) >= 512) fail('Original mutation challenge history reached its bound');
+  if (!state.refreshOriginal) {
+    state.refreshOriginal = Object.fromEntries(['challenged', 'planned', 'planStarted', 'attestation', 'feedback', 'failures']
+      .filter(key => Object.hasOwn(state, key)).map(key => [key, structuredClone(state[key])]));
+    await save(location, state);
+  }
+  if (canonical(state.refreshOriginal.challenged.challenge) !== canonical(old)) fail('Original archived challenge binding changed');
+  const ref = { challengeId: old.challengeId, challengeDigest: sha256(canonical(old)) };
+  const input = { ...Object.fromEntries(fields.map(field => [field, identity[field]])),
+    ...(identity.previousPassId ? { previousPassId: identity.previousPassId } : {}),
+    mutationPublicKey: mutator.mutationPublicKey, refreshExpiredChallenge: ref };
+  const refreshed = state.refreshed ?? await remote('refreshed', 'mutation-snapshot-challenge', input, state, location, dependencies);
+  challengeBinding(refreshed.challenge, identity, mutator, { live: false });
+  if (canonical(refreshed.challenge.previousChallenge) !== canonical(ref)) fail('Fresh challenge lost its exact expired predecessor');
+  state.attempts = [...(state.attempts ?? []), { ...state.refreshOriginal, archivedAt: new Date().toISOString() }];
+  for (const key of ['challenged', 'planned', 'planStarted', 'attestation', 'failures', 'refreshOriginal', 'refreshed']) delete state[key];
+  state.challenged = refreshed;
+  await save(location, state);
+  return refreshed;
+}