@entrorove/skill 0.1.61 → 0.1.64

package/local-discipline-repository.mjs

@@ -27,7 +27,7 @@ function sourceLimit(relative, bytes, sources, used, required) {
     `Semantic inspection of "${relative}" (${bytes} bytes) exceeds ${reason}; limits are ${disciplineAnalysisLimits.fileBytes} bytes per file, ${disciplineAnalysisLimits.sourceBytes} total bytes and ${disciplineAnalysisLimits.files} files. Preserve the original flow and split its approved inspection before retrying`);
   return reason;
 }
-async function integrityOnlyFile(root, relative) {
+export async function repositoryIntegrityFile(root, relative) {
   // This path returns only an integrity digest. It never exposes source bytes or
   // contributes semantic facts outside the signed source-read scope.
   const before = await mutationTarget14(root, relative);
@@ -39,7 +39,9 @@ async function integrityOnlyFile(root, relative) {
     for await (const chunk of handle.createReadStream({ autoClose: false })) digest.update(chunk);
     const last = await handle.stat(), current = await mutationTarget14(root, relative);
     if (!sameFile(first, last) || !sameFile(last, current.stat)) mutationFail14('ENTROROVE_FILE_CHANGED', `${relative} changed during integrity observation`);
-    return { sha256: digest.digest('hex'), mode: last.mode & 0o777 };
+    return { sha256: digest.digest('hex'), mode: last.mode & 0o777,
+      identity: { dev: last.dev, ino: last.ino, nlink: last.nlink, birthtimeMs: last.birthtimeMs,
+        ctimeMs: last.ctimeMs, mtimeMs: last.mtimeMs, size: last.size } };
   } finally { await handle.close(); }
 }
 async function inventory(root, prefix = '') {
@@ -77,7 +79,7 @@ export async function disciplineRepositoryObservation(input, root, { analyze = f
     const allowed = !restricted || withinBudgetScope(relative, restricted);
     const bytes = overrides.has(relative) ? Buffer.byteLength(overrides.get(relative)) : stat.size;
     const limited = semantic && allowed ? sourceLimit(relative, bytes, sources, sourceBytes, required) : null;
-    const read = semantic && allowed && !limited ? await mutationRead14(input, root, relative) : await integrityOnlyFile(root, relative);
+    const read = semantic && allowed && !limited ? await mutationRead14(input, root, relative) : await repositoryIntegrityFile(root, relative);
     files.push({ path: relative, sha256: read.sha256, mode: read.mode, kind: 'file' });
     if (semantic && allowed && !limited) { sources.push({ path: relative, content: overrides.get(relative) ?? read.content.toString('utf8') }); sourceBytes += bytes; }
     else if (limited) unresolved.push({ path: relative, reason: limited, bytes });
@@ -124,7 +126,7 @@ export function disciplineRepositoryDifferences(before, after, authorized = new
   }
   return changed;
 }
-export async function assertDisciplineRepository(input, root, review, ledger) {
+export async function observeDisciplineRepositoryState(input, root, review, ledger) {
   const expected = new Map();
   for (const [relative, write] of Object.entries(ledger.writes ?? {})) {
     if (write.status !== 'written') mutationFail14('ENTROROVE_MUTATION_PASS_CONSUMED', 'Repository comparison found an unresolved physical action');
@@ -137,6 +139,10 @@ export async function assertDisciplineRepository(input, root, review, ledger) {
   }
   const current = await disciplineRepositoryObservation(input, root);
   const changed = disciplineRepositoryDifferences(review.comparison, current.comparison, expected);
+  return { comparison: current.comparison, changed };
+}
+export async function assertDisciplineRepository(input, root, review, ledger) {
+  const { comparison, changed } = await observeDisciplineRepositoryState(input, root, review, ledger);
   if (changed.length) mutationFail14('ENTROROVE_DISCIPLINE_REPOSITORY_DRIFT', `Whole-repository comparison differs outside completed declared actions: ${changed.join(', ')}`);
-  return current.comparison;
+  return comparison;
 }

package/local-finder-plist.mjs

@@ -0,0 +1,87 @@
+// Bounded structural inspection only. No property values leave this reader.
+const invalid = () => { throw new Error('invalid-finder-property-list'); };
+function integer(bytes, offset, size, end = bytes.length) {
+  if (![1, 2, 4, 8].includes(size) || offset < 0 || offset + size > end) invalid();
+  let value = 0n;
+  for (let index = offset; index < offset + size; index++) value = value * 256n + BigInt(bytes[index]);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) invalid();
+  return Number(value);
+}
+function length(bytes, start, end, info) {
+  if (info !== 15) return { count: info, offset: start };
+  const marker = bytes[start];
+  if (marker === undefined || marker >> 4 !== 1 || (marker & 15) > 3) invalid();
+  const size = 2 ** (marker & 15);
+  return { count: integer(bytes, start + 1, size, end), offset: start + 1 + size };
+}
+function string(bytes, start, count, width, end) {
+  const size = count * width;
+  if (count > 65536 || start + size > end) invalid();
+  const content = bytes.subarray(start, start + size);
+  if (width === 1 && content.some(value => value > 127)) invalid();
+  return new TextDecoder(width === 2 ? 'utf-16be' : 'ascii', { fatal: true }).decode(content);
+}
+function object(state, id, depth) {
+  if (!Number.isSafeInteger(id) || id < 0 || id >= state.offsets.length || depth > 64 || state.visiting.has(id)) invalid();
+  if (state.read.has(id)) return state.read.get(id);
+  state.visiting.add(id);
+  const start = state.offsets[id], end = state.ends.get(start), marker = state.bytes[start];
+  if (marker === undefined) invalid();
+  const type = marker >> 4, info = marker & 15;
+  let cursor = start + 1, text = null;
+  if (type === 0) { if (![0, 8, 9].includes(info)) invalid(); }
+  else if (type === 1) {
+    if (info > 4) invalid();
+    cursor += 2 ** info;
+  } else if (type === 2 || type === 3) {
+    const size = type === 3 ? 8 : 2 ** info;
+    if (type === 3 && info !== 3 || ![4, 8].includes(size) || cursor + size > end) invalid();
+    const value = size === 4 ? state.bytes.readFloatBE(cursor) : state.bytes.readDoubleBE(cursor);
+    if (!Number.isFinite(value)) invalid();
+    cursor += size;
+  } else if ([4, 5, 6, 10, 13].includes(type)) {
+    const value = length(state.bytes, cursor, end, info); cursor = value.offset;
+    if (value.count > 1_048_576) invalid();
+    if (type === 4) cursor += value.count;
+    else if (type === 5 || type === 6) {
+      text = string(state.bytes, cursor, value.count, type === 6 ? 2 : 1, end);
+      cursor += value.count * (type === 6 ? 2 : 1);
+    } else {
+      if (value.count > 10000) invalid();
+      const total = value.count * (type === 13 ? 2 : 1), keys = new Set();
+      for (let index = 0; index < total; index++) {
+        const reference = integer(state.bytes, cursor, state.referenceSize, end); cursor += state.referenceSize;
+        const child = object(state, reference, depth + 1);
+        if (type === 13 && index < value.count) {
+          if (child.text === null || keys.has(child.text)) invalid();
+          keys.add(child.text);
+        }
+      }
+    }
+  } else if (type === 8) cursor += info + 1;
+  else invalid();
+  if (cursor > end) invalid();
+  state.visiting.delete(id);
+  const result = { text }; state.read.set(id, result); return result;
+}
+export function validateFinderPropertyList(bytes) {
+  if (!Buffer.isBuffer(bytes) || bytes.length < 40 || bytes.length > 1_048_576
+    || bytes.subarray(0, 8).toString('latin1') !== 'bplist00') invalid();
+  const trailer = bytes.length - 32;
+  if (bytes.subarray(trailer, trailer + 6).some(value => value !== 0)) invalid();
+  const offsetSize = bytes[trailer + 6], referenceSize = bytes[trailer + 7];
+  if (![1, 2, 4, 8].includes(offsetSize) || ![1, 2, 4, 8].includes(referenceSize)) invalid();
+  const count = integer(bytes, trailer + 8, 8), top = integer(bytes, trailer + 16, 8), table = integer(bytes, trailer + 24, 8);
+  if (!count || count > 10000 || top >= count || table < 8 || table + count * offsetSize !== trailer) invalid();
+  const offsets = Array.from({ length: count }, (_, index) => integer(bytes, table + index * offsetSize, offsetSize));
+  if (new Set(offsets).size !== count || offsets.some(offset => offset < 8 || offset >= table)) invalid();
+  const sorted = [...offsets].sort((a, b) => a - b), ends = new Map(sorted.map((offset, index) => [offset, sorted[index + 1] ?? table]));
+  const state = { bytes, offsets, ends, referenceSize, read: new Map(), visiting: new Set() };
+  if (bytes[offsets[top]] >> 4 !== 13) invalid();
+  object(state, top, 0);
+  // Finder can retain unreferenced duplicate scalar objects. Inspect those
+  // too; an unused object is not an exemption from structural validation.
+  for (let id = 0; id < count; id++) object(state, id, 0);
+  if (state.read.size !== count) invalid();
+  return { objects: count };
+}

package/local-finder-store.mjs

@@ -0,0 +1,115 @@
+import { validateFinderPropertyList } from './local-finder-plist.mjs';
+
+const invalid = () => { throw new Error('invalid-finder-store'); };
+function reader(bytes, start = 0, end = bytes.length) {
+  let cursor = start;
+  return {
+    take(size) {
+      if (!Number.isSafeInteger(size) || size < 0 || cursor + size > end) invalid();
+      const result = bytes.subarray(cursor, cursor + size); cursor += size; return result;
+    },
+    number() { return this.take(4).readUInt32BE(); },
+    byte() { return this.take(1)[0]; },
+  };
+}
+function allocation(bytes) {
+  if (bytes.length < 2048 || bytes.length > 1_048_576 || bytes.subarray(0, 8).toString('hex') !== '0000000142756431') invalid();
+  const header = reader(bytes, 8, 36), offset = header.number(), size = header.number();
+  if (header.number() !== offset || offset < 32 || size < 1024 || offset + size + 4 > bytes.length) invalid();
+  const book = reader(bytes, offset + 4, offset + size + 4), count = book.number();
+  if (count < 3 || count > 8192 || book.number() !== 0) invalid();
+  const blocks = [], intervals = [[0, 32]];
+  for (let index = 0; index < count; index++) {
+    const address = book.number();
+    if (!address) { blocks.push(null); continue; }
+    const power = address & 31, start = (address & 0xffffffe0) >>> 0, length = 2 ** power;
+    if (power < 5 || power > 20 || start < 32 || start % length || start + length + 4 > bytes.length) invalid();
+    blocks.push({ offset: start, length }); intervals.push([start, start + length]);
+  }
+  if (book.take((Math.ceil(count / 256) * 256 - count) * 4).some(byte => byte !== 0)) invalid();
+  if (blocks[0]?.offset !== offset || blocks[0].length < size || book.number() !== 1 || book.byte() !== 4
+    || book.take(4).toString('latin1') !== 'DSDB') invalid();
+  const master = book.number();
+  if (!master || !blocks[master]) invalid();
+  for (let power = 0; power < 32; power++) {
+    const entries = book.number();
+    if (entries > 8192 || power < 5 && entries) invalid();
+    for (let index = 0; index < entries; index++) {
+      const start = book.number(), length = 2 ** power;
+      if (start < 32 || start % length || start + length > 2 ** 31) invalid();
+      intervals.push([start, start + length]);
+    }
+  }
+  intervals.sort((a, b) => a[0] - b[0]);
+  if (intervals.some((range, index) => index && range[0] !== intervals[index - 1][1])
+    || intervals.at(-1)[1] !== 2 ** 31 || Math.max(...blocks.filter(Boolean).map(block => block.offset + block.length)) + 4 !== bytes.length) invalid();
+  return { blocks, master };
+}
+const fixedBlobs = new Map([['Iloc', [16]], ['dilc', [32]], ['fwi0', [16]], ['icgo', [8]], ['icsp', [8]],
+  ['icvo', [18, 26]], ['info', [40, 48]], ['lssp', [8]], ['lsvo', [76]], ['BKGD', [12]]]);
+const plistBlobs = new Set(['bwsp', 'icvp', 'lsvp', 'lsvP']);
+const expectedTypes = new Map([
+  ...[...fixedBlobs.keys(), ...plistBlobs].map(code => [code, 'blob']),
+  ...['ICVO', 'LSVO', 'dscl'].map(code => [code, 'bool']),
+  ...['fwsw', 'vSrn'].map(code => [code, 'long']),
+  ...['fwvh', 'icvt', 'lsvt'].map(code => [code, 'shor']),
+  ...['cmmt', 'extn', 'GRP0'].map(code => [code, 'ustr']),
+  ...['logS', 'lg1S', 'phyS', 'ph1S'].map(code => [code, 'comp']),
+  ...['modD', 'moDD'].map(code => [code, 'dutc']), ['vstl', 'type'],
+]);
+function unicode(input) {
+  const count = input.number();
+  if (count > 65536) invalid();
+  const value = new TextDecoder('utf-16be', { fatal: true }).decode(input.take(count * 2));
+  if (value.includes('\0')) invalid();
+  return value;
+}
+function record(input) {
+  const name = unicode(input), code = input.take(4).toString('latin1'), type = input.take(4).toString('latin1');
+  if (!name || name.length > 1024 || name.includes('/') || expectedTypes.get(code) !== type) invalid();
+  if (type === 'blob') {
+    const blob = input.take(input.number());
+    if (plistBlobs.has(code)) validateFinderPropertyList(blob);
+    else if (!fixedBlobs.get(code).includes(blob.length)) invalid();
+    if (code === 'BKGD' && !['DefB', 'ClrB'].includes(blob.subarray(0, 4).toString('latin1'))) invalid();
+  } else if (type === 'ustr') unicode(input);
+  else if (type === 'bool') { if (input.byte() > 1) invalid(); }
+  else if (type === 'comp' || type === 'dutc') input.take(8);
+  else if (type === 'shor') { if (input.number() > 65535) invalid(); }
+  else if (type === 'long') input.number();
+  else if (!['icnv', 'clmv', 'Nlsv', 'Flwv'].includes(input.take(4).toString('latin1'))) invalid();
+  return name.normalize('NFD').toLowerCase() + '\0' + code;
+}
+function tree(bytes, blocks, master) {
+  const readBlock = id => {
+    const block = blocks[id];
+    if (!block) invalid();
+    return reader(bytes, block.offset + 4, block.offset + block.length + 4);
+  };
+  const info = readBlock(master), root = info.number(), levels = info.number(), records = info.number(), nodes = info.number(), pageSize = info.number();
+  if (levels > 32 || records > 10000 || !nodes || nodes > 8190 || pageSize !== 4096) invalid();
+  const visited = new Set([0, master]);
+  let actualRecords = 0, previous = null;
+  const walk = (id, level) => {
+    if (visited.has(id) || !blocks[id] || blocks[id].length > pageSize) invalid();
+    visited.add(id);
+    const input = readBlock(id), right = input.number(), count = input.number();
+    if (Boolean(right) !== Boolean(level) || count > 10000 || actualRecords + count > records) invalid();
+    for (let index = 0; index < count; index++) {
+      if (right) walk(input.number(), level - 1);
+      const key = record(input);
+      if (previous !== null && previous >= key) invalid();
+      previous = key; actualRecords++;
+    }
+    if (right) walk(right, level - 1);
+  };
+  walk(root, levels);
+  if (actualRecords !== records || visited.size !== nodes + 2
+    || blocks.some((block, id) => block && !visited.has(id))) invalid();
+  return { format: 'finder-ds-store/1.0', records, nodes, bytes: bytes.length };
+}
+export function validateFinderStore(bytes) {
+  if (!Buffer.isBuffer(bytes)) invalid();
+  const { blocks, master } = allocation(bytes);
+  return tree(bytes, blocks, master);
+}

package/local-mutation-authority.mjs

@@ -92,6 +92,16 @@ function contentFor(input, baseline) {
   if (input.expectedSha256 !== undefined && input.expectedSha256 !== null && input.expectedSha256 !== baseline.sha256) {
     mutationFail14('ENTROROVE_WRITE_BASELINE', 'Target differs from the expected snapshot hash');
   }
+  if (Object.hasOwn(input, 'contentBase64')) {
+    if (Object.hasOwn(input, 'content') || typeof input.contentBase64 !== 'string'
+      || input.contentBase64.length > 16_000_000 || input.contentBase64.length % 4
+      || !/^[A-Za-z0-9+/]*={0,2}$/.test(input.contentBase64)) {
+      mutationFail14('ENTROROVE_CONTENT_INVALID', 'Use exactly one text/JSON content or canonical bounded contentBase64');
+    }
+    const bytes = Buffer.from(input.contentBase64, 'base64');
+    if (bytes.toString('base64') !== input.contentBase64) mutationFail14('ENTROROVE_CONTENT_INVALID', 'Binary content must use canonical base64');
+    return bytes;
+  }
   let content; try { content = typeof input.content === 'string' ? input.content : JSON.stringify(input.content); }
   catch { mutationFail14('ENTROROVE_CONTENT_INVALID', 'Guarded-write content must be finite JSON or text'); }
   if (typeof content !== 'string') mutationFail14('ENTROROVE_CONTENT_INVALID', 'Guarded-write content must be JSON or text');
@@ -103,6 +113,7 @@ async function performWrite(input, state, value) {
   return withSwarmMutationLease(input, pass, async () => {
     const baseline = snapshot.manifest.files.find(file => file.path === target), content = contentFor(input, baseline);
     const discipline = await disciplineWritePreflight(input, current, content);
+    mutationLifetime14(pass);
     const entry = { status: 'pending', contentDigest: sha256(content), mode: baseline.mode ?? 0o644, at: new Date().toISOString() };
     await saveMutationConsumption14(locations, { ...ledger, writes: { ...ledger.writes, [target]: entry } });
     await auditMutation14(input, 'guarded-write-authorized', { passId: pass.passId, sha256: entry.contentDigest,

package/local-mutation-completion-evidence.mjs

@@ -0,0 +1,83 @@
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { createInterface } from 'node:readline';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationFile14, mutationStateRoot14, readMutationJson14, mutationFail14 } from './local-mutation-files.mjs';
+
+const fail = () => mutationFail14('ENTROROVE_DISCIPLINE_REPOSITORY_DRIFT',
+  'Post-write recovery requires the original successful write audit and intact execution ledger; no baseline or permission was changed');
+const iso = value => typeof value === 'string' && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+
+function checkedLedger(value, repositoryDigest) {
+  if (value.schemaVersion !== 'entrorove.execution-ledger/1.0' || value.repositoryDigest !== repositoryDigest
+    || !Array.isArray(value.records) || value.records.length > 100_000 || value.sequence !== value.records.length) fail();
+  let previous = null;
+  for (const [index, record] of value.records.entries()) {
+    const { digest, previousDigest, ...unsigned } = record;
+    if (record.sequence !== index + 1 || previousDigest !== previous || !iso(record.at)
+      || digest !== sha256(canonical(unsigned) + (previous ?? ''))) fail();
+    previous = digest;
+  }
+  if (value.head !== previous) fail();
+  return value.records;
+}
+
+async function matchingAudit(file, pass, candidates) {
+  const item = await mutationFile14(file);
+  if (item.stat.nlink !== 1 || item.stat.size > 256 * 1024 * 1024
+    || process.platform !== 'win32' && (item.stat.mode & 0o077)
+    || process.getuid && item.stat.uid !== process.getuid()) fail();
+  const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  const matched = new Map();
+  try {
+    const before = await handle.stat();
+    if (before.dev !== item.stat.dev || before.ino !== item.stat.ino || before.size < item.stat.size) fail();
+    if (item.stat.size) {
+      const lines = createInterface({ input: handle.createReadStream({ start: 0, end: item.stat.size - 1, autoClose: false }), crlfDelay: Infinity });
+      try {
+        for await (const line of lines) {
+          if (Buffer.byteLength(line) > 1_048_576) fail();
+          let record; try { record = JSON.parse(line); } catch { fail(); }
+          if (record.event !== 'guarded-write' || record.passId !== pass.passId) continue;
+          if (record.schemaVersion !== 'entrorove.local-execution/1.0' || record.flowId !== pass.flowId
+            || record.stepId !== pass.stepId || record.repositoryDigest !== pass.repositoryDigest || !iso(record.at)) fail();
+          const candidate = candidates.get(record.targetPathDigest);
+          if (!candidate || matched.has(candidate.targetPath) || record.sha256 !== candidate.sha256
+            || Date.parse(record.at) < Date.parse(candidate.writtenAt) || Date.parse(record.at) > Date.parse(candidate.at)) fail();
+          matched.set(candidate.targetPath, record);
+        }
+      } finally { lines.close(); }
+    }
+    const after = await handle.stat(), current = await mutationFile14(file);
+    if (after.dev !== item.stat.dev || after.ino !== item.stat.ino || after.nlink !== 1
+      || after.size < item.stat.size || current.stat.dev !== after.dev || current.stat.ino !== after.ino) fail();
+    return matched;
+  } finally { await handle.close(); }
+}
+
+export async function mutationCompletionEvidence(input, state) {
+  const { pass, ledger } = state, stateRoot = await mutationStateRoot14(input);
+  let records;
+  try { records = checkedLedger(await readMutationJson14(path.join(stateRoot, 'ledgers', pass.repositoryDigest, 'state.json')), pass.repositoryDigest); }
+  catch { fail(); }
+  const candidates = new Map();
+  for (const [targetPath, written] of Object.entries(ledger.writes)) {
+    if (written.status !== 'written') continue;
+    const matches = records.filter(record => record.event === 'guarded-write' && record.passId === pass.passId && record.targetPath === targetPath);
+    const record = matches[0];
+    if (matches.length !== 1 || record.flowId !== pass.flowId || record.stepId !== pass.stepId
+      || record.sha256 !== written.contentDigest || !iso(written.writtenAt)
+      || Date.parse(record.at) < Date.parse(written.writtenAt) || Date.parse(record.at) > Date.now()) fail();
+    candidates.set(sha256(targetPath), { ...record, writtenAt: written.writtenAt });
+  }
+  if (!candidates.size) fail();
+  let audits;
+  try { audits = await matchingAudit(path.join(stateRoot, 'invocations.jsonl'), pass, candidates); } catch { fail(); }
+  return [...candidates.values()].sort((a, b) => a.targetPath < b.targetPath ? -1 : 1).map(record => {
+    const audit = audits.get(record.targetPath);
+    if (!audit) fail();
+    return { path: record.targetPath, sha256: record.sha256, writtenAt: record.writtenAt, completedAt: record.at,
+      ledgerSequence: record.sequence, ledgerRecordDigest: record.digest, auditRecordDigest: sha256(canonical(audit)),
+      source: 'original-successful-write-audit-and-ledger' };
+  });
+}

package/local-mutation-consumption.mjs

@@ -2,7 +2,7 @@ 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 { mutationFail14, mutationRead14, mutationTarget14, 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';
@@ -10,10 +10,11 @@ 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 { observeCompletedMutationEnvironment, readMutationEnvironmentObservation } from './local-mutation-environment-observation.mjs';
 import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
+import { assertDisciplineRepository } from './local-discipline-repository.mjs';
 
-const fail = () => mutationFail14('ENTROROVE_MUTATION_CONSUMPTION_INVALID', 'Mutation consumption requires its actual completed original writes, unchanged protection and separate M signer');
+const fail = () => mutationFail14('ENTROROVE_MUTATION_CONSUMPTION_INVALID', 'Mutation consumption requires actual original writes or expired unchanged unwritten targets, intact protection and the 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 });
@@ -24,36 +25,58 @@ export async function preservedMutationConsumptionState(input) {
 }
 async function actualWrites(input, state) {
   const { pass, binding, ledger } = state;
-  if (!state.complete || Object.keys(ledger.writes).length !== pass.paths.length) fail();
+  if (!state.complete && Date.now() < Date.parse(pass.expiresAt)) 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 = [];
+  const writes = [], unwritten = [];
+  const create = pass.writeDelegation.purpose === 'planned-file-create';
   for (const target of pass.paths) {
     const completed = ledger.writes[target], before = snapshot.manifest.files.find(file => file.path === target);
+    if (completed?.status !== 'written') {
+      if (!before || completed && (completed.status !== 'pending' || !iso(completed.at)
+        || Date.parse(completed.at) < Date.parse(pass.expiresAt) || Date.parse(completed.at) > Date.now())) fail();
+      const item = await mutationTarget14(binding.root, target, true);
+      const current = item.exists ? await mutationRead14(input, binding.root, target)
+        : { sha256: sha256('entrorove.missing-file/1.0'), mode: null };
+      if (item.exists !== before.exists || current.sha256 !== before.sha256 || current.mode !== before.mode) fail();
+      unwritten.push({ path: target, beforeSha256: before.sha256, beforeMode: before.mode,
+        observedSha256: current.sha256, observedMode: current.mode, ledgerStatus: completed ? 'expired-before-write' : 'untouched',
+        attemptedAt: completed?.at ?? null, attemptedContentDigest: completed?.contentDigest ?? null });
+      continue;
+    }
     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)
+    if (!before || (create ? before.exists !== false || before.mode !== null : !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') });
+    if (current.sha256 !== completed.contentDigest || current.mode !== completed.mode || current.mode !== (create ? 0o644 : before.mode)) fail();
+    if (pass.writeDelegation.purpose === 'preserved-existing-modify') 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;
+  const review = await readDisciplineSnapshot(snapshot);
+  const writtenLedger = { ...ledger, writes: Object.fromEntries(Object.entries(ledger.writes).filter(([, value]) => value.status === 'written')) };
+  if (!writes.length) await assertDisciplineRepository(input, binding.root, review, writtenLedger);
+  else await observeCompletedMutationEnvironment(input, state, review, writtenLedger);
+  return { writes, ...(unwritten.length ? { unwritten, reconciledAt: new Date(Date.now()).toISOString() } : {}) };
 }
-function receiptCore(pass, writes) {
-  return { schemaVersion: 'entrorove.preserved-mutation-consumption/1.0', purpose: 'preserved-existing-modify-consumption',
+function receiptCore(pass, physical) {
+  return { schemaVersion: 'entrorove.preserved-mutation-consumption/1.0', purpose: `${pass.writeDelegation.purpose}-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 };
+    protectedFilesDigest: sha256(canonical(pass.writeDelegation.protectedFiles)), ...physical };
 }
 function cachedReceipt(value, pass, core) {
   const { signature, issuedAt, expiresAt, nonce, ...actual } = value;
+  if (core.reconciledAt) {
+    if (!iso(actual.reconciledAt) || Date.parse(actual.reconciledAt) < Date.parse(pass.expiresAt)
+      || Date.parse(actual.reconciledAt) > Date.parse(issuedAt)) fail();
+    core = { ...core, reconciledAt: actual.reconciledAt };
+  }
   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
@@ -62,7 +85,7 @@ function cachedReceipt(value, pass, core) {
   return value;
 }
 async function consumptionReceipt(input, state, { renewExpired = false, allowExpiredReplay = false } = {}) {
-  const writes = await actualWrites(input, state), core = receiptCore(state.pass, writes);
+  const physical = await actualWrites(input, state), core = receiptCore(state.pass, physical);
   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;
@@ -86,7 +109,9 @@ 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);
+    const environmentObservation = await readMutationEnvironmentObservation(input, state.pass);
     return { schemaVersion: 'entrorove.local-execution/1.0', status: 'reported', consumptionReceipt: receipt,
+      ...(environmentObservation ? { environmentObservation, environmentObservationAcknowledgedByServer: false } : {}),
       claimsVerifiedExecution: false, claimsCompletion: false,
       nextAction: { operation: 'mutation-pass-settle', input: { passId: state.pass.passId, consumptionReceipt: receipt } } };
   });

package/local-mutation-environment-observation.mjs

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import { randomUUID, sign, verify } from 'node:crypto';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationFail14, mutationStateRoot14, atomicMutationJson14, readMutationJson14 } from './local-mutation-files.mjs';
+import { observeDisciplineRepositoryState, repositoryIntegrityFile } from './local-discipline-repository.mjs';
+import { mutationCompletionEvidence } from './local-mutation-completion-evidence.mjs';
+import { loadPreservedMutationSigner } from './local-preserved-mutation-signer.mjs';
+import { preservedMutationPublicKey } from './local-preserved-mutation-wire.mjs';
+import { finderMetadataPath, observeFinderMetadataChanges } from './local-mutation-finder-observation.mjs';
+
+const schemaVersion = 'entrorove.post-write-environment-observation/1.0';
+const fail = () => mutationFail14('ENTROROVE_DISCIPLINE_REPOSITORY_DRIFT',
+  'Environment drift is not a proven new regular file created after the expired pass and its original successful write checks; original source protection remains enforced');
+const iso = value => typeof value === 'string' && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+const attribution = changes => changes.some(change => change?.kind === 'validated-finder-metadata')
+  ? changes.every(change => change?.kind === 'validated-finder-metadata')
+    ? 'unattributed-post-write-finder-metadata' : 'unattributed-post-write-environment'
+  : 'unattributed-post-write-additions';
+function location(stateRoot, pass) {
+  return path.join(stateRoot, 'post-write-environment', pass.repositoryDigest, pass.passId + '.json');
+}
+function verified(value, pass) {
+  const { signature, ...unsigned } = value ?? {}, key = preservedMutationPublicKey(pass.writeDelegation.mutationPublicKey);
+  const expected = { schemaVersion, keyId: pass.writeDelegation.mutationKeyId, ownerId: pass.ownerId, taskId: pass.taskId,
+    flowId: pass.flowId, stepId: pass.stepId, passId: pass.passId, passDigest: sha256(canonical(pass)),
+    originalReviewDigest: pass.snapshotReceipt.disciplineReviewDigest,
+    attribution: attribution(Array.isArray(value?.changes) ? value.changes : []), grantsWriteAuthority: false,
+    claimsRepositoryUnchanged: false, claimsAuthorizedEnvironmentChange: false };
+  if (Object.entries(expected).some(([field, expected]) => canonical(value?.[field]) !== canonical(expected))
+    || !iso(value.observedAt) || Date.parse(value.observedAt) > Date.now()
+    || !Array.isArray(value.changes) || !value.changes.length || !Array.isArray(value.completionEvidence)
+    || !verify(null, Buffer.from(canonical(unsigned)), key.key, Buffer.from(signature ?? '', 'base64url'))) fail();
+  return value;
+}
+export async function readMutationEnvironmentObservation(input, pass) {
+  try { return verified(await readMutationJson14(location(await mutationStateRoot14(input), pass)), pass); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+}
+async function additions(root, review, comparison, changed, state, completionEvidence) {
+  const { pass } = state, before = new Set(review.comparison.files.map(file => file.path));
+  const protectedPaths = new Set([...pass.paths, ...pass.writeDelegation.protectedFiles.map(file => file.path)]);
+  const completedAt = Math.max(Date.parse(pass.expiresAt), ...completionEvidence.map(record => Date.parse(record.completedAt)));
+  if (Date.now() < Date.parse(pass.expiresAt) || changed.length > 512) fail();
+  const changes = [];
+  for (const relative of changed) {
+    const observed = comparison.files.find(file => file.path === relative);
+    if (before.has(relative) || protectedPaths.has(relative) || observed?.kind !== 'file') fail();
+    const current = await repositoryIntegrityFile(root, relative), identity = current.identity;
+    if (current.sha256 !== observed.sha256 || current.mode !== observed.mode || current.mode & 0o111
+      || identity.nlink !== 1 || !Number.isFinite(identity.birthtimeMs) || identity.birthtimeMs <= completedAt
+      || identity.birthtimeMs > Date.now() || identity.ctimeMs < identity.birthtimeMs) fail();
+    changes.push({ path: relative, before: null, after: { sha256: current.sha256, mode: current.mode },
+      physicalIdentity: identity, createdAt: new Date(identity.birthtimeMs).toISOString() });
+  }
+  return changes;
+}
+export async function observeCompletedMutationEnvironment(input, state, review, writtenLedger) {
+  const { comparison, changed } = await observeDisciplineRepositoryState(input, state.binding.root, review, writtenLedger);
+  if (!changed.length) return null;
+  if (changed.length > 512) fail();
+  const completionEvidence = await mutationCompletionEvidence(input, state);
+  const finder = changed.filter(finderMetadataPath), other = changed.filter(relative => !finderMetadataPath(relative));
+  const changes = [...(finder.length ? await observeFinderMetadataChanges(state.binding.root, review, comparison, finder, state, completionEvidence) : []),
+    ...await additions(state.binding.root, review, comparison, other, state, completionEvidence)].sort((a, b) => a.path < b.path ? -1 : 1);
+  const pass = state.pass;
+  const core = { schemaVersion, keyId: pass.writeDelegation.mutationKeyId, ownerId: pass.ownerId, taskId: pass.taskId,
+    flowId: pass.flowId, stepId: pass.stepId, passId: pass.passId, passDigest: sha256(canonical(pass)),
+    originalReviewDigest: pass.snapshotReceipt.disciplineReviewDigest,
+    originalComparisonDigest: sha256(canonical(review.comparison)), observedComparisonDigest: sha256(canonical(comparison)),
+    attribution: attribution(changes), grantsWriteAuthority: false,
+    claimsRepositoryUnchanged: false, claimsAuthorizedEnvironmentChange: false, completionEvidence, changes };
+  const stateRoot = await mutationStateRoot14(input), file = location(stateRoot, pass);
+  let previous;
+  try { previous = verified(await readMutationJson14(file), pass); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  if (previous) {
+    const { signature: _, observedAt: __, nonce: ___, ...original } = previous;
+    if (canonical(original) !== canonical(core)) fail();
+    return previous;
+  }
+  const signer = await loadPreservedMutationSigner(input, state.binding.signerConfigPath, core.keyId);
+  const unsigned = { ...core, observedAt: new Date().toISOString(), nonce: randomUUID() };
+  const result = { ...unsigned, signature: sign(null, Buffer.from(canonical(unsigned)), signer.privateKey).toString('base64url') };
+  await atomicMutationJson14(file, result, { privateFrom: stateRoot });
+  return result;
+}

package/local-mutation-finder-observation.mjs

@@ -0,0 +1,58 @@
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { sha256 } from './local-integrity.mjs';
+import { mutationTarget14, mutationFail14 } from './local-mutation-files.mjs';
+import { validateFinderStore } from './local-finder-store.mjs';
+
+const fail = () => mutationFail14('ENTROROVE_DISCIPLINE_REPOSITORY_DRIFT',
+  'Finder metadata recovery requires bounded valid allocator/tree/property-list bytes, original successful write evidence, unchanged protected sources, and single-link non-executable files changed only after completion');
+const same = (left, right) => ['dev', 'ino', 'nlink', 'size', 'mtimeMs', 'ctimeMs', 'mode'].every(key => left[key] === right[key]);
+export const finderMetadataPath = relative => path.posix.basename(relative) === '.DS_Store';
+
+async function metadataFile(root, relative) {
+  const item = await mutationTarget14(root, relative), handle = await fs.open(item.target, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const before = await handle.stat();
+    if (!same(before, item.stat) || !before.isFile() || before.nlink !== 1 || before.mode & 0o7111
+      || before.size > 1_048_576) fail();
+    const bytes = Buffer.alloc(before.size);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const read = await handle.read(bytes, offset, bytes.length - offset, offset);
+      if (!read.bytesRead) fail();
+      offset += read.bytesRead;
+    }
+    let format;
+    try { format = validateFinderStore(bytes); } catch { fail(); }
+    const after = await handle.stat(), current = await mutationTarget14(root, relative);
+    if (!same(before, after) || !same(after, current.stat)) fail();
+    return { sha256: sha256(bytes), mode: after.mode & 0o777, format,
+      identity: { dev: after.dev, ino: after.ino, nlink: after.nlink, birthtimeMs: after.birthtimeMs,
+        ctimeMs: after.ctimeMs, mtimeMs: after.mtimeMs, size: after.size } };
+  } finally { await handle.close(); }
+}
+export async function observeFinderMetadataChanges(root, review, comparison, changed, state, completionEvidence) {
+  const pass = state.pass, protectedPaths = new Set([...pass.paths, ...pass.writeDelegation.protectedFiles.map(file => file.path)]);
+  const completedAt = Math.max(...completionEvidence.map(record => Date.parse(record.completedAt)));
+  if (!completionEvidence.length || !Number.isFinite(completedAt) || Date.now() < Date.parse(pass.expiresAt)
+    || !changed.length || changed.length > 512) fail();
+  const changes = [];
+  let bytes = 0;
+  for (const relative of changed) {
+    const before = review.comparison.files.find(file => file.path === relative) ?? null;
+    const observed = comparison.files.find(file => file.path === relative);
+    if (!finderMetadataPath(relative) || protectedPaths.has(relative) || observed?.kind !== 'file'
+      || before && (before.kind !== 'file' || before.mode !== observed.mode || before.mode & 0o111)) fail();
+    const current = await metadataFile(root, relative), identity = current.identity;
+    if (current.sha256 !== observed.sha256 || current.mode !== observed.mode
+      || ![identity.birthtimeMs, identity.mtimeMs, identity.ctimeMs].every(value => Number.isFinite(value) && value <= Date.now())
+      || identity.mtimeMs <= completedAt || identity.ctimeMs <= completedAt
+      || !before && identity.birthtimeMs <= completedAt || identity.birthtimeMs > identity.ctimeMs) fail();
+    bytes += identity.size;
+    if (bytes > 8_388_608) fail();
+    changes.push({ path: relative, kind: 'validated-finder-metadata', before,
+      after: { sha256: current.sha256, mode: current.mode }, physicalIdentity: identity, format: current.format,
+      originalContentAvailable: false, claimsOriginalContentFormatValidated: false });
+  }
+  return changes;
+}