@entrorove/skill 0.1.73 → 0.1.81

package/design-research.mjs

@@ -1,43 +1,23 @@
-import https from 'node:https';
-import dns from 'node:dns/promises';
 import net from 'node:net';
 import path from 'node:path';
 import { parse as yaml } from 'yaml';
 import { mutationRead14, mutationTarget14 } from './local-mutation-files.mjs';
 import { sha256 } from './local-integrity.mjs';
 import { designFail } from './design-policy.mjs';
+import { publicResearchAddresses, researchResponse } from './design-research-network.mjs';
 
 import { FRAMEWORK_DOC_HOSTS } from './design-frameworks.mjs';
 export { FRAMEWORK_DOC_HOSTS } from './design-frameworks.mjs';
 export function researchUrl(value) {
   let url; try { url = new URL(value); } catch { designFail('RESEARCH_URL', 'Research requires an absolute public HTTPS URL'); }
   if (url.protocol !== 'https:' || url.username || url.password || url.port && url.port !== '443' || url.hash
-    || net.isIP(url.hostname) || /(^|\.)(localhost|local|internal|test|invalid)$/i.test(url.hostname)
+    || net.isIP(url.hostname.replace(/^\[|\]$/g, '')) || /(^|\.)(localhost|local|internal|test|invalid)$/i.test(url.hostname)
     || [...url.searchParams.keys()].some(key => /token|secret|password|key|signature|credential/i.test(key))) designFail('RESEARCH_URL', 'Research URLs must be public, credential-free HTTPS references');
   return url;
 }
