@entrorove/skill 0.1.36 → 0.1.38

package/local-archguard-language-ast.mjs

@@ -7,6 +7,13 @@ const grammars = new Map();
 for (const language of ['css', 'python', 'java', 'rust']) {
   grammars.set(language, await Parser.Language.load(require.resolve(`tree-sitter-wasms/out/tree-sitter-${language}.wasm`)));
 }
+export async function withArchguardSyntaxTree(file, language, inspect) {
+  if (!['css','python','java','rust','php'].includes(language)) throw new Error('ARCH-AST-LANGUAGE-UNSUPPORTED');
+  if (!grammars.has(language)) grammars.set(language, await Parser.Language.load(require.resolve(`tree-sitter-wasms/out/tree-sitter-${language}.wasm`)));
+  const parser = new Parser(); parser.setLanguage(grammars.get(language));
+  const tree = parser.parse(file.content);
+  try { return inspect(tree.rootNode); } finally { tree.delete(); parser.delete(); }
+}
 const EXTENSIONS = new Map([['css', 'css'], ['wxss', 'css'], ['py', 'python'], ['java', 'java'], ['rs', 'rust']]);
 const ROOTS = { css: 'stylesheet', python: 'module', java: 'program', rust: 'source_file' };
 const FUNCTIONS = { css: [], python: ['function_definition', 'lambda'], java: ['method_declaration', 'constructor_declaration', 'lambda_expression'],

package/local-cli.mjs

@@ -23,6 +23,8 @@ import { LOCAL_BUDGET_TRANSITION_OPERATIONS } from './local-budget-transition.mj
 import { ARCHGUARD_LOCAL_OPERATIONS } from './local-archguard-operations.mjs';
 import { LOCAL_BUDGET_HANDOFF_OPERATIONS } from './local-budget-handoff.mjs';
 import { LOCAL_CHAIN_OPERATIONS } from './local-chain-operations.mjs';
+import { DISCIPLINE_LOCAL_OPERATIONS } from './local-discipline-operations.mjs';
+import { assertIdeExecution } from './ide-session.mjs';
 import { runManagedWorkflowLocalStep } from './workflow-local-client.mjs';
 import { localErrorEnvelope } from './local-error.mjs';
 
@@ -37,6 +39,7 @@ async function stdinJson() {
 }
 
 const operations = {
+  ...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,
   'budget-init': budgetInit, 'budget-context': budgetContext, 'budget-read': budgetRead, 'budget-status': budgetStatus,
@@ -76,7 +79,7 @@ function capabilitiesFor(group) {
 async function checkedLocalInput(operation, input) {
   try { return validateLocalInput(operation, input); }
   catch (cause) {
-    if (['guarded-write', 'gate-issue', 'mutate-gate', 'mutation-snapshot-attest'].includes(operation)) await recordMutationDenied14(input, cause, operation);
+    if (['guarded-write', 'guarded-delete', 'guarded-move', 'gate-issue', 'mutate-gate', 'mutation-snapshot-attest'].includes(operation)) await recordMutationDenied14(input, cause, operation);
     throw cause;
   }
 }
@@ -91,6 +94,7 @@ export async function runLocal(args = [], dependencies) {
     const handler = operations[operation];
     if (!handler) throw new Error(`Usage: entrorove local <${['capabilities', ...Object.keys(operations)].join('|')}> [repositoryRoot]`);
     const input = await stdinJson();
+    await assertIdeExecution(['local', ...args], input);
     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;
@@ -105,6 +109,7 @@ export async function runLocal(args = [], dependencies) {
 export async function runLocalInput(operation, input, dependencies) {
   if (operation === 'capabilities' || operation === 'help') { validateLocalInput(operation, input); return LOCAL_CAPABILITIES; }
   const handler = operations[operation];
+  await assertIdeExecution(['local', operation], input);
   if (!handler) throw new Error(`Unsupported local operation: ${operation}`);
   const validated = await checkedLocalInput(operation, input);
   const supplied = operation === 'workflow-run-step' || Object.hasOwn(LOCAL_CHAIN_OPERATIONS, operation) ? dependencies : undefined;

package/local-contracts.mjs

@@ -8,6 +8,7 @@ import { MERGE_LOCAL_OPERATION_SCHEMAS } from './local-merge-contracts.mjs';
 import { WORKFLOW_LOCAL_OPERATION_SCHEMA } from './workflow-local-contracts.mjs';
 import { HANDOFF_WRITE_PASS_SCHEMA, HANDOFF_PROVISIONAL_LEASE_SCHEMA, HANDOFF_SNAPSHOT_CANDIDATE_SCHEMA } from './local-task-handoff-contracts.mjs';
 import { LOCAL_CHAIN_OPERATION_SCHEMAS } from './local-chain-contracts.mjs';
+import { DISCIPLINE_DECLARATION_SCHEMA } from './local-discipline-contracts.mjs';
 import { array, binding, change, confirmation, enumeration, evidence, evidenceArray, executionContext, executionPlan,
   formula, formulaDefinitions, formulaEntry, decimalValues, identifier, integer, ledgerIdentifier, modes, nullable, object, paths, record, relativePath, sha256, text } from './local-contract-types.mjs';
 
@@ -31,7 +32,9 @@ add('mutation-snapshot-attest', { ...step, taskId: identifier, snapshotId: ident
   ['repositoryRoot', 'flowId', 'stepId', 'snapshotId', 'challenge', 'signerConfigPath']);
 const write = { ...step, taskId: identifier, generation: integer(1), executionAttemptNonce: identifier, gatePassPath: text, targetPath: relativePath, workerId: identifier, leaseId: identifier };
 add('gate-verify', write, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath']);
-add('guarded-write', { ...write, content: {}, expectedSha256: nullable(sha256) }, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath', 'content']);
+add('discipline-review|discipline-check', write, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath']);
+add('guarded-delete|guarded-move', { ...write, declaration: DISCIPLINE_DECLARATION_SCHEMA }, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath', 'declaration']);
+add('guarded-write', { ...write, content: {}, expectedSha256: nullable(sha256), declaration: DISCIPLINE_DECLARATION_SCHEMA }, ['repositoryRoot', 'flowId', 'stepId', 'gatePassPath', 'targetPath', 'content']);
 schemas['guarded-write'] = { oneOf: [schemas['guarded-write'], object({ ...step, targetPath: relativePath, content: {},
   expectedSha256: nullable(sha256), handoffId: ledgerIdentifier, epoch: integer(1, 2147483647),
   handoffPass: HANDOFF_WRITE_PASS_SCHEMA, provisionalLease: HANDOFF_PROVISIONAL_LEASE_SCHEMA },

package/local-discipline-actions.mjs

@@ -0,0 +1,71 @@
+import { canonical, sha256 } from './local-integrity.mjs';
+import { checkedPass } from './local-mutation-authority.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { withTaskHandoffWriteFence } from './local-task-handoff-fence.mjs';
+import { withSwarmMutationLease } from './local-swarm-mutation.mjs';
+import { disciplineApprovedPolicy } from './local-discipline-contracts.mjs';
+import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
+import { assertDisciplineRepository } from './local-discipline-repository.mjs';
+import { saveMutationConsumption14 } from './local-mutation-pass-store.mjs';
+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.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 ?? {};
+  if (!intent || intent.kind !== kind || canonical(supplied) !== canonical(intent)
+    || usageReviewDigest !== value.snapshot.manifest.disciplineReviewDigest) {
+    mutationFail14('ENTROROVE_DISCIPLINE_NEEDS_HUMAN', 'Physical action must match its exact signed proposal and original usage artifact');
+  }
+  if (kind === 'delete') {
+    const definitions = review.analysis.definitions.filter(item => item.path === value.target);
+    if (!review.scanComplete || definitions.some(item => item.usage === 'unknown')) mutationFail14('ENTROROVE_DISCIPLINE_USAGE_UNKNOWN', 'Unknown references forbid file deletion');
+    if (canonical([...intent.deletedSymbols ?? []].sort()) !== canonical(definitions.map(item => item.symbol).sort())) {
+      mutationFail14('ENTROROVE_DISCIPLINE_NEEDS_HUMAN', 'File deletion must declare every removed symbol and its task requirement');
+    }
+    if (definitions.some(item => item.usage === 'in-use') && !intent.exceptions?.includes('delete-in-use')) {
+      mutationFail14('ENTROROVE_DISCIPLINE_NEEDS_HUMAN', 'Referenced symbols need explicit deletion authorization');
+    }
+  }
+  return intent;
+}
+async function perform(input, kind, original, state) {
+  const value = await checkedPass(input, state), { pass, snapshot, ledger, binding, locations } = value;
+  if (canonical(pass) !== canonical(original.pass)) mutationFail14('ENTROROVE_MUTATION_PASS_CHANGED', 'Structural action changed its original pass while waiting');
+  return withSwarmMutationLease(input, pass, async () => {
+    const review = await readDisciplineSnapshot(snapshot), intent = actionIntent(input, value, kind, review);
+    await assertDisciplineRepository(input, binding.root, review, ledger);
+    const source = snapshot.manifest.files.find(file => file.path === value.target);
+    const at = new Date().toISOString();
+    const writes = { ...ledger.writes, [value.target]: { status: 'pending', kind: 'delete', contentDigest: source.sha256, mode: source.mode, at } };
+    let destination;
+    if (kind === 'move') {
+      const next = await checkedPass({ ...input, targetPath: intent.destinationPath }, state);
+      if (next.pass.passId !== pass.passId) mutationFail14('ENTROROVE_MUTATION_WRITE_SCOPE', 'Move destination needs the same original pass');
+      destination = snapshot.manifest.files.find(file => file.path === intent.destinationPath);
+      writes[intent.destinationPath] = { status: 'pending', kind: 'create', contentDigest: source.sha256, mode: source.mode, at };
+    }
+    await saveMutationConsumption14(locations, { ...ledger, writes });
+    await auditMutation14(input, 'guarded-action-authorized', { passId: pass.passId, disciplineReviewDigest: snapshot.manifest.disciplineReviewDigest, declaredKind: kind });
+    if (kind === 'move') await moveMutationProjectFile14(input, binding.root, source, destination);
+    else await removeMutationProjectFile14(input, binding.root, source);
+    const move = destination ? { move: { sourcePath: value.target, destinationPath: intent.destinationPath, sourceDigest: source.sha256 } } : {};
+    writes[value.target] = { ...writes[value.target], ...move, status: 'written' };
+    if (destination) writes[intent.destinationPath] = { ...writes[intent.destinationPath], ...move, status: 'written' };
+    await saveMutationConsumption14(locations, { ...ledger, writes });
+    await assertDisciplineRepository(input, binding.root, review, { ...ledger, writes });
+    await auditMutation14(input, `guarded-${kind}`, { passId: pass.passId, declaredKind: kind });
+    return { schemaVersion: 'entrorove.local-execution/1.0', status: 'verified', action: kind, targetPath: value.target,
+      ...(destination ? { destinationPath: intent.destinationPath, sha256: source.sha256 } : {}), usageReviewDigest: snapshot.manifest.disciplineReviewDigest };
+  });
+}
+async function guardedAction(input, kind) {
+  return withMutationAudit14(input, `guarded-${kind}`, async () => {
+    const value = await checkedPass(input), pass = value.pass;
+    return withStateLock(value.locations.consumptionPath, () => withTaskHandoffWriteFence({ ...input,
+      epoch: pass.epoch, passId: pass.passId, leaseId: pass.leaseId }, state => perform(input, kind, value, state)));
+  });
+}
+export const guardedDelete = input => guardedAction(input, 'delete');
+export const guardedMove = input => guardedAction(input, 'move');

package/local-discipline-analysis.mjs

@@ -0,0 +1,153 @@
+import ts from 'typescript';
+import { archguardScriptSource } from './local-archguard-ast.mjs';
+import { canonical, sha256 } from './local-integrity.mjs';
+
+const location = (source, node) => ({ path: source.fileName, line: source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1 });
+const unwrap = node => {
+  while (node && (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node))) node = node.expression;
+  return node;
+};
+function nameOf(node) {
+  return node && (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node)) ? node.text : null;
+}
+function tokenLines(source) {
+  const scanner = ts.createScanner(ts.ScriptTarget.Latest, true, source.languageVariant, source.text), lines = new Map();
+  let token;
+  while ((token = scanner.scan()) !== ts.SyntaxKind.EndOfFileToken) {
+    const line = source.getLineAndCharacterOfPosition(scanner.getTokenPos()).line;
+    const values = lines.get(line) ?? []; values.push(`${token}:${scanner.getTokenText()}`); lines.set(line, values);
+  }
+  return new Map([...lines].map(([line, values]) => [line, sha256(canonical(values))]));
+}
+export function disciplineFormattingLines(before, after, filename) {
+  const left = archguardScriptSource({ path: filename, content: before }), right = archguardScriptSource({ path: filename, content: after });
+  if (!left || !right) return [];
+  const oldLines = before.split('\n'), newLines = after.split('\n'), a = tokenLines(left), b = tokenLines(right);
+  const index = new Map(), next = new Map();
+  for (const [line, digest] of a) index.set(digest, [...index.get(digest) ?? [], line]);
+  for (const [line, digest] of b) next.set(digest, [...next.get(digest) ?? [], line]);
+  const findings = [];
+  for (const [digest, lines] of next) {
+    const previous = index.get(digest);
+    if (previous?.length === lines.length) lines.forEach((line, occurrence) => {
+      if (oldLines[previous[occurrence]] !== newLines[line]) findings.push(line + 1);
+    });
+  }
+  if (canonical([...a.values()]) === canonical([...b.values()]) && before !== after) {
+    return [...new Set([...findings, ...newLines.flatMap((value, line) => value !== oldLines[line] ? [line + 1] : [])])].sort((a, b) => a - b);
+  }
+  return findings;
+}
+function publicDefinition(node) {
+  return node.modifiers?.some(item => [ts.SyntaxKind.ExportKeyword, ts.SyntaxKind.DefaultKeyword].includes(item.kind))
+    || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node);
+}
+function symbolNode(node) {
+  return ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)
+    || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isVariableDeclaration(node)
+    || ts.isPropertySignature(node) || ts.isMethodSignature(node) || ts.isPropertyDeclaration(node) || ts.isMethodDeclaration(node)
+    || ts.isPropertyAssignment(node) || ts.isEnumMember(node);
+}
+function definition(source, node) {
+  const name = nameOf(node.name); if (!name) return null;
+  let parent = node.parent;
+  while (parent && !ts.isSourceFile(parent) && !nameOf(parent.name)) parent = parent.parent;
+  const owner = parent && !ts.isSourceFile(parent) ? nameOf(parent.name) : null;
+  const symbol = owner ? `${owner}.${name}` : name;
+  let ancestor = node;
+  while (ancestor && !ts.isSourceFile(ancestor) && !publicDefinition(ancestor)) ancestor = ancestor.parent;
+  const exported = Boolean(ancestor && !ts.isSourceFile(ancestor));
+  const contract = exported && (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isFunctionDeclaration(node));
+  const signature = ts.isFunctionDeclaration(node) ? canonical({ parameters: node.parameters.map(item => item.getText(source)), type: node.type?.getText(source) ?? null }) : node.getText(source);
+  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;
+  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]);
+    }
+    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;
+  }
+  return false;
+}
+function mapping(source, node, checker) {
+  if (!ts.isVariableDeclaration(node) || !ts.isTypeReferenceNode(node.type ?? {}) || !node.initializer) return null;
+  const type = node.type.typeArguments?.[0];
+  if (!type || !ts.isTypeOperatorNode(type) || type.operator !== ts.SyntaxKind.KeyOfKeyword || !ts.isTypeReferenceNode(type.type)) return null;
+  let entity = checker.getTypeAtLocation(type.type)?.symbol ?? checker.getSymbolAtLocation(type.type.typeName);
+  if (entity?.flags & ts.SymbolFlags.Alias) entity = checker.getAliasedSymbol(entity);
+  const declarations = entity?.declarations;
+  if (!declarations?.length) return null;
+  const value = unwrap(node.initializer); if (!ts.isObjectLiteralExpression(value)) return null;
+  const fields = [], unresolved = [];
+  for (const property of value.properties) {
+    const key = nameOf(property.name);
+    if (!key || !ts.isPropertyAssignment(property)) { unresolved.push(location(source, property)); continue; }
+    const value = property.initializer;
+    const actual = ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value) ? canonical(value.text)
+      : ts.isNumericLiteral(value) ? canonical(Number(value.text))
+        : ts.createPrinter({ removeComments: true }).printNode(ts.EmitHint.Expression, value, source);
+    fields.push({ name: key, valueDigest: sha256(actual) });
+  }
+  const original = declarations[0], origin = location(original.getSourceFile(), original);
+  return { ...location(source, node), symbol: nameOf(node.name), entity: `${origin.path}:${entity.name}`,
+    role: 'source-entity-field-mapping', fields: fields.sort((a, b) => a.name.localeCompare(b.name)), unresolved };
+}
+function programFor(sources, edges) {
+  const host = ts.createCompilerHost({ noLib: true, allowJs: true });
+  const virtualRoot = '/entrorove-repository/', relative = filename => filename.startsWith(virtualRoot) ? filename.slice(virtualRoot.length) : filename;
+  host.getCurrentDirectory = () => virtualRoot.slice(0, -1);
+  host.getSourceFile = filename => sources.get(relative(filename));
+  host.fileExists = filename => sources.has(relative(filename)); host.readFile = filename => sources.get(relative(filename))?.text;
+  host.writeFile = () => {};
+  host.resolveModuleNames = (names, from) => names.map(name => {
+    const edge = edges.find(item => item.from === relative(from) && item.specifier === name && item.to !== null);
+    return edge && sources.has(edge.to) ? { resolvedFileName: edge.to } : undefined;
+  });
+  return ts.createProgram([...sources.keys()], { noLib: true, allowJs: true, checkJs: false }, host);
+}
+export function analyzeDisciplineSources(files, { edges = [], unresolved = [] } = {}) {
+  const sources = new Map(), unsupported = [];
+  for (const file of files) {
+    const parsed = archguardScriptSource(file);
+    if (!parsed || parsed.parseDiagnostics.length) { unsupported.push({ path: file.path, reason: parsed ? 'syntax-unresolved' : 'language-unresolved' }); continue; }
+    sources.set(file.path, parsed);
+  }
+  const program = programFor(sources, edges), checker = program.getTypeChecker(), definitions = [], mappings = [], references = new Map();
+  const unknown = [...unresolved, ...unsupported];
+  for (const source of sources.values()) {
+    const visit = node => {
+      if (unresolvedNode(node)) 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 }); }
+        const fact = mapping(source, node, checker); if (fact) mappings.push(fact);
+      }
+      ts.forEachChild(node, visit);
+    }; visit(source);
+  }
+  const names = new Set(definitions.map(item => item.nameNode));
+  for (const source of sources.values()) {
+    const visit = node => {
+      if ((ts.isIdentifier(node) || ts.isStringLiteral(node)) && !names.has(node)) {
+        let symbol = checker.getSymbolAtLocation(node);
+        if (symbol?.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+        if (symbol) { const points = references.get(symbol) ?? []; points.push(location(source, node)); references.set(symbol, points); }
+      }
+      ts.forEachChild(node, visit);
+    }; visit(source);
+  }
+  return { mappings, unresolved: unknown, definitions: definitions.map(({ entry, symbol }) => {
+    const points = references.get(symbol) ?? [];
+    return { ...entry, references: points, usage: points.length ? 'in-use' : unknown.length || entry.exported ? 'unknown' : 'unused' };
+  }) };
+}
+export function disciplineDuplicateMappings(original, candidate) {
+  return candidate.mappings.flatMap(next => original.mappings.filter(existing => existing.entity === next.entity && existing.role === next.role
+    && !(existing.path === next.path && existing.symbol === next.symbol)).map(existing => ({ existing, candidate: next,
+    equal: !existing.unresolved.length && !next.unresolved.length && canonical(existing.fields) === canonical(next.fields) })));
+}

package/local-discipline-batch.mjs

@@ -0,0 +1,32 @@
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationFail14 } from './local-mutation-files.mjs';
+import { disciplineWritePreflight } from './local-discipline-gate.mjs';
+import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
+import { assertDisciplineRepository } from './local-discipline-repository.mjs';
+
+export async function disciplineBatchBefore(input, value, options, before, after, ledger) {
+  const review = await readDisciplineSnapshot(value.snapshot);
+  await assertDisciplineRepository(input, value.binding.root, review, ledger);
+  // A rollback is already separately cloud-signed against exact restore hashes
+  // by mutationBatchReceiptBinding14. It restores that known image, rather than
+  // proposing a new definition or reusing a forward mutation permission.
+  const restoration = options.contract?.schemaVersion === 'entrorove.merge-rollback-authorization/1.0';
+  if (restoration) return review;
+  for (const file of after) {
+    const original = before.find(item => item.path === file.path);
+    if (canonical(original) === canonical(file)) continue;
+    if (!file.exists) mutationFail14('ENTROROVE_DISCIPLINE_NEEDS_HUMAN', 'Forward batch deletion requires its separate guarded deletion declaration');
+    const source = options.contents?.find(item => item.path === file.path);
+    if (!source) {
+      if (/\.(?:[cm]?[jt]sx?|php|py|java|rs|vue|svelte|css)$/iu.test(file.path)) mutationFail14('ENTROROVE_DISCIPLINE_REVIEW_REQUIRED', 'Source batch needs actual candidate bytes before any write');
+      continue;
+    }
+    const bytes = Buffer.from(source.contentBase64, 'base64');
+    if (bytes.toString('base64') !== source.contentBase64 || sha256(bytes) !== file.sha256) mutationFail14('ENTROROVE_DISCIPLINE_REVIEW_INVALID', 'Batch candidate bytes differ from the exact signed after image');
+    const intent = value.pass.disciplinePolicy?.writes.find(write => write.targetPath === file.path);
+    await disciplineWritePreflight({ ...input, targetPath: file.path,
+      ...(intent ? { declaration: { ...intent, usageReviewDigest: value.snapshot.manifest.disciplineReviewDigest } } : {}) },
+    { ...value, target: file.path, ledger }, bytes.toString('utf8'));
+  }
+  return review;
+}

