@entrorove/skill 0.1.62 → 0.1.67

package/local-runner-discipline.mjs

@@ -2,11 +2,14 @@ import { canonical, sha256 } from './local-integrity.mjs';
 import { disciplineRepositoryObservation, disciplineRepositoryDifferences } from './local-discipline-repository.mjs';
 import { atomicMutationJson14, privateMutationDirectory14, mutationStateRoot14, readMutationJson14 } from './local-mutation-files.mjs';
 import path from 'node:path';
+import { designRunnerBefore, designRunnerAfter } from './design-runner.mjs';
+import { replacementRunnerBefore, replacementRunnerAfter } from './rollback-runner.mjs';
 
 export async function runnerDisciplineBefore(input, authority) {
-  if (!authority.plan.policy.discipline) return null;
+  const packageOriginals = await replacementRunnerBefore(input, authority);
+  const designOriginals = await designRunnerBefore(input, authority);
   const original = await disciplineRepositoryObservation(input, authority.root);
-  return { input, original: original.comparison, readOnly: authority.plan.policy.discipline.access === 'read-only' };
+  return { input, designOriginals, packageOriginals, original: original.comparison, readOnly: authority.plan.policy.discipline?.access === 'read-only' };
 }
 export async function runnerDisciplineAfter(before, authority, processResult) {
   if (!before) return null;
@@ -28,5 +31,16 @@ export async function runnerDisciplineAfter(before, authority, processResult) {
       { code: 'ENTROROVE_READ_ONLY_EXECUTION_DRIFT', execution: { schemaVersion: 'entrorove.validator-local-runner/1.0',
         status: 'failed', process: processResult, evidence: [], effects: 'unknown', comparison: report } });
   }
-  return { ...report, reportDigest };
+  try {
+    await replacementRunnerAfter(before.input, authority, before.original, after, changed, before.packageOriginals);
+    await designRunnerAfter(before.input, authority, changed, before.designOriginals);
+  }
+  catch (error) {
+    error.execution = { schemaVersion: 'entrorove.validator-local-runner/1.0', status: 'failed', process: processResult,
+      evidence: [], effects: 'unknown', comparison: report };
+    throw error;
+  }
+  // Keep legacy non-discipline subjects compatible with their frozen Validator
+  // schema; the actual comparison and UI refusal above still ran and persisted.
+  return authority.plan.policy.discipline ? { ...report, reportDigest } : null;
 }

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,114 @@
+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;
+}
+// Metadata inspection reuses the complete CRC/length validation above; no entry
+// is written or executed. Invalid names, duplicates and links remain unknown.
+export function zipMetadataEntries(bytes) {
+  if (!verifiedZip(bytes)) return null;
+  const found = directory(bytes), result = new Map();
+  for (const entry of found.entries) {
+    let name;
+    try { name = new TextDecoder('utf-8', { fatal: true }).decode(entry.name); } catch { return null; }
+    const mode = bytes.readUInt32LE(entry.central + 38) >>> 16, type = mode & 0o170000;
+    if (!name || name.startsWith('/') || /[\\\u0000-\u001f\u007f]/.test(name) || /^[A-Za-z]:/.test(name)
+      || name.split('/').some(part => part === '..' || part === '.') || result.has(name)
+      || type && ![0o100000, 0o040000].includes(type)) return null;
+    const start = entry.local + 30 + bytes.readUInt16LE(entry.local + 26) + bytes.readUInt16LE(entry.local + 28);
+    const compressed = bytes.subarray(start, start + entry.compressed);
+    const metadata = /(?:^|\/)(?:package|manifest)\.json$/.test(name);
+    if (metadata && entry.expanded > 262_144) return null;
+    result.set(name, metadata ? entry.method === 0 ? compressed
+      : inflateRawSync(compressed, { maxOutputLength: Math.max(1, entry.expanded) }) : null);
+  }
+  return result;
+}

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "entrorove.skill-manifest/1.0",
   "name": "entrorove",
-  "version": "0.1.62",
+  "version": "0.1.67",
   "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;
+}

package/mutation-client.mjs

