@entrorove/skill 0.1.62 → 0.1.67

package/remote-transport.mjs

@@ -1,9 +1,14 @@
 import http from 'node:http';
 import https from 'node:https';
+import { createGunzip } from 'node:zlib';
 
 const PRE_CONNECT = new Set(['ECONNREFUSED', 'ECONNRESET', 'EAI_AGAIN', 'ENOTFOUND', 'ENETUNREACH',
   'ENETDOWN', 'EHOSTUNREACH', 'ETIMEDOUT', 'ECONNABORTED']);
-const MAX_BYTES = 1_048_576;
+// A scope response retains its exact role map, signed S/W proof and recovery
+// records together. Bound the whole envelope rather than one embedded record.
+const MAX_BYTES = 8_388_608;
+const RESPONSE_CODES = new Set(['RESPONSE_TOO_LARGE', 'RESPONSE_INTERRUPTED',
+  'RESPONSE_ENCODING_INVALID', 'RESPONSE_ENCODING_UNSUPPORTED']);
 
 export function trustedOrigin(value) {
   let url;
@@ -15,34 +20,60 @@ export function trustedOrigin(value) {
   return url.origin;
 }
 
-function failure(code, established) {
-  return Object.assign(new Error(established ? 'Entrorove response was interrupted after connection establishment'
+function failure(code, established, detail = {}) {
+  return Object.assign(new Error(code === 'RESPONSE_TOO_LARGE' ? 'Entrorove response exceeds the bounded eight MiB envelope limit'
+    : code === 'RESPONSE_ENCODING_INVALID' ? 'Entrorove response has invalid compressed content'
+    : code === 'RESPONSE_ENCODING_UNSUPPORTED' ? 'Entrorove response uses an unnegotiated content encoding'
+    : established ? 'Entrorove response was interrupted after connection establishment'
     : 'Entrorove connection failed before request transmission'), {
     code: 'ENTROROVE_TRANSPORT', established, retryableBeforeTransmission: !established && PRE_CONNECT.has(code),
-    transportCode: PRE_CONNECT.has(code) ? code : 'CONNECTION_REJECTED',
+    transportCode: PRE_CONNECT.has(code) || RESPONSE_CODES.has(code) ? code : 'CONNECTION_REJECTED',
+    ...(code === 'RESPONSE_TOO_LARGE' ? { responseLimitBytes: MAX_BYTES, receivedBytes: detail.receivedBytes } : {}),
   });
 }
 
+function readResponse(response, request, done) {
+  const encoding = response.headers['content-encoding']?.trim().toLowerCase();
+  const decoded = encoding === 'gzip' ? createGunzip() : response;
+  const chunks = []; let size = 0; let wireBytes = 0; let ended = false;
+  const fail = cause => {
+    if (ended) return; ended = true; done(cause);
+    if (decoded !== response) decoded.destroy(); response.destroy(); request.destroy();
+  };
+  response.on('aborted', () => fail({ code: 'RESPONSE_INTERRUPTED' }));
+  response.on('error', cause => fail(cause));
+  if (encoding && !['identity', 'gzip'].includes(encoding)) {
+    fail({ code: 'RESPONSE_ENCODING_UNSUPPORTED' }); return;
+  }
+  if (decoded !== response) decoded.on('error', () => fail({ code: 'RESPONSE_ENCODING_INVALID' }));
+  response.on('data', chunk => {
+    if (ended) return; wireBytes += chunk.length;
+    if (wireBytes > MAX_BYTES) fail({ code: 'RESPONSE_TOO_LARGE', receivedBytes: wireBytes });
+  });
+  decoded.on('data', chunk => {
+    if (ended) return; size += chunk.length;
+    if (size > MAX_BYTES) fail({ code: 'RESPONSE_TOO_LARGE', receivedBytes: size });
+    else chunks.push(chunk);
+  });
+  decoded.on('end', () => {
+    if (ended) return; ended = true;
+    done(null, { ok: response.statusCode >= 200 && response.statusCode < 300,
+      status: response.statusCode, headers: response.headers, body: Buffer.concat(chunks).toString('utf8') });
+  });
+  if (decoded !== response) response.pipe(decoded);
+}
+
 async function attempt(url, options) {
   return new Promise((resolve, reject) => {
     let established = false; let settled = false;
     const done = (cause, result) => {
       if (settled) return; settled = true; clearTimeout(timer);
-      if (cause) reject(failure(cause.code, established)); else resolve(result);
+      if (cause) reject(failure(cause.code, established, cause)); else resolve(result);
     };
     const client = url.protocol === 'https:' ? https : http;
     const request = client.request(url, { method: options.method, headers: options.headers,
       agent: false }, response => {
-      established = true; const chunks = []; let size = 0;
-      response.on('data', chunk => {
-        size += chunk.length;
-        if (size > MAX_BYTES) { done({ code: 'RESPONSE_TOO_LARGE' }); response.destroy(); request.destroy(); }
-        else chunks.push(chunk);
-      });
-      response.on('aborted', () => done({ code: 'RESPONSE_INTERRUPTED' }));
-      response.on('error', cause => done(cause));
-      response.on('end', () => done(null, { ok: response.statusCode >= 200 && response.statusCode < 300,
-        status: response.statusCode, headers: response.headers, body: Buffer.concat(chunks).toString('utf8') }));
+      established = true; readResponse(response, request, done);
     });
     request.on('socket', socket => {
       socket.once(url.protocol === 'https:' ? 'secureConnect' : 'connect', () => { established = true; });
@@ -57,7 +88,8 @@ export async function requestTransport(origin, pathname, options = {}) {
   const trusted = trustedOrigin(origin);
   if (typeof pathname !== 'string' || !pathname.startsWith('/api/') || pathname.includes('://')) throw new Error('Invalid Entrorove API path');
   const url = new URL(pathname, trusted);
-  const configured = { timeoutMs: 15_000, method: 'GET', ...options };
+  const configured = { timeoutMs: 15_000, method: 'GET', ...options,
+    headers: { ...options.headers, 'accept-encoding': 'gzip' } };
   const originalGeneration = configured.method === 'GET' && /^\/api\/skill\/feedback\/[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(url.pathname)
     && /^\?generation=[1-9][0-9]{0,14}$/.test(url.search) && Number.isSafeInteger(Number(url.searchParams.get('generation')));
   if (url.origin !== trusted || url.hash || url.search && !originalGeneration) throw new Error('Invalid Entrorove API path');

package/reuse-discipline-release.mjs

@@ -8,13 +8,15 @@ const equivalence = ['local-equivalence-runner.mjs', 'validator-runtime-build.mj
   'runtime/validator-runtime-v7.0.44.mjs', 'runtime/validator-runtime-v7.0.44.d.mts'];
 const cleanup = ['snapshot-retention.mjs', 'snapshot-cleanup-journal.mjs'];
 const documentation = ['IDE-EXECUTION.md', 'REUSE-DISCIPLINE.md'];
-export const REUSE_DISCIPLINE_SOURCE_FILES = [...ide, ...discipline, ...equivalence, ...cleanup, ...documentation, 'reuse-discipline-release.mjs'];
+const replacement = ['install-identity.mjs', 'package-archive.mjs', 'package-replacement.mjs', 'rollback-history.mjs', 'rollback-runner.mjs'];
+export const REUSE_DISCIPLINE_SOURCE_FILES = [...ide, ...discipline, ...equivalence, ...cleanup, ...documentation, ...replacement, 'reuse-discipline-release.mjs'];
 export const reuseDisciplineReleaseLabels = Object.fromEntries([
   ...ide.map(file => [file, { zh: 'Codex 后续轮次工具门禁', en: 'Codex tool guards across turns' }]),
   ...discipline.map(file => [file, { zh: '复用与变更一致性门禁', en: 'reuse and change consistency checks' }]),
   ...equivalence.map(file => [file, { zh: '真实新旧路径逐字段验证', en: 'actual fieldwise parallel-path verification' }]),
   ...cleanup.map(file => [file, { zh: '验收后快照自动清理', en: 'verified snapshot cleanup' }]),
   ...documentation.map(file => [file, { zh: 'IDE 执行与复用纪律文档', en: 'IDE execution and reuse discipline documentation' }]),
+  ...replacement.map(file => [file, { zh: '包降级、版本冲突与凭证回滚门禁', en: 'package downgrade, version conflict and evidence-bound rollback guards' }]),
   ['reuse-discipline-release.mjs', { zh: '复用纪律版本追踪', en: 'reuse discipline release tracking' }],
   ['local-typescript-function-reference.mjs', { zh: 'TypeScript 类型与 Vue 属性构造器引用分析', en: 'TypeScript type and Vue prop constructor references' }],
   ['local-scope-import-expressions.mjs', { zh: '不可变有限动态导入与逐站点未核实诊断', en: 'immutable finite imports and precise unresolved import diagnostics' }],

package/rollback-history.mjs

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { atomicMutationJson14, mutationFail14, mutationFile14, mutationPath14, mutationStateRoot14,
+  privateMutationDirectory14, readMutationJson14 } from './local-mutation-files.mjs';
+
+const SHA = /^[a-f0-9]{64}$/;
+async function location(input, root, target, digest) {
+  mutationPath14(target);
+  if (!SHA.test(digest)) mutationFail14('ENTROROVE_ROLLBACK_HISTORY_INVALID', 'Rollback comparison requires exact file digests');
+  const state = await mutationStateRoot14(input), repositoryDigest = sha256(root);
+  const directory = path.join(state, 'rollback-baselines', repositoryDigest, sha256(target));
+  return { state, directory, file: path.join(directory, `${digest}.json`), repositoryDigest };
+}
+async function read(loc, target, digest) {
+  let info;
+  try { info = await mutationFile14(loc.file); } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  if (info.stat.size > 8192) mutationFail14('ENTROROVE_ROLLBACK_HISTORY_INVALID', 'Rollback baseline record exceeds its bounded schema');
+  const record = await readMutationJson14(loc.file), { recordDigest, ...body } = record;
+  if (body.schemaVersion !== 'entrorove.rollback-baseline/1.0' || body.repositoryDigest !== loc.repositoryDigest
+    || body.targetPath !== target || body.baselineDigest !== digest || sha256(canonical(body)) !== recordDigest
+    || !['mutation-snapshot', 'approved-process-comparison'].includes(body.proof?.kind)
+    || !SHA.test(body.proof.authorityDigest ?? '') || !SHA.test(body.proof.baselineManifestDigest ?? '')
+    || body.claimsCompletedWrite !== false || body.grantsRollbackAuthority !== false) {
+    mutationFail14('ENTROROVE_ROLLBACK_HISTORY_INVALID', 'Rollback baseline record is invalid; preserve the record and original failure');
+  }
+  return record;
+}
+export async function assertRollbackCandidate(input, root, target, current, candidate) {
+  if (current === candidate) return;
+  const loc = await location(input, root, target, candidate);
+  if (await read(loc, target, candidate)) mutationFail14('ENTROROVE_ROLLBACK_PROOF_REQUIRED',
+    'Candidate restores an actually observed historical file image; use the original independently signed rollback with exact current/restore hashes and transaction records');
+}
+// These immutable observations prove only earlier bytes. They never claim a
+// pending process finished, revive old write authority, or authorize rollback.
+export async function rememberRollbackBaseline(input, root, target, digest, proof) {
+  const loc = await location(input, root, target, digest);
+  if (await read(loc, target, digest)) return;
+  const body = { schemaVersion: 'entrorove.rollback-baseline/1.0', repositoryDigest: loc.repositoryDigest,
+    targetPath: target, baselineDigest: digest, proof, claimsCompletedWrite: false, grantsRollbackAuthority: false };
+  await privateMutationDirectory14(loc.directory, { privateFrom: loc.state });
+  try { await atomicMutationJson14(loc.file, { ...body, recordDigest: sha256(canonical(body)) }, { privateFrom: loc.state }); }
+  catch (error) { if (error.code !== 'ENTROROVE_STATE_EXISTS' || !await read(loc, target, digest)) throw error; }
+}
+export async function rememberMutationBaselines(input, value, before) {
+  const proof = { kind: 'mutation-snapshot', authorityDigest: sha256(canonical(value.pass)),
+    baselineManifestDigest: value.pass.snapshotManifestDigest };
+  for (const file of before) if (file.exists) {
+    await rememberRollbackBaseline(input, value.binding.root, file.path, file.sha256, proof);
+  }
+}

package/rollback-runner.mjs

@@ -0,0 +1,77 @@
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationFail14, mutationRead14, mutationTarget14 } from './local-mutation-files.mjs';
+import { archiveFormat } from './package-archive.mjs';
+import { assertPackageReplacement } from './package-replacement.mjs';
+import { assertRollbackCandidate, rememberRollbackBaseline } from './rollback-history.mjs';
+
+const rollbackVerbs = new Set(['reset', 'restore', 'revert', 'checkout', 'switch']);
+function gitOperation(args) {
+  for (let index = 0; index < args.length; index++) {
+    const value = args[index];
+    if (['-C', '-c', '--git-dir', '--work-tree', '--namespace', '--config-env'].includes(value)) { index++; continue; }
+    if (value.startsWith('-')) continue;
+    return value;
+  }
+  return '';
+}
+export function assertNoBlindRollback(policy) {
+  const executable = path.basename(policy.executable).replace(/\.exe$/i, '').toLowerCase(), args = policy.args ?? [];
+  const direct = executable === 'git' && rollbackVerbs.has(gitOperation(args));
+  const shell = ['sh', 'bash', 'zsh', 'dash', 'cmd', 'powershell', 'pwsh'].includes(executable);
+  const script = args.join(' ');
+  const indirect = shell && /(?:^|[;&|\n\s])(?:\S*\/)?git\s+(?:(?:-C|-c|--git-dir|--work-tree)\s+\S+\s+)*(?:reset|restore|revert|checkout|switch)(?:\s|$)/i.test(script);
+  if (direct || indirect) mutationFail14('ENTROROVE_ROLLBACK_PROOF_REQUIRED',
+    'Direct rollback commands cannot run through an ordinary validation plan; use the independently signed exact-image rollback entry, preserving original transaction and failure records');
+  if (shell && /(?:^|[;&|\n\s])(?:\S*\/)?(?:npm|pnpm|yarn|bun)\s+(?:i|install|add|update|upgrade|ci|exec|dlx)(?:\s|$)/i.test(script)) {
+    mutationFail14('ENTROROVE_PACKAGE_PROVENANCE_REQUIRED', 'Shell-wrapped package replacement cannot prove its destination or frozen inputs; use a direct frozen package-manager plan or the managed installer');
+  }
+}
+function assertFrozenInstall(authority) {
+  const policy = authority.plan.policy, executable = path.basename(policy.executable).replace(/\.(?:exe|cmd)$/i, '').toLowerCase();
+  const args = policy.args ?? [], operation = args.find(value => ['i', 'install', 'add', 'update', 'upgrade', 'ci', 'exec', 'dlx'].includes(value));
+  if (!['npm', 'pnpm', 'yarn', 'bun'].includes(executable) || !operation) return;
+  const install = ['install', 'i', 'ci'].includes(operation);
+  const frozen = executable === 'npm' ? operation === 'ci' : args.includes('--frozen-lockfile') || executable === 'yarn' && args.includes('--immutable');
+  const files = authority.plan.files ?? [], manifest = files.some(file => file.path === 'package.json');
+  const lock = files.some(file => (executable === 'npm' ? ['package-lock.json', 'npm-shrinkwrap.json']
+    : executable === 'pnpm' ? ['pnpm-lock.yaml'] : executable === 'yarn' ? ['yarn.lock'] : ['bun.lock', 'bun.lockb']).includes(file.path));
+  const positional = args.slice(args.indexOf(operation) + 1).filter((value, index, rest) => !value.startsWith('-') && !(index && rest[index - 1].startsWith('--')));
+  if (!install || !frozen || !manifest || !lock || positional.length || args.some(value => /^(?:--prefix|--dir|--cwd|--global|-g|--force)(?:=|$)/.test(value))) {
+    mutationFail14('ENTROROVE_PACKAGE_PROVENANCE_REQUIRED', 'Ordinary runner package installation requires its actual frozen manifest/lock in the original tested source set and no supplied package or destination override; use the managed installer for skill updates');
+  }
+}
+const packagePath = target => /(?:^|\/)(?:package|manifest)\.json$/i.test(target) || archiveFormat(target, Buffer.alloc(0));
+export async function replacementRunnerBefore(input, authority) {
+  assertNoBlindRollback(authority.plan.policy);
+  assertFrozenInstall(authority);
+  const originals = new Map(), writes = authority.plan.policy.discipline?.writes ?? [];
+  for (const write of writes) {
+    const current = await mutationTarget14(authority.root, write.targetPath, true);
+    if (current.exists) {
+      if (current.stat.size > 64 * 1024 * 1024) {
+        if (packagePath(write.targetPath)) mutationFail14('ENTROROVE_PACKAGE_VERSION_UNKNOWN', 'Package baseline exceeds bounded inspection; no process was started');
+        continue;
+      }
+      const bytes = (await mutationRead14(input, authority.root, write.targetPath)).content;
+      if (packagePath(write.targetPath) || archiveFormat(write.targetPath, bytes)) originals.set(write.targetPath, bytes);
+    }
+  }
+  return originals;
+}
+export async function replacementRunnerAfter(input, authority, before, after, changed, originals) {
+  const proof = { kind: 'approved-process-comparison', authorityDigest: authority.planFile?.sha256 ?? sha256(canonical(authority.plan)),
+    baselineManifestDigest: sha256(canonical(before)) };
+  for (const target of changed) {
+    const previous = before.files.find(file => file.path === target), current = after.files.find(file => file.path === target);
+    if (!previous || !current || previous.kind !== 'file' || current.kind !== 'file') continue;
+    await assertRollbackCandidate(input, authority.root, target, previous.sha256, current.sha256);
+    if (previous.sha256 !== current.sha256 && (packagePath(target) || originals.has(target))) {
+      if (!originals.has(target)) mutationFail14('ENTROROVE_PACKAGE_VERSION_UNKNOWN', 'Process replaced an undeclared package without a verifiable original image; preserve this failed run and unknown effects');
+      const state = await mutationTarget14(authority.root, target);
+      if (state.stat.size > 64 * 1024 * 1024) mutationFail14('ENTROROVE_PACKAGE_VERSION_UNKNOWN', 'Replacement exceeds bounded package inspection');
+      assertPackageReplacement(target, originals.get(target), (await mutationRead14(input, authority.root, target)).content);
+    }
+    await rememberRollbackBaseline(input, authority.root, target, previous.sha256, proof);
+  }
+}

package/scope-amendment-client.mjs

@@ -113,7 +113,7 @@ export async function runScopeAmend(repositoryRoot, input, dependencies) {
     return { schemaVersion, status: 'blocked', flowId: input?.flowId,
       code: error?.code?.startsWith('ENTROROVE_') ? error.code : 'ENTROROVE_SCOPE_AMENDMENT_PREREQUISITE',
       message: ['ENTROROVE_SCOPE_AMENDMENT_BINDING', 'ENTROROVE_SCOPE_AMENDMENT_STATE', 'ENTROROVE_SCOPE_AMENDMENT_UNKNOWN',
-        'ENTROROVE_SCOPE_AMENDMENT_NOT_SENT'].includes(error?.code) ? error.message
+        'ENTROROVE_SCOPE_AMENDMENT_NOT_SENT', 'ENTROROVE_SCOPE_AMENDMENT_MUTATION_PENDING'].includes(error?.code) ? error.message
         : 'Scope amendment stopped; preserve the original proposal, signer, journal and actual evidence.',
       ...(requestId ? { requestId } : {}), ...(error?.output ? { output: error.output } : {}),
       ...(error?.feedback ? { feedback: error.feedback } : {}),

package/scope-amendment-consumption.mjs

@@ -0,0 +1,32 @@
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { mutationFail14, privateMutationDirectory14 } from './local-mutation-files.mjs';
+import { preservedMutationConsumptionState, attestMutationConsumption14 } from './local-mutation-consumption.mjs';
+import { readMutationConnection } from './mutation-connection-state.mjs';
+
+export async function observeScopeMutationConsumption(location, state, pass) {
+  // A pending S keeps its exact old attestation and is recovered with GET. A
+  // new signed S challenge can observe the same physical writes afresh, but
+  // must not fork an unresolved settlement of that original M receipt.
+  if (state.pending || state.attestation) mutationFail14('ENTROROVE_SCOPE_AMENDMENT_MUTATION_PENDING',
+    'Recover the original pending scope request before observing its M consumption again');
+  const input = { repositoryRoot: location.root, home: location.home,
+    flowId: pass.flowId, taskId: pass.taskId, stepId: pass.stepId, gatePassPath: location.identity.gatePassPath };
+  const original = await preservedMutationConsumptionState(input), { binding } = original;
+  if (canonical(original.pass) !== canonical(pass)) mutationFail14('ENTROROVE_SCOPE_AMENDMENT_BINDING', 'Original mutation pass changed');
+  const directory = path.join(binding.directory, 'settlements');
+  await privateMutationDirectory14(directory, { privateFrom: binding.stateRoot });
+  const journal = { ...binding, file: path.join(directory, `${pass.passId}.json`) };
+  const identity = { flowId: pass.flowId, stepId: pass.stepId, passDigest: sha256(canonical(pass)),
+    repositoryRoot: binding.root, apiOrigin: location.identity.apiOrigin, mutationKeyId: binding.binding.keyId };
+  return withStateLock(journal.file, async () => {
+    const settlement = await readMutationConnection(journal, identity);
+    if (settlement.pending || settlement.settled) mutationFail14('ENTROROVE_SCOPE_AMENDMENT_MUTATION_PENDING',
+      'Recover the original mutation-settle request before a fresh scope observation; do not replace its receipt');
+    // Renewal re-reads every original target and protected file, verifies the
+    // old signature and write times, and archives the expired observation.
+    // The original pass, write ledger and their expiry remain unchanged.
+    return attestMutationConsumption14(input, { renewExpired: true });
+  });
+}

package/scope-amendment-mutation.mjs

@@ -1,6 +1,6 @@
 import { mutationPass14 } from './local-mutation-wire.mjs';
 import { readMutationJson14 } from './local-mutation-files.mjs';
-import { attestMutationConsumption14 } from './local-mutation-consumption.mjs';
+import { observeScopeMutationConsumption } from './scope-amendment-consumption.mjs';
 import { amendmentFail } from './scope-amendment-wire.mjs';
 import path from 'node:path';
 import { sha256 } from './local-integrity.mjs';
@@ -20,7 +20,6 @@ export async function scopeAmendmentMutation(location, state, challenge, facts)
     || pass.memberScopeKeyId !== challenge.keyId || pass.memberScopeBindingDigest !== challenge.originalBindingDigest
     || pass.scopeRevisionDigest !== challenge.authorityRevisionDigest
     || changed.some(file => !pass.paths.includes(file.path))) amendmentFail('Scope refresh cannot replace its actual original mutation pass or approved write paths');
-  const observed = await attestMutationConsumption14({ repositoryRoot: location.root, home: location.home,
-    flowId: pass.flowId, taskId: pass.taskId, stepId: pass.stepId, gatePassPath }, { allowExpiredReplay: true });
+  const observed = await observeScopeMutationConsumption(location, state, pass);
   return { passId: pass.passId, consumptionReceipt: observed.consumptionReceipt };
 }

package/scope-amendment-observer.mjs

@@ -27,7 +27,8 @@ export async function observeScopeAmendment(location, state) {
   if (!state.snapshotId) { state.snapshotId = `scope-amend-${randomUUID()}`; await saveScopeAmendmentState(location, state); }
   const input = { repositoryRoot: location.root, home: location.home, flowId: challenge.flowId, stepId: challenge.stepId,
     snapshotId: state.snapshotId, paths: challenge.files.map(file => file.path).sort(),
-    contractDigest: challenge.proposalDigest, importContexts: location.binding.importContexts };
+    contractDigest: challenge.proposalDigest, importContexts: location.binding.importContexts,
+    scopeCreatePaths: challenge.files.filter(file => file.access === 'create').map(file => file.path) };
   if (!state.snapshot) {
     if (!state.snapshotStarted) {
       state.snapshotStarted = true; await saveScopeAmendmentState(location, state);

package/scope-amendment-remote.mjs

@@ -6,6 +6,7 @@ import { acknowledgeAutomaticFeedback, queryAutomaticFeedback, verifyAutomaticFe
 import { readInvocations } from './local-invocations.mjs';
 import { saveScopeAmendmentState } from './scope-amendment-state.mjs';
 import { amendmentFail } from './scope-amendment-wire.mjs';
+import { retireMissingChallenge } from './scope-amendment-retirement.mjs';
 
 const unknown = requestId => Object.assign(new Error('Scope amendment outcome is unknown; recover the original request with GET only'),
   { code: 'ENTROROVE_SCOPE_AMENDMENT_UNKNOWN', outcomeUnknown: true, requestId });
@@ -15,13 +16,16 @@ async function recover(pending, dependencies) {
     const response = await requestTransport(origin, `/api/skill/status/${pending.requestId}`, {
       headers: { authorization: `Bearer ${token}`, ...ideClientHeaders() } });
     const result = parseTransportResponse(response, 'original scope amendment status');
+    if (response.status === 404 && result?.error === 'request-not-found') {
+      throw Object.assign(unknown(pending.requestId), { requestNotFound: true });
+    }
     if (result?.output?.requestId !== pending.requestId || response.status >= 500
       || ['running', 'pending'].includes(result.output.status)) throw unknown(pending.requestId);
     result.feedback ??= await queryAutomaticFeedback(pending.requestId, dependencies);
     verifyAutomaticFeedback(result.feedback, pending.requestId, pending.requestId);
     result.feedback = await acknowledgeAutomaticFeedback(result.feedback, origin, token, ideClientHeaders());
     return { response, result };
-  } catch { throw unknown(pending.requestId); }
+  } catch (error) { throw error?.requestNotFound ? error : unknown(pending.requestId); }
 }
 async function notSent(pending, home) {
   try {
@@ -36,7 +40,13 @@ export async function amendmentRemote(stage, operation, payload, state, location
     if (state.pending.stage !== stage || state.pending.requestId !== requestId || canonical(state.pending.input) !== canonical(input)) {
       amendmentFail('Recover the original amendment request before another operation');
     }
-    ({ response, result } = await recover(state.pending, dependencies));
+    if (state.challengeRetirement) await retireMissingChallenge(state, location, dependencies, recover, notSent);
+    try { ({ response, result } = await recover(state.pending, dependencies)); }
+    catch (error) {
+      if (!error?.requestNotFound || stage !== 'challenged') throw error;
+      await retireMissingChallenge(state, location, dependencies, recover, notSent);
+      ({ response, result } = await recover(state.pending, dependencies));
+    }
   } else {
     state.pending = { stage, operation: 'continue', input, requestId };
     await saveScopeAmendmentState(location, state);

package/scope-amendment-retirement.mjs

@@ -0,0 +1,54 @@
+import { canonical, sha256 } from './local-integrity.mjs';
+import { buildInvocation, invokeRemoteResult } from './remote-client.mjs';
+import { scopeRevisionAuthority, amendmentFail } from './scope-amendment-wire.mjs';
+import { saveScopeAmendmentState } from './scope-amendment-state.mjs';
+
+export async function retireMissingChallenge(state, location, dependencies, recover, notSent) {
+  const original = state.pending;
+  if (original.stage !== 'challenged' || original.input.operation !== 'workflow-scope-challenge') {
+    amendmentFail('Only the original missing challenge preparation has a retirement path');
+  }
+  const input = { requestId: original.requestId, flowId: original.input.flowId, payload: original.input.payload };
+  const call = buildInvocation('scope-challenge-retire', input);
+  let attempt = state.challengeRetirement;
+  if (attempt && (attempt.requestId !== call.requestId || canonical(attempt.input) !== canonical(input))) {
+    amendmentFail('Challenge retirement must retain its original preparation envelope');
+  }
+  if (!attempt) {
+    attempt = state.challengeRetirement = { requestId: call.requestId, input, state: 'pending' };
+    await saveScopeAmendmentState(location, state);
+    try {
+      const { result } = await invokeRemoteResult({ operation: 'scope-challenge-retire', input }, dependencies);
+      attempt.output = result.output; attempt.feedback = result.feedback; attempt.state = 'completed';
+      await saveScopeAmendmentState(location, state);
+    } catch (error) {
+      if (await notSent(attempt, dependencies.home)) {
+        attempt.state = 'not-sent'; await saveScopeAmendmentState(location, state);
+      }
+      throw error;
+    }
+  } else if (attempt.state !== 'completed') {
+    // A retirement with an uncertain outcome has its own original GET. Neither
+    // the original challenge nor the retirement is retransmitted here.
+    if (attempt.state === 'not-sent') {
+      delete state.challengeRetirement; await saveScopeAmendmentState(location, state);
+      return retireMissingChallenge(state, location, dependencies, recover, notSent);
+    }
+    const { result } = await recover(attempt, dependencies);
+    attempt.output = result.output; attempt.feedback = result.feedback; attempt.state = 'completed';
+    await saveScopeAmendmentState(location, state);
+  }
+  const output = attempt.output;
+  if (output?.requestId !== call.requestId) amendmentFail('Retirement lost its original request identity');
+  if (output.status === 'blocked' && output.result?.reason === 'original-admission-already-recorded') return;
+  if (output.status !== 'succeeded' || output.result?.retired !== true) amendmentFail('The server did not retire this original missing preparation');
+  const receipt = scopeRevisionAuthority(output.result.retirement, 'entrorove.scope-challenge-retirement/1.0');
+  if (receipt.purpose !== 'scope-challenge-retirement' || receipt.requestId !== original.requestId
+    || receipt.retirementRequestId !== call.requestId || receipt.flowId !== input.flowId
+    || receipt.proposalId !== input.payload.proposalId || receipt.proposalDigest !== input.payload.proposalDigest
+    || receipt.receiverId !== input.payload.receiverId || receipt.attemptId !== input.payload.attemptId
+    || receipt.originalInputDigest !== sha256(canonical(original.input)) || receipt.outcome !== 'retired-before-admission'
+    || ['claimsOriginalExecution', 'grantsExecutionAuthority', 'grantsWriteAuthority', 'claimsCompletion'].some(key => receipt[key] !== false)) {
+    amendmentFail('Challenge retirement changed its exact original preparation or authority boundary');
+  }
+}

package/scope-amendment-state.mjs

@@ -10,11 +10,14 @@ import { trustedOrigin } from './remote-transport.mjs';
 
 const fail = message => scopeFail('ENTROROVE_SCOPE_AMENDMENT_STATE', message);
 const maximumStateBytes = 1_000_000;
-async function privateItem(file, final = 'file') {
+// A journal retains the challenge, S proof, original pending request and full
+// signed response together. Each signed authority retains its own 1 MB bound.
+const maximumJournalBytes = 8_000_000;
+async function privateItem(file, final = 'file', maximumBytes = maximumStateBytes) {
   const value = await mutationFile14(file, { final });
   if (process.getuid && value.stat.uid !== process.getuid()
     || process.platform !== 'win32' && value.stat.mode & 0o077
-    || final === 'file' && (value.stat.nlink !== 1 || value.stat.size > maximumStateBytes)) {
+    || final === 'file' && (value.stat.nlink !== 1 || value.stat.size > maximumBytes)) {
     fail('Scope amendment controls must be bounded private files owned by the current OS account');
   }
   return value;
@@ -80,7 +83,7 @@ export async function scopeAmendmentLocation(repositoryRoot, input, dependencies
 }
 export async function readScopeAmendmentState(location) {
   let value;
-  try { await privateItem(location.file); value = await readMutationJson14(location.file); }
+  try { await privateItem(location.file, 'file', maximumJournalBytes); value = await readMutationJson14(location.file); }
   catch (error) { if (error.code !== 'ENOENT') throw error; }
   if (!value) return { schemaVersion: 'entrorove.scope-amendment-state/1.0', identity: location.identity };
   if (value.schemaVersion !== 'entrorove.scope-amendment-state/1.0'
@@ -89,6 +92,6 @@ export async function readScopeAmendmentState(location) {
   return value;
 }
 export async function saveScopeAmendmentState(location, value) {
-  if (Buffer.byteLength(canonical(value)) > maximumStateBytes) fail('Scope amendment state exceeds its bounded private file limit');
+  if (Buffer.byteLength(canonical(value)) + 1 > maximumJournalBytes) fail('Scope amendment state exceeds its bounded private file limit');
   return atomicMutationJson14(location.file, value, { privateFrom: location.stateRoot, replace: true });
 }

package/task-entry-client.mjs

@@ -28,5 +28,6 @@ export async function routeTaskEntry(data, token, dependencies) {
   if (!task || typeof task.goal !== 'string') throw new Error('Task entry requires the original task goal');
   const ideTaskId = ideTaskIdentity(data.ideTaskId);
   return runCloudTask({ goal: task.goal, task,
+    ...(data.images === undefined ? {} : { images: data.images }),
     ...(ideTaskId ? { ideTaskId } : {}),...(choice ? { sandboxChoice: choice } : {}) },dependencies);
 }

package/version.mjs

@@ -1,8 +1,25 @@
+// SemVer 2 precedence, without Number rounding or lexical version ordering.
+export function versionParts(value) {
+  const match = typeof value === 'string' && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/.exec(value);
+  if (!match || match[4]?.split('.').some(part => /^\d+$/.test(part) && part.length > 1 && part[0] === '0')) {
+    throw Object.assign(new Error('Package version must be an unambiguous SemVer value'), { code: 'ENTROROVE_PACKAGE_VERSION_UNKNOWN' });
+  }
+  return { core: match.slice(1, 4).map(BigInt), pre: match[4]?.split('.') ?? [] };
+}
 export function compareVersions(left, right) {
-  const a = left.split('.').map(Number);
-  const b = right.split('.').map(Number);
+  const a = versionParts(left), b = versionParts(right);
   for (let index = 0; index < 3; index += 1) {
-    if (a[index] !== b[index]) return a[index] - b[index];
+    if (a.core[index] !== b.core[index]) return a.core[index] > b.core[index] ? 1 : -1;
+  }
+  if (!a.pre.length || !b.pre.length) return a.pre.length === b.pre.length ? 0 : a.pre.length ? -1 : 1;
+  for (let index = 0; index < Math.max(a.pre.length, b.pre.length); index += 1) {
+    const x = a.pre[index], y = b.pre[index];
+    if (x === y) continue;
+    if (x === undefined || y === undefined) return x === undefined ? -1 : 1;
+    const numericX = /^\d+$/.test(x), numericY = /^\d+$/.test(y);
+    if (numericX && numericY) return BigInt(x) > BigInt(y) ? 1 : -1;
+    if (numericX !== numericY) return numericX ? -1 : 1;
+    return x > y ? 1 : -1;
   }
   return 0;
 }

package/workflow-local-runner.mjs

@@ -312,6 +312,15 @@ export async function observeWorkflowLocalStep(rawInput) {
     return { ...structuredClone(state.result), cached: true };
   }));
 }
+export function verifyOriginalWorkflowPlan(value) {
+  const configured = publicKey(process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY?.trim(), 'ENTROROVE_WORKFLOW_AUTHORITY_KEY');
+  const plan = validatePlan(verifyAuthority(value, configured));
+  lifetime(plan.acceptedAt, plan.expiresAt, MAX_PLAN_MS, Date.now());
+  return plan;
+}
+export function verifyOriginalWorkflowAuthority(value) {
+  return verifyAuthority(value, publicKey(process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY?.trim(), 'ENTROROVE_WORKFLOW_AUTHORITY_KEY'));
+}
 export async function runWorkflowLocalStep(rawInput) {
   let input; try { input = structuredClone(rawInput); } catch { fail('ENTROROVE_WORKFLOW_JSON', 'workflow values must be finite JSON'); }
   const authority = await prepare(input);

package/workflow-observation-client.mjs

@@ -5,6 +5,7 @@ const safeId = value => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:-
 const safeRequest = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
 const messages = {
   ENTROROVE_LOCAL_OBSERVATION_UNKNOWN: 'Original observation outcome is unknown; recover its original GET without repeating execution',
+  ENTROROVE_LOCAL_OBSERVATION_REJECTED: 'Original observation request failed and was acknowledged; repair its cause and read the original live task guidance',
   ENTROROVE_LOCAL_OBSERVATION_NOT_SENT: 'Observation was not transmitted; repair its local or discovery prerequisite and reuse the original input',
   ENTROROVE_LOCAL_OBSERVATION_PREREQUISITE: 'Local observation requires cloud sandbox disabled and its original live execution lease',
   ENTROROVE_SCOPE_RECEIPT_EXPIRED: 'Refresh the original scope evidence and reuse the original observation input',
@@ -24,6 +25,11 @@ function blocked(error, input) {
       'ENTROROVE_SCOPE_RUNNER_REQUIRED', 'ENTROROVE_SCOPE_SNAPSHOT_REQUIRED', 'ENTROROVE_SCOPE_AFTER_WRITE_REQUIRED'].includes(code));
   const reason = ['sandbox-enabled', 'cloud-sandbox-enabled', 'lease-expired', 'receipt-expired', 'after-write-observation-required'].includes(output?.reason)
     ? output.reason : undefined;
+  const rejected = code === 'ENTROROVE_LOCAL_OBSERVATION_REJECTED' && cause.knownTerminalFailure === true
+    && requestId && cause.rejection?.status === 'failed' && cause.rejection.acknowledged === true
+    && /^[a-f0-9-]{36}$/.test(cause.rejection.receiptId ?? '')
+    && Number.isSafeInteger(cause.rejection.generation) && cause.rejection.generation > 0
+    && ['member-observation-admit', 'member-observation-report'].includes(cause.rejection.operation);
   return { schemaVersion: 'entrorove.local-observation-connection/1.0', status: 'blocked',
     ...(safeId(input?.flowId) ? { flowId: input.flowId } : {}), independentValidation: 'pending', code,
     message: messages[code] ?? 'Local observation could not continue; its original command and result remain preserved',
@@ -33,6 +39,11 @@ function blocked(error, input) {
         ...(safeRequest(output.requestId) ? { resumeRequestId: output.requestId } : {}) } } } : {}),
     ...(cause.outcomeUnknown === true && requestId ? { outcomeUnknown: true, requestId, repeatPost: false,
       nextAction: { operation: 'workflow-observe-step', reuseOriginalInput: true, method: 'GET' } } : {}),
+    ...(rejected ? { outcomeUnknown: false, requestId, repeatPost: false, grantsExecutionAuthority: false,
+      rejection: { operation: cause.rejection.operation, status: 'failed', receiptId: cause.rejection.receiptId,
+        generation: cause.rejection.generation, acknowledged: true, effects: 'not-inferred' },
+      nextAction: { operation: 'task-resume', input: { flowId: input.flowId }, preserveOriginalFlow: true,
+        localProcessMayStart: false, originalRequestRetained: true } } : {}),
     ...(cause.knownBeforeTransmission === true && requestId ? { requestId, knownBeforeTransmission: true } : {}) };
 }
 export async function runWorkflowObserveStep(repositoryRoot, input, dependencies) {

package/workflow-observation-connection.mjs

@@ -9,7 +9,8 @@ import { verifyWorkflowLocalAcceptance } from './workflow-local-acceptance.mjs';
 import { buildInvocation } from './remote-client.mjs';
 
 async function connect(input, state, location, dependencies) {
-  const fields = ['taskId', 'flowId', 'stepId', 'leaseId', 'generation', ...(Object.hasOwn(input, 'settlementId') ? ['settlementId'] : [])];
+  const fields = ['taskId', 'flowId', 'stepId', 'leaseId', 'generation', ...(Object.hasOwn(input, 'settlementId') ? ['settlementId'] : []),
+    ...(Object.hasOwn(input, 'dependencyRepairDigest') ? ['dependencyRepairDigest'] : [])];
   const original = Object.fromEntries(fields.map(key => [key, input[key]]));
   const admitted = state.admitted ?? await observationRemote('admitted', 'member-observation-admit', original, state, location, dependencies);
   const admission = observationAdmission(admitted.admission, input, { allowExpired: Boolean(state.result) });

package/workflow-observation-remote.mjs

@@ -51,6 +51,18 @@ function cachedReportPrerequisite(result, pending, state, location) {
     && next.reuseOriginalInput === true && next.resumeRequestId === pending.requestId && next.preserveOriginalFlow === true
     && result.feedback?.acknowledgement?.stored === true && result.feedback.resultDigest === sha256(canonical(output));
 }
+function terminalRejection(result, pending) {
+  const output = result?.output, feedback = result?.feedback, ack = feedback?.acknowledgement;
+  try { verifyAutomaticFeedback(feedback, pending.requestId, pending.requestId); } catch { return null; }
+  if (output?.schemaVersion !== 'entrorove.skill.response/1.0' || output.requestId !== pending.requestId
+    || output.status !== 'failed' || feedback.resultDigest !== sha256(canonical(output))
+    || feedback.evaluation.operation !== pending.operation || feedback.evaluation.status !== 'failed'
+    || ack?.stored !== true || ack.requestId !== pending.requestId || ack.receiptId !== feedback.receiptId
+    || ack.generation !== (feedback.generation ?? 1)) return null;
+  return { operation: pending.operation, status: 'failed', receiptId: feedback.receiptId,
+    generation: feedback.generation ?? 1, acknowledged: true, effects: 'not-inferred',
+    ...(/^[a-z][a-z0-9-]{0,63}$/.test(output.error ?? '') ? { error: output.error } : {}) };
+}
 export async function observationRemote(stage, operation, input, state, location, dependencies) {
   const requestId = buildInvocation(operation, input).requestId;
   let response, result;
@@ -79,6 +91,17 @@ export async function observationRemote(stage, operation, input, state, location
       throw Object.assign(new Error(result.output.message ?? 'Original local observation prerequisite is unresolved'),
         { code: result.output.code, output: result.output });
     }
+    const rejection = terminalRejection(result, state.pending);
+    if (rejection) {
+      const failure = { ...state.pending, output: result.output, feedback: result.feedback };
+      if (canonical(state.failures?.at(-1) ?? null) !== canonical(failure)) state.failures = [...(state.failures ?? []), failure];
+      state.rejection = failure;
+      // Keep the original pending binding: a known failure grants no retry,
+      // no replacement admission and no second launch of a cached process.
+      await saveObservationState(location, state);
+      throw Object.assign(new Error('The original observation request failed and its receipt was acknowledged'),
+        { code: 'ENTROROVE_LOCAL_OBSERVATION_REJECTED', knownTerminalFailure: true, requestId, rejection });
+    }
     throw unknown(requestId);
   }
   state[stage] = result.output; delete state.pending; await saveObservationState(location, state);
@@ -91,9 +114,11 @@ export async function authorizeObservation(admission, dependencies, launching) {
   const status = parseTransportResponse(response, 'original local observation account');
   if (!response.ok || status?.schemaVersion !== 'entrorove.flow-status/1.0'
     || status.flow?.flowId !== admission.flowId || status.flow.ownerId !== admission.ownerId
-    || launching && (status.flow.stepId !== admission.stepId || status.flow.status !== 'running'
+    || launching && (status.flow.stepId !== admission.stepId && !memberProducerRepairStepMatches(status, admission)
+      || status.flow.status !== 'running'
       || status.workflow?.phase !== 'execute' || status.workflow.terminalAt
       || ['pending', 'declined'].includes(status.workflow.authorization))) {
     observationFail('Current account cannot confirm its original local observation task and execution step');
   }
 }
+import { memberProducerRepairStepMatches } from './member-producer-repair-authority.mjs';