@entrorove/skill 0.1.51 → 0.1.53

package/local-approved-process.mjs

@@ -0,0 +1,54 @@
+import { fork } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
+
+const SUPERVISOR = new URL('./local-approved-supervisor.mjs', import.meta.url);
+const MESSAGE_SCHEMA = 'entrorove.approved-process-supervision/1.0';
+const RUNNER_SCHEMA = 'entrorove.validator-local-runner/1.0';
+
+function launchInput(authority) {
+  const now = Date.now(), policy = authority.policy;
+  const leaseDeadline = authority.executionDeadlineAt === undefined ? Infinity : Date.parse(authority.executionDeadlineAt);
+  const startDeadlineAt = authority.startDeadlineAt === undefined ? null : Date.parse(authority.startDeadlineAt);
+  if ((!Number.isFinite(leaseDeadline) && leaseDeadline !== Infinity) || leaseDeadline <= now
+    || (startDeadlineAt !== null && (!Number.isFinite(startDeadlineAt) || startDeadlineAt <= now))) {
+    throw Object.assign(new Error('workflow execution lease expired before process launch'), { code: 'ENTROROVE_WORKFLOW_EXPIRED' });
+  }
+  return { schemaVersion: MESSAGE_SCHEMA, root: authority.root, executable: policy.executable, args: policy.args,
+    environment: policy.environment, timeoutMs: policy.timeoutMs, maxOutputBytes: policy.maxOutputBytes,
+    objectPlan: Boolean(authority.objectPlan), deadlineAt: Math.min(now + policy.timeoutMs, leaseDeadline), startDeadlineAt,
+    leaseDeadline: leaseDeadline <= now + policy.timeoutMs };
+}
+
+function supervisionError(code, message, effects = 'unknown') {
+  return Object.assign(new Error(message), { code,
+    execution: { schemaVersion: RUNNER_SCHEMA, status: 'failed', evidence: [], effects } });
+}
+
+export async function runApprovedProcess(authority) {
+  const started = performance.now(), input = launchInput(authority);
+  return new Promise((resolve, reject) => {
+    let finished = false;
+    const supervisor = fork(SUPERVISOR, [], { execPath: process.execPath, execArgv: [], env: {}, detached: true,
+      stdio: ['ignore', 'ignore', 'ignore', 'ipc'], serialization: 'json' });
+    const finish = (error, result) => {
+      if (finished) return; finished = true;
+      if (supervisor.connected) supervisor.disconnect();
+      if (error) reject(error); else resolve({ ...result, durationMs: Math.max(0, Math.round(performance.now() - started)) });
+    };
+    supervisor.on('message', message => {
+      if (message?.schemaVersion !== MESSAGE_SCHEMA || message.type !== 'result') return;
+      if (message.error) {
+        const error = Object.assign(new Error(message.error.message), { code: message.error.code });
+        if (message.process) error.execution = { schemaVersion: RUNNER_SCHEMA, status: 'failed', process: message.process,
+          evidence: [], effects: message.process.started === true ? 'unknown' : 'none' };
+        finish(error); return;
+      }
+      finish(null, message.process);
+    });
+    supervisor.once('error', () => finish(supervisionError('ENTROROVE_PROCESS_SUPERVISOR', 'Approved process supervision could not start', 'none')));
+    supervisor.once('close', () => { if (!finished) finish(supervisionError('ENTROROVE_PROCESS_SUPERVISOR', 'Approved process supervision ended without a result')); });
+    supervisor.send(input, error => {
+      if (error) finish(supervisionError('ENTROROVE_PROCESS_SUPERVISOR', 'Approved process supervision could not receive its frozen command', 'none'));
+    });
+  });
+}

package/local-approved-supervisor.mjs

@@ -0,0 +1,99 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+
+const MESSAGE_SCHEMA = 'entrorove.approved-process-supervision/1.0';
+const RUNNER_SCHEMA = 'entrorove.validator-local-runner/1.0';
+const FIELDS = ['schemaVersion', 'root', 'executable', 'args', 'environment', 'timeoutMs', 'maxOutputBytes', 'objectPlan', 'deadlineAt', 'startDeadlineAt', 'leaseDeadline'];
+const ENV = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function validInput(value) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).sort().join('|') === [...FIELDS].sort().join('|') && value.schemaVersion === MESSAGE_SCHEMA
+    && typeof value.root === 'string' && path.isAbsolute(value.root) && !value.root.includes('\0')
+    && typeof value.executable === 'string' && path.isAbsolute(value.executable) && !value.executable.includes('\0')
+    && Array.isArray(value.args) && value.args.length <= 128
+    && value.args.every(item => typeof item === 'string' && !item.includes('\0') && item.length <= 4096)
+    && value.environment && typeof value.environment === 'object' && !Array.isArray(value.environment)
+    && Object.keys(value.environment).length <= 64
+    && Object.entries(value.environment).every(([key, item]) => ENV.test(key) && typeof item === 'string' && !item.includes('\0') && item.length <= 16_384)
+    && Number.isSafeInteger(value.timeoutMs) && value.timeoutMs > 0 && value.timeoutMs <= 300_000
+    && Number.isSafeInteger(value.maxOutputBytes) && value.maxOutputBytes > 0 && value.maxOutputBytes <= 1_048_576
+    && typeof value.objectPlan === 'boolean' && typeof value.leaseDeadline === 'boolean'
+    && (value.startDeadlineAt === null || Number.isSafeInteger(value.startDeadlineAt))
+    && Number.isSafeInteger(value.deadlineAt) && value.deadlineAt <= Date.now() + value.timeoutMs;
+}
+
+function resultMessage(processResult, error) {
+  return { schemaVersion: MESSAGE_SCHEMA, type: 'result', process: processResult,
+    ...(error ? { error: { code: error.code ?? 'ENTROROVE_PROCESS_SUPERVISOR', message: String(error.message).slice(0, 1024) } } : {}) };
+}
+
+function deliver(value) {
+  if (!process.connected) return;
+  process.send(value, () => { if (process.connected) process.disconnect(); });
+}
+
+function assertLaunchable(input) {
+  if (!process.connected || input.deadlineAt <= Date.now() || input.startDeadlineAt !== null && input.startDeadlineAt <= Date.now()) {
+    throw Object.assign(new Error('workflow execution lease expired before process launch'), { code: 'ENTROROVE_WORKFLOW_EXPIRED' });
+  }
+}
+
+function supervise(input) {
+  const started = performance.now(), stdout = [], stderr = [], stdoutHash = createHash('sha256'), stderrHash = createHash('sha256');
+  let bytes = 0, dropped = 0, timedOut = false, terminating = false, spawned = false, closed = false;
+  let processStartedAt = null, spawnError = null, killTimer;
+  assertLaunchable(input);
+  const child = spawn(input.executable, input.args, { cwd: input.root, env: { ...input.environment },
+    shell: false, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+  const signalGroup = signal => { if (!closed && child.pid) { try { process.kill(-child.pid, signal); } catch {} } };
+  const terminate = () => {
+    if (terminating || closed) return; terminating = true; signalGroup('SIGTERM');
+    killTimer = setTimeout(() => signalGroup('SIGKILL'), 250);
+  };
+  const consume = (target, hash, chunk) => {
+    const data = Buffer.from(chunk); hash.update(data);
+    const keep = Math.max(0, Math.min(data.length, input.maxOutputBytes - bytes));
+    if (keep) target.push(data.subarray(0, keep)); bytes += keep; dropped += data.length - keep;
+    if (dropped) terminate();
+  };
+  const timer = setTimeout(() => { timedOut = true; terminate(); }, Math.max(1, input.deadlineAt - Date.now()));
+  process.once('disconnect', terminate); process.once('SIGTERM', terminate); process.once('SIGINT', terminate);
+  child.stdout.on('data', chunk => consume(stdout, stdoutHash, chunk)); child.stderr.on('data', chunk => consume(stderr, stderrHash, chunk));
+  child.once('spawn', () => { spawned = true; processStartedAt = new Date().toISOString(); });
+  child.once('error', error => { spawnError = error; terminate(); });
+  child.once('exit', () => signalGroup('SIGKILL'));
+  child.once('close', (exitCode, signal) => {
+    closed = true; clearTimeout(timer); clearTimeout(killTimer);
+    process.removeListener('disconnect', terminate); process.removeListener('SIGTERM', terminate); process.removeListener('SIGINT', terminate);
+    const processResult = { schemaVersion: RUNNER_SCHEMA,
+      status: exitCode === 0 && signal === null && !timedOut && !dropped && !spawnError ? 'succeeded' : 'failed',
+      exitCode, signal, timedOut, outputLimitExceeded: dropped > 0, durationMs: Math.max(0, Math.round(performance.now() - started)),
+      stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8'),
+      stdoutSha256: stdoutHash.digest('hex'), stderrSha256: stderrHash.digest('hex'), capturedBytes: bytes, droppedBytes: dropped,
+      ...(input.objectPlan ? { started: spawned, startedAt: processStartedAt, finishedAt: new Date().toISOString(),
+        executionDeadlineExceeded: timedOut && input.leaseDeadline } : {}) };
+    deliver(resultMessage(processResult, spawnError));
+  });
+  if (!process.connected) terminate();
+}
+
+function main() {
+  if (process.argv.length !== 2 || typeof process.send !== 'function' || !process.connected) { process.exitCode = 2; return; }
+  const startup = setTimeout(() => { if (process.connected) process.disconnect(); }, 5_000);
+  const disconnect = () => clearTimeout(startup); process.once('disconnect', disconnect);
+  process.once('message', input => {
+    clearTimeout(startup); process.removeListener('disconnect', disconnect);
+    if (!process.connected) return;
+    if (!validInput(input)) {
+      deliver(resultMessage(null, { code: 'ENTROROVE_PROCESS_SUPERVISOR', message: 'Approved process supervision requires one bounded frozen command' })); return;
+    }
+    try { supervise(input); }
+    catch (error) { deliver(resultMessage(null, error.code === 'ENTROROVE_WORKFLOW_EXPIRED' ? error
+      : { code: 'ENTROROVE_PROCESS_SUPERVISOR', message: 'Approved process supervision could not launch its frozen command' })); }
+  });
+}
+
+main();

package/local-cli.mjs

@@ -28,6 +28,10 @@ import { DISCIPLINE_LOCAL_OPERATIONS } from './local-discipline-operations.mjs';
 import { assertIdeExecution, settleBreakGlassSession } from './ide-session.mjs';
 import { runManagedWorkflowLocalStep } from './workflow-local-client.mjs';
 import { localErrorEnvelope } from './local-error.mjs';
+import { preparePreservedMutationSigner } from './local-preserved-mutation-signer.mjs';
+import { hydrateCloudMutationAuthority } from './cloud-mutation-authority.mjs';
+import { attestMutationConsumption14 } from './local-mutation-consumption.mjs';
+import { apiUrl } from './remote-client.mjs';
 
 async function stdinJson() {
   let raw = '';
@@ -40,6 +44,8 @@ async function stdinJson() {
 }
 
 const operations = {
+  'mutation-consumption-attest': attestMutationConsumption14,
+  'mutation-delegate-prepare': preparePreservedMutationSigner,
   ...DISCIPLINE_LOCAL_OPERATIONS,
   'snapshot-plan': snapshotPlan, 'snapshot-verify': snapshotVerify, 'mutation-snapshot-attest': attestMutationSnapshot14, 'mutate-gate': mutateGate,
   'gate-issue': issueMutationPass, 'gate-verify': verifyMutationPass, 'guarded-write': guardedWrite,
@@ -79,7 +85,11 @@ function capabilitiesFor(group) {
 }
 
 async function checkedLocalInput(operation, input) {
-  try { return validateLocalInput(operation, input); }
+  try {
+    const validated = validateLocalInput(operation, input);
+    if (['mutation-snapshot-attest', 'mutation-consumption-attest', 'workflow-run-step', 'mutate-gate', 'gate-issue', 'gate-verify', 'guarded-write', 'guarded-delete', 'guarded-move', 'discipline-review', 'discipline-check'].includes(operation)) await hydrateCloudMutationAuthority(input.home, new URL(apiUrl).origin);
+    return validated;
+  }
   catch (cause) {
     if (['guarded-write', 'guarded-delete', 'guarded-move', 'gate-issue', 'mutate-gate', 'mutation-snapshot-attest'].includes(operation)) await recordMutationDenied14(input, cause, operation);
     throw cause;
@@ -94,9 +104,10 @@ export async function runLocal(args = [], dependencies) {
       process.stdout.write(`${JSON.stringify(capabilitiesFor(args[1]))}\n`); return;
     }
     const handler = operations[operation];
-    if (!handler) throw new Error(`Usage: entrorove local <${['capabilities', ...Object.keys(operations)].join('|')}> [repositoryRoot]`);
+    if (!handler && process.stdin.isTTY) throw new Error(`Unsupported local operation: ${operation}`);
     const input = await stdinJson();
     await assertIdeExecution(['local', ...args], input);
+    if (!handler) throw new Error(`Usage: entrorove local <${['capabilities', ...Object.keys(operations)].join('|')}> [repositoryRoot]`);
     if (args[1] && input.repositoryRoot === undefined) input.repositoryRoot = args[1];
     const validated = await checkedLocalInput(operation, input);
     const supplied = operation === 'workflow-run-step' || Object.hasOwn(LOCAL_CHAIN_OPERATIONS, operation) ? dependencies : undefined;

package/local-contracts.mjs

@@ -29,6 +29,8 @@ add('flow-cancel|flow-abandon', flowLifecycle, ['repositoryRoot', 'flowId']);
 add('snapshot-plan', { ...step, paths, snapshotId: identifier, contractDigest: nullable(sha256), handoffCandidate: HANDOFF_SNAPSHOT_CANDIDATE_SCHEMA }, ['repositoryRoot', 'flowId', 'stepId', 'paths']);
 add('snapshot-verify', { ...step, snapshotId: identifier }, ['repositoryRoot', 'flowId', 'stepId', 'snapshotId']);
 const gate = { ...step, taskId: identifier, mutationPass: record };
+add('mutation-delegate-prepare', { ...step, taskId: identifier }, ['repositoryRoot', 'home', 'flowId']);
+add('mutation-consumption-attest', { ...step, taskId: identifier, gatePassPath: text }, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath']);
 add('mutate-gate|gate-issue', gate, ['repositoryRoot', 'flowId', 'stepId', 'mutationPass']);
 add('mutation-snapshot-attest', { ...step, taskId: identifier, snapshotId: identifier, challenge: record, signerConfigPath: text },
   ['repositoryRoot', 'flowId', 'stepId', 'snapshotId', 'challenge', 'signerConfigPath']);

package/local-delegated-modify-analysis.mjs

@@ -0,0 +1,232 @@
+import ts from 'typescript';
+import { parse as parseVue, parseCache } from '@vue/compiler-sfc';
+import { canonical } from './local-integrity.mjs';
+import { createScopeImportResolver } from './local-scope-import-expressions.mjs';
+import { isDynamicFunctionReference, isTypeOnlyReference } from './local-typescript-function-reference.mjs';
+
+const fail = () => { throw Object.assign(new Error('Preserved modification changed an existing definition, public contract, dependency, or unsupported source boundary'),
+  { code: 'ENTROROVE_MUTATION_DELEGATION_CHANGE' }); };
+const printer = ts.createPrinter({ removeComments: true });
+const print = node => node ? printer.printNode(ts.EmitHint.Unspecified, node, node.getSourceFile()) : null;
+function unwrap(node) {
+  while (node && (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)
+    || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node))) node = node.expression;
+  return node;
+}
+function names(node) {
+  if (!node) return [];
+  if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isPrivateIdentifier(node)) return [node.text];
+  if (ts.isObjectBindingPattern(node) || ts.isArrayBindingPattern(node)) return node.elements.flatMap(item => ts.isBindingElement(item) ? names(item.name) : []);
+  return [print(node)];
+}
+function owner(node) {
+  if (node.name) return names(node.name).join(',');
+  if (node.parent?.name && (ts.isVariableDeclaration(node.parent) || ts.isPropertyAssignment(node.parent))) return names(node.parent.name).join(',');
+  return '<anonymous>';
+}
+function scope(node) {
+  const parts = [];
+  for (let parent = node.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
+    if (ts.isFunctionLike(parent) || ts.isClassLike(parent) || ts.isModuleDeclaration(parent)) parts.unshift(`${parent.kind}:${owner(parent)}`);
+  }
+  return parts.join('/');
+}
+const modifiers = node => node.modifiers?.map(value => value.kind) ?? [];
+function signature(node) {
+  return { kind: node.kind, name: node.name ? print(node.name) : null, modifiers: modifiers(node), optional: Boolean(node.questionToken),
+    generator: Boolean(node.asteriskToken), types: node.typeParameters?.map(print) ?? [], type: print(node.type),
+    parameters: node.parameters?.map(print) ?? [] };
+}
+function exported(node, exportNames) {
+  if (names(node.name).some(name => exportNames.has(name))) return true;
+  for (let current = node; current && !ts.isSourceFile(current); current = current.parent) {
+    if (current !== node && ts.isFunctionLike(current)) return false;
+    if (current.modifiers?.some(value => [ts.SyntaxKind.ExportKeyword, ts.SyntaxKind.DefaultKeyword].includes(value.kind))
+      || ts.isExportAssignment(current)) return true;
+  }
+  return false;
+}
+function exportedNames(source) {
+  const result = new Set();
+  for (const node of source.statements) {
+    if (ts.isExportDeclaration(node) && !node.moduleSpecifier && node.exportClause && ts.isNamedExports(node.exportClause)) {
+      for (const item of node.exportClause.elements) result.add((item.propertyName ?? item.name).text);
+    }
+    if (ts.isExportAssignment(node) && ts.isIdentifier(unwrap(node.expression))) result.add(unwrap(node.expression).text);
+  }
+  const common = node => {
+    if (commonJs(node)) {
+      const value = unwrap(node.right);
+      if (ts.isIdentifier(value)) result.add(value.text);
+      if (ts.isObjectLiteralExpression(value)) for (const property of value.properties) {
+        if (ts.isShorthandPropertyAssignment(property)) result.add(property.name.text);
+        if (ts.isPropertyAssignment(property) && ts.isIdentifier(unwrap(property.initializer))) result.add(unwrap(property.initializer).text);
+      }
+    }
+    ts.forEachChild(node, common);
+  };
+  common(source);
+  return result;
+}
+function isDefinition(node) {
+  return ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)
+    || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isEnumMember(node)
+    || ts.isPropertySignature(node) || ts.isMethodSignature(node) || ts.isPropertyDeclaration(node) || ts.isMethodDeclaration(node)
+    || ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node) || ts.isGetAccessorDeclaration(node)
+    || ts.isSetAccessorDeclaration(node) || ts.isModuleDeclaration(node) || ts.isImportSpecifier(node) || ts.isImportClause(node)
+    || ts.isNamespaceImport(node) || ts.isImportEqualsDeclaration(node) || ts.isTypeParameterDeclaration(node);
+}
+const increment = (map, key) => map.set(key, (map.get(key) ?? 0) + 1);
+function variableContract(node) {
+  const value = unwrap(node.initializer);
+  return { ...signature(node), binding: node.parent.flags & (ts.NodeFlags.Const | ts.NodeFlags.Let),
+    callable: value && ts.isFunctionLike(value) ? signature(value) : null,
+    alias: value && (ts.isIdentifier(value) || ts.isPropertyAccessExpression(value) || ts.isElementAccessExpression(value)) ? print(value) : null };
+}
+function isDependency(node) {
+  return ts.isImportDeclaration(node) || ts.isExportDeclaration(node) || ts.isImportEqualsDeclaration(node) || ts.isImportTypeNode(node)
+    || ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword
+      || ts.isIdentifier(node.expression) && node.expression.text === 'require');
+}
+function dependency(node, source, resolve) {
+  const call = ts.isCallExpression(node);
+  return { syntax: print(node), alternatives: call ? resolve(node.arguments[0]) : null,
+    comments: source.text.slice(node.getStart(source), node.end).match(/\/\*[\s\S]*?\*\//g) ?? [] };
+}
+function commonJs(node) {
+  return ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken
+    && /^(?:module\.exports|exports)(?:\.[A-Za-z_$][\w$]*|\[[\s\S]+\])?$/.test(print(node.left) ?? '');
+}
+function sourceChecker(source) {
+  const filename = `/${source.fileName.replace(/^\/+/, '')}`;
+  const matches = value => `/${value.replace(/^\/+/, '')}` === filename;
+  return ts.createProgram([filename], { noLib: true, noResolve: true, allowJs: true }, {
+    getSourceFile: value => matches(value) ? source : undefined, getDefaultLibFileName: () => '/none.d.ts', writeFile: () => {},
+    getCurrentDirectory: () => '/', getDirectories: () => [], fileExists: matches,
+    readFile: value => matches(value) ? source.text : undefined, getCanonicalFileName: value => value,
+    useCaseSensitiveFileNames: () => true, getNewLine: () => '\n',
+  }).getTypeChecker();
+}
+function exportedObject(value) {
+  return value.properties.map(property => {
+    const initializer = ts.isPropertyAssignment(property) ? unwrap(property.initializer) : property;
+    return { name: print(property.name), kind: property.kind,
+      alias: ts.isIdentifier(initializer) || ts.isPropertyAccessExpression(initializer) ? print(initializer) : null,
+      callable: ts.isFunctionLike(initializer) ? signature(initializer) : null };
+  });
+}
+function unknownReference(node, context) {
+  if (isTypeOnlyReference(node)) return false;
+  if (ts.isIdentifier(node) && (['eval', 'createRequire'].includes(node.text) || isDynamicFunctionReference(node, context))) return true;
+  if (ts.isIdentifier(node) && node.text === 'require' && !(ts.isCallExpression(node.parent) && node.parent.expression === node)
+    && !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node)) return true;
+  if (ts.isElementAccessExpression(node) && (!ts.isStringLiteralLike(node.argumentExpression)
+    || ['Function', 'eval', 'require', 'createRequire'].includes(node.argumentExpression.text))) return true;
+  return ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression)
+    && ['Object', 'Reflect'].includes(node.expression.expression.text) && ['get', 'set', 'defineProperty'].includes(node.expression.name.text);
+}
+function scriptProjection(part) {
+  const kind = /\.[jt]sx$/i.test(part.path) ? ts.ScriptKind.TSX : /\.[cm]?js$/i.test(part.path) ? ts.ScriptKind.JS : ts.ScriptKind.TS;
+  const source = ts.createSourceFile(part.path, part.content, ts.ScriptTarget.Latest, true, kind);
+  if (source.parseDiagnostics.length) fail();
+  const result = { dependencies: [], definitions: new Map(), signatures: new Map(), public: [], unknown: new Map() };
+  const exports = exportedNames(source), resolve = createScopeImportResolver(source);
+  let visited = 0, checker;
+  const inferred = node => {
+    checker ??= sourceChecker(source);
+    return checker.typeToString(checker.getTypeAtLocation(node), node, ts.TypeFormatFlags.NoTruncation);
+  };
+  const visit = node => {
+    if (++visited > 200_000) fail();
+    const key = `${scope(node)}/${node.kind}:${names(node.name).join(',')}`;
+    if (isDependency(node)) result.dependencies.push(dependency(node, source, resolve));
+    if (isDefinition(node)) for (const name of names(node.name)) increment(result.definitions, `${scope(node)}/${node.kind}:${name}`);
+    if (ts.isClassExpression(node)) increment(result.definitions, `${scope(node)}/${node.kind}:${owner(node)}`);
+    if (ts.isFunctionLike(node)) increment(result.signatures, canonical({ scope: scope(node), signature: signature(node) }));
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) increment(result.signatures, canonical({ key, contract: print(node) }));
+    if (exported(node, exports) && isDefinition(node)) {
+      const contract = ts.isVariableDeclaration(node) ? variableContract(node) : signature(node);
+      result.public.push({ key, contract });
+      if (ts.isFunctionLike(node) || ts.isVariableDeclaration(node) && (contract.callable || contract.alias)) {
+        result.public.push({ key, inferred: inferred(node) });
+      }
+      if (ts.isPropertyAssignment(node) && ['props', 'emits'].includes(names(node.name)[0])) result.public.push({ key, metadata: print(node.initializer) });
+      if (ts.isClassDeclaration(node)) result.public.push({ key, heritage: node.heritageClauses?.map(print) ?? [] });
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)
+      && ['defineProps', 'defineEmits', 'defineSlots', 'defineModel', 'withDefaults'].includes(node.expression.text)) {
+      result.public.push({ macro: print(node) });
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'defineExpose') {
+      result.public.push({ expose: node.arguments.map(value => ts.isObjectLiteralExpression(value) ? exportedObject(value) : print(value)) });
+    }
+    if (ts.isExportAssignment(node) && ![ts.SyntaxKind.ObjectLiteralExpression, ts.SyntaxKind.CallExpression,
+      ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ClassExpression, ts.SyntaxKind.ArrowFunction].includes(unwrap(node.expression).kind)) {
+      result.public.push({ defaultAlias: print(node.expression), equals: node.isExportEquals });
+    }
+    if (commonJs(node)) result.public.push({ commonJs: print(node.left), contract: ts.isFunctionLike(unwrap(node.right))
+      ? { signature: signature(unwrap(node.right)), inferred: inferred(unwrap(node.right)) }
+      : ts.isObjectLiteralExpression(unwrap(node.right)) ? exportedObject(unwrap(node.right)) : print(node.right) });
+    if (unknownReference(node, part.context)) increment(result.unknown, print(node));
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return result;
+}
+function templateParts(root, path) {
+  const parts = [], seen = new WeakSet();
+  const walk = node => {
+    if (!node || typeof node !== 'object' || seen.has(node)) return;
+    seen.add(node);
+    if (node.type === 7 && ['on', 'for'].includes(node.name) && node.exp?.content) {
+      parts.push({ path: `${path}.ts`, content: node.name === 'for' ? `for (${node.exp.content}) {}` : node.exp.content });
+      seen.add(node.exp);
+    }
+    if (node.type === 4 && !node.isStatic && node.content) parts.push({ path: `${path}.ts`, content: `void (${node.content});` });
+    for (const [key, child] of Object.entries(node)) if (!['loc', 'ast', 'parent', 'codegenNode'].includes(key)) {
+      if (Array.isArray(child)) child.forEach(walk); else walk(child);
+    }
+  };
+  walk(root);
+  return parts;
+}
+function parts(path, content) {
+  if (!/\.vue$/i.test(path)) {
+    if (!/\.[cm]?[jt]sx?$/i.test(path)) fail();
+    return { metadata: [], scripts: [{ path, content }] };
+  }
+  const parsed = parseVue(content, { filename: path, sourceMap: false, templateParseOptions: { expressionPlugins: ['typescript'] } });
+  parseCache.clear();
+  if (parsed.errors.length) fail();
+  const value = parsed.descriptor, scripts = [];
+  const metadata = [value.template?.attrs ?? null, value.styles.map(block => ({ attrs: block.attrs, content: block.content })),
+    value.customBlocks.map(block => ({ type: block.type, attrs: block.attrs, content: block.content }))];
+  if (value.template?.lang) fail();
+  for (const [index, block] of [value.script, value.scriptSetup].entries()) {
+    metadata.push(block?.attrs ?? null);
+    if (!block) continue;
+    const extension = { javascript: 'js', typescript: 'ts' }[block.lang] ?? block.lang ?? 'js';
+    if (!['js', 'ts', 'jsx', 'tsx'].includes(extension)) fail();
+    scripts.push({ path: `${path}.${index}.${extension}`, content: block.src ? `import ${JSON.stringify(block.src)};` : block.content,
+      context: { vueComponent: true, vueSetup: block === value.scriptSetup } });
+  }
+  scripts.push(...templateParts(value.template?.ast, path));
+  return { metadata, scripts };
+}
+function retained(before, after) {
+  for (const [key, count] of before) if ((after.get(key) ?? 0) < count) fail();
+}
+export function assertDelegatedSourceModification(input) {
+  const { path, before, after } = input ?? {};
+  if (typeof path !== 'string' || typeof before !== 'string' || typeof after !== 'string'
+    || Buffer.byteLength(before) > 1_048_576 || Buffer.byteLength(after) > 1_048_576) fail();
+  try {
+    const original = parts(path, before), candidate = parts(path, after);
+    if (canonical(original.metadata) !== canonical(candidate.metadata) || original.scripts.length !== candidate.scripts.length) fail();
+    for (let index = 0; index < original.scripts.length; index++) {
+      const a = scriptProjection(original.scripts[index]), b = scriptProjection(candidate.scripts[index]);
+      if (canonical(a.dependencies) !== canonical(b.dependencies) || canonical(a.public) !== canonical(b.public)) fail();
+      retained(a.definitions, b.definitions); retained(a.signatures, b.signatures); retained(b.unknown, a.unknown);
+    }
+  } catch { fail(); }
+}