@@ -2,7 +2,7 @@ import path from 'node:path';
 import { canonical, sha256 } from './local-integrity.mjs';
 import { withStateLock } from './local-state-lock.mjs';
 import { mutationId14, mutationPaths14, mutationTarget14, mutationFail14, privateMutationDirectory14,
-  readMutationJson14, atomicMutationJson14 } from './local-mutation-files.mjs';
+  atomicMutationJson14 } from './local-mutation-files.mjs';
 import { preparePreservedMutationSigner, preservedMutationLocation } from './local-preserved-mutation-signer.mjs';
 import { snapshotPlan14, snapshotVerify14 } from './local-mutation-snapshot.mjs';
 import { attestMutationSnapshot14 } from './local-mutation-binding.mjs';
@@ -17,8 +17,10 @@ import { appendInvocation, readInvocations } from './local-invocations.mjs';
 import { bootstrapCloudMutationAuthority } from './cloud-mutation-authority.mjs';
 import { attestMutationConsumption14, preservedMutationConsumptionState } from './local-mutation-consumption.mjs';
 import { scopeAmendmentRefreshAction } from './scope-amendment-reference.mjs';
+import { readMutationConnection as readConnection } from './mutation-connection-state.mjs';
+import { readMutationEnvironmentObservation } from './local-mutation-environment-observation.mjs';
+import { refreshExpiredMutationChallenge } from './mutation-challenge-refresh.mjs';
 