package/local-discipline-contracts.d.mts

@@ -0,0 +1,6 @@
+export const DISCIPLINE_POLICY_SCHEMA: Record<string, any>;
+export function disciplinePolicy(value: unknown): Record<string, any>;
+export function disciplineApprovedPolicy(value: unknown): Record<string, any>;
+export function disciplineDataSnapshotsBound(value: unknown, files: readonly { path: string; sha256: string }[]): boolean;
+export function disciplineProposalDigest(value: unknown): string;
+export function disciplineHumanTriggers(value: unknown): string[];

package/local-discipline-contracts.mjs

@@ -0,0 +1,62 @@
+import Ajv from 'ajv';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { object, array, text, identifier, relativePath, sha256 as shaSchema, integer } from './local-contract-types.mjs';
+
+const refs = { ...array(identifier, 1), uniqueItems: true };
+const defect = object({ path: relativePath, line: integer(1) }, ['path', 'line']);
+export const DISCIPLINE_WRITE_SCHEMA = object({ targetPath: relativePath,
+  kind: { enum: ['modify', 'create', 'delete', 'move', 'format'] }, destinationPath: relativePath,
+  reason: text, requirementRefs: refs, deletedSymbols: { ...array(text), uniqueItems: true },
+  exceptions: { ...array({ enum: ['new-definition', 'contract-change', 'rewrite', 'delete-in-use'] }), uniqueItems: true },
+  defectReference: defect, futureFields: { ...array(identifier), uniqueItems: true },
+}, ['targetPath', 'kind', 'reason', 'requirementRefs']);
+const approval = object({ interactionId: identifier, interactionDigest: shaSchema, auditId: identifier,
+  proposalDigest: shaSchema }, ['interactionId', 'interactionDigest', 'auditId', 'proposalDigest']);
+export const DISCIPLINE_POLICY_SCHEMA = object({ schemaVersion: { const: 'entrorove.discipline-policy/1.0' },
+  requirementIds: refs, writes: array(DISCIPLINE_WRITE_SCHEMA, 1), approval,
+  dataOperations: array(object({ operation: { enum: ['delete', 'migrate', 'rebuild'] }, target: text,
+    reason: text, requirementRefs: refs, snapshotArtifactDigest: shaSchema }, ['operation', 'target', 'reason', 'requirementRefs', 'snapshotArtifactDigest'])),
+}, ['schemaVersion', 'requirementIds', 'writes']);
+export const DISCIPLINE_DECLARATION_SCHEMA = object({ ...DISCIPLINE_WRITE_SCHEMA.properties,
+  usageReviewDigest: shaSchema }, DISCIPLINE_WRITE_SCHEMA.required);
+const validate = new Ajv({ allErrors: true, strict: true }).compile(DISCIPLINE_POLICY_SCHEMA);
+export function disciplinePolicy(value) {
+  if (!validate(value)) throw Object.assign(new Error(`Invalid discipline policy: ${validate.errors.map(error => error.instancePath || error.keyword).join(', ')}`), { code: 'ENTROROVE_DISCIPLINE_POLICY_INVALID' });
+  const requirements = new Set(value.requirementIds), paths = new Set();
+  for (const write of value.writes) {
+    if (paths.has(write.targetPath) || write.requirementRefs.some(id => !requirements.has(id))
+      || (write.kind === 'move') !== Boolean(write.destinationPath) || write.destinationPath === write.targetPath) {
+      throw Object.assign(new Error('Discipline writes require unique paths, original requirements and exact move destinations'), { code: 'ENTROROVE_DISCIPLINE_POLICY_INVALID' });
+    }
+    paths.add(write.targetPath);
+  }
+  if (value.dataOperations?.some(action => action.requirementRefs.some(id => !requirements.has(id)))) {
+    throw Object.assign(new Error('Data operations must reference original requirements'), { code: 'ENTROROVE_DISCIPLINE_POLICY_INVALID' });
+  }
+  return structuredClone(value);
+}
+export function disciplineProposalDigest(value) {
+  const { approval, ...proposal } = disciplinePolicy(value);
+  return sha256(canonical(proposal));
+}
+export function disciplineHumanTriggers(value) {
+  const policy = disciplinePolicy(value), triggers = new Set();
+  for (const write of policy.writes) {
+    for (const exception of write.exceptions ?? []) triggers.add(exception);
+    if (['delete', 'move'].includes(write.kind) || write.deletedSymbols?.length) triggers.add(write.kind === 'move' ? 'move' : 'delete');
+  }
+  if (policy.dataOperations?.length) triggers.add('existing-data');
+  return [...triggers].sort();
+}
+export function disciplineApprovedPolicy(value) {
+  const policy = disciplinePolicy(value);
+  if (disciplineHumanTriggers(policy).length && (!policy.approval || policy.approval.proposalDigest !== disciplineProposalDigest(policy))) {
+    throw Object.assign(new Error('This exact change proposal needs the original persisted human approval'), { code: 'ENTROROVE_DISCIPLINE_NEEDS_HUMAN' });
+  }
+  return policy;
+}
+export function disciplineDataSnapshotsBound(value, files) {
+  const policy = disciplineApprovedPolicy(value);
+  return Array.isArray(files) && !policy.dataOperations?.some(action =>
+    !files.some(file => file.sha256 === action.snapshotArtifactDigest));
+}

