@entrorove/skill 0.1.71 → 0.1.78

package/design-stage.mjs

@@ -0,0 +1,78 @@
+import { designFail } from './design-policy.mjs';
+import { browserStepHandoffs } from './design-storage.mjs';
+
+export function validateDesignStage(policy) {
+  const stage = policy.rules.stage;
+  if (!stage) return;
+  const active = new Set(stage.pageIds), passive = new Set(stage.readOnlyPages.map(item => item.pageId));
+  if (active.size !== stage.pageIds.length || passive.size !== stage.readOnlyPages.length
+    || stage.requirementIds.some(id => !policy.site.requirementIds.includes(id))
+    || policy.site.pages.some(page => Number(active.has(page.id)) + Number(passive.has(page.id)) !== 1)
+    || [...active, ...passive].some(id => !policy.site.pages.some(page => page.id === id))) {
+    designFail('STAGE', 'A stage retains the whole site and partitions every original page into executable or source-bound read-only context');
+  }
+  for (const id of stage.edgeIds) {
+    const edge = policy.site.edges.find(item => item.id === id);
+    if (!edge || !active.has(edge.from) || !active.has(edge.to)) designFail('STAGE', 'Every executable stage edge must retain its original endpoints');
+  }
+  const sources = new Map();
+  for (const page of stage.readOnlyPages) for (const source of page.sources) {
+    if (!policy.rules.verificationPaths.includes(source.path)
+      || sources.has(source.path) && sources.get(source.path) !== source.sha256
+      || page.sources.filter(item => item.path === source.path).length !== 1) {
+      designFail('STAGE', 'Read-only context requires exact existing source hashes in the unchanged verification range');
+    }
+    sources.set(source.path, source.sha256);
+  }
+}
+export const executableDesignPages = policy => policy.rules.stage?.pageIds ?? policy.site.pages.map(page => page.id);
+export const executableDesignEdges = policy => policy.rules.stage?.edgeIds ?? policy.site.edges.map(edge => edge.id);
+export function designAcceptanceScope(policy) {
+  return { mode: policy.rules.stage ? 'stage' : 'whole-site', ...(policy.rules.stage ? { stageId: policy.rules.stage.id } : {}),
+    pageIds: executableDesignPages(policy), edgeIds: executableDesignEdges(policy),
+    readOnlyPageIds: (policy.rules.stage?.readOnlyPages ?? []).map(page => page.pageId),
+    claimsWholeBusinessCompletion: false };
+}
+export async function assertDesignStageSources(input, policy) {
+  const sources = new Map((policy.rules.stage?.readOnlyPages ?? []).flatMap(page => page.sources.map(source => [source.path, source.sha256])));
+  if (!sources.size) return;
+  const { repositoryIntegrityFile } = await import('./local-discipline-repository.mjs');
+  for (const [name, expected] of sources) {
+    const actual = await repositoryIntegrityFile(input.repositoryRoot, name);
+    if (actual.sha256 !== expected) designFail('STAGE_SOURCE_CHANGED', 'A frozen read-only context source changed; preserve this result and obtain a truthful new baseline');
+  }
+}
+export function assertDesignStageWrite(policy, name) {
+  const expected = (policy.rules.stage?.readOnlyPages ?? []).flatMap(page => page.sources).find(source => source.path === name);
+  if (expected) designFail('STAGE_READ_ONLY', 'This source is frozen as read-only context in the original approved stage');
+}
+const sensitive = /token|secret|password|passphrase|credential|authorization|cookie|session.?id|private.?key|api.?key|^(?:auth|roles?|permissions?|authenticated|isAdmin|isLoggedIn|accessLevel)$/i;
+function safeHandoffValue(value) {
+  if (value === null) return true;
+  if (/-----BEGIN .*PRIVATE KEY|\bBearer\s+|https?:\/\/[^\s/]+:[^\s/]+@/i.test(value)) return false;
+  let parsed; try { parsed = JSON.parse(value); } catch { return !/[?&](?:token|key|secret|password|signature)=/i.test(value); }
+  const pending = [parsed]; let nodes = 0;
+  while (pending.length) {
+    if (++nodes > 1024) return false;
+    const node = pending.pop();
+    if (node && typeof node === 'object') for (const [key, item] of Object.entries(node)) {
+      if (sensitive.test(key)) return false;
+      pending.push(item);
+    }
+    else if (typeof node === 'string' && /\bBearer\s+|[?&](?:token|secret|password|signature)=/i.test(node)) return false;
+  }
+  return true;
+}
+export function validateDesignHandoffs(step, edge) {
+  const handoffs = browserStepHandoffs(step, edge);
+  if (!handoffs.length) return;
+  if (!['navigate', 'open'].includes(edge.kind) || step.action === 'fill' || step.mutations.length
+    || step.storageHandoffs?.length && step.readBack
+    || step.readBack && (step.readBack.jsonPointer || step.readBack.kind !== 'local-storage')
+    || new Set(handoffs.map(item => `${item.area}\0${item.key}`)).size !== handoffs.length
+    || handoffs.some(item => sensitive.test(item.key)
+      || (item.method === 'removeItem') !== (item.after === null)
+      || !safeHandoffValue(item.before) || !safeHandoffValue(item.after))) {
+    designFail('HANDOFF', 'Only an explicit navigation/open action may declare exact noncredential storage handoffs; no HTTP commit or success authority is granted');
+  }
+}

package/design-storage.mjs