-const schema = 'entrorove.mutation-connection-state/1.0';
 const fields = ['taskId', 'flowId', 'stepId', 'leaseId', 'generation', 'runnerId', 'paths'];
 const fail = message => mutationFail14('ENTROROVE_MUTATION_CONNECTION_BINDING', message);
 const unknown = requestId => Object.assign(new Error(`Mutation connection outcome is unknown; recover original requestId=${requestId} without repeating its POST`),
@@ -36,18 +38,6 @@ function inputIdentity(input) {
   if (Object.hasOwn(input, 'previousPassId')) mutationId14(input.previousPassId, 'previousPassId');
   return { ...input, paths: mutationPaths14(input.paths) };
 }
-async function readConnection(location, identity) {
-  let value;
-  try { value = await readMutationJson14(location.file); }
-  catch (error) { if (error.code !== 'ENOENT') throw error; }
-  if (!value) return { schemaVersion: schema, identity };
-  if (value.schemaVersion !== schema || canonical(value.identity) !== canonical(identity)
-    || value.pending && (value.pending.requestId !== buildInvocation(value.pending.operation, value.pending.input).requestId
-      || !['mutation-snapshot-challenge', 'mutation-pass-issue', 'mutation-pass-settle'].includes(value.pending.operation))) {
-    fail('Mutation connection journal differs from the original repository, request or physical key');
-  }
-  return value;
-}
 async function recoverRemote(pending, dependencies) {
   try {
     const token = await dependencies.readCredential(dependencies.home), origin = trustedOrigin(dependencies.apiOrigin());
@@ -90,7 +80,11 @@ async function remote(stage, operation, input, state, location, dependencies) {
     }
   }
   delete state.pending;
+  if (result.feedback) state.feedback = result.feedback;
   if (!response.ok || !['succeeded', 'reported'].includes(result?.output?.status)) {
+    const failure = { operation, requestId, code: result?.output?.code ?? null, ...(result?.output ? { output: result.output } : {}),
+      ...(result.feedback ? { feedback: result.feedback } : {}) };
+    if (canonical(state.failures?.at(-1) ?? null) !== canonical(failure)) state.failures = [...(state.failures ?? []), failure];
     try { await save(location, state); } catch { throw unknown(requestId); }
     throw Object.assign(new Error(result?.output?.message ?? `Mutation connection blocked at ${operation}`),
       { code: result?.output?.code ?? 'ENTROROVE_MUTATION_CONNECTION_BLOCKED', output: result?.output, requestId });
@@ -147,17 +141,21 @@ async function authorizeCachedConnection(identity, pass, dependencies) {
     mutationFail14('ENTROROVE_MUTATION_CONNECTION_AUTHORIZATION', 'Current account could not confirm the original active mutation flow');
   }
   if (!response.ok || status?.schemaVersion !== 'entrorove.flow-status/1.0' || status.flow?.flowId !== identity.flowId
-    || status.flow.ownerId !== pass.ownerId || status.flow.stepId !== identity.stepId || status.flow.status !== 'running'
+    || status.flow.ownerId !== pass.ownerId || status.flow.stepId !== identity.stepId
+      && !memberProducerRepairStepMatches(status, pass, { settledPass: true }) || status.flow.status !== 'running'
     || !['execute', 'merge', 'deliver'].includes(status.workflow?.phase) || status.workflow.terminalAt
     || ['pending', 'declined'].includes(status.workflow.authorization)) {
     mutationFail14('ENTROROVE_MUTATION_CONNECTION_AUTHORIZATION', 'Current account must retain the original owned active flow and business step');
   }
+  return status;
 }
 async function connect(identity, local, mutator, location, dependencies) {
   const state = await readConnection(location, identity);
-  const challenged = state.challenged ?? await remote('challenged', 'mutation-snapshot-challenge',
+  let challenged = state.challenged ?? await remote('challenged', 'mutation-snapshot-challenge',
     { ...Object.fromEntries(fields.map(field => [field, identity[field]])),
       ...(identity.previousPassId ? { previousPassId: identity.previousPassId } : {}), mutationPublicKey: mutator.mutationPublicKey }, state, location, dependencies);
+  challenged = await refreshExpiredMutationChallenge({ state, identity, mutator, location, dependencies, fields },
+    { remote, save, challengeBinding });
   const challenge = challenged.challenge;
   challengeBinding(challenge, identity, mutator, { live: !state.gatePassPath });
   const input = { ...local, snapshotId: challenge.snapshotId };
@@ -167,9 +165,14 @@ async function connect(identity, local, mutator, location, dependencies) {
     if (canonical(stored) !== canonical(state.issued.pass)) fail('Installed mutation pass differs from its original connection');
     await authorizeCachedConnection(identity, stored, dependencies);
     const consumption = await preservedMutationConsumptionState({ ...input, gatePassPath: state.gatePassPath });
-    if (consumption.complete) return { schemaVersion: 'entrorove.mutation-connection/1.0', status: 'blocked', flowId: identity.flowId,
-      code: 'ENTROROVE_MUTATION_SETTLEMENT_REQUIRED', gatePassPath: state.gatePassPath,
-      message: 'Original physical writes are consumed; settle their actual M receipt with fresh S evidence before requesting the next restricted pass',
+    const expiredIncomplete = !consumption.complete && Date.parse(stored.expiresAt) <= Date.now();
+    const hasWrites = Object.values(consumption.ledger.writes).some(value => value.status === 'written');
+    if (consumption.complete || expiredIncomplete) return { schemaVersion: 'entrorove.mutation-connection/1.0', status: 'blocked', flowId: identity.flowId,
+      code: expiredIncomplete ? hasWrites ? 'ENTROROVE_MUTATION_PARTIAL_SETTLEMENT_REQUIRED' : 'ENTROROVE_MUTATION_UNUSED_SETTLEMENT_REQUIRED'
+        : 'ENTROROVE_MUTATION_SETTLEMENT_REQUIRED', gatePassPath: state.gatePassPath,
+      message: expiredIncomplete && !hasWrites
+        ? 'Close only the original expired unused pass with fresh S and exact unchanged unwritten targets. Zero writes do not complete work or authorize tests; unknown pending effects remain refused'
+        : 'Settle only the actual original completed writes with fresh S. Preserve original protection, failed records and any exact unchanged unwritten targets; unknown pending effects remain refused',
       localAction: await scopeAmendmentRefreshAction({ ...input, gatePassPath: state.gatePassPath }, stored) ?? { command: 'npx @entrorove/skill mutation-settle <absolute repositoryRoot>',
         input: { taskId: stored.taskId, flowId: stored.flowId, stepId: stored.stepId, gatePassPath: state.gatePassPath } } };
     passBinding(state.issued.pass, challenge, state.attestation);
@@ -226,7 +229,7 @@ async function settleMutation(repositoryRoot, input, dependencies) {
   await bootstrapCloudMutationAuthority(dependencies);
   const local = { ...input, repositoryRoot, home: dependencies.home }, original = await preservedMutationConsumptionState(local);
   const { pass, binding } = original;
-  await authorizeCachedConnection({ flowId: pass.flowId, stepId: pass.stepId }, pass, dependencies);
+  const flowStatus = await authorizeCachedConnection({ flowId: pass.flowId, stepId: pass.stepId }, pass, dependencies);
   const directory = path.join(binding.directory, 'settlements'); await privateMutationDirectory14(directory, { privateFrom: binding.stateRoot });
   const location = { ...binding, file: path.join(directory, `${pass.passId}.json`) };
   const identity = { flowId: pass.flowId, stepId: pass.stepId, passDigest: sha256(canonical(pass)),
@@ -250,17 +253,31 @@ async function settleMutation(repositoryRoot, input, dependencies) {
     }
     settlementBinding(output, pass, state.consumptionReceipt, state.settlementId);
     if (state.settlementId === undefined) { state.settlementId = output.settlementId; await save(location, state); }
+    const remaining = state.consumptionReceipt.unwritten?.map(file => file.path);
+    const environmentObservation = await readMutationEnvironmentObservation(local, pass);
     return { schemaVersion: 'entrorove.mutation-settlement/1.0', status: 'reported', settled: true,
       flowId: pass.flowId, taskId: pass.taskId, passId: pass.passId, settlementId: output.settlementId,
       consumptionReceiptDigest: output.consumptionReceiptDigest,
+      ...(environmentObservation ? { environmentObservation, environmentObservationAcknowledgedByServer: false } : {}),
       claimsVerifiedExecution: false, claimsCompletion: false, ...(state.feedback ? { feedback: state.feedback } : {}),
-      observationAction: { command: 'npx @entrorove/skill workflow-observe-step <absolute repositoryRoot>', independentValidation: 'pending',
-        input: { taskId: pass.taskId, flowId: pass.flowId, stepId: pass.stepId, leaseId: pass.leaseId,
-          generation: pass.generation, settlementId: output.settlementId } },
+      ...(remaining ? { partial: true, unused: state.consumptionReceipt.writes.length === 0,
+        writtenPaths: state.consumptionReceipt.writes.map(file => file.path), unwrittenPaths: remaining } : {}),
+      ...(!remaining ? { observationAction: { command: 'npx @entrorove/skill workflow-observe-step <absolute repositoryRoot>', independentValidation: 'pending',
+        input: settlementObservationInput(output, pass, flowStatus) } } : {}),
       localAction: { command: 'npx @entrorove/skill mutation-connect <absolute repositoryRoot>',
-        input: { ...Object.fromEntries(fields.map(field => [field, pass[field]])), previousPassId: pass.passId } } };
+        input: { ...Object.fromEntries(fields.map(field => [field, pass[field]])), ...(remaining ? { paths: remaining } : {}), previousPassId: pass.passId } } };
   });
 }
+function settlementObservationInput(output, pass, flowStatus) {
+  const original = Object.fromEntries(['taskId', 'flowId', 'stepId', 'leaseId', 'generation'].map(k => [k, pass[k]]));
+  original.settlementId = output.settlementId;
+  const dependencyRepairDigest = memberProducerRepairDependency(flowStatus, pass);
+  const input = output.observationInput ?? { ...original, ...(dependencyRepairDigest ? { dependencyRepairDigest } : {}) };
+  const { dependencyRepairDigest: dependency, ...identity } = input;
+  if (canonical(identity) !== canonical(original) || dependency !== undefined && !/^[a-f0-9]{64}$/.test(dependency)
+    || dependencyRepairDigest && dependency !== dependencyRepairDigest) fail('Observation guidance lost its original settled identity or accepted ancestor repair');
+  return input;
+}
 async function runMutationClient(operation, repositoryRoot, input, dependencies, work) {
   let preflight = true;
   try {
@@ -290,3 +307,4 @@ async function runMutationClient(operation, repositoryRoot, input, dependencies,
 }
 export const runMutationConnect = (repositoryRoot, input, dependencies) => runMutationClient('mutation-connect', repositoryRoot, input, dependencies, connectMutation);
 export const runMutationSettle = (repositoryRoot, input, dependencies) => runMutationClient('mutation-settle', repositoryRoot, input, dependencies, settleMutation);
+import { memberProducerRepairStepMatches, memberProducerRepairDependency } from './member-producer-repair-authority.mjs';