@entrorove/skill 0.1.68 → 0.1.69

package/remote-client.mjs

@@ -40,6 +40,7 @@ export function buildInvocation(operation, input) {
     'handoff-prepare', 'handoff-release', 'handoff-claim', 'handoff-status', 'handoff-resume', 'handoff-execution-authority', 'mutation-snapshot-challenge', 'mutation-pass-issue', 'mutation-pass-settle',
     'member-observation-admit', 'member-observation-report', 'member-observation-status',
     'scope-runner-prepare', 'scope-runner-register', 'scope-runner-challenge', 'scope-runner-attest',
+    'scope-runner-context-review', 'scope-runner-context-status', 'scope-runner-context-challenge', 'scope-runner-context-apply',
     'start', 'continue'].includes(operation)) throw new Error('Invalid entrorove operation');
   if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('Input must be a JSON object');
   const id = requestId(operation, input);

package/scope-amendment-observer.mjs

@@ -27,7 +27,9 @@ 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.contextAuthority?.record.importContexts ?? location.binding.importContexts,
+    ...(location.contextAuthority ? { contextRevisionDigest: location.contextAuthority.revisionDigest,
+      contextEvidence: location.contextAuthority.record.evidence } : {}),
     scopeCreatePaths: challenge.files.filter(file => file.access === 'create').map(file => file.path) };
   if (!state.snapshot) {
     if (!state.snapshotStarted) {

package/scope-amendment-state.mjs

@@ -7,6 +7,7 @@ import { retainedScope } from './local-scope-state.mjs';
 import { mutationHome14, mutationFile14, privateMutationDirectory14,
   readMutationJson14, atomicMutationJson14 } from './local-mutation-files.mjs';
 import { trustedOrigin } from './remote-transport.mjs';
+import { boundScopeContexts } from './scope-context-state.mjs';
 
 const fail = message => scopeFail('ENTROROVE_SCOPE_AMENDMENT_STATE', message);
 const maximumStateBytes = 1_000_000;
@@ -78,8 +79,9 @@ export async function scopeAmendmentLocation(repositoryRoot, input, dependencies
     originalFactsDigest: original.originalFactsDigest, originalSnapshotDigest: original.originalSnapshot.digest };
   const directory = path.join(base, 'amendments', sha256(canonical(input)));
   await privateMutationDirectory14(directory, { privateFrom: stateRoot });
+  const contextAuthority = await boundScopeContexts(base, binding, dependencies);
   return { root, home, stateRoot, directory, file: path.join(directory, 'journal.json'), identity,
-    binding, key, signerConfigPath, original };
+    binding, key, signerConfigPath, original, contextAuthority };
 }
 export async function readScopeAmendmentState(location) {
   let value;

package/scope-context-client.mjs

@@ -0,0 +1,134 @@
+import path from 'node:path';
+import { randomUUID, sign } from 'node:crypto';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { atomicMutationJson14, readMutationJson14 } from './local-mutation-files.mjs';
+import { bootstrapCloudMutationAuthority } from './cloud-mutation-authority.mjs';
+import { contextInput, contextFail, retainedContexts, originalContextDigest, contextChallenge } from './scope-context-wire.mjs';
+import { scopeContextLocation, effectiveScopeContexts, retainContextAuthority,
+  readContextJournal, saveContextJournal } from './scope-context-state.mjs';
+import { contextRemote } from './scope-context-remote.mjs';
+import { inspectContextEvidence, observeScopeContext } from './scope-context-observer.mjs';
+
+const schemaVersion = 'entrorove.scope-context-connection/1.0';
+async function archive(location, state) {
+  if (!state.attemptId) return;
+  const file = path.join(location.directory, `${state.attemptId}-${sha256(canonical(state))}.json`);
+  try { if (canonical(await readMutationJson14(file)) !== canonical(state)) contextFail('Context attempt history changed'); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; await atomicMutationJson14(file, state, { privateFrom: location.stateRoot }); }
+}
+async function journal(location, input) {
+  let state = await readContextJournal(location, input);
+  if (state.previous || input.action === 'status' && state.completed
+    || input.action === 'apply' && state.completed && !state.applied || state.rejection && !state.pending) {
+    await archive(location, state.previous ?? state); state = {};
+  }
+  if (!state.attemptId) {
+    state = { schemaVersion: 'entrorove.scope-context-journal/1.0', localBindingDigest: location.localBindingDigest,
+      input, attemptId: randomUUID() }; await saveContextJournal(location, state);
+  }
+  return state;
+}
+function proposalFor(status, input, location) {
+  const proposal = status.proposal;
+  if (!proposal || proposal.proposalId !== input.proposalId || proposal.proposalDigest !== input.proposalDigest
+    || ['flowId', 'runnerId', 'repositoryId', 'keyId'].some(field => proposal[field] !== location.binding[field])
+    || proposal.localBindingDigest !== location.localBindingDigest
+    || canonical(proposal.targetPaths) !== canonical(location.binding.targetPaths)
+    || !['pending', 'approved', 'declined'].includes(proposal.approval?.status)) contextFail('Current account has no matching original context proposal');
+  retainedContexts(location.binding.importContexts, proposal.importContexts); return proposal;
+}
+function waiting(value, flowId) {
+  const status = value.proposal?.approval?.status;
+  return { ...value, schemaVersion, status: status === 'declined' ? 'blocked' : 'needs-input', flowId,
+    grantsExecutionAuthority: false, claimsCompletion: false,
+    nextStep: value.nextStep ?? { operation: 'interaction-answer', requiresOriginalOwnerApproval: true,
+      interactionId: value.proposal?.approval?.interactionId, interactionDigest: value.proposal?.approval?.interactionDigest } };
+}
+async function liveStatus(location, state, dependencies) {
+  if (!state.checked) await contextRemote('checked', 'scope-runner-context-status', {
+    flowId: location.binding.flowId, attemptId: state.attemptId }, state, location, dependencies);
+  const effective = await effectiveScopeContexts(location);
+  if (!Number.isSafeInteger(state.checked.expectedRevision) || state.checked.expectedRevision !== (effective?.record.revision ?? 0)) contextFail('Live context revision differs from its retained original history');
+  if ((state.checked.effective?.revisionDigest ?? null) !== (effective?.revisionDigest ?? null)) contextFail('Live context head differs from retained signed history; recover its original apply request');
+  return state.checked;
+}
+async function review(location, state, dependencies) {
+  if (state.reviewed) return waiting(state.reviewed, location.binding.flowId);
+  const status = await liveStatus(location, state, dependencies), head = await effectiveScopeContexts(location), input = state.input;
+  retainedContexts(head?.record.importContexts ?? location.binding.importContexts, input.importContexts);
+  if (!state.proposal) {
+    const evidence = await inspectContextEvidence(location, input.importContexts, input.evidencePaths);
+    state.proposal = { schemaVersion: 'entrorove.scope-context-proposal/1.0', flowId: location.binding.flowId,
+      runnerId: location.binding.runnerId, repositoryId: location.binding.repositoryId, keyId: location.binding.keyId,
+      localBindingDigest: location.localBindingDigest, expectedRevision: status.expectedRevision,
+      previousDigest: head?.revisionDigest ?? originalContextDigest(location), originalImportContexts: location.binding.importContexts,
+      importContexts: input.importContexts, evidence, reason: input.reason, attemptId: state.attemptId };
+    state.signature = sign(null, Buffer.from(canonical(state.proposal)), location.key).toString('base64url');
+    await saveContextJournal(location, state);
+  }
+  const output = await contextRemote('reviewed', 'scope-runner-context-review', { flowId: location.binding.flowId,
+    proposal: state.proposal, signature: state.signature }, state, location, dependencies);
+  state.completed = true; await saveContextJournal(location, state); return waiting(output, location.binding.flowId);
+}
+async function applied(location, state) {
+  const effective = state.applied.contextAuthority;
+  const challenge = contextChallenge(state.challenged.challenge, location, state.proposal, { allowExpired: true });
+  if (state.applied.grantsExecutionAuthority !== false || !effective?.record
+    || canonical(effective.record.attestation) !== canonical(state.attestation)
+    || ['proposalId', 'proposalDigest', 'ownerId', 'taskDigest', 'chainDigest'].some(field => effective.record[field] !== challenge[field])
+    || canonical(effective.record.importContexts) !== canonical(challenge.importContexts)
+    || canonical(effective.record.evidence) !== canonical(challenge.evidence)) contextFail('Applied context authority differs from this exact actual candidate');
+  const retained = await retainContextAuthority(location, effective);
+  state.completed = true; await saveContextJournal(location, state);
+  return { schemaVersion, status: 'succeeded', flowId: location.binding.flowId, contextRevisionDigest: retained.revisionDigest,
+    revision: retained.record.revision, grantsExecutionAuthority: false, claimsCompletion: false, nextOperation: 'scope-connect',
+    nextInput: { flowId: location.binding.flowId, paths: [...location.binding.targetPaths], importContexts: retained.record.importContexts } };
+}
+async function apply(location, state, dependencies) {
+  if (state.applied) return applied(location, state);
+  const status = await liveStatus(location, state, dependencies), proposal = proposalFor(status, state.input, location);
+  if (proposal.approval.status !== 'approved') {
+    state.completed = true; await saveContextJournal(location, state); return waiting(status, location.binding.flowId);
+  }
+  state.proposal = proposal; await saveContextJournal(location, state);
+  if (!state.challenged) await contextRemote('challenged', 'scope-runner-context-challenge', { flowId: location.binding.flowId,
+    proposalId: proposal.proposalId, proposalDigest: proposal.proposalDigest, attemptId: state.attemptId }, state, location, dependencies);
+  contextChallenge(state.challenged.challenge, location, proposal);
+  if (!state.attestation) {
+    state.attestation = await observeScopeContext(location, state, proposal); await saveContextJournal(location, state);
+  }
+  await contextRemote('applied', 'scope-runner-context-apply', { flowId: location.binding.flowId,
+    proposalId: proposal.proposalId, proposalDigest: proposal.proposalDigest, attestation: state.attestation }, state, location, dependencies);
+  return applied(location, state);
+}
+async function run(location, input, dependencies) {
+  const state = await journal(location, input);
+  if (state.pending) await contextRemote(state.pending.stage, state.pending.operation, state.pending.input, state, location, dependencies);
+  try {
+    if (input.action === 'review') return await review(location, state, dependencies);
+    if (input.action === 'apply') return await apply(location, state, dependencies);
+    const status = await liveStatus(location, state, dependencies);
+    state.completed = true; await saveContextJournal(location, state);
+    return { schemaVersion, ...status, status: 'succeeded', flowId: input.flowId, grantsExecutionAuthority: false, claimsCompletion: false };
+  } catch (error) {
+    if (!state.pending) { state.rejection ??= { code: error.code, message: error.message }; await saveContextJournal(location, state); }
+    throw error;
+  }
+}
+export async function runScopeContext(repositoryRoot, input, dependencies) {
+  try {
+    contextInput(input); await dependencies.install();
+    if (!await dependencies.agreementAccepted(dependencies.home)) return dependencies.agreementRequired(dependencies.home);
+    await bootstrapCloudMutationAuthority(dependencies);
+    const location = await scopeContextLocation(repositoryRoot, input.flowId, dependencies);
+    return await withStateLock(path.join(location.base, 'connection'), () => run(location, input, dependencies));
+  } catch (error) {
+    return { schemaVersion, status: 'blocked', flowId: input?.flowId,
+      code: error?.code?.startsWith('ENTROROVE_') ? error.code : 'ENTROROVE_SCOPE_CONTEXT_PREREQUISITE',
+      message: error?.code?.startsWith('ENTROROVE_') ? error.message : 'Context recovery stopped; preserve original signer, binding, journal and evidence.',
+      ...(error?.requestId ? { requestId: error.requestId } : {}), ...(error?.output ? { output: error.output } : {}),
+      ...(error?.outcomeUnknown ? { outcomeUnknown: true, nextAction: { operation: 'scope-context', method: 'GET',
+        requestId: error.requestId, reuseOriginalInput: true, repeatPost: false } } : {}) };
+  }
+}

package/scope-context-observation.mjs

@@ -0,0 +1,42 @@
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationHome14, readMutationJson14 } from './local-mutation-files.mjs';
+import { contextPrivate, effectiveScopeContexts } from './scope-context-state.mjs';
+import { contextExact, contextFail, contextList } from './scope-context-wire.mjs';
+import { hydrateCloudMutationAuthority } from './cloud-mutation-authority.mjs';
+import { trustedOrigin } from './remote-transport.mjs';
+
+export async function scopeContextObservation(input, root, apiOrigin = 'https://entrorove.com') {
+  if (!input.flowId) return null;
+  const home = await mutationHome14(input.home), origin = trustedOrigin(apiOrigin);
+  const stateRoot = path.join(home, '.entrorove'), base = path.join(stateRoot, 'scope-runners', sha256(`${origin}:${input.flowId}:${root}`));
+  try { await contextPrivate(path.join(base, 'context-authority'), 'directory'); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  await contextPrivate(path.join(base, 'identity/binding.json'), 'file', 1_000_000);
+  const binding = await readMutationJson14(path.join(base, 'identity/binding.json'));
+  contextExact(binding, ['schemaVersion', 'flowId', 'repositoryRoot', 'apiOrigin', 'targetPaths', 'importContexts', 'runnerId', 'repositoryId', 'publicKey', 'keyId']);
+  if (binding.schemaVersion !== 'entrorove.local-scope-binding/1.0' || binding.flowId !== input.flowId
+    || binding.repositoryRoot !== root || binding.apiOrigin !== origin) contextFail('Snapshot contexts require their original local flow, root and repository binding');
+  contextList(binding.importContexts);
+  if (!await hydrateCloudMutationAuthority(home, origin)) contextFail('Snapshot context authority requires its existing private local public-key pin');
+  const head = await effectiveScopeContexts({ base, binding, localBindingDigest: sha256(canonical(binding)) });
+  if (!head) contextFail('Snapshot context history has no accepted signed head');
+  return { apiOrigin: origin, ...head };
+}
+function boundInput(input, context) {
+  if (!context) return input;
+  const fields = { importContexts: context.record.importContexts, contextRevisionDigest: context.revisionDigest,
+    contextEvidence: context.record.evidence };
+  if (Object.keys(fields).some(field => Object.hasOwn(input, field) && canonical(input[field]) !== canonical(fields[field]))) {
+    contextFail('Mutation observation cannot replace its original approved snapshot contexts');
+  }
+  return { ...input, ...fields };
+}
+export async function scopeContextSnapshotInput(input, root, context, { initial = false } = {}) {
+  if (context) contextExact(context, ['apiOrigin', 'record', 'revisionDigest']);
+  const current = await scopeContextObservation(input, root, context?.apiOrigin);
+  if (!context && current && !initial || context && (!current || canonical(context) !== canonical(current))) {
+    contextFail('Mutation snapshot context authority differs from its original signed same-flow history');
+  }
+  return { input: boundInput(input, context ?? (initial ? current : null)), context: context ?? (initial ? current : null) };
+}

package/scope-context-observer.mjs

@@ -0,0 +1,61 @@
+import { randomUUID, sign } from 'node:crypto';
+import { canonical } from './local-integrity.mjs';
+import { scopeRead, scopeTarget } from './local-scope-files.mjs';
+import { snapshotPlan, snapshotVerify } from './local-execution.mjs';
+import { collectScopeFacts } from './local-scope-repository.mjs';
+import { readScopeSnapshot, verifyFreshScopeSnapshot } from './local-scope-snapshot.mjs';
+import { attestScopeFacts } from './local-scope-signature.mjs';
+import { contextChallenge, contextFail } from './scope-context-wire.mjs';
+import { saveContextJournal } from './scope-context-state.mjs';
+
+export async function inspectContextEvidence(location, contexts, evidencePaths) {
+  const paths = new Set(evidencePaths);
+  for (const context of contexts) {
+    const directory = await scopeTarget(location.root, context.sourcePrefix);
+    if (!directory.stat.isDirectory()) contextFail('Context source prefix must be an actual repository directory');
+    paths.add(context.configPath);
+  }
+  if (paths.size > 200) contextFail('Context evidence exceeds its 200-file inspection bound');
+  const evidence = [];
+  for (const relative of [...paths].sort()) {
+    const target = await scopeTarget(location.root, relative);
+    if (!target.stat.isFile() || target.stat.size > 1_048_576) contextFail('Build evidence must be an actual ordinary bounded repository file');
+    const read = await scopeRead(location.root, relative, { repositoryRoot: location.root });
+    evidence.push({ path: relative, sha256: read.sha256 });
+  }
+  return evidence;
+}
+export async function observeScopeContext(location, state, proposal) {
+  const challenge = contextChallenge(state.challenged.challenge, location, proposal);
+  const evidence = await inspectContextEvidence(location, challenge.importContexts, challenge.evidence.map(file => file.path));
+  if (canonical(evidence) !== canonical(challenge.evidence)) contextFail('Actual build configuration or loader evidence changed since review');
+  if (!state.snapshotId) { state.snapshotId = `context-${randomUUID()}`; await saveContextJournal(location, state); }
+  const input = { repositoryRoot: location.root, home: location.home, flowId: challenge.flowId, stepId: challenge.stepId,
+    snapshotId: state.snapshotId, paths: [...location.binding.targetPaths], importContexts: challenge.importContexts,
+    contextRevisionDigest: proposal.proposalDigest, contextEvidence: challenge.evidence,
+    signerConfigPath: location.signerConfigPath, ownerId: challenge.ownerId,
+    task: challenge.task, taskDigest: challenge.taskDigest, chainDigest: challenge.chainDigest,
+    repositoryId: challenge.repositoryId, challenge: challenge.challenge };
+  if (!state.snapshot) {
+    if (state.snapshotStarted) contextFail('Interrupted context snapshot must be inspected before another observation; preserve its files');
+    state.snapshotStarted = true; await saveContextJournal(location, state);
+    try { state.snapshot = await snapshotPlan(input); }
+    catch (error) { delete state.snapshotStarted; await saveContextJournal(location, state); throw error; }
+    await saveContextJournal(location, state);
+  }
+  const verified = await snapshotVerify(input);
+  if (verified.verified !== true || verified.receipt.snapshotDigest !== state.snapshot.snapshotDigest) contextFail('Actual context candidate snapshot did not verify');
+  const snapshot = await readScopeSnapshot(input, location.root);
+  const facts = await collectScopeFacts(location.root, input.paths, undefined, snapshot.known, input);
+  facts.snapshotEvidence = await verifyFreshScopeSnapshot(input, location.root, facts);
+  const observed = await attestScopeFacts(input, { repositoryRoot: location.root, facts,
+    snapshotDigest: facts.snapshotEvidence.snapshotDigest }, { maximumExpiresAt: Date.parse(challenge.expiresAt) });
+  if (!observed.attestation || canonical(observed.attestation.importContexts) !== canonical(challenge.importContexts)
+    || observed.attestation.contextRevisionDigest !== proposal.proposalDigest
+    || Date.parse(observed.attestation.expiresAt) > Date.parse(challenge.expiresAt)) contextFail('Context candidate requires its actual purpose-bound original S proof');
+  const after = await inspectContextEvidence(location, challenge.importContexts, challenge.evidence.map(file => file.path));
+  if (canonical(after) !== canonical(evidence)) contextFail('Build evidence changed while observing its actual imports');
+  const core = { schemaVersion: 'entrorove.scope-context-attestation/1.0', challengeId: challenge.challengeId,
+    proposalDigest: proposal.proposalDigest, scopeAttestation: observed.attestation };
+  return { ...core, signature: sign(null, Buffer.from(canonical(core)), location.key).toString('base64url') };
+}

package/scope-context-release.mjs

@@ -0,0 +1,8 @@
+export const SCOPE_CONTEXT_SOURCE_FILES = [
+  'scope-context-client.mjs', 'scope-context-observer.mjs', 'scope-context-observation.mjs', 'scope-context-remote.mjs',
+  'scope-context-state.mjs', 'scope-context-wire.mjs', 'scope-context-release.mjs',
+]
+export const scopeContextReleaseNote = {
+  zh: '新增首次范围门禁前的构建上下文纠正：原账号审核真实配置和构建证据，原 S 签名完整路径快照，通过服务挑战追加上下文权威记录；保留原 flow、绑定、旧上下文和失败历史，不授予写入或完成权限。',
+  en: 'Add build-context recovery before the first scope gate: original owner review of actual configuration and build evidence, original S proof of all target paths, and challenge-bound append-only context authority. Preserve the original flow, binding, contexts and failures without granting writes or completion.',
+}

package/scope-context-remote.mjs

@@ -0,0 +1,60 @@
+import { canonical } from './local-integrity.mjs';
+import { buildInvocation, invokeRemoteResult } from './remote-client.mjs';
+import { requestTransport, parseTransportResponse } from './remote-transport.mjs';
+import { ideClientHeaders } from './ide-presentation.mjs';
+import { acknowledgeAutomaticFeedback, queryAutomaticFeedback, verifyAutomaticFeedback } from './automatic-feedback-client.mjs';
+import { readInvocations } from './local-invocations.mjs';
+import { saveContextJournal } from './scope-context-state.mjs';
+import { contextFail } from './scope-context-wire.mjs';
+
+const unknown = requestId => Object.assign(new Error('Context recovery outcome is unknown; query its original request with GET only'),
+  { code: 'ENTROROVE_SCOPE_CONTEXT_UNKNOWN', outcomeUnknown: true, requestId });
+async function recover(pending, dependencies) {
+  try {
+    const origin = dependencies.apiOrigin(), token = await dependencies.readCredential(dependencies.home);
+    const response = await requestTransport(origin, `/api/skill/status/${pending.requestId}`, {
+      headers: { authorization: `Bearer ${token}`, ...ideClientHeaders() } });
+    const result = parseTransportResponse(response, 'original context recovery status');
+    if (result?.output?.requestId !== pending.requestId || !response.ok || ['running', 'pending'].includes(result.output.status)) throw unknown(pending.requestId);
+    if (pending.operation !== 'scope-runner-context-status' || result.feedback) {
+      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); }
+}
+async function notSent(pending, home) {
+  try {
+    const rows = (await readInvocations(home)).filter(row => row.kind === 'remote' && row.requestId === pending.requestId);
+    return !rows.length || rows.at(-1).event === 'not-sent';
+  } catch (error) { return error.code === 'ENOENT'; }
+}
+export async function contextRemote(stage, operation, input, state, location, dependencies) {
+  const requestId = buildInvocation(operation, input).requestId; let response, result;
+  if (state.pending) {
+    if (state.pending.stage !== stage || state.pending.requestId !== requestId || state.pending.operation !== operation
+      || canonical(state.pending.input) !== canonical(input)) contextFail('Recover the original context POST before another operation');
+    ({ response, result } = await recover(state.pending, dependencies));
+  } else {
+    state.pending = { stage, operation, input, requestId }; await saveContextJournal(location, state);
+    try { ({ response, result } = await invokeRemoteResult({ operation, input }, dependencies)); }
+    catch (error) {
+      if (await notSent(state.pending, dependencies.home)) {
+        delete state.pending; await saveContextJournal(location, state);
+        throw Object.assign(new Error('Context request was not transmitted; repair its prerequisite and reuse the original input'),
+          { code: 'ENTROROVE_SCOPE_CONTEXT_NOT_SENT', knownBeforeTransmission: true, requestId });
+      }
+      throw unknown(requestId);
+    }
+  }
+  if (!result?.output || result.output.requestId !== requestId) throw unknown(requestId);
+  if (result.feedback) state.feedback = result.feedback;
+  if (!response.ok || !['succeeded', 'needs-input'].includes(result.output.status)) {
+    state.rejection = { requestId, output: result.output }; delete state.pending; await saveContextJournal(location, state);
+    throw Object.assign(new Error('Original context request was rejected; preserve its exact evidence and history'),
+      { code: result.output.code ?? 'ENTROROVE_SCOPE_CONTEXT_REJECTED', requestId, output: result.output });
+  }
+  state[stage] = result.output.result ?? result.output; delete state.pending; await saveContextJournal(location, state);
+  return state[stage];
+}

package/scope-context-state.mjs

@@ -0,0 +1,88 @@
+import { constants, promises as fs } from 'node:fs';
+import { createPrivateKey, createPublicKey } from 'node:crypto';
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { scopeRoot, scopePath } from './local-scope-files.mjs';
+import { mutationHome14, mutationFile14, readMutationJson14, atomicMutationJson14,
+  privateMutationDirectory14 } from './local-mutation-files.mjs';
+import { trustedOrigin } from './remote-transport.mjs';
+import { contextExact, contextFail, contextList, validateContextAuthority } from './scope-context-wire.mjs';
+import { hydrateCloudMutationAuthority, bootstrapCloudMutationAuthority } from './cloud-mutation-authority.mjs';
+
+export async function contextPrivate(file, final = 'file', maximumBytes = 8_000_000) {
+  const item = await mutationFile14(file, { final });
+  if (process.getuid && item.stat.uid !== process.getuid() || process.platform !== 'win32' && item.stat.mode & 0o077
+    || final === 'file' && (item.stat.nlink !== 1 || item.stat.size > maximumBytes)) contextFail('Context recovery controls must be bounded private files owned by this OS account');
+  return item;
+}
+async function privateText(file) {
+  const before = await contextPrivate(file, 'file', 1_000_000);
+  const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const opened = await handle.stat(), text = await handle.readFile('utf8'), after = await handle.stat(), latest = await contextPrivate(file);
+    if ([opened, after, latest.stat].some(stat => ['dev', 'ino', 'size', 'mtimeMs', 'ctimeMs', 'mode'].some(field => stat[field] !== before.stat[field]))) contextFail('Original context signer changed while reading');
+    return text;
+  } finally { await handle.close(); }
+}
+export async function scopeContextLocation(repositoryRoot, flowId, dependencies) {
+  const root = await scopeRoot(repositoryRoot), home = await mutationHome14(dependencies.home), apiOrigin = trustedOrigin(dependencies.apiOrigin());
+  const relative = path.relative(root, home);
+  if (!relative || relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)) contextFail('Context controls must remain outside the observed repository');
+  const stateRoot = path.join(home, '.entrorove'), base = path.join(stateRoot, 'scope-runners', sha256(`${apiOrigin}:${flowId}:${root}`)), controls = path.join(base, 'identity');
+  for (const directory of [stateRoot, path.dirname(base), base, controls]) await contextPrivate(directory, 'directory');
+  const binding = JSON.parse(await privateText(path.join(controls, 'binding.json')));
+  contextExact(binding, ['schemaVersion', 'flowId', 'repositoryRoot', 'apiOrigin', 'targetPaths', 'importContexts', 'runnerId', 'repositoryId', 'publicKey', 'keyId']);
+  if (binding.schemaVersion !== 'entrorove.local-scope-binding/1.0' || binding.flowId !== flowId || binding.repositoryRoot !== root || binding.apiOrigin !== apiOrigin
+    || !Array.isArray(binding.targetPaths) || !binding.targetPaths.length
+    || canonical(binding.targetPaths) !== canonical([...new Set(binding.targetPaths.map(scopePath))].sort())) contextFail('The original context task binding is unavailable');
+  contextList(binding.importContexts);
+  const signerConfigPath = path.join(controls, 'signer.json'), config = JSON.parse(await privateText(signerConfigPath));
+  contextExact(config, ['schemaVersion', 'privateKeyPath', 'keyId', 'receiptTtlMs']);
+  if (config.schemaVersion !== 'entrorove.scope-signer/1.0' || config.privateKeyPath !== path.join(controls, 'private.pem') || config.keyId !== binding.keyId
+    || !Number.isSafeInteger(config.receiptTtlMs) || config.receiptTtlMs < 1 || config.receiptTtlMs > 300_000) contextFail('Original context signer configuration changed');
+  const key = createPrivateKey(await privateText(config.privateKeyPath)), der = createPublicKey(key).export({ type: 'spki', format: 'der' });
+  if (key.asymmetricKeyType !== 'ed25519' || der.toString('base64') !== binding.publicKey || sha256(der) !== binding.keyId) contextFail('Original context signing key changed');
+  return { root, home, apiOrigin, stateRoot, base, binding, key, signerConfigPath, localBindingDigest: sha256(canonical(binding)),
+    directory: path.join(base, 'context-recovery'), file: path.join(base, 'context-recovery', 'journal.json') };
+}
+export async function effectiveScopeContexts(location) {
+  const directory = path.join(location.base, 'context-authority');
+  try { await contextPrivate(directory, 'directory'); } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  const names = (await fs.readdir(directory)).sort(); let current = null;
+  if (names.length > 100 || names.some(name => !/^\d{6}-[a-f0-9]{64}\.json$/.test(name))) contextFail('Context authority history is invalid');
+  for (const name of names) {
+    const file = path.join(directory, name); await contextPrivate(file, 'file', 1_000_000);
+    const saved = await readMutationJson14(file), checked = validateContextAuthority(saved.record, location, current);
+    if (saved.revisionDigest !== checked.revisionDigest || name !== `${String(checked.record.revision).padStart(6, '0')}-${checked.revisionDigest}.json`) contextFail('Context history checksum or order changed');
+    current = checked;
+  }
+  return current;
+}
+export async function boundScopeContexts(base, binding, dependencies) {
+  try { await contextPrivate(path.join(base, 'context-authority'), 'directory'); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  if (!await hydrateCloudMutationAuthority(dependencies.home, dependencies.apiOrigin())) await bootstrapCloudMutationAuthority(dependencies);
+  return effectiveScopeContexts({ base, binding, localBindingDigest: sha256(canonical(binding)) });
+}
+export async function retainContextAuthority(location, effective) {
+  const current = await effectiveScopeContexts(location);
+  if (current?.revisionDigest === effective?.revisionDigest && canonical(current.record) === canonical(effective.record)) return current;
+  const checked = validateContextAuthority(effective?.record, location, current);
+  if (effective.revisionDigest !== checked.revisionDigest) contextFail('Applied context authority checksum changed');
+  const directory = path.join(location.base, 'context-authority'), file = path.join(directory, `${String(checked.record.revision).padStart(6, '0')}-${checked.revisionDigest}.json`);
+  await atomicMutationJson14(file, checked, { privateFrom: location.stateRoot }); return checked;
+}
+export async function readContextJournal(location, input) {
+  try {
+    await contextPrivate(location.file);
+    const value = await readMutationJson14(location.file);
+    if (value.schemaVersion !== 'entrorove.scope-context-journal/1.0' || value.localBindingDigest !== location.localBindingDigest) contextFail('Context journal cannot replace its original identity');
+    if (value.pending && canonical(value.input) !== canonical(input)) contextFail('Recover the original pending context request before another operation');
+    return canonical(value.input) === canonical(input) ? value : { previous: value };
+  } catch (error) { if (error.code === 'ENOENT') return {}; throw error; }
+}
+export async function saveContextJournal(location, state) {
+  if (Buffer.byteLength(canonical(state)) > 8_000_000) contextFail('Context journal exceeds its bounded state limit');
+  await privateMutationDirectory14(location.directory, { privateFrom: location.stateRoot });
+  return atomicMutationJson14(location.file, state, { replace: true, privateFrom: location.stateRoot });
+}

package/scope-context-wire.mjs

@@ -0,0 +1,84 @@
+import { canonical, sha256 } from './local-integrity.mjs';
+import { scopeFail, scopePath } from './local-scope-files.mjs';
+import { scopeRevisionAuthority } from './scope-amendment-wire.mjs';
+
+const id = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
+const hash = /^[a-f0-9]{64}$/;
+export const contextFail = message => scopeFail('ENTROROVE_SCOPE_CONTEXT_BINDING', message);
+export function contextExact(value, fields) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || canonical(Object.keys(value).sort()) !== canonical([...fields].sort())) contextFail('Scope context fields are invalid');
+}
+export function contextList(values) {
+  if (!Array.isArray(values) || values.length > 100
+    || new Set(values.map(value => value?.sourcePrefix)).size !== values.length) contextFail('Scope contexts require unique source prefixes and at most 100 configurations');
+  for (const value of values) {
+    contextExact(value, ['sourcePrefix', 'configPath']); scopePath(value.sourcePrefix); scopePath(value.configPath);
+    if (!/(?:^|\/)(?:ts|js)config(?:\.[^/]+)?\.json$/.test(value.configPath)) contextFail('A context requires an actual tsconfig or jsconfig path');
+  }
+  return values;
+}
+export function retainedContexts(original, values) {
+  contextList(values);
+  if (original.some(prior => !values.some(value => canonical(value) === canonical(prior)))) {
+    contextFail('Context correction must retain every original build context unchanged');
+  }
+}
+function contextEvidence(values) {
+  if (!Array.isArray(values) || values.length > 200 || new Set(values.map(value => value?.path)).size !== values.length) contextFail('Context build evidence is invalid');
+  for (const value of values) {
+    contextExact(value, ['path', 'sha256']); scopePath(value.path);
+    if (!hash.test(value.sha256 ?? '')) contextFail('Context build evidence requires actual file hashes');
+  }
+}
+export function contextInput(input) {
+  const common = ['flowId', 'action'];
+  if (input?.action === 'review') common.push('importContexts', 'evidencePaths', 'reason');
+  else if (input?.action === 'apply') common.push('proposalId', 'proposalDigest');
+  else if (input?.action !== 'status') contextFail('Expected scope-context review, apply or status');
+  contextExact(input, common);
+  if (!id.test(input.flowId ?? '')) contextFail('Context recovery requires its original flow');
+  if (input.action === 'apply' && (!id.test(input.proposalId ?? '') || !hash.test(input.proposalDigest ?? ''))) contextFail('Context apply requires the original exact proposal');
+  if (input.action === 'review') {
+    contextList(input.importContexts);
+    if (!Array.isArray(input.evidencePaths) || !input.evidencePaths.length || input.evidencePaths.length > 100
+      || new Set(input.evidencePaths).size !== input.evidencePaths.length
+      || typeof input.reason !== 'string' || !input.reason.trim() || input.reason.length > 2000) contextFail('Context review requires actual bounded build evidence and a reason');
+    input.evidencePaths.forEach(scopePath);
+  }
+  return input;
+}
+export const originalContextDigest = location => sha256(canonical({ localBindingDigest: location.localBindingDigest,
+  importContexts: location.binding.importContexts }));
+export function validateContextAuthority(value, location, previous) {
+  const record = scopeRevisionAuthority(value, 'entrorove.scope-context-authority/1.0');
+  const expectedRevision = (previous?.record.revision ?? 0) + 1;
+  if (['flowId', 'runnerId', 'repositoryId', 'keyId'].some(field => record[field] !== location.binding[field])
+    || record.localBindingDigest !== location.localBindingDigest || record.revision !== expectedRevision
+    || record.previousDigest !== (previous?.revisionDigest ?? originalContextDigest(location))
+    || canonical(record.originalImportContexts) !== canonical(location.binding.importContexts)
+    || canonical(record.targetPaths) !== canonical(location.binding.targetPaths)
+    || !id.test(record.ownerId ?? '') || !hash.test(record.taskDigest ?? '') || !hash.test(record.chainDigest ?? '')
+    || !id.test(record.proposalId ?? '') || !hash.test(record.proposalDigest ?? '')) contextFail('Context authority replaced its original signer, paths or revision chain');
+  retainedContexts(previous?.record.importContexts ?? location.binding.importContexts, record.importContexts);
+  contextEvidence(record.evidence);
+  if (previous && ['ownerId', 'taskDigest', 'chainDigest'].some(field => record[field] !== previous.record[field])
+    || record.importContexts.some(context => !record.evidence.some(file => file.path === context.configPath))) contextFail('Context authority lost its original task or actual configuration evidence');
+  return { record, revisionDigest: sha256(canonical(record)) };
+}
+export function contextChallenge(value, location, proposal, { allowExpired = false } = {}) {
+  const challenge = scopeRevisionAuthority(value, 'entrorove.scope-context-challenge/1.0');
+  if (['flowId', 'runnerId', 'repositoryId', 'keyId'].some(field => challenge[field] !== location.binding[field])
+    || challenge.localBindingDigest !== location.localBindingDigest
+    || ['proposalId', 'proposalDigest', 'expectedRevision', 'previousDigest', 'ownerId', 'taskDigest', 'chainDigest'].some(field => challenge[field] !== proposal[field])
+    || canonical(challenge.targetPaths) !== canonical(location.binding.targetPaths)
+    || canonical(challenge.importContexts) !== canonical(proposal.importContexts)
+    || canonical(challenge.evidence) !== canonical(proposal.evidence)
+    || ['stepId', 'challengeId', 'challenge'].some(field => !id.test(challenge[field] ?? '')) || !challenge.task) contextFail('Context challenge differs from its exact original proposal');
+  retainedContexts(location.binding.importContexts, challenge.importContexts);
+  contextEvidence(challenge.evidence);
+  const issued = Date.parse(challenge.issuedAt), expires = Date.parse(challenge.expiresAt);
+  if (!Number.isFinite(issued) || !Number.isFinite(expires) || issued > Date.now() + 5000
+    || expires <= issued || expires - issued > 90_000 || !allowExpired && expires <= Date.now()) contextFail('Context challenge is expired');
+  return challenge;
+}