package/local-discipline-gate.mjs

@@ -0,0 +1,85 @@
+import { canonical, sha256 } from './local-integrity.mjs';
+import { mutationFail14 } from './local-mutation-files.mjs';
+import { disciplineApprovedPolicy } from './local-discipline-contracts.mjs';
+import { disciplineDuplicateMappings, disciplineFormattingLines } from './local-discipline-analysis.mjs';
+import { disciplineRepositoryObservation, assertDisciplineRepository } from './local-discipline-repository.mjs';
+import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
+import { readSnapshotCopy14 } from './local-mutation-snapshot.mjs';
+
+const needs = message => mutationFail14('ENTROROVE_DISCIPLINE_NEEDS_HUMAN', message);
+function declaredWrite(input, pass, baseline) {
+  const expectedKind = baseline.exists ? 'modify' : 'create';
+  const policy = pass.disciplinePolicy ? disciplineApprovedPolicy(pass.disciplinePolicy) : null;
+  const planned = policy?.writes.find(write => write.targetPath === input.targetPath);
+  if (input.declaration) {
+    const { usageReviewDigest, ...supplied } = input.declaration;
+    if (!planned || canonical(planned) !== canonical(supplied)) needs('Write declaration must match the original cloud-signed execution plan');
+  }
+  if (planned && !['modify', 'create', 'format'].includes(planned.kind)) needs('The declared physical action must use its matching guarded entry point');
+  if (planned && planned.kind !== 'format' && planned.kind !== expectedKind) needs('Declared write kind differs from the actual snapshot baseline');
+  return planned;
+}
+function requireException(intent, kind, message) {
+  if (!intent?.exceptions?.includes(kind)) needs(message);
+}
+function checkRemoved(review, candidate, target, intent, digest, declaration) {
+  const before = review.analysis.definitions.filter(item => item.path === target), after = new Set(candidate.definitions.filter(item => item.path === target).map(item => item.symbol));
+  const removed = before.filter(item => !after.has(item.symbol));
+  if (!removed.length) return [];
+  if (!intent || declaration?.usageReviewDigest !== digest
+    || canonical([...intent.deletedSymbols ?? []].sort()) !== canonical(removed.map(item => item.symbol).sort())) {
+    needs(`Deleted symbols require their original usage review ${digest}, declared reasons and requirement references: ${removed.map(item => item.symbol).join(', ')}`);
+  }
+  for (const item of removed) {
+    if (item.usage === 'unknown') mutationFail14('ENTROROVE_DISCIPLINE_USAGE_UNKNOWN', `Usage is unknown; preserve ${item.path}:${item.line} ${item.symbol}`);
+    if (item.usage === 'in-use') requireException(intent, 'delete-in-use', `Deletion is still referenced: ${item.path}:${item.line} ${item.symbol}`);
+  }
+  return removed.map(item => ({ path: item.path, symbol: item.symbol, usage: item.usage, reviewDigest: digest }));
+}
+function checkContracts(review, candidate, target, intent) {
+  const after = new Map(candidate.definitions.filter(item => item.path === target).map(item => [item.symbol, item]));
+  for (const before of review.analysis.definitions.filter(item => item.path === target && item.contract)) {
+    const current = after.get(before.symbol);
+    if (current && before.signatureDigest !== current.signatureDigest) {
+      requireException(intent, 'contract-change', `Existing field, type or interface contract changed at ${before.path}:${before.line} ${before.symbol}`);
+    }
+  }
+}
+function checkReuse(review, candidate, target, intent, parallelPaths) {
+  const duplicates = disciplineDuplicateMappings(review.analysis, { mappings: candidate.mappings.filter(item => item.path === target) });
+  if (duplicates.length) {
+    const original = duplicates[0].existing;
+    requireException(intent, 'new-definition', `Reuse the existing business fact at ${original.path}:${original.line} ${original.symbol}`);
+    requireException(intent, 'rewrite', 'A parallel definition requires a concrete existing defect and independent equivalence evidence');
+    if (intent.defectReference?.path !== original.path || intent.defectReference?.line !== original.line
+      || /更清晰|便于维护|更合理|clearer|maintainab|more.general/i.test(intent.reason)) needs('Rewrite reason must cite the exact existing definition and a concrete defect');
+    if (duplicates.some(item => !parallelPaths?.some(pair => pair.originalPath === item.existing.path && pair.candidatePath === target))) {
+      needs('Parallel definitions require equivalence declarations frozen in the same signed execution plan');
+    }
+  }
+  const old = new Set(review.analysis.definitions.filter(item => item.path === target).map(item => item.symbol));
+  const added = candidate.definitions.filter(item => item.path === target && item.exported && !old.has(item.symbol));
+  if (added.length && !intent) needs('New public definitions require a current requirement and reuse declaration');
+  if (intent && /未来|扩展|更通用|future|extensib|more.general/i.test(intent.reason)
+    && (!intent.futureFields?.length || intent.futureFields.some(name => !candidate.definitions.some(item => item.name === name)))) {
+    mutationFail14('ENTROROVE_DISCIPLINE_SPECULATIVE', 'Future abstractions require concrete named fields already demanded by the current requirement');
+  }
+  return { searchTerms: [...new Set([...added.map(item => item.name), ...candidate.mappings.filter(item => item.path === target).map(item => item.symbol)])],
+    results: duplicates.map(item => ({ path: item.existing.path, line: item.existing.line, symbol: item.existing.symbol })),
+    empty: duplicates.length === 0, complete: review.scanComplete };
+}
+export async function disciplineWritePreflight(input, value, content) {
+  const { pass, target, binding, snapshot, ledger } = value;
+  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 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,
+    candidateDigest: sha256(content), comparisonScope: review.comparison.scope };
+}