@@ -0,0 +1,63 @@
+import { canonical } from './local-integrity.mjs';
+
+export function browserStepHandoffs(step, edge) {
+  if (step.storageHandoffs?.length) return step.storageHandoffs;
+  if (!['navigate', 'open'].includes(edge.kind) || step.readBack?.kind !== 'local-storage') return [];
+  const proof = step.readBack;
+  return [{ area: 'local-storage', key: proof.key, method: proof.after === null ? 'removeItem' : 'setItem', count: 1,
+    before: proof.before === null ? null : canonical(proof.before), after: proof.after === null ? null : canonical(proof.after), format: 'json' }];
+}
+function normalized(value, format) {
+  if (value === null || format !== 'json') return value;
+  try { return canonical(JSON.parse(value)); } catch { return undefined; }
+}
+async function storageSnapshot(page) {
+  return page.evaluate(() => {
+    let total = 0;
+    const read = store => {
+      if (store.length > 256) throw new Error('storage observation limit');
+      return Object.fromEntries(Array.from({ length: store.length }, (_, index) => {
+        const key = store.key(index), value = store.getItem(key); total += key.length + value.length;
+        if (total > 1_048_576) throw new Error('storage observation limit');
+        return [key, value];
+      }));
+    };
+    return { 'local-storage': read(localStorage), 'session-storage': read(sessionStorage) };
+  });
+}
+export function browserStorage(base, parents) {
+  let before = new Map(), actor;
+  const empty = () => ({ 'local-storage': {}, 'session-storage': {} });
+  return {
+    async begin(context, page) {
+      actor = page; before = new Map();
+      for (const current of context.pages()) if (new URL(current.url()).origin === base.origin) before.set(current, await storageSnapshot(current));
+    },
+    async check(context, current, handoffs, writes, commits, failures) {
+      if (commits) return;
+      const same = (value, expected, format) => normalized(value, format) === normalized(expected, format);
+      if (writes.length !== handoffs.length || handoffs.some(expected => writes.filter(event =>
+        [actor, current].includes(event.page) && event.area === expected.area && event.key === expected.key && event.method === expected.method
+        && same(event.before, expected.before, expected.format) && same(event.after, expected.after, expected.format)).length !== 1)) {
+        failures.push('unexpected-browser-storage-write');
+      }
+      for (const page of context.pages()) {
+        if (new URL(page.url()).origin !== base.origin) continue;
+        const original = before.get(page) ?? before.get(parents.get(page)) ?? empty(), after = await storageSnapshot(page);
+        for (const area of ['local-storage', 'session-storage']) {
+          const expected = { ...original[area] };
+          const applies = area === 'local-storage' || page === actor || page === current && !before.has(page);
+          for (const change of handoffs.filter(value => applies && value.area === area)) {
+            const value = Object.hasOwn(expected, change.key) ? expected[change.key] : null;
+            if (!same(value, change.before, change.format)) failures.push('handoff-before-state');
+            if (change.after === null) delete expected[change.key]; else expected[change.key] = change.after;
+          }
+          if (Object.keys(after[area]).length !== Object.keys(expected).length || Object.keys(expected).some(key => {
+            const declaration = handoffs.find(value => applies && value.area === area && value.key === key);
+            return !Object.hasOwn(after[area], key) || !same(after[area][key], expected[key], declaration?.format);
+          })) failures.push('handoff-storage-state');
+        }
+      }
+    }
+  };
+}

package/fs-request-trace.mjs

@@ -0,0 +1,67 @@
+import { createHook } from 'node:async_hooks';
+import { performance } from 'node:perf_hooks';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const sdkRoot = path.dirname(fileURLToPath(import.meta.url));
+function captureFsStack(exclude) {
+  const value = {}; Error.captureStackTrace(value, exclude); return value;
+}
+export function fsTraceStack(stack, root = sdkRoot) {
+  const frames = [];
+  for (const line of String(stack ?? '').split('\n').slice(1, 40)) {
+    const match = /(?:\()?((?:file:\/\/\/|node:)[^()\s]+):(\d+):(\d+)\)?$/.exec(line.trim());
+    if (!match) continue;
+    const [, source, row, column] = match; let module;
+    if (source.startsWith('node:')) module = source;
+    else {
+      let filename; try { filename = fileURLToPath(source); } catch { continue; }
+      const relative = path.relative(root, filename);
+      if (!relative || relative.startsWith('..') || path.isAbsolute(relative) || !/^[A-Za-z0-9_./-]+\.mjs$/.test(relative)) continue;
+      if (relative === 'fs-request-trace.mjs') continue;
+      module = relative;
+    }
+    frames.push({ module, line: Number(row), column: Number(column) });
+    if (frames.length >= 12) break;
+  }
+  return frames;
+}
+export function createFsRequestTrace({ hookFactory = createHook, now = () => performance.now(),
+  repeat = setInterval, cancel = clearInterval, write = value => process.stderr.write(`${JSON.stringify(value)}\n`),
+  stack = captureFsStack, thresholdMs = 15_000, maximumPending = 128 } = {}) {
+  if (!Number.isSafeInteger(thresholdMs) || thresholdMs < 1 || !Number.isSafeInteger(maximumPending)
+    || maximumPending < 1 || maximumPending > 128) throw new Error('Invalid bounded FS trace settings');
+  const pending = new Map(); let dropped = 0, reported = 0, enabled = true;
+  const emit = value => { try { write({ schemaVersion: 'entrorove.fs-request-trace/1.0', metadataOnly: true, ...value }); } catch {} };
+  const hook = hookFactory({
+    init: function fsInit(asyncId, type, triggerAsyncId) {
+      if ((type !== 'FSREQPROMISE' && type !== 'FSREQCALLBACK') || !enabled) return;
+      if (pending.size >= maximumPending) { dropped++; return; }
+      try { pending.set(asyncId, { asyncId, triggerAsyncId, resourceType: type, created: now(), stack: stack(fsInit), reported: false }); }
+      catch { dropped++; }
+    },
+    destroy(asyncId) { pending.delete(asyncId); },
+    promiseResolve(asyncId) { pending.delete(asyncId); },
+  });
+  const check = () => {
+    for (const request of pending.values()) {
+      const elapsedMs = Math.max(0, Math.floor(now() - request.created));
+      if (request.reported || elapsedMs < thresholdMs) continue;
+      request.reported = true; reported++;
+      let creationStack = [];
+      try { creationStack = fsTraceStack(typeof request.stack === 'string' ? request.stack : request.stack?.stack); } catch {}
+      request.stack = null;
+      emit({ kind: 'fs-request-stall', resourceType: request.resourceType, asyncId: request.asyncId,
+        triggerAsyncId: request.triggerAsyncId, elapsedMs, pendingCount: pending.size, dropped,
+        creationStack, creationStackAvailable: creationStack.length > 0, cancelsRequest: false, grantsExecutionAuthority: false });
+    }
+  };
+  hook.enable(); const timer = repeat(check, Math.min(1000, thresholdMs)); timer.unref?.();
+  const stop = () => {
+    if (enabled) { enabled = false; hook.disable(); cancel(timer); pending.clear(); }
+    return { enabled, pendingCount: pending.size, dropped, reported };
+  };
+  stop.inspect = () => ({ enabled, pendingCount: pending.size, dropped, reported });
+  return stop;
+}
+export const startFsTrace = () => createFsRequestTrace();