package/scope-runner-client.mjs

@@ -7,6 +7,7 @@ import { withStateLock } from './local-state-lock.mjs';
 import { snapshotPlan, snapshotVerify } from './local-execution.mjs';
 import { probe } from './local-probe.mjs';
 import { invokeRemoteResult } from './remote-client.mjs';
+import { boundScopeContexts } from './scope-context-state.mjs';
 
 async function privateDirectory(directory) {
   await fs.mkdir(directory, { recursive: true, mode: 0o700 });
@@ -23,7 +24,7 @@ async function readPrivate(file) {
   const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
   try { return await handle.readFile('utf8'); } finally { await handle.close(); }
 }
-async function signer(directory, identity) {
+async function signer(directory, identity, dependencies) {
   const controls = path.join(directory, 'identity'), file = path.join(controls, 'binding.json');
   let binding;
   try { binding = JSON.parse(await readPrivate(file)); }
@@ -41,7 +42,9 @@ async function signer(directory, identity) {
       await fs.rename(stage, controls);
     } finally { await fs.rm(stage, { recursive: true, force: true }); }
   }
-  if (Object.keys(identity).some(field => canonical(binding[field]) !== canonical(identity[field]))) {
+  const contextAuthority = await boundScopeContexts(directory, binding, dependencies);
+  if (Object.keys(identity).filter(field => field !== 'importContexts').some(field => canonical(binding[field]) !== canonical(identity[field]))
+    || canonical(contextAuthority?.record.importContexts ?? binding.importContexts) !== canonical(identity.importContexts)) {
     scopeFail('ENTROROVE_SCOPE_REPLACEMENT', 'The original local task signer, repository and path set cannot be replaced');
   }
   await privateDirectory(controls);
@@ -49,7 +52,7 @@ async function signer(directory, identity) {
   if (key.asymmetricKeyType !== 'ed25519' || sha256(createPublicKey(key).export({ type: 'spki', format: 'der' })) !== binding.keyId) {
     scopeFail('ENTROROVE_SCOPE_STATE', 'Original scope signer key identity changed');
   }
-  return { binding, key, signerConfigPath: path.join(controls, 'signer.json') };
+  return { binding, key, signerConfigPath: path.join(controls, 'signer.json'), contextAuthority };
 }
 async function remote(operation, input, dependencies) {
   const { response, result } = await invokeRemoteResult({ operation, input }, dependencies);
@@ -60,7 +63,7 @@ async function remote(operation, input, dependencies) {
   return result.output;
 }
 async function connect(identity, directory, dependencies) {
-  const { binding, key, signerConfigPath } = await signer(directory, identity);
+  const { binding, key, signerConfigPath, contextAuthority } = await signer(directory, identity, dependencies);
   const prepared = await remote('scope-runner-prepare', { flowId: identity.flowId, attemptId: randomUUID(), runnerId: binding.runnerId,
     repositoryId: binding.repositoryId, publicKey: binding.publicKey, targetPaths: identity.targetPaths }, dependencies);
   const enrollment = prepared.enrollment;
@@ -76,7 +79,8 @@ async function connect(identity, directory, dependencies) {
     scopeFail('ENTROROVE_SCOPE_BINDING', 'Cloud scope challenge differs from the original account and accepted task');
   }
   const input = { repositoryRoot: identity.repositoryRoot, home: dependencies.home, flowId: identity.flowId,
-    stepId: challenge.stepId, paths: identity.targetPaths, snapshotId: `snapshot-${randomUUID()}`, importContexts: identity.importContexts };
+    stepId: challenge.stepId, paths: identity.targetPaths, snapshotId: `snapshot-${randomUUID()}`, importContexts: identity.importContexts,
+    ...(contextAuthority ? { contextRevisionDigest: contextAuthority.revisionDigest, contextEvidence: contextAuthority.record.evidence } : {}) };
   const planned = await snapshotPlan(input), verified = await snapshotVerify(input);
   if (verified.verified !== true || verified.receipt.snapshotDigest !== planned.snapshotDigest) scopeFail('ENTROROVE_SCOPE_SNAPSHOT', 'Actual copied snapshot did not verify');
   const observed = await probe({ ...input, ownerId: challenge.ownerId, task: challenge.task, taskDigest: challenge.taskDigest,