-function publicIp(address) {
-  if (net.isIP(address) !== 4) return false;
-  const [a, b, c] = address.split('.').map(Number);
-  return ![0, 10, 127].includes(a) && a < 224 && !(a === 169 && b === 254)
-    && !(a === 172 && b >= 16 && b <= 31) && !(a === 192 && (b === 168 || b === 0 && [0, 2].includes(c)))
-    && !(a === 198 && ([18, 19].includes(b) || b === 51 && c === 100)) && !(a === 203 && b === 0 && c === 113)
-    && !(a === 100 && b >= 64 && b <= 127);
-}
 export async function fetchDesignReference(value, redirects = 0) {
-  const url = researchUrl(value), addresses = await dns.lookup(url.hostname, { all: true, family: 4 });
-  if (!addresses.length || addresses.some(item => !publicIp(item.address))) designFail('RESEARCH_URL', 'Research hostname resolves outside the public internet');
-  const result = await new Promise((resolve, reject) => {
-    const req = https.get(url, { headers: { accept: 'text/html,text/plain,application/json', 'user-agent': 'Entrorove design research' },
-      lookup: (_host, options, callback) => callback(null, options.all ? [addresses[0]] : addresses[0].address, 4) }, response => {
-      const chunks = []; let bytes = 0;
-      response.on('data', chunk => { bytes += chunk.length; if (bytes > 2_097_152) req.destroy(Object.assign(new Error('Research response exceeds 2 MiB'), { code: 'ENTROROVE_DESIGN_RESEARCH_SIZE' })); else chunks.push(chunk); });
-      response.on('end', () => resolve({ status: response.statusCode, location: response.headers.location, type: response.headers['content-type'], body: Buffer.concat(chunks) }));
-      response.on('error', reject);
-    });
-    req.setTimeout(15_000, () => req.destroy(Object.assign(new Error('Research fetch timed out'), { code: 'ENTROROVE_DESIGN_RESEARCH_TIMEOUT' })));
-    req.on('error', reject);
-  });
+  const url = researchUrl(value), addresses = await publicResearchAddresses(url.hostname);
+  const result = await researchResponse(url, addresses);
   if ([301, 302, 303, 307, 308].includes(result.status)) {
     if (!result.location || redirects >= 4) designFail('RESEARCH_REDIRECT', 'Research redirect did not resolve to a bounded public reference');
     return fetchDesignReference(new URL(result.location, url).href, redirects + 1);
@@ -76,7 +56,10 @@ export async function assertDeclaredDesignFrameworks(input, design) {
         if (!checked.has(name)) {
           const actual = JSON.parse((await mutationRead14(input, input.repositoryRoot, name)).content.toString('utf8'));
           const packages = { ...actual.dependencies, ...actual.devDependencies };
-          if (Object.keys(packages).some(packageName => Object.hasOwn(FRAMEWORK_DOC_HOSTS, packageName) && !declared.has(packageName))) designFail('FRAMEWORK_MISSING', 'Research every actual declared framework in the nearest UI package using its official documentation and locked version');
+          if (Object.keys(packages).some(packageName => Object.hasOwn(FRAMEWORK_DOC_HOSTS, packageName)
+            && !design.frameworks.some(framework => framework.packageName === packageName && framework.packagePath === name))) {
+            designFail('FRAMEWORK_MISSING', 'Research every actual declared framework in its nearest UI package using that package file and locked version');
+          }
           checked.add(name);
         }
         break;

package/design-runner.mjs

@@ -3,10 +3,12 @@ import { assertDesignDeclaration } from './design-declaration.mjs';
 import { assertDesignWrite } from './design-gate.mjs';
 import { designUiCandidate } from './design-ui.mjs';
 import { designFail } from './design-policy.mjs';
+import { assertDesignStageSources } from './design-stage.mjs';
 
 export async function designRunnerBefore(input, authority) {
   const policy = authority.plan.policy.discipline, originals = new Map();
   if (!policy || policy.access === 'read-only') return originals;
+  if (policy.design) await assertDesignStageSources(input, policy.design);
   assertDesignDeclaration(policy, policy.writes.flatMap(write => [write.targetPath, ...(write.destinationPath ? [write.destinationPath] : [])]));
   for (const write of policy.writes) {
     const target = await mutationTarget14(authority.root, write.targetPath, true);
@@ -19,6 +21,7 @@ export async function designRunnerBefore(input, authority) {
 }
 export async function designRunnerAfter(input, authority, changed, originals) {
   const policy = authority.plan.policy.discipline;
+  if (policy?.design) await assertDesignStageSources(input, policy.design);
   for (const name of changed) {
     const target = await mutationTarget14(authority.root, name, true);
     const source = target.exists && target.stat.size <= 2_097_152

package/design-stage-contracts.mjs

@@ -0,0 +1,12 @@
+import { object, array, text, identifier, relativePath, sha256 } from './local-contract-types.mjs';
+
+const names = min => ({ ...array(identifier, min), maxItems: 256, uniqueItems: true });
+const source = object({ path: relativePath, sha256 }, ['path', 'sha256']);
+export const DESIGN_STAGE_SCHEMA = object({ id: identifier, requirementIds: names(1), pageIds: names(1), edgeIds: names(0),
+  readOnlyPages: { ...array(object({ pageId: identifier, sources: { ...array(source, 1), maxItems: 128 } }, ['pageId', 'sources']), 0), maxItems: 128 } },
+['id', 'requirementIds', 'pageIds', 'edgeIds', 'readOnlyPages']);
+const value = { anyOf: [{ type: 'string', maxLength: 8192 }, { type: 'null' }] };
+export const DESIGN_HANDOFF_SCHEMA = object({ area: { enum: ['local-storage', 'session-storage'] },
+  key: { ...text, maxLength: 128, pattern: '^[^\\u0000-\\u001f\\u007f]+$' },
+  method: { enum: ['setItem', 'removeItem'] }, before: value, after: value, count: { const: 1 } },
+['area', 'key', 'method', 'before', 'after', 'count']);

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-approved-process.mjs

@@ -25,7 +25,11 @@ function supervisionError(code, message, effects = 'unknown') {
 }
 
 export async function runApprovedProcess(authority) {
-  const started = performance.now(), input = launchInput(authority);
+  const started = performance.now();
+  let input;
+  try { input = launchInput(authority); }
+  catch (error) { throw Object.assign(error, { execution: { schemaVersion: RUNNER_SCHEMA, status: 'failed', evidence: [],
+    effects: 'none', prelaunchVerified: true } }); }
   return new Promise((resolve, reject) => {
     let finished = false;
     const supervisor = fork(SUPERVISOR, [], { execPath: process.execPath, execArgv: [], env: {}, detached: true,

package/local-cli.mjs

@@ -44,6 +44,45 @@ async function stdinJson() {
   return value;
 }
 
+// Discovery takes an optional input object. A host that keeps stdin open
+// without writing must not block the skill, so wait only briefly for data.
+export async function optionalStdinJson(idleMs = 200) {
+  if (process.stdin.isTTY) return {};
+  return new Promise((resolve, reject) => {
+    let raw = '';
+    let settled = false;
+    let timer;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      process.stdin.off('data', onData);
+      process.stdin.off('end', onEnd);
+      process.stdin.off('error', onError);
+      process.stdin.pause();
+    };
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error) return reject(error);
+      if (!raw.trim()) return resolve({});
+      let value;
+      try { value = JSON.parse(raw); } catch { return reject(new Error('Local input must be valid JSON')); }
+      if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return reject(new Error('local input must be a JSON object'));
+      }
+      resolve(value);
+    };
+    const onData = chunk => { raw += chunk; };
+    const onEnd = () => finish();
+    const onError = error => finish(error);
+    process.stdin.on('data', onData);
+    process.stdin.once('end', onEnd);
+    process.stdin.once('error', onError);
+    timer = setTimeout(() => finish(), idleMs);
+    process.stdin.resume();
+  });
+}
+
 const operations = {
   'mutation-consumption-attest': attestMutationConsumption14,
   'mutation-delegate-prepare': preparePreservedMutationSigner,
@@ -102,7 +141,7 @@ export async function runLocal(args = [], dependencies) {
   try {
     const operation = args[0];
     if (operation === 'capabilities' || operation === 'help') {
-      validateLocalInput(operation, process.stdin.isTTY ? {} : await stdinJson());
+      validateLocalInput(operation, await optionalStdinJson());
       process.stdout.write(`${JSON.stringify(capabilitiesFor(args[1]))}\n`); return;
     }
     const handler = operations[operation];

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

@@ -71,15 +71,19 @@ async function probeHandoffCandidate(input, root, candidate, signingOptions) {
 }
 function probeSigningOptions(options) {
   if (!options || typeof options !== 'object' || Array.isArray(options)
-    || Object.keys(options).some(key => key !== 'maximumExpiresAt')
-    || options.maximumExpiresAt !== undefined && (!Number.isSafeInteger(options.maximumExpiresAt) || options.maximumExpiresAt < 1)) {
-    scopeFail('ENTROROVE_SCOPE_ATTESTATION_BINDING', 'Internal probe signing options require only a finite exact deadline');
+    || 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 };
+  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, signingOptions);

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'