package/local-contracts.mjs

@@ -101,7 +101,7 @@ const scopeInteraction = object({ type: enumeration(['confirm', 'choice', 'multi
 const scopeTask = object({ goal: { ...text, pattern: '\\S', maxLength: 12000 }, workType: enumeration(['implementation', 'documentation', 'calculation', 'merge', 'review', 'decision', 'diagnosis']),
   difficulty: enumeration(['low', 'medium', 'high']), risk: enumeration(['low', 'medium', 'high']), crossModule: { type: 'boolean' }, parallel: { type: 'boolean' }, needParallel: { type: 'boolean' },
   unclear: { type: 'boolean' }, architectureContract: { type: 'boolean' }, explicitAimlockRequested: { type: 'boolean' }, explicitEntroroveRequested: { type: 'boolean' }, userSpecifiedSkills: array(text),
-  requirements: { ...array(scopeRequirement, 1), maxItems: 500 }, phase: enumeration(['plan', 'coordinate', 'architecture', 'verify', 'merge', 'decision']), baselineRef: text, interaction: scopeInteraction }, ['goal', 'workType', 'difficulty', 'risk']);
+  requirements: { ...array(scopeRequirement, 1), maxItems: 500 }, authorization: record, phase: enumeration(['plan', 'coordinate', 'architecture', 'verify', 'merge', 'decision']), baselineRef: text, interaction: scopeInteraction }, ['goal', 'workType', 'difficulty', 'risk']);
 const probe = { ...step, paths: probePaths, targetPaths: probePaths, task: scopeTask, baselineRef: text, snapshotId: identifier,
   targetSymbols: array(text, 1), contextMapPath: relativePath, importContexts, contextRevisionDigest: sha256,
   contextEvidence: { ...array(object({ path: relativePath, sha256 }, ['path', 'sha256'])), maxItems: 200 }, signerConfigPath: nullable(text),

package/local-discipline-repository.mjs

@@ -100,8 +100,10 @@ export async function disciplineRepositoryObservation(input, root, { analyze = f
   let graph;
   try { graph = roots.length ? await importGraph(root, roots, input, disciplineAnalysisLimits) : { edges: [], dynamicSources: [], complete: true }; }
   catch (error) {
-    if (!['ENTROROVE_IMPORT_UNRESOLVED', 'ENTROROVE_IMPORT_INVALID', 'ENTROROVE_IMPORT_UNSUPPORTED', 'ENTROROVE_SCOPE_LIMIT', 'ENTROROVE_BUDGET_SCOPE'].includes(error.code)) throw error;
-    graph = { edges: [], dynamicSources: [], complete: false }; unresolved.push({ reason: error.code, message: error.message });
+    if (!['ENTROROVE_IMPORT_UNRESOLVED', 'ENTROROVE_IMPORT_INVALID', 'ENTROROVE_IMPORT_UNSUPPORTED', 'ENTROROVE_IMPORT_ADDRESS_UNSUPPORTED', 'ENTROROVE_SCOPE_LIMIT', 'ENTROROVE_BUDGET_SCOPE'].includes(error.code)) throw error;
+    const address = error.code === 'ENTROROVE_IMPORT_ADDRESS_UNSUPPORTED'
+      ? { path: error.sourcePath, sha256: error.sourceSha256, selectorDigest: error.selectorDigest } : {};
+    graph = { edges: [], dynamicSources: [], complete: false }; unresolved.push({ ...address, reason: error.code, message: error.message });
   }
   for (const [relative, content] of overrides) if (semanticSource(relative) && /\.(?:[cm]?[jt]sx?|vue)$/i.test(relative)) {
     try {

package/local-invocations.mjs

@@ -3,6 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import os from 'node:os';
 import path from 'node:path';
 import { withStateLock } from './local-state-lock.mjs';
+import { servicePrerequisite } from './service-prerequisite.mjs';
 
 const SHA = /^[a-f0-9]{64}$/;
 const UUID = /^[a-f0-9-]{36}$/;
@@ -66,6 +67,11 @@ export async function appendInvocation(value, home = os.homedir()) {
     || !['remote', 'local'].includes(value.kind)) throw new Error('Invalid invocation ledger metadata');
   const record = { schemaVersion: 'entrorove.invocation/1.0', eventId: randomUUID(), at: new Date().toISOString(),
     kind: value.kind, operation: value.operation, requestId: value.requestId, event: value.event };
+  if (value.servicePrerequisite !== undefined) {
+    const prerequisite = servicePrerequisite({ status: 403 }, value.servicePrerequisite);
+    if (value.event !== 'rejected' || !prerequisite) throw new Error('Invalid service prerequisite rejection receipt');
+    record.servicePrerequisite = prerequisite;
+  }
   if (value.durationMs !== undefined) {
     if (!Number.isSafeInteger(value.durationMs) || value.durationMs < 0) throw new Error('Invalid local invocation duration');
     record.durationMs = value.durationMs;

package/local-mutation-files.mjs

@@ -1,12 +1,20 @@
-import { constants, promises as fs } from 'node:fs';
+import nodeFs, { constants, promises as fs } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import os from 'node:os';
 import path from 'node:path';
+import { setImmediate as yieldMetadata14 } from 'node:timers/promises';
 import { canonical, sha256 } from './local-integrity.mjs';
 import { readBudgetedProjectFile } from './local-budget-reads.mjs';
 
 const ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 export const mutationFail14 = (code, message) => { throw Object.assign(new Error(message), { code }); };
+let metadataObservations14 = 0;
+// Observe metadata afresh without waiting for a queued filesystem completion.
+// Yield between bounded groups so timers and signals still run during scans.
+async function lstatMetadata14(target) {
+  if (++metadataObservations14 % 128 === 0) await yieldMetadata14();
+  return nodeFs.lstatSync(target);
+}
 export function mutationId14(value, field) {
   if (typeof value !== 'string' || !ID.test(value)) mutationFail14('ENTROROVE_ID_INVALID', `${field} must be a safe identifier`);
   return value;
@@ -46,11 +54,11 @@ export function mutationInside14(root, target, field = 'path') {
 async function inspectPath(target, { allowMissing = false, final = 'file', code = 'ENTROROVE_FILE_INVALID' } = {}) {
   const resolved = absolute(target, 'filesystem path');
   const base = path.parse(resolved).root; const parts = path.relative(base, resolved).split(path.sep).filter(Boolean);
-  let current = base; const ancestors = [{ path: base, stat: await fs.lstat(base) }];
+  let current = base; const ancestors = [{ path: base, stat: await lstatMetadata14(base) }];
   if (!parts.length) return { target: resolved, stat: ancestors[0].stat, exists: true, ancestors };
   for (const [index, part] of parts.entries()) {
     current = path.join(current, part); let stat;
-    try { stat = await fs.lstat(current); } catch (error) {
+    try { stat = await lstatMetadata14(current); } catch (error) {
       if (error.code === 'ENOENT' && allowMissing) return { target: resolved, exists: false, stat: null, ancestors };
       throw error;
     }
@@ -71,7 +79,7 @@ async function canonicalDirectoryPath(value, { allowMissing = false, code }) {
   for (const [index, part] of parts.entries()) {
     const candidate = path.join(current, part);
     let stat;
-    try { stat = await fs.lstat(candidate); } catch (error) {
+    try { stat = await lstatMetadata14(candidate); } catch (error) {
       if (error.code === 'ENOENT' && allowMissing) return path.join(current, ...parts.slice(index));
       throw error;
     }
@@ -90,7 +98,7 @@ async function canonicalDirectoryPath(value, { allowMissing = false, code }) {
 }
 async function assertAncestors(item, code = 'ENTROROVE_STATE_CHANGED') {
   for (const ancestor of item.ancestors) {
-    const stat = await fs.lstat(ancestor.path);
+    const stat = await lstatMetadata14(ancestor.path);
     if (stat.isSymbolicLink() || !stat.isDirectory() || !sameNode(stat, ancestor.stat)) {
       mutationFail14(code, 'mutation path ancestors changed during filesystem access');
     }

package/local-probe.mjs

@@ -50,7 +50,7 @@ async function handoffReadBudget(input) {
   const loaded = await loadBudget(await budgetLocation(binding));
   return loaded.state.enforced && loaded.state.grant?.purpose === 'handoff-read';
 }
-async function probeHandoffCandidate(input, root, candidate) {
+async function probeHandoffCandidate(input, root, candidate, signingOptions) {
   scopeBinding(input);
   const native = await import('./local-task-handoff-read-authority.mjs');
   const readHome = await native.assertTaskHandoffReadHome({ ...input, taskId: candidate.receiverTaskId, ownerId: candidate.ownerId });
@@ -67,13 +67,26 @@ async function probeHandoffCandidate(input, root, candidate) {
     preservedSnapshotDigest: null, preservedSnapshotId: null, currentSnapshotFresh: true,
     receiverOrigin: { flowId: candidate.flowId, taskId: candidate.receiverTaskId,
       scopeDigest: candidate.receiverOriginalScopeDigest, checkpointDigest: candidate.receiverCheckpointDigest,
-      acceptanceReceiptId: candidate.receiverAcceptanceReceiptId, sourceCopiesVerified: false } });
+      acceptanceReceiptId: candidate.receiverAcceptanceReceiptId, sourceCopiesVerified: false } }, signingOptions);
 }
-export async function probe(input) {
+function probeSigningOptions(options) {
+  if (!options || typeof options !== 'object' || Array.isArray(options)
+    || Object.keys(options).some(key => !['maximumExpiresAt', 'beforeSign'].includes(key))
+    || options.maximumExpiresAt !== undefined && (!Number.isSafeInteger(options.maximumExpiresAt) || options.maximumExpiresAt < 1)
+    || options.beforeSign !== undefined && typeof options.beforeSign !== 'function') {
+    scopeFail('ENTROROVE_SCOPE_ATTESTATION_BINDING', 'Internal probe signing options require a finite deadline or an original bound challenge callback');
+  }
+  return { maximumExpiresAt: options.maximumExpiresAt, beforeSign: options.beforeSign };
+}
+export async function probe(input, options = {}) {
+  const signingOptions = probeSigningOptions(options);
   rejectScopePrivileges(input);
+  if (signingOptions.beforeSign && Object.hasOwn(input, 'handoffCandidate')) {
+    scopeFail('ENTROROVE_SCOPE_ATTESTATION_BINDING', 'Temporary handoff candidates cannot renew an ordinary scope challenge');
+  }
   const root = await scopeRoot(input.repositoryRoot);
   const candidate = await verifiedScopeCandidate(input, root);
-  if (candidate && await handoffReadBudget(input)) return probeHandoffCandidate(input, root, candidate);
+  if (candidate && await handoffReadBudget(input)) return probeHandoffCandidate(input, root, candidate, signingOptions);
   const hasBinding = ['flowId', 'stepId', 'snapshotId'].some(field => input[field] !== undefined);
   const retained = hasBinding ? await retainedScope(input, root, true) : null;
   const fresh = !!candidate || (!!retained && retained.stepId !== input.stepId);
@@ -97,15 +110,15 @@ export async function probe(input) {
         classification: { ...result.classification, mode: candidate ? result.classification.mode : retained.mode }, requiredMode: result.classification.mode,
         originalBinding: { flowId: retained.flowId, stepId: retained.stepId, snapshotId: retained.originalSnapshot.snapshotId },
         snapshotDigest: result.facts.snapshotEvidence.snapshotDigest, preservedSnapshotDigest: retained.originalSnapshot.digest,
-        preservedSnapshotId: retained.originalSnapshot.snapshotId, currentSnapshotFresh: true });
+        preservedSnapshotId: retained.originalSnapshot.snapshotId, currentSnapshotFresh: true }, signingOptions);
     }
     const saved = await initializeScope(input, result.repositoryRoot, result.facts, result.classification);
     return attestScopeFacts(input, { ...result, revision: saved.state.revision, statePath: saved.statePath,
       classification: { ...result.classification, mode: saved.state.mode }, requiredMode: result.classification.mode,
       snapshotDigest: result.facts.snapshotEvidence.snapshotDigest, preservedSnapshotDigest: saved.state.originalSnapshot.digest,
-      preservedSnapshotId: saved.state.originalSnapshot.snapshotId, currentSnapshotFresh: true });
+      preservedSnapshotId: saved.state.originalSnapshot.snapshotId, currentSnapshotFresh: true }, signingOptions);
   }
-  return attestScopeFacts(input, result);
+  return attestScopeFacts(input, result, signingOptions);
 }
 function observationReassessment(input, result) {
   const previousMode = input.currentMode === undefined ? result.classification.mode : input.currentMode;

package/local-recovery-budget.mjs

@@ -0,0 +1,31 @@
+// Durable per-operation limits. These are recovery limits, not an execution
+// permission, and callers cannot enlarge them through request payloads.
+const limits = Object.freeze({ attempt: 2, signing: 2, status: 3, prerequisite: 2 });
+const fail = recovery => Object.assign(new Error('Automatic recovery limit reached; preserve the original task and pending evidence, and report the concrete failure before another attempt'),
+  { code: 'ENTROROVE_RECOVERY_EXHAUSTED', recovery: structuredClone(recovery), automaticRetryAllowed: false });
+export function consumeRecovery(state, kind, eventId) {
+  if (!Object.hasOwn(limits, kind)) throw new Error('Unknown recovery boundary');
+  const recovery = Object.hasOwn(state, 'recovery') ? state.recovery : { schemaVersion: 'entrorove.recovery-budget/1.0', counts: {} };
+  if (!recovery || recovery.schemaVersion !== 'entrorove.recovery-budget/1.0' || !recovery.counts || Array.isArray(recovery.counts)
+    || Object.keys(recovery).some(key => !['schemaVersion', 'counts', 'events'].includes(key))
+    || Object.entries(recovery.counts).some(([key, value]) => !Object.hasOwn(limits, key)
+      || !Number.isSafeInteger(value) || value < 0 || value > limits[key])) {
+    throw Object.assign(new Error('Original recovery accounting is invalid'), { code: 'ENTROROVE_RECOVERY_STATE' });
+  }
+  if (recovery.events && (Array.isArray(recovery.events) || Object.entries(recovery.events).some(([key, value]) =>
+    !Object.hasOwn(limits, key) || typeof value !== 'string' || !value || value.length > 256 || !recovery.counts[key]))) {
+    throw Object.assign(new Error('Original recovery event is invalid'), { code: 'ENTROROVE_RECOVERY_STATE' });
+  }
+  if (eventId !== undefined && (typeof eventId !== 'string' || !eventId || eventId.length > 256)) throw new Error('Invalid recovery event');
+  if (eventId && recovery.events?.[kind] === eventId) return structuredClone(recovery);
+  if ((recovery.counts[kind] ?? 0) >= limits[kind]) throw fail(recovery);
+  recovery.counts[kind] = (recovery.counts[kind] ?? 0) + 1;
+  if (eventId) recovery.events = { ...recovery.events, [kind]: eventId };
+  state.recovery = recovery;
+  return structuredClone(recovery);
+}
+export function recoveryFailureFields(error) {
+  return error?.code === 'ENTROROVE_RECOVERY_EXHAUSTED' || error?.code === 'ENTROROVE_RECOVERY_STATE'
+    ? { code: error.code, message: error.message, automaticRetryAllowed: false,
+      ...(error.recovery ? { recovery: error.recovery } : {}) } : {};
+}

package/local-scope-repository.mjs

@@ -21,6 +21,7 @@ import { uniConditionalVariants } from './local-scope-uni-conditional.mjs';
 import { createUniBuildInspection } from './local-scope-uni-build.mjs';
 import { createScopeBuildIO } from './local-scope-build-io.mjs';
 import { observeBuildFacts } from './local-scope-build-facts.mjs';
+import { scopeWriteFiles, scopeWriteObservation } from './scope-write-observation.mjs';
 
 const execute = promisify(execFile);
 const inspectionFreshness = new WeakMap();
@@ -247,7 +248,11 @@ function declarationModules(content, from) {
 }
 async function resolveImport(root, from, specifier, workspace, input, aliases, configPath, declarations) {
   if (specifier.startsWith('/') || /^[A-Za-z]:/.test(specifier) || specifier.includes('\\') || /[\u0000-\u001f\u007f]/.test(specifier)) {
-    scopeFail('ENTROROVE_PATH_UNSAFE', 'Source module addresses require safe repository-relative or declared package selectors');
+    // This is a source expression, not permission to probe an absolute target.
+    // Strict dependency inspection still rejects it; whole-repository usage
+    // observation can retain this specific semantic uncertainty without I/O.
+    throw Object.assign(new Error('Source module address has no supported local projection; no target was inspected'),
+      { code: 'ENTROROVE_IMPORT_ADDRESS_UNSUPPORTED', sourcePath: from, selectorDigest: sha256(specifier) });
   }
   if (/^(?:https?:|file:|data:)/i.test(specifier)) scopeFail('ENTROROVE_IMPORT_UNSUPPORTED', 'remote source imports cannot be inspected as local facts');
   if (declarations.has(specifier)) return null;
@@ -367,7 +372,10 @@ export async function importGraph(root, originals, input = { repositoryRoot: roo
       catch (error) {
         const missing = error.code === 'ENTROROVE_IMPORT_UNRESOLVED' && specifier.startsWith('.')
           ? error.missingCandidates?.filter(candidate => pendingCreates.has(candidate)) : null;
-        if (error.code !== 'ENTROROVE_IMPORT_UNRESOLVED') throw error;
+        if (error.code !== 'ENTROROVE_IMPORT_UNRESOLVED') {
+          if (error.code === 'ENTROROVE_IMPORT_ADDRESS_UNSUPPORTED') error.sourceSha256 = read.sha256;
+          throw error;
+        }
         unresolvedImports.push({ path: relative, specifier, reason: missing?.length ? 'approved-create-not-present' : 'source-import-unresolved',
           candidatePaths: missing?.length ? missing : error.missingCandidates ?? [] });
         dynamic = true;
@@ -435,6 +443,13 @@ export async function collectScopeFacts(root, requested, baselineRef, knownFiles
   const verifyGraph = inspectionFreshness.get(graph), observedMetadata = graph.workspaceMetadata.map(file => ({ path: file.path, sha256: file.sha256 }));
   inspectionFreshness.set(graph, async () => { await verifyGraph(); await stableScope(root, observedMetadata, input, scopeBuildSourceRead); });
   const observedGit = await observeGitFacts(root, files, baselineRef, input); const history = observedGit.facts;
+  let writeScope;
+  if (input.scopeWritePaths !== undefined) {
+    const writable = scopeWriteFiles(files, input.scopeWritePaths);
+    const observed = await observeGitFacts(root, writable, baselineRef, input);
+    if (['available', 'head', 'baseline'].some(field => observed.facts[field] !== history[field])) scopeFail('ENTROROVE_SCOPE_CHANGED', 'Write observation lost the full scope Git identity');
+    writeScope = scopeWriteObservation(writable, observed, knownFiles);
+  }
   const modules = [...new Map(graph.nodes.map(node => [node.boundary.path, node.boundary])).values()].sort((a, b) => a.path.localeCompare(b.path));
   await stableScope(root, files, input);
   await stableScope(root, modules.filter(module => module.manifestPath).map(module => ({ path: module.manifestPath, sha256: module.manifestDigest })), input, scopeBuildSourceRead);
@@ -445,7 +460,7 @@ export async function collectScopeFacts(root, requested, baselineRef, knownFiles
     : sourceLines + files.filter(file => !file.exists).reduce((sum, file) => sum + (knownFiles.find(previous => previous.path === file.path)?.lines ?? 0), 0);
   return { targetPaths: [...new Set(requested)].sort(), fileCount: files.length, files, bytes, sourceLines, tokenEstimate: Math.ceil(bytes / 4), modules,
     crossModule: modules.length > 1, risk: observedScopeRisk(files), importGraph: graph, git: history,
-    estimatedChangedLines };
+    estimatedChangedLines, ...(writeScope ? { writeScope } : {}) };
 }
 async function contextEvidence(root, graph, input) {
   if (input.contextEvidence === undefined) return;

package/local-scope-signature.mjs

@@ -37,8 +37,8 @@ function binding(input, result) {
 }
 async function signingChallenge(input, beforeSign, maximumExpiresAt) {
   if (beforeSign === undefined) return { input, maximumExpiresAt };
-  if (typeof beforeSign !== 'function' || !input.contextRevisionDigest || Object.hasOwn(input, 'handoffCandidate')) {
-    scopeFail('ENTROROVE_SCOPE_ATTESTATION_BINDING', 'Challenge renewal is restricted to an original context observation');
+  if (typeof beforeSign !== 'function' || Object.hasOwn(input, 'handoffCandidate')) {
+    scopeFail('ENTROROVE_SCOPE_ATTESTATION_BINDING', 'Challenge renewal requires an original bound scope observation');
   }
   const fresh = await beforeSign();
   if (!fresh || Object.keys(fresh).sort().join(',') !== 'challenge,maximumExpiresAt'

package/local-source-execution.mjs

@@ -0,0 +1,47 @@
+import { prerequisiteFields } from './service-prerequisite.mjs';
+export { startFsTrace } from './fs-request-trace.mjs';
+
+const flag = '--local-source';
+const commands = new Set(['invoke', 'native', 'scope-connect', 'scope-context', 'scope-amend', 'mutation-connect',
+  'mutation-settle', 'workflow-observe-step', 'cloud-task', 'cloud-status', 'cloud-watch', 'feedback', 'status',
+  'flows', 'usage', 'billing', 'recurring', 'host-message', 'queue', 'local', 'review']);
+const documents = ['SKILL.md', 'CAPABILITY-MAP.md', 'AGREEMENT.md', 'manifest.json', 'IDE-EXECUTION.md',
+  'REUSE-DISCIPLINE.md', 'DELIVERY-BOUNDARIES.md', 'DESIGN-GATES.md'];
+const fail = message => { throw Object.assign(new Error(message), { code: 'ENTROROVE_LOCAL_SOURCE_IDENTITY' }); };
+let announced = false;
+
+export function localSourceArguments(args) {
+  const count = args.filter(value => value === flag).length;
+  const tracing = args.filter(value => value === '--trace-fs').length;
+  if (!count && !tracing) return { args, localSource: false };
+  if (!count || tracing > 1 || tracing && args.at(-2) !== '--trace-fs') fail('--trace-fs requires explicit --local-source and must immediately precede it');
+  if (count !== 1 || args.at(-1) !== flag || !commands.has(args[0])) {
+    fail('Use --local-source exactly once, as the final argument of an SDK operation; installation and account configuration are excluded');
+  }
+  return { args: args.slice(0, tracing ? -2 : -1), localSource: true, ...(tracing ? { traceFs: true } : {}) };
+}
+export function verifyLocalSourceInstall(target, managed, bundle) {
+  if (!managed || typeof managed !== 'object' || managed.version !== bundle?.manifest?.version
+    || !/^[a-f0-9]{64}$/.test(managed.packageDigest ?? '') || !/^[a-f0-9]{64}$/.test(bundle.packageDigest ?? '')
+    || Object.keys(managed.files ?? {}).sort().join('\0') !== [...documents].sort().join('\0')
+    || documents.some(name => managed.files[name] !== bundle.hashes[name])) {
+    fail('Local unpublished source requires the existing pristine managed eight documents at the same version; preserve the installation and repair this mismatch explicitly');
+  }
+  return { schemaVersion: 'entrorove.local-source-execution/1.0', status: 'verified', mode: 'local-unpublished-source',
+    declaredVersion: bundle.manifest.version, managedDirectory: target, sourceDigest: bundle.packageDigest,
+    managedPackageDigest: managed.packageDigest, published: false, managedUnchanged: true,
+    grantsExecutionAuthority: false, managedInstallationPresent: true, updated: false };
+}
+export function localSourceInstall(target, managed, bundle, { explicit, hostId, hooks } = {}) {
+  if (explicit || hostId !== undefined || hooks) fail('Local source execution cannot install, replace, clean up or configure hooks');
+  const verified = verifyLocalSourceInstall(target, managed, bundle);
+  if (!announced) { process.stdout.write(`${JSON.stringify(verified)}\n`); announced = true; }
+  return verified;
+}
+export function cliErrorText(error) {
+  const prerequisite = prerequisiteFields(error);
+  return prerequisite.servicePrerequisite ? JSON.stringify({ status: 'blocked', code: error.code,
+    message: error.message, ...prerequisite, ...(error.requestId ? { requestId: error.requestId } : {}),
+    ...(error.outcomeUnknown ? { outcomeUnknown: true, repeatPost: false } : {}) })
+    : error instanceof SyntaxError ? 'Invalid JSON data' : error.message;
+}

package/manifest.json

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

package/mutation-challenge-refresh.mjs

@@ -1,6 +1,7 @@
 import { canonical, sha256 } from './local-integrity.mjs';
 import { buildInvocation } from './remote-client.mjs';
 import { mutationFail14 } from './local-mutation-files.mjs';
+import { consumeRecovery } from './local-recovery-budget.mjs';
 
 const fail = message => mutationFail14('ENTROROVE_MUTATION_CHALLENGE_REFRESH', message);
 export async function refreshExpiredMutationChallenge(context, callbacks) {
@@ -36,6 +37,8 @@ export async function refreshExpiredMutationChallenge(context, callbacks) {
     await save(location, state);
   }
   if (canonical(state.refreshOriginal.challenged.challenge) !== canonical(old)) fail('Original archived challenge binding changed');
+  consumeRecovery(state, 'signing', old.challengeId);
+  await save(location, state);
   const ref = { challengeId: old.challengeId, challengeDigest: sha256(canonical(old)) };
   const input = { ...Object.fromEntries(fields.map(field => [field, identity[field]])),
     ...(identity.previousPassId ? { previousPassId: identity.previousPassId } : {}),

package/mutation-client.mjs

@@ -21,6 +21,8 @@ import { readMutationConnection as readConnection } from './mutation-connection-
 import { readMutationEnvironmentObservation } from './local-mutation-environment-observation.mjs';
 import { refreshExpiredMutationChallenge } from './mutation-challenge-refresh.mjs';
 import { scopeContextObservation, scopeContextSnapshotInput } from './scope-context-observation.mjs';
+import { prerequisiteError, retainPrerequisite, retryKnownPrerequisite, prerequisiteFields } from './service-prerequisite.mjs';
+import { consumeRecovery, recoveryFailureFields } from './local-recovery-budget.mjs';
 
 const fields = ['taskId', 'flowId', 'stepId', 'leaseId', 'generation', 'runnerId', 'paths'];
 const fail = message => mutationFail14('ENTROROVE_MUTATION_CONNECTION_BINDING', message);
@@ -44,13 +46,16 @@ async function recoverRemote(pending, dependencies) {
     const token = await dependencies.readCredential(dependencies.home), origin = trustedOrigin(dependencies.apiOrigin());
     const response = await requestTransport(origin, `/api/skill/status/${pending.requestId}`, { headers: { authorization: `Bearer ${token}`, ...ideClientHeaders() } });
     const result = await parseTransportResponse(response, 'original mutation connection status');
+    const prerequisite = prerequisiteError(response, result, { requestId: pending.requestId });
+    if (prerequisite) throw Object.assign(unknown(pending.requestId), { servicePrerequisite: prerequisite.servicePrerequisite });
     if (!response.ok || result?.output?.requestId !== pending.requestId || ['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());
     await appendInvocation({ kind: 'remote', operation: 'status', requestId: pending.requestId, event: 'status', usage: result.usage ?? [] }, dependencies.home);
     return { response, result };
-  } catch { throw unknown(pending.requestId); }
+  } catch (error) { throw Object.assign(unknown(pending.requestId),
+    error?.servicePrerequisite ? { servicePrerequisite: error.servicePrerequisite } : {}); }
 }
 async function knownNotSent(error, pending, home) {
   if (error?.requestId && error.requestId !== pending.requestId || error?.retryableBeforeTransmission === true) return true;
@@ -62,22 +67,27 @@ async function knownNotSent(error, pending, home) {
 async function remote(stage, operation, input, state, location, dependencies) {
   const requestId = buildInvocation(operation, input).requestId;
   let response, result;
-  if (state.pending) {
+  const existing = Boolean(state.pending);
+  if (existing) {
     if (state.pending.stage !== stage || state.pending.operation !== operation || canonical(state.pending.input) !== canonical(input)) {
       fail('Recover the original mutation request before another operation or input');
     }
+  }
+  if (existing && !await retryKnownPrerequisite(state, location, save)) {
+    consumeRecovery(state, 'status'); await save(location, state);
     ({ response, result } = await recoverRemote(state.pending, dependencies));
   } else {
-    state.pending = { stage, operation, input, requestId };
+    if (!existing) state.pending = { stage, operation, input, requestId };
     try { await save(location, state); } catch { throw notSent(requestId); }
     try { ({ response, result } = await invokeRemoteResult({ operation, input }, dependencies)); }
     catch (error) {
+      if (await retainPrerequisite(error, state, location, save)) throw error;
       if (await knownNotSent(error, state.pending, dependencies.home)) {
         delete state.pending;
         try { await save(location, state); } catch { throw notSent(requestId); }
         throw notSent(requestId);
       }
-      throw unknown(requestId);
+      throw Object.assign(unknown(requestId), error?.servicePrerequisite ? { servicePrerequisite: error.servicePrerequisite } : {});
     }
   }
   delete state.pending;
@@ -294,6 +304,7 @@ async function runMutationClient(operation, repositoryRoot, input, dependencies,
     if (error?.outcomeUnknown === true && requestId) return {
       schemaVersion: 'entrorove.mutation-connection/1.0', status: 'blocked', flowId: input?.flowId, requestId,
       code: 'ENTROROVE_MUTATION_CONNECTION_OUTCOME_UNKNOWN', outcomeUnknown: true, recoverable: true,
+      ...prerequisiteFields(error),
       message: `Original mutation request outcome is unknown; rerun ${operation} with the same input to recover only its original GET, without repeating its POST`,
       nextAction: { operation, requestId, method: 'GET', reuseOriginalInput: true, repeatPost: false },
     };
@@ -301,11 +312,12 @@ async function runMutationClient(operation, repositoryRoot, input, dependencies,
     const knownBeforeTransmission = preflight || error?.knownBeforeTransmission === true;
     return { schemaVersion: 'entrorove.mutation-connection/1.0', status: 'blocked', flowId: input?.flowId,
       code: typed ? error.code : 'ENTROROVE_MUTATION_CONNECTION_LOCAL_PREREQUISITE',
+      ...prerequisiteFields(error),
       message: typed ? error.message : 'Mutation connection stopped at a local prerequisite; preserve its journal and repair before reusing the original input',
       ...(requestId ? { requestId } : {}), ...(knownBeforeTransmission ? { knownBeforeTransmission: true } : {}),
       recovery: { operation, reuseOriginalInput: true, preserveJournal: true,
         ...(knownBeforeTransmission ? { remoteAttemptedThisRun: false } : {}) },
-      ...(error?.output ? { output: error.output } : {}) };
+      ...(error?.output ? { output: error.output } : {}), ...recoveryFailureFields(error) };
   }
 }
 export const runMutationConnect = (repositoryRoot, input, dependencies) => runMutationClient('mutation-connect', repositoryRoot, input, dependencies, connectMutation);