package/local-discipline-native.mjs

@@ -0,0 +1,33 @@
+import { withArchguardSyntaxTree } from './local-archguard-language-ast.mjs';
+import { sha256 } from './local-integrity.mjs';
+
+const languages = { php: 'php', py: 'python', java: 'java', rs: 'rust' };
+const declarations = new Set(['class_declaration','class_definition','interface_declaration','trait_declaration','enum_declaration',
+  'function_definition','method_declaration','function_item','struct_item','const_item','property_element','const_element']);
+export async function nativeDisciplineDefinitions(files) {
+  const definitions = [];
+  for (const file of files) {
+    const language = languages[file.path.split('.').at(-1)]; if (!language) continue;
+    const found = await withArchguardSyntaxTree(file, language, root => {
+      if (root.hasError) return [];
+      const output = [];
+      const visit = (node, owner = []) => {
+        let nested = owner;
+        if (declarations.has(node.type)) {
+          const name = node.childForFieldName('name') ?? node.namedChildren.find(child => ['name','identifier','variable_name'].includes(child.type));
+          if (name) {
+            const text = name.text, body = node.childForFieldName('body');
+            const signature = body ? file.content.slice(node.startIndex, body.startIndex) : node.text;
+            output.push({ path: file.path, line: node.startPosition.row + 1, symbol: [...owner,text].join('.'), name: text,
+              exported: true, contract: Boolean(body), signatureDigest: sha256(signature), references: [], usage: 'unknown',
+              parser: `tree-sitter/${language}` });
+            if (body) nested = [...owner,text];
+          }
+        }
+        node.namedChildren.forEach(child => visit(child, nested));
+      }; visit(root); return output;
+    });
+    definitions.push(...found);
+  }
+  return definitions;
+}

package/local-discipline-operations.mjs

@@ -0,0 +1,39 @@
+import { checkedPass } from './local-mutation-authority.mjs';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { readDisciplineSnapshot } from './local-discipline-snapshot.mjs';
+import { assertDisciplineRepository, disciplineRepositoryDifferences } from './local-discipline-repository.mjs';
+import { guardedDelete, guardedMove } from './local-discipline-actions.mjs';
+
+async function observation(input, checkpoint = false) {
+  const value = await checkedPass(input, undefined, { allowTargetDrift: checkpoint });
+  const review = await readDisciplineSnapshot(value.snapshot);
+  return { value, review };
+}
+export async function readDisciplineReview(input) {
+  const { value, review } = await observation(input);
+  return { schemaVersion: 'entrorove.discipline-review-result/1.0', status: 'observed',
+    flowId: value.pass.flowId, snapshotId: value.snapshot.manifest.snapshotId,
+    usageReviewDigest: value.snapshot.manifest.disciplineReviewDigest, scanComplete: review.scanComplete,
+    scanScope: review.comparison.scope, excludedDirectoryNames: review.comparison.excludedDirectoryNames,
+    definitions: review.analysis.definitions.filter(item => item.path === value.target),
+    existingMappings: review.analysis.mappings, unresolved: review.analysis.unresolved, thresholds: review.thresholds };
+}
+export async function checkDisciplineChanges(input) {
+  const { value, review } = await observation(input, true);
+  const actual = await assertDisciplineRepository(input, value.binding.root, review, value.ledger);
+  const changed = disciplineRepositoryDifferences(review.comparison, actual);
+  const moves = [...new Map(Object.values(value.ledger.writes).filter(write => write.move).map(write =>
+    [canonical(write.move), write.move])).values()];
+  const report = { schemaVersion: 'entrorove.discipline-diff/1.0', flowId: value.pass.flowId, taskId: value.pass.taskId,
+    stepId: value.pass.stepId, snapshotId: value.snapshot.manifest.snapshotId,
+    usageReviewDigest: value.snapshot.manifest.disciplineReviewDigest, comparisonScope: review.comparison.scope,
+    originalManifestDigest: sha256(canonical(review.comparison)), actualManifestDigest: sha256(canonical(actual)),
+    changedPaths: changed, declaredMoves: moves, moveDetection: 'explicit-guarded-move-events',
+    gates: { outsidePathsZero: changed.every(name => value.pass.paths.includes(name)),
+      undeclaredPhysicalActionsZero: true, undeclaredMovesZero: true, originalUsageReviewBound: true },
+    thresholds: review.thresholds, rollbackScope: [...value.pass.paths] };
+  return { schemaVersion: 'entrorove.local-execution/1.0', status: 'verified', report, reportDigest: sha256(canonical(report)),
+    signingBoundary: 'original-cloud-pass-and-local-observation; delivery-still-requires-independent-test-receipt' };
+}
+export const DISCIPLINE_LOCAL_OPERATIONS = { 'discipline-review': readDisciplineReview,
+  'discipline-check': checkDisciplineChanges, 'guarded-delete': guardedDelete, 'guarded-move': guardedMove };