package/local-discipline-actions.mjs

@@ -11,6 +11,7 @@ import { auditMutation14, withMutationAudit14 } from './local-mutation-audit.mjs
 import { mutationFail14, removeMutationProjectFile14, moveMutationProjectFile14 } from './local-mutation-files.mjs';
 
 function actionIntent(input, value, kind, review) {
+  if (value.pass.writeDelegation) mutationFail14('ENTROROVE_MUTATION_DELEGATION_CHANGE', 'Preserved mutation forbids structural file actions');
   if (!value.pass.disciplinePolicy) mutationFail14('ENTROROVE_DISCIPLINE_NEEDS_HUMAN', `${kind} needs a separately approved original change declaration`);
   const policy = disciplineApprovedPolicy(value.pass.disciplinePolicy), intent = policy.writes.find(write => write.targetPath === value.target);
   const { usageReviewDigest, ...supplied } = input.declaration ?? {};
@@ -63,6 +64,7 @@ async function perform(input, kind, original, state) {
 async function guardedAction(input, kind) {
   return withMutationAudit14(input, `guarded-${kind}`, async () => {
     const value = await checkedPass(input), pass = value.pass;
+    if (pass.writeDelegation) mutationFail14('ENTROROVE_MUTATION_DELEGATION_CHANGE', 'Preserved mutation forbids structural file actions');
     return withStateLock(value.locations.consumptionPath, () => withTaskHandoffWriteFence({ ...input,
       epoch: pass.epoch, passId: pass.passId, leaseId: pass.leaseId }, state => perform(input, kind, value, state)));
   });

package/local-discipline-analysis.mjs

@@ -1,6 +1,8 @@
 import ts from 'typescript';
 import { archguardScriptSource } from './local-archguard-ast.mjs';
 import { canonical, sha256 } from './local-integrity.mjs';
+import { isTypeOnlyReference, isDynamicFunctionReference } from './local-typescript-function-reference.mjs';
+import { createScopeImportResolver } from './local-scope-import-expressions.mjs';
 
 export const disciplineAnalysisLimits = Object.freeze({ fileBytes: 1_048_576, sourceBytes: 8_388_608, files: 512, nodes: 200_000 });
 function analysisLimit(file, reason, limit, required) {
@@ -77,12 +79,15 @@ function definition(source, node) {
   return { ...location(source, node), symbol, name, exported: Boolean(exported), contract: Boolean(contract),
     signatureDigest: contract ? sha256(signature) : null };
 }
-function unresolvedNode(node) {
-  if (ts.isElementAccessExpression(node) && nameOf(node.argumentExpression) === null) return true;
-  if (ts.isIdentifier(node) && ['eval', 'Function', 'createRequire'].includes(node.text)) return true;
+function unresolvedNode(node, resolve) {
+  if (isTypeOnlyReference(node)) return false;
+  if (ts.isElementAccessExpression(node) && (nameOf(node.argumentExpression) === null
+    || ['eval', 'Function', 'createRequire', 'require'].includes(nameOf(node.argumentExpression)))) return true;
+  if (ts.isIdentifier(node) && (['eval', 'createRequire'].includes(node.text) || isDynamicFunctionReference(node))) return true;
   if (ts.isCallExpression(node)) {
     if (node.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(node.expression) && node.expression.text === 'require') {
-      return node.arguments.length !== 1 || !ts.isStringLiteral(node.arguments[0]);
+      return !node.arguments.length || node.arguments.length > (node.expression.kind === ts.SyntaxKind.ImportKeyword ? 2 : 1)
+        || resolve(node.arguments[0]) === null;
     }
     if (ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression)
       && ['Reflect', 'Object'].includes(node.expression.expression.text) && ['get', 'set', 'defineProperty'].includes(node.expression.name.text)) return true;
@@ -148,8 +153,9 @@ export function analyzeDisciplineSources(files, { edges = [], unresolved = [], r
   const program = programFor(sources, edges), checker = program.getTypeChecker(), definitions = [], mappings = [], references = new Map();
   const unknown = [...unresolved, ...unsupported];
   for (const source of sources.values()) {
+    const resolve = createScopeImportResolver(source, checker);
     const visit = node => {
-      if (unresolvedNode(node)) unknown.push({ ...location(source, node), reason: 'dynamic-reference' });
+      if (unresolvedNode(node, resolve)) unknown.push({ ...location(source, node), reason: 'dynamic-reference' });
       if (symbolNode(node)) {
         const entry = definition(source, node);
         if (entry) { const symbol = checker.getSymbolAtLocation(node.name); definitions.push({ entry, symbol, nameNode: node.name }); }

package/local-discipline-gate.mjs

@@ -5,6 +5,7 @@ import { disciplineDuplicateMappings, disciplineFormattingLines } from './local-
 import { disciplineRepositoryObservation, assertDisciplineRepository } from './local-discipline-repository.mjs';
 import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
 import { readSnapshotCopy14 } from './local-mutation-snapshot.mjs';
+import { assertDelegatedSourceModification } from './local-delegated-modify-analysis.mjs';
 
 const needs = message => mutationFail14('ENTROROVE_DISCIPLINE_NEEDS_HUMAN', message);
 function declaredWrite(input, pass, baseline) {
@@ -73,11 +74,12 @@ export async function disciplineWritePreflight(input, value, content) {
   const review = await readDisciplineSnapshot(snapshot), baseline = snapshot.manifest.files.find(file => file.path === target);
   await assertDisciplineRepository(input, binding.root, review, ledger);
   const intent = declaredWrite(input, pass, baseline);
+  const original = baseline.exists ? (await readSnapshotCopy14(input, snapshot.snapshotRoot, snapshot.manifest, target)).content.toString('utf8') : '';
+  if (pass.writeDelegation) assertDelegatedSourceModification({ path: target, before: original, after: content });
   const candidate = await disciplineRepositoryObservation(input, binding.root, { analyze: true, overrides: new Map([[target, content]]) });
   const removed = checkRemoved(review, candidate.analysis, target, intent, snapshot.manifest.disciplineReviewDigest, input.declaration);
   checkContracts(review, candidate.analysis, target, intent);
   const reuse = checkReuse(review, candidate.analysis, target, intent, pass.parallelPaths);
-  const original = baseline.exists ? (await readSnapshotCopy14(input, snapshot.snapshotRoot, snapshot.manifest, target)).content.toString('utf8') : '';
   const formatting = baseline.exists ? disciplineFormattingLines(original, content, target) : [];
   if (formatting.length) mutationFail14('ENTROROVE_DISCIPLINE_FORMAT_SCOPE', `Formatting touches lines without functional changes: ${target}:${formatting.join(',')}`);
   return { reviewDigest: snapshot.manifest.disciplineReviewDigest, declaredKind: baseline.exists ? 'modify' : 'create', removed, reuse,

package/local-discipline-repository.mjs

@@ -90,25 +90,28 @@ export async function disciplineRepositoryObservation(input, root, { analyze = f
   if (!analyze) return { comparison };
   // The existing resolver supplies actual aliases, package exports and import edges.
   // Unsupported/dynamic references stay unknown; they are never converted to unused.
-  const roots = sources.filter(file => paths.includes(file.path) && /\.[cm]?[jt]sx?$/i.test(file.path)).map(file => ({ path: file.path, exists: true }));
+  const roots = sources.filter(file => paths.includes(file.path) && /\.(?:[cm]?[jt]sx?|vue)$/i.test(file.path)).map(file => ({ path: file.path, exists: true }));
   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 });
   }
-  for (const [relative, content] of overrides) if (semanticSource(relative) && /\.[cm]?[jt]sx?$/i.test(relative)) {
+  for (const [relative, content] of overrides) if (semanticSource(relative) && /\.(?:[cm]?[jt]sx?|vue)$/i.test(relative)) {
     try {
       const candidate = await scopeCandidateImports(root, { path: relative, content }, input);
       graph.edges = [...graph.edges.filter(edge => edge.from !== relative), ...candidate.edges];
-      if (candidate.dynamic) unresolved.push({ path: relative, reason: 'candidate-dynamic-import' });
+      if (candidate.dynamic) unresolved.push(...(candidate.unresolvedImports?.length ? candidate.unresolvedImports
+        : [{ path: relative, reason: 'candidate-dynamic-import' }]));
     } catch (error) {
       if (!['ENTROROVE_IMPORT_UNRESOLVED', 'ENTROROVE_IMPORT_INVALID', 'ENTROROVE_IMPORT_UNSUPPORTED', 'ENTROROVE_BUDGET_SCOPE'].includes(error.code)) throw error;
       unresolved.push({ path: relative, reason: error.code });
     }
   }
   const analysis = analyzeDisciplineSources(sources, { edges: graph.edges, requiredPaths: [...required],
-    unresolved: [...unresolved, ...graph.dynamicSources.map(item => ({ path: item.path, reason: 'dynamic-import' }))] });
+    unresolved: [...unresolved, ...(graph.unresolvedImports ?? []),
+      ...graph.dynamicSources.filter(item => !graph.unresolvedImports?.some(site => site.path === item.path))
+        .map(item => ({ path: item.path, reason: 'dynamic-import' }))] });
   analysis.definitions.push(...await nativeDisciplineDefinitions(sources));
   return { comparison, analysis, scanComplete: graph.complete && analysis.unresolved.length === 0 };
 }

package/local-error.mjs

@@ -13,6 +13,8 @@ export const LOCAL_ERROR_CODE_CATALOG = Object.freeze({
   ENTROROVE_DISCIPLINE_USAGE_UNKNOWN: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
   ENTROROVE_DISCIPLINE_REVIEW_REQUIRED: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
   ENTROROVE_DISCIPLINE_DATA_SNAPSHOT_REQUIRED: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
+  ENTROROVE_MUTATION_DELEGATION_CHANGE: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
+  ENTROROVE_MUTATION_DELEGATION_INVALID: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
   ENTROROVE_IDE_GUARD_REQUIRED: Object.freeze({ disposition: 'needs-human', stability: 'stable' }),
   ENTROROVE_IDE_GUARD_UNSUPPORTED: Object.freeze({ disposition: 'terminal', stability: 'stable' }),
 });
@@ -25,6 +27,7 @@ const BLOCKED_CODES = new Set([
   'ENTROROVE_GIT_UNAVAILABLE',
   'ENTROROVE_MUTATE_NOT_ACCEPTED', 'ENTROROVE_MUTATION_AUTHORITY_REQUIRED',
   'ENTROROVE_MUTATION_PASS_INVALID', 'ENTROROVE_MUTATION_PASS_EXPIRED',
+  'ENTROROVE_MUTATION_DELEGATION_CHANGE', 'ENTROROVE_MUTATION_DELEGATION_INVALID',
   'ENTROROVE_BUDGET_LEASE_EXPIRED', 'ENTROROVE_BUDGET_AUTHORITY_REQUIRED',
   'ENTROROVE_SWARM_AUTHORITY_INVALID', 'ENTROROVE_SWARM_CLOUD_AUTHORITY_REQUIRED',
   'ENTROROVE_HANDOFF_FENCE', 'ENTROROVE_HANDOFF_WRITE_REVOKED',

package/local-execution.mjs

@@ -277,7 +277,7 @@ export async function finalGate(input) {
 }
 
 const LOCAL_OPERATION_GROUPS = Object.freeze(['core', 'budget', 'scope', 'merge', 'chain', 'handoff', 'archguard', 'calctool', 'swarm', 'validator', 'formula', 'evidence']);
-const PASS_REQUIRED_OPERATIONS = new Set(['mutation-snapshot-attest', 'mutate-gate', 'gate-issue', 'gate-verify', 'guarded-write',
+const PASS_REQUIRED_OPERATIONS = new Set(['mutation-snapshot-attest', 'mutation-consumption-attest', 'mutate-gate', 'gate-issue', 'gate-verify', 'guarded-write',
   'discipline-review', 'discipline-check', 'guarded-delete', 'guarded-move',
   'merge-verified', 'rollback', 'archguard-contract-create', 'archguard-contract-update', 'archguard-checkpoint', 'archguard-scope-request',
   'budget-handoff', 'budget-transition', 'spawn-bind', 'peer-complete', 'complete']);