@entrorove/skill 0.1.23 → 0.1.24

package/local-final-gate16-checks.mjs

@@ -0,0 +1,88 @@
+import { createHash } from 'node:crypto';
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { compileFormulaEngine, validateFormulaEngine } from './local-formula-engine.mjs';
+import { formulaFinalGate } from './local-formula-tests.mjs';
+
+export const FINAL_GATE16_ROLE_SCHEMA = 'entrorove.calctool-role-result/1.0';
+export const OPS_CONFIG16_SCHEMA = 'entrorove.calctool-ops-config/1.0';
+export const FINAL_GATE16_ROLES = Object.freeze(['audit', 'test', 'ops']);
+export const sha16 = value => createHash('sha256').update(value).digest('hex');
+export function fail16(code, message) { throw Object.assign(new Error(message), { code }); }
+export function exact16(value, fields, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || Object.keys(value).sort().join('|') !== [...fields].sort().join('|')) fail16('FINAL_GATE16_FIELDS', `${label} requires its exact fields`);
+  return value;
+}
+export function relative16(value) {
+  if (typeof value !== 'string' || !value || value !== value.normalize('NFC') || path.isAbsolute(value)
+    || /^[A-Za-z]:/.test(value) || /[\\\u0000-\u001f\u007f]/.test(value)
+    || value.split('/').some(part => !part || part === '.' || part === '..')) fail16('FINAL_GATE16_PATH', 'Expected a normalized relative file path');
+  return value;
+}
+export async function readFile16(repositoryRoot, relativePath) {
+  if (typeof repositoryRoot !== 'string' || !path.isAbsolute(repositoryRoot)) fail16('FINAL_GATE16_ROOT', 'repositoryRoot must be absolute');
+  const root = await fs.realpath(repositoryRoot), target = path.join(root, relative16(relativePath));
+  if (await fs.realpath(target) !== target) fail16('FINAL_GATE16_FILE', 'Checker files cannot have symlinked ancestors');
+  const handle = await fs.open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > 1024 * 1024) fail16('FINAL_GATE16_FILE', 'Checker input must be a bounded regular file');
+    const bytes = await handle.readFile(), after = await handle.stat(), current = await fs.lstat(target);
+    if (stat.dev !== current.dev || stat.ino !== current.ino || stat.size !== after.size || stat.mtimeMs !== after.mtimeMs)
+      fail16('FINAL_GATE16_FILE_CHANGED', 'Checker input changed while reading');
+    return { path: relativePath, bytes, sha256: sha16(bytes) };
+  } finally { await handle.close(); }
+}
+export async function inputs16(input) {
+  const [engineFile, opsFile] = await Promise.all([readFile16(input.repositoryRoot, input.enginePath), readFile16(input.repositoryRoot, input.opsConfigPath)]);
+  let engine, ops;
+  try { engine = JSON.parse(engineFile.bytes); ops = JSON.parse(opsFile.bytes); }
+  catch { fail16('FINAL_GATE16_JSON', 'Engine and operations configuration must be valid JSON'); }
+  return { engine, ops, engineFile, opsFile };
+}
+async function executable16(config, label) {
+  exact16(config, label === 'package manager' ? ['name', 'path', 'sha256'] : ['path', 'sha256'], label);
+  if (typeof config.path !== 'string' || !path.isAbsolute(config.path) || !/^[0-9a-f]{64}$/.test(config.sha256 ?? ''))
+    fail16('FINAL_GATE16_EXECUTABLE', `${label} requires an absolute executable and SHA256`);
+  const resolved = await fs.realpath(config.path), stat = await fs.lstat(config.path);
+  if (resolved !== config.path || !stat.isFile() || stat.isSymbolicLink() || !(stat.mode & 0o111) || stat.size > 256 * 1024 * 1024)
+    fail16('FINAL_GATE16_EXECUTABLE', `${label} must be a real regular executable`);
+  await fs.access(config.path, constants.X_OK);
+  if (sha16(await fs.readFile(config.path)) !== config.sha256) fail16('FINAL_GATE16_EXECUTABLE_HASH', `${label} executable bytes changed`);
+  return resolved;
+}
+export async function operations16(ops) {
+  exact16(ops, ['schemaVersion', 'node', 'packageManager', 'commands'], 'operations configuration');
+  if (ops.schemaVersion !== OPS_CONFIG16_SCHEMA) fail16('FINAL_GATE16_OPS_SCHEMA', 'Operations configuration schema is invalid');
+  const node = await executable16(ops.node, 'Node'), manager = await executable16(ops.packageManager, 'package manager');
+  if (node !== await fs.realpath(process.execPath) || Number(process.versions.node.split('.')[0]) < 18)
+    fail16('FINAL_GATE16_NODE', 'The checker must actually run the approved Node 18+ executable');
+  if (!['npm', 'pnpm', 'yarn'].includes(ops.packageManager.name)
+    || ![ops.packageManager.name, `${ops.packageManager.name}.js`, `${ops.packageManager.name}.cjs`, `${ops.packageManager.name}-cli.js`].includes(path.basename(manager)))
+    fail16('FINAL_GATE16_PACKAGE_MANAGER', 'A supported actual package manager executable is required');
+  exact16(ops.commands, ['install', 'run'], 'operations commands');
+  for (const [name, args] of Object.entries(ops.commands)) if (!Array.isArray(args) || !args.length || args.length > 128
+    || args.some(value => typeof value !== 'string' || !value || value.length > 4096 || /[\u0000-\u001f\u007f]/.test(value))
+    || args[0] !== name || (name === 'run' && (args.length < 2 || !/^[A-Za-z0-9][A-Za-z0-9:_-]{0,127}$/.test(args[1]))))
+    fail16('FINAL_GATE16_COMMAND_CONFIG', 'Install and run commands require explicit bounded argv configuration');
+  return { passed: true, findings: [], checks: { nodeExecutable: true, packageManagerExecutable: true,
+    commandsConfigured: true, commandsExecuted: false }, actualNodeVersion: process.versions.node };
+}
+export async function role16(role, loaded, gateId) {
+  if (!FINAL_GATE16_ROLES.includes(role) || typeof gateId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(gateId))
+    fail16('FINAL_GATE16_ROLE', 'The checker requires its original role and frozen gate ID');
+  const findings = validateFormulaEngine(loaded.engine); let program;
+  if (!findings.length) program = compileFormulaEngine(loaded.engine);
+  let result = { passed: findings.length === 0, findings, checks: { engineValid: findings.length === 0 } };
+  if (role === 'test' && program) {
+    const tested = formulaFinalGate(loaded.engine);
+    result = { passed: tested.computationsPassed, findings: tested.findings, tests: tested.tests,
+      checks: { benchmarkSamples: tested.tests.length, passingSamples: tested.tests.filter(value => value.passed).length } };
+  }
+  if (role === 'ops' && program) result = await operations16(loaded.ops);
+  return { schemaVersion: FINAL_GATE16_ROLE_SCHEMA, role, gateId, status: 'reported', ...result,
+    engineId: program?.engineId ?? loaded.engine?.engineId ?? null, engineVersion: program?.engineVersion ?? null,
+    engineSha256: loaded.engineFile.sha256, opsConfigSha256: loaded.opsFile.sha256,
+    engineDigest: program?.engineDigest ?? null, programDigest: program?.programDigest ?? null };
+}

package/local-final-gate16-contract.mjs

@@ -0,0 +1,15 @@
+const text = { type: 'string', minLength: 1, maxLength: 4096 };
+const identifier = { type: 'string', pattern: '^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$' };
+const relative = { ...text, pattern: '^(?!/)(?![A-Za-z]:)(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\\\)(?!.*(?:^|/)(?:\\.\\.?)(?:/|$)).+' };
+const object = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: false });
+const control = object({ planPath: relative, approvalPath: text, signerConfigPath: { anyOf: [text, { type: 'null' }] } });
+export const FINAL_GATE16_INPUT_SCHEMA = Object.freeze(object({ repositoryRoot: text, home: text,
+  enginePath: relative, opsConfigPath: relative, gateId: identifier, flowId: identifier, stepId: identifier,
+  plans: object({ audit: control, test: control, ops: control }) }, ['repositoryRoot', 'enginePath', 'opsConfigPath', 'gateId', 'flowId', 'stepId', 'plans']));
+export const FINAL_GATE16_READ_INPUT_SCHEMA = Object.freeze(object({ repositoryRoot: text, home: text,
+  gateId: identifier, flowId: identifier, stepId: identifier }, ['repositoryRoot', 'gateId', 'flowId', 'stepId']));
+export const FINAL_GATE16_SCHEMA = 'entrorove.calctool-final-gate/2.0';
+export const FINAL_GATE16_BUNDLE_PREFIX = 'entrorove-final-gate16/';
+export const FINAL_GATE16_WORKER_PATH = FINAL_GATE16_BUNDLE_PREFIX + 'local-final-gate16-worker.mjs';
+export const finalGate16Args = (role, enginePath, opsConfigPath) => [FINAL_GATE16_WORKER_PATH, role, enginePath, opsConfigPath];
+export const finalGate16Tests = role => [{ testId: `calctool-final-gate16:${role}`, path: FINAL_GATE16_WORKER_PATH }];

package/local-final-gate16-plan.mjs

@@ -0,0 +1,66 @@
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import Ajv from 'ajv';
+import { compileFormulaEngine, formulaCanonical } from './local-formula-engine.mjs';
+import { FINAL_GATE16_INPUT_SCHEMA, finalGate16Args, finalGate16Tests } from './local-final-gate16-contract.mjs';
+import { finalGate16Bundle } from './local-final-gate16-bundle.mjs';
+import { exact16, fail16, inputs16, readFile16, sha16, FINAL_GATE16_ROLES } from './local-final-gate16-checks.mjs';
+
+const validate = new Ajv({ strict: true, allErrors: true }).compile(FINAL_GATE16_INPUT_SCHEMA);
+export const digest16 = value => sha16(formulaCanonical(value));
+export function checkInput16(input) {
+  if (!validate(input)) fail16('FINAL_GATE16_INPUT', 'Final gate requires its exact repository, identity, source and three plan locators');
+  if (input.enginePath === input.opsConfigPath) fail16('FINAL_GATE16_INPUT', 'Engine and operations configuration must be different files');
+  return { ...input, home: input.home ?? homedir() };
+}
+export function validateFinalGate16RolePlan(plan, role, binding) {
+  const policy = plan?.policy, declaration = plan?.evidencePolicy;
+  if (plan?.schemaVersion !== 'validator.execution-plan/1.0' || plan.frozen !== true || !policy)
+    fail16('FINAL_GATE16_PLAN', 'Each role requires a frozen independent execution plan');
+  exact16(declaration, ['kind', 'runner', 'flowId', 'stepId'], 'role evidence policy');
+  if (declaration.kind !== 'test' || !['trusted-runner', 'sandbox'].includes(declaration.runner)
+    || declaration.flowId !== binding.flowId || (role === 'audit' && declaration.stepId !== binding.stepId))
+    fail16('FINAL_GATE16_ROLE_BINDING', 'Role evidence must retain its original gate context and actual signed workflow step');
+  if (formulaCanonical(policy.args) !== formulaCanonical(finalGate16Args(role, binding.enginePath, binding.opsConfigPath))
+    || formulaCanonical(plan.tests) !== formulaCanonical(finalGate16Tests(role))
+    || formulaCanonical(policy.environment) !== formulaCanonical({ ENTROROVE_FINAL_GATE16_ID: binding.gateId }))
+    fail16('FINAL_GATE16_ROLE_COMMAND', 'Each role must execute the fixed checker, tests and frozen gate ID');
+  if (policy.executable !== binding.ops.node?.path || policy.executableSha256 !== binding.ops.node?.sha256)
+    fail16('FINAL_GATE16_NODE_BINDING', 'Checker executable must be the actual Node configured in the frozen operations file');
+  const files = plan.files;
+  if (!Array.isArray(files) || !files.length || files.length > 512) fail16('FINAL_GATE16_MANIFEST', 'Role manifest must be nonempty and bounded');
+  for (const [index, file] of files.entries()) if (!file || Object.keys(file).sort().join('|') !== 'path|sha256'
+    || !/^[0-9a-f]{64}$/.test(file.sha256 ?? '') || typeof file.path !== 'string'
+    || (index && files[index - 1].path >= file.path)) fail16('FINAL_GATE16_MANIFEST', 'Role manifest must be sorted and unique');
+  for (const file of binding.requiredFiles) if (!files.some(value => value.path === file.path && value.sha256 === file.sha256))
+    fail16('FINAL_GATE16_CHECKER_MANIFEST', 'Role manifest omits or changes a fixed checker closure or original input');
+  const artifact = sha16(`validator.file-manifest/1.0\n${files.map(file => `${file.path}\0${file.sha256}`).join('\n')}`);
+  if (artifact !== plan.artifactSha256) fail16('FINAL_GATE16_MANIFEST', 'Role artifact must use the independent Validator manifest digest');
+  return plan;
+}
+export async function prepareFinalGate16(input) {
+  input = checkInput16(input);
+  const rootStat = await fs.lstat(input.repositoryRoot);
+  if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) fail16('FINAL_GATE16_ROOT', 'Repository must be a real directory');
+  const loaded = await inputs16(input), program = compileFormulaEngine(loaded.engine), bundle = await finalGate16Bundle();
+  const requiredFiles = [{ path: input.enginePath, sha256: loaded.engineFile.sha256 },
+    { path: input.opsConfigPath, sha256: loaded.opsFile.sha256 }, ...bundle.map(({ path, sha256 }) => ({ path, sha256 }))];
+  if (new Set(requiredFiles.map(file => file.path)).size !== requiredFiles.length)
+    fail16('FINAL_GATE16_MANIFEST', 'Engine and operations configuration cannot replace the fixed checker closure');
+  const roles = {};
+  for (const role of FINAL_GATE16_ROLES) {
+    const file = await readFile16(input.repositoryRoot, input.plans[role].planPath); let plan;
+    try { plan = JSON.parse(file.bytes); } catch { fail16('FINAL_GATE16_PLAN_JSON', 'Role execution plan must be JSON'); }
+    validateFinalGate16RolePlan(plan, role, { ...input, ops: loaded.ops, requiredFiles });
+    for (const entry of plan.files) if ((await readFile16(input.repositoryRoot, entry.path)).sha256 !== entry.sha256)
+      fail16('FINAL_GATE16_SOURCE_CHANGED', 'A role manifest file differs from its frozen source');
+    roles[role] = { plan, planSha256: file.sha256, planBytes: file.bytes.toString('base64') };
+  }
+  const audit = roles.audit.plan;
+  if (new Set(FINAL_GATE16_ROLES.map(role => roles[role].plan.validationRunId)).size !== 3)
+    fail16('FINAL_GATE16_ROLE_IDENTITY', 'Each role requires a different signed execution identity');
+  for (const role of FINAL_GATE16_ROLES) for (const field of ['files', 'contracts', 'chainId', 'memberId'])
+    if (formulaCanonical(roles[role].plan[field]) !== formulaCanonical(audit[field]))
+      fail16('FINAL_GATE16_SHARED_BINDING', 'All role plans must retain the same source manifest, contracts, chain and member');
+  return { input: structuredClone(input), inputDigest: digest16(input), loaded, program, roles, requiredFiles };
+}

package/local-final-gate16-proof.mjs

@@ -0,0 +1,75 @@
+import { promises as fs } from 'node:fs';
+import { verifyTestEvidence } from './local-evidence-verification.mjs';
+import { compileFormulaEngine, formulaCanonical } from './local-formula-engine.mjs';
+import { FINAL_GATE16_ROLES, fail16, sha16, role16 } from './local-final-gate16-checks.mjs';
+import { digest16, checkInput16, validateFinalGate16RolePlan } from './local-final-gate16-plan.mjs';
+import { finalGate16Bundle } from './local-final-gate16-bundle.mjs';
+
+const same16 = (a, b) => formulaCanonical(a) === formulaCanonical(b);
+export function verifyRoleEvidence16(role, execution, prepared, now) {
+  const { plan, planSha256 } = prepared.roles[role], item = execution?.evidence?.[0], subject = item?.subject;
+  if (!execution || execution.evidence?.length !== 1 || execution.planSha256 !== planSha256 || !subject)
+    fail16('FINAL_GATE16_ROLE_RECEIPT', 'Each role requires its original single actual execution evidence');
+  for (const field of ['planId', 'validationRunId', 'memberId', 'chainId', 'artifactSha256', 'files', 'tests', 'contracts', 'goldenBaseline'])
+    if (!same16(subject[field], plan[field])) fail16('FINAL_GATE16_SIGNED_PLAN', 'Role evidence must retain the complete original frozen plan');
+  const command = [plan.policy.executable, ...plan.policy.args].map(value => JSON.stringify(value)).join(' ');
+  if (subject.policy?.executionPlanSha256 !== planSha256 || subject.policy?.command !== command
+    || subject.policy?.evidenceKind !== 'test' || subject.policy?.evidenceRunner !== plan.evidencePolicy.runner
+    || !same16(subject.policy?.workflowBinding, { flowId: prepared.input.flowId, stepId: plan.evidencePolicy.stepId }))
+    fail16('FINAL_GATE16_SIGNED_POLICY', 'Role evidence must retain the signed checker command and workflow identity');
+  const process = execution.process;
+  for (const field of ['exitCode', 'signal', 'timedOut', 'outputLimitExceeded'])
+    if (!same16(subject.execution?.[field], process?.[field])) fail16('FINAL_GATE16_PROCESS', 'Actual role process differs from its signed execution');
+  if (process.durationMs !== item.durationMs || sha16(process.stdout) !== process.stdoutSha256 || sha16(process.stderr) !== process.stderrSha256)
+    fail16('FINAL_GATE16_PROCESS', 'Actual process metadata must retain its original execution evidence');
+  return verifyTestEvidence(item, { publicKey: processEnvPin16(), now,
+    binding: { flowId: prepared.input.flowId, stepId: plan.evidencePolicy.stepId, artifactSha256: plan.artifactSha256 } });
+}
+export function processEnvPin16() { return process.env.ENTROROVE_VALIDATOR_RECEIPT_PUBLIC_KEY || undefined; }
+export function snapshotPrepared16(prepared) {
+  return { input: prepared.input, inputDigest: prepared.inputDigest, roles: prepared.roles,
+    engineBytes: prepared.loaded.engineFile.bytes.toString('base64'), opsBytes: prepared.loaded.opsFile.bytes.toString('base64') };
+}
+function originalBytes16(value) {
+  if (typeof value !== 'string') fail16('FINAL_GATE16_HISTORY_BYTES', 'Original source bytes must be retained');
+  const bytes = Buffer.from(value, 'base64');
+  if (bytes.toString('base64') !== value) fail16('FINAL_GATE16_HISTORY_BYTES', 'Original source encoding is invalid');
+  return bytes;
+}
+async function assertHistoricalNode16(ops) {
+  const executable = await fs.realpath(process.execPath), stat = await fs.stat(executable);
+  if (!stat.isFile() || stat.size > 256 * 1024 * 1024 || !(stat.mode & 0o111)
+    || ops?.node?.path !== executable || ops.node.sha256 !== sha16(await fs.readFile(executable)))
+    fail16('FINAL_GATE16_HISTORY_NODE', 'Historical checker evidence requires the original independently identified host Node executable; changed runtime identity needs trusted review');
+}
+export async function restorePrepared16(record) {
+  const saved = record.prepared, input = checkInput16(saved.input);
+  if (digest16(input) !== saved.inputDigest) fail16('FINAL_GATE16_HISTORY_INPUT', 'Original gate input binding changed');
+  const engineBytes = originalBytes16(saved.engineBytes), opsBytes = originalBytes16(saved.opsBytes);
+  const loaded = { engine: JSON.parse(engineBytes), ops: JSON.parse(opsBytes),
+    engineFile: { bytes: engineBytes, sha256: sha16(engineBytes) }, opsFile: { bytes: opsBytes, sha256: sha16(opsBytes) } };
+  await assertHistoricalNode16(loaded.ops);
+  const requiredFiles = [{ path: input.enginePath, sha256: loaded.engineFile.sha256 }, { path: input.opsConfigPath, sha256: loaded.opsFile.sha256 },
+    ...(await finalGate16Bundle()).map(({ path, sha256 }) => ({ path, sha256 }))];
+  for (const role of FINAL_GATE16_ROLES) {
+    const entry = saved.roles[role], bytes = originalBytes16(entry.planBytes);
+    if (entry.planSha256 !== sha16(bytes) || !same16(JSON.parse(bytes), entry.plan))
+      fail16('FINAL_GATE16_HISTORY_PLAN', 'Original signed role plan bytes changed');
+    validateFinalGate16RolePlan(entry.plan, role, { ...input, ops: loaded.ops, requiredFiles });
+  }
+  const audit = saved.roles.audit.plan;
+  if (new Set(FINAL_GATE16_ROLES.map(role => saved.roles[role].plan.validationRunId)).size !== 3)
+    fail16('FINAL_GATE16_HISTORY_PLAN', 'Original role identities changed');
+  for (const role of FINAL_GATE16_ROLES) for (const field of ['files', 'contracts', 'chainId', 'memberId'])
+    if (!same16(saved.roles[role].plan[field], audit[field])) fail16('FINAL_GATE16_HISTORY_PLAN', 'Original shared role binding changed');
+  return { input, inputDigest: saved.inputDigest, loaded, program: compileFormulaEngine(loaded.engine), roles: saved.roles, requiredFiles };
+}
+export async function historicalRole16(role, prepared, original) {
+  if (role !== 'ops') return role16(role, prepared.loaded, prepared.input.gateId);
+  const audit = await role16('audit', prepared.loaded, prepared.input.gateId);
+  if (!original?.passed || !same16(original.checks, { nodeExecutable: true, packageManagerExecutable: true, commandsConfigured: true, commandsExecuted: false }))
+    fail16('FINAL_GATE16_HISTORY_OPS', 'Original successful operations check changed');
+  const result = { ...audit, role: 'ops', passed: true, findings: [], checks: original.checks, actualNodeVersion: original.actualNodeVersion };
+  if (!same16(result, original)) fail16('FINAL_GATE16_HISTORY_OPS', 'Original operations source binding changed');
+  return result;
+}

package/local-final-gate16-release.mjs

@@ -0,0 +1,17 @@
+export const FINAL_GATE16_PACKAGE_FILES = Object.freeze([
+  "local-final-gate16.mjs",
+  "local-final-gate16-checks.mjs",
+  "local-final-gate16-worker.mjs",
+  "local-final-gate16-plan.mjs",
+  "local-final-gate16-bundle.mjs",
+  "local-final-gate16-state.mjs",
+  "local-final-gate16-proof.mjs",
+  "local-final-gate16-contract.mjs",
+  "local-final-gate16-release.mjs"
+]);
+
+export function withFinalGate16ReleaseLabels(labels) {
+  const note = { zh: 'Calctool 审计测试运维真实检查与独立最终闸门',
+    en: 'Calctool audit, test, operations checks and independent final gate' };
+  return { ...labels, ...Object.fromEntries(FINAL_GATE16_PACKAGE_FILES.map(name => [name, note])) };
+}

package/local-final-gate16-state.mjs

@@ -0,0 +1,70 @@
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { digest16 } from './local-final-gate16-plan.mjs';
+import { fail16, sha16 } from './local-final-gate16-checks.mjs';
+
+const STATE_SCHEMA = 'entrorove.calctool-final-gate-state/1.0';
+const MAX_BYTES = 16 * 1024 * 1024;
+function privateStat16(stat, directory) {
+  if ((directory ? !stat.isDirectory() : !stat.isFile()) || stat.isSymbolicLink()
+    || stat.uid !== process.getuid() || (stat.mode & 0o777) !== (directory ? 0o700 : 0o600))
+    fail16('FINAL_GATE16_PRIVATE_STATE', 'Gate state must retain its actual private owner and permissions');
+}
+export async function statePath16(input, create = false) {
+  if (typeof process.getuid !== 'function') fail16('FINAL_GATE16_POSIX', 'Private gate recovery requires POSIX');
+  const home = path.resolve(input.home ?? homedir()), root = path.resolve(input.repositoryRoot);
+  if (await fs.realpath(home) !== home || await fs.realpath(root) !== root)
+    fail16('FINAL_GATE16_STATE_PATH', 'Gate home and repository cannot have symlinked ancestors');
+  let directory = home;
+  for (const part of ['.entrorove', 'calctool', 'final-gates', sha16(root), input.flowId]) {
+    directory = path.join(directory, part);
+    if (create) { try { await fs.mkdir(directory, { mode: 0o700 }); } catch (error) { if (error.code !== 'EEXIST') throw error; } }
+    try { privateStat16(await fs.lstat(directory), true); }
+    catch (error) { if (!create && error.code === 'ENOENT') return null; throw error; }
+  }
+  return path.join(directory, `${input.gateId}.json`);
+}
+function encoded16(record) {
+  const data = { schemaVersion: STATE_SCHEMA, record, recordDigest: digest16(record) };
+  const bytes = Buffer.from(JSON.stringify(data) + '\n');
+  if (bytes.length > MAX_BYTES) fail16('FINAL_GATE16_STATE_SIZE', 'Gate recovery state is bounded');
+  return bytes;
+}
+export async function readState16(input) {
+  const target = await statePath16(input); if (!target) return null;
+  let handle;
+  try { handle = await fs.open(target, constants.O_RDONLY | constants.O_NOFOLLOW); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  try {
+    const stat = await handle.stat(); privateStat16(stat, false);
+    if (stat.size > MAX_BYTES) fail16('FINAL_GATE16_STATE_SIZE', 'Gate recovery state is bounded');
+    const bytes = await handle.readFile(), current = await fs.lstat(target);
+    if (current.ino !== stat.ino || current.dev !== stat.dev || current.size !== stat.size)
+      fail16('FINAL_GATE16_STATE_CHANGED', 'Gate state changed while reading');
+    let value; try { value = JSON.parse(bytes); } catch { fail16('FINAL_GATE16_STATE_JSON', 'Gate recovery state is invalid'); }
+    if (Object.keys(value).sort().join('|') !== 'record|recordDigest|schemaVersion'
+      || value.schemaVersion !== STATE_SCHEMA || value.recordDigest !== digest16(value.record))
+      fail16('FINAL_GATE16_STATE_DIGEST', 'Gate recovery state digest does not match');
+    return value.record;
+  } finally { await handle.close(); }
+}
+export async function createState16(input, record) {
+  const target = await statePath16(input, true); let handle;
+  try { handle = await fs.open(target, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600); }
+  catch (error) { if (error.code === 'EEXIST') return false; throw error; }
+  try { await handle.writeFile(encoded16(record)); await handle.sync(); }
+  finally { await handle.close(); }
+  return true;
+}
+export async function writeState16(input, record) {
+  const target = await statePath16(input), temporary = `${target}.${randomUUID()}.tmp`;
+  if (!target) fail16('FINAL_GATE16_STATE_MISSING', 'Gate state must exist before execution');
+  privateStat16(await fs.lstat(target), false);
+  const handle = await fs.open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+  try { await handle.writeFile(encoded16(record)); await handle.sync(); }
+  finally { await handle.close(); }
+  try { await fs.rename(temporary, target); const directory = await fs.open(path.dirname(target), constants.O_RDONLY); try { await directory.sync(); } finally { await directory.close(); } }
+  finally { await fs.rm(temporary, { force: true }); }
+}

package/local-final-gate16-worker.mjs

@@ -0,0 +1,19 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { inputs16, role16, fail16 } from './local-final-gate16-checks.mjs';
+
+export async function runFinalGate16Worker(args = process.argv.slice(2)) {
+  if (args.length !== 3) fail16('FINAL_GATE16_WORKER_ARGS', 'Expected role, engine path and operations configuration path');
+  const [role, enginePath, opsConfigPath] = args;
+  const loaded = await inputs16({ repositoryRoot: process.cwd(), enginePath, opsConfigPath });
+  return role16(role, loaded, process.env.ENTROROVE_FINAL_GATE16_ID);
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    const result = await runFinalGate16Worker();
+    process.stdout.write(JSON.stringify(result) + '\n'); process.exitCode = result.passed ? 0 : 2;
+  } catch (error) {
+    process.stderr.write(JSON.stringify({ status: 'blocked', code: error.code ?? 'FINAL_GATE16_WORKER', message: error.message }) + '\n');
+    process.exitCode = 2;
+  }
+}

package/local-final-gate16.mjs

@@ -0,0 +1,137 @@
+import Ajv from 'ajv';
+import { homedir } from 'node:os';
+import { runApprovedPlan } from './local-approved-plan.mjs';
+import { FINAL_GATE16_READ_INPUT_SCHEMA, FINAL_GATE16_SCHEMA } from './local-final-gate16-contract.mjs';
+import { FINAL_GATE16_ROLES, fail16, role16 } from './local-final-gate16-checks.mjs';
+import { checkInput16, prepareFinalGate16, digest16 } from './local-final-gate16-plan.mjs';
+import { createState16, readState16, writeState16 } from './local-final-gate16-state.mjs';
+import { verifyRoleEvidence16, snapshotPrepared16, restorePrepared16, historicalRole16 } from './local-final-gate16-proof.mjs';
+
+const validateRead = new Ajv({ strict: true, allErrors: true }).compile(FINAL_GATE16_READ_INPUT_SCHEMA);
+function response16(input, status, details = {}) {
+  return { schemaVersion: FINAL_GATE16_SCHEMA, status, guarantee: 'await-server-for-workflow',
+    gateId: input?.gateId ?? null, flowId: input?.flowId ?? null, stepId: input?.stepId ?? null,
+    historicalRecovery: false, currentAuthorization: false, ...details };
+}
+function failure16(input, error, details = {}) {
+  return response16(input, 'blocked', { code: error.code ?? 'FINAL_GATE16_FAILED', reason: error.message, ...details });
+}
+function matchRecord16(input, record, full) {
+  const original = record.prepared?.input;
+  for (const field of ['repositoryRoot', 'home', 'flowId', 'stepId', 'gateId'])
+    if (input[field] !== original?.[field]) fail16('FINAL_GATE16_RECOVERY_BINDING', 'Gate recovery must retain its original repository, home and workflow identity');
+  if (full && digest16(input) !== record.prepared.inputDigest)
+    fail16('FINAL_GATE16_RECOVERY_BINDING', 'The same gate ID cannot execute or recover different input');
+}
+function checkHistoricalRoles16(record, prepared) {
+  if (!record.roles || Object.keys(record.roles).some(role => !FINAL_GATE16_ROLES.includes(role)))
+    fail16('FINAL_GATE16_HISTORY_ROLE', 'Historical roles require their exact original identities');
+  for (const role of Object.keys(record.roles)) {
+    const original = record.roles[role], response = original.response, execution = original.execution;
+    if (!response || Object.keys(response).sort().join('|') !== 'evidence|process|result|status|verifiedAt'
+      || !['verified', 'blocked', 'incomplete'].includes(response.status) || original.result?.role !== role
+      || original.result?.gateId !== prepared.input.gateId || original.result?.status !== 'reported'
+      || digest16(response.process) !== digest16(execution.process) || digest16(response.evidence) !== digest16(execution.evidence)
+      || digest16(response.result) !== digest16(original.result))
+      fail16('FINAL_GATE16_HISTORY_ROLE', 'Historical role output differs from its original execution');
+    const item = execution.evidence[0], time = response.verifiedAt === null ? Date.parse(item?.receipt?.issuedAt) : Date.parse(response.verifiedAt);
+    const verified = verifyRoleEvidence16(role, execution, prepared, Number.isSafeInteger(time) ? time : Date.now());
+    if (item.receipt && !verified.verified) fail16('FINAL_GATE16_HISTORY_RECEIPT', 'Original role receipt must verify with the configured independent trust pin');
+    if (response.status === 'verified' && (!verified.successful || !original.result.passed || time < Date.parse(item.receipt.issuedAt)))
+      fail16('FINAL_GATE16_HISTORY_ROLE', 'Historical verified role lacks its original successful evidence');
+  }
+}
+async function recovered16(input, record, full) {
+  matchRecord16(input, record, full); const prepared = await restorePrepared16(record);
+  if (!['pending', 'finished'].includes(record.state)) fail16('FINAL_GATE16_HISTORY_STATE', 'Original gate execution state is invalid');
+  if (record.state !== 'finished') return response16(input, 'incomplete', { historicalRecovery: true,
+    executionState: 'unknown', reason: 'This gate was already admitted; its interrupted execution must not be repeated', roles: record.roles ?? {} });
+  const output = record.output;
+  if (output?.schemaVersion !== FINAL_GATE16_SCHEMA || !['verified', 'blocked', 'incomplete'].includes(output.status)
+    || output.gateId !== input.gateId || output.flowId !== input.flowId || output.stepId !== input.stepId
+    || output.guarantee !== 'await-server-for-workflow') fail16('FINAL_GATE16_HISTORY_RESULT', 'Historical gate identity or status changed');
+  checkHistoricalRoles16(record, prepared);
+  if (output.status !== 'verified') return response16(input, output.status, { historicalRecovery: true,
+    ...Object.fromEntries(['roles', 'verifiedAt', 'engineSha256', 'opsConfigSha256', 'engineDigest', 'programDigest', 'reason', 'code', 'executionState']
+      .filter(key => output[key] !== undefined).map(key => [key, output[key]])) });
+  const now = Date.parse(output.verifiedAt);
+  if (!Number.isSafeInteger(now)) fail16('FINAL_GATE16_HISTORY_TIME', 'The original verification time is required');
+  if (!output.roles || Object.keys(output.roles).sort().join('|') !== 'audit|ops|test')
+    fail16('FINAL_GATE16_HISTORY_ROLE', 'Verified gate history requires exactly its three original roles');
+  for (const role of FINAL_GATE16_ROLES) {
+    const original = record.roles[role], issuedAt = Date.parse(original?.execution?.evidence?.[0]?.receipt?.issuedAt);
+    if (now < issuedAt || now < Date.parse(original?.execution?.subject?.executedAt))
+      fail16('FINAL_GATE16_HISTORY_TIME', 'Historical verification cannot precede original role execution');
+    const verified = verifyRoleEvidence16(role, original.execution, prepared, now);
+    if (!verified.verified || !verified.successful) fail16('FINAL_GATE16_HISTORY_RECEIPT', 'Original independent role receipt no longer verifies with the configured trust pin');
+    const actual = await historicalRole16(role, prepared, original.result);
+    if (digest16(actual) !== digest16(original.result) || !actual.passed || original.response.status !== 'verified'
+      || now < Date.parse(original.response.verifiedAt) || digest16(output.roles[role]) !== digest16(original.response))
+      fail16('FINAL_GATE16_HISTORY_RESULT', 'Historical role conclusion changed');
+  }
+  return response16(input, 'verified', { historicalRecovery: true, roles: output.roles, verifiedAt: output.verifiedAt,
+    engineSha256: prepared.loaded.engineFile.sha256, opsConfigSha256: prepared.loaded.opsFile.sha256,
+    engineDigest: prepared.program.engineDigest, programDigest: prepared.program.programDigest });
+}
+export async function readFinalGate16(input) {
+  try {
+    if (!validateRead(input)) fail16('FINAL_GATE16_READ_INPUT', 'Gate reads require their exact original repository and identity');
+    input = { ...input, home: input.home ?? homedir() }; const record = await readState16(input);
+    return record ? await recovered16(input, record, false) : response16(input, 'incomplete', { historicalRecovery: true,
+      executionState: 'not-started', reason: 'There is no original gate execution to recover' });
+  } catch (error) { return failure16(input, error, { historicalRecovery: true }); }
+}
+async function performRole16(role, prepared) {
+  const input = prepared.input, control = input.plans[role];
+  const execution = await runApprovedPlan({ repositoryRoot: input.repositoryRoot, home: input.home, flowId: input.flowId, ...control });
+  let result;
+  try { result = await role16(role, prepared.loaded, input.gateId); }
+  catch (error) { result = { role, gateId: input.gateId, status: 'reported', passed: false,
+    findings: [{ code: error.code ?? 'FINAL_GATE16_ROLE_FAILED', message: error.message }] }; }
+  const now = Date.now();
+  const verification = verifyRoleEvidence16(role, execution, prepared, now);
+  const status = result.passed && verification.verified && verification.successful ? 'verified'
+    : execution.process?.exitCode !== 0 || !result.passed || verification.status === 'blocked' ? 'blocked' : 'incomplete';
+  const response = { status, result, process: execution.process, evidence: execution.evidence,
+    verifiedAt: status === 'verified' ? new Date(now).toISOString() : null };
+  return { execution, result, response };
+}
+function finished16(input, prepared, record) {
+  const now = Date.now(), roles = Object.fromEntries(FINAL_GATE16_ROLES.map(role => [role, record.roles[role].response]));
+  let status = FINAL_GATE16_ROLES.every(role => roles[role].status === 'verified') ? 'verified'
+    : FINAL_GATE16_ROLES.some(role => roles[role].status === 'blocked') ? 'blocked' : 'incomplete';
+  if (status === 'verified') for (const role of FINAL_GATE16_ROLES) {
+    const verified = verifyRoleEvidence16(role, record.roles[role].execution, prepared, now);
+    if (!verified.verified || !verified.successful) { status = verified.status === 'blocked' ? 'blocked' : 'incomplete'; roles[role] = { ...roles[role], status, verification: verified }; }
+  }
+  return response16(input, status, { roles, verifiedAt: status === 'verified' ? new Date(now).toISOString() : null,
+    currentAuthorization: status === 'verified', engineSha256: prepared.loaded.engineFile.sha256,
+    opsConfigSha256: prepared.loaded.opsFile.sha256, engineDigest: prepared.program.engineDigest,
+    programDigest: prepared.program.programDigest });
+}
+export async function runFinalGate16(input) {
+  if (validateRead(input)) return readFinalGate16(input);
+  let record, admitted = false;
+  try {
+    input = checkInput16(input); const existing = await readState16(input);
+    if (existing) return await recovered16(input, existing, true);
+    const prepared = await prepareFinalGate16(input);
+    record = { state: 'pending', prepared: snapshotPrepared16(prepared), roles: {}, admittedAt: new Date().toISOString(), activeRole: null };
+    admitted = await createState16(input, record);
+    if (!admitted) return await recovered16(input, await readState16(input), true);
+    for (const role of FINAL_GATE16_ROLES) {
+      record.activeRole = role; await writeState16(input, record);
+      record.roles[role] = await performRole16(role, prepared); await writeState16(input, record);
+    }
+    record.output = finished16(input, prepared, record); record.state = 'finished'; record.activeRole = null;
+    await writeState16(input, record); return record.output;
+  } catch (error) {
+    const unknown = Boolean(error.execution && error.execution.effects !== 'none');
+    const output = unknown ? response16(input, 'incomplete', { executionState: 'unknown', reason: error.message }) : failure16(input, error);
+    if (admitted && record) {
+      record.state = unknown ? 'pending' : 'finished'; record.output = output;
+      try { await writeState16(input, record); } catch { return response16(input, 'incomplete', { executionState: 'unknown', reason: 'Gate execution cannot safely finish its original recovery record' }); }
+    }
+    return output;
+  }
+}

package/local-formula-ast.mjs

@@ -0,0 +1,97 @@
+import { Decimal, formulaError } from './local-decimal.mjs';
+
+export const FORMULA_OPERATORS = Object.freeze(['add', 'sub', 'mul', 'div', 'safeDivide', 'percentOf', 'round', 'if']);
+const ARITY = { add: [0, 1000], mul: [0, 1000], sub: [2, 2], div: [2, 2], safeDivide: [2, 2], percentOf: [2, 2], round: [1, 1], if: [3, 3] };
+export function formulaKey(value) {
+  if (typeof value !== 'string' || !value.trim() || value.length > 128 || /[\u0000-\u001f\u007f]/.test(value)) throw formulaError('FORMULA_KEY_INVALID', 'formula and field keys must be non-empty strings of at most 128 characters');
+  return value;
+}
+export function formulaObject(value, field) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw formulaError('FORMULA_NODE_INVALID', `${field} must be a plain object`);
+}
+export function normalizeFormula(node, budget = { nodes: 0, active: new Set() }, depth = 0) {
+  formulaObject(node, 'formula node');
+  if (depth > 64 || ++budget.nodes > 10000) throw formulaError('FORMULA_LIMIT', 'formula exceeds its depth or node limit');
+  if (budget.active.has(node)) throw formulaError('FORMULA_CYCLE', 'formula AST contains an object cycle');
+  const keys = Object.keys(node);
+  if (keys.length === 1 && Object.hasOwn(node, 'ref')) return { ref: formulaKey(node.ref) };
+  if (keys.length === 1 && Object.hasOwn(node, 'lit')) return { lit: Decimal.from(node.lit).toString() };
+  if (!Object.hasOwn(ARITY, node.op)) throw formulaError('UNSUPPORTED_OPERATOR', `Unsupported operator: ${String(node.op)}`);
+  if (keys.length !== 2 || !keys.includes('args') || !keys.includes('op')) throw formulaError('FORMULA_NODE_INVALID', 'operator nodes contain only op and args');
+  const [minimum, maximum] = ARITY[node.op];
+  if (!Array.isArray(node.args) || node.args.length < minimum || node.args.length > maximum || node.args.some((_, i) => !Object.hasOwn(node.args, i))) throw formulaError('FORMULA_ARGS_INVALID', `${node.op} requires ${minimum === maximum ? minimum : `${minimum}..${maximum}`} arguments`);
+  budget.active.add(node);
+  const args = Array.from(node.args, item => normalizeFormula(item, budget, depth + 1));
+  budget.active.delete(node);
+  return { op: node.op, args };
+}
+export function formulaRefs(node, output = new Set()) {
+  if (Object.hasOwn(node, 'ref')) output.add(node.ref);
+  if (node.args) for (const item of node.args) formulaRefs(item, output);
+  return [...output].sort();
+}
+function evaluateNode(node, resolve) {
+  if (Object.hasOwn(node, 'lit')) return Decimal.from(node.lit);
+  if (Object.hasOwn(node, 'ref')) return Decimal.from(resolve(node.ref));
+  const [left, right, alternate] = node.args;
+  switch (node.op) {
+    case 'add': return node.args.reduce((total, item) => total.plus(evaluateNode(item, resolve)), Decimal.from('0'));
+    case 'mul': return node.args.reduce((total, item) => total.times(evaluateNode(item, resolve)), Decimal.from('1'));
+    case 'sub': return evaluateNode(left, resolve).minus(evaluateNode(right, resolve));
+    case 'div': return evaluateNode(left, resolve).div(evaluateNode(right, resolve));
+    case 'safeDivide': { const denominator = evaluateNode(right, resolve); return denominator.isZero() ? Decimal.from('0') : evaluateNode(left, resolve).div(denominator); }
+    case 'percentOf': return evaluateNode(left, resolve).div(evaluateNode(right, resolve)).times('100');
+    case 'round': return evaluateNode(left, resolve).rounded(2);
+    case 'if': return evaluateNode(left, resolve).isZero() ? evaluateNode(alternate, resolve) : evaluateNode(right, resolve);
+    default: throw formulaError('UNSUPPORTED_OPERATOR', 'unsupported normalized formula operator');
+  }
+}
+export function evaluateFormula(node, values = {}) {
+  formulaObject(values, 'formula values');
+  return evaluateNode(normalizeFormula(node), key => {
+    if (!Object.hasOwn(values, key) || values[key] === null || values[key] === undefined || values[key] === '') throw formulaError('MISSING_INPUT', `missing input: ${key}`, { fieldId: key });
+    return values[key];
+  });
+}
+export function compileFormulaGraph(formulas, fieldKeys) {
+  if (!Array.isArray(formulas) || formulas.length > 1000) throw formulaError('FORMULA_GRAPH_INVALID', 'formulas must be an array of at most 1000 definitions');
+  if (fieldKeys !== undefined && !Array.isArray(fieldKeys)) throw formulaError('FORMULA_GRAPH_INVALID', 'fieldKeys must be an array');
+  const fields = fieldKeys === undefined ? undefined : new Set(fieldKeys.map(formulaKey));
+  const definitions = new Map(); const budget = { nodes: 0, active: new Set() };
+  for (const item of formulas) {
+    formulaObject(item, 'formula definition'); const key = formulaKey(item.key);
+    if (definitions.has(key) || fields?.has(key)) throw formulaError('FORMULA_KEY_INVALID', 'formula keys must be unique and separate from input fields');
+    definitions.set(key, { key, expression: normalizeFormula(item.expression, budget) });
+  }
+  const dependencies = Object.fromEntries([...definitions].map(([key, item]) => [key, formulaRefs(item.expression)]));
+  const visiting = new Set(); const done = new Set(); const order = [];
+  const visit = key => {
+    if (done.has(key)) return;
+    if (visiting.has(key)) throw formulaError('FORMULA_CYCLE', `formula cycle at ${key}`);
+    visiting.add(key);
+    for (const ref of dependencies[key]) {
+      if (definitions.has(ref)) visit(ref);
+      else if (fields && !fields.has(ref)) throw formulaError('FORMULA_REF_UNKNOWN', `unknown formula reference: ${ref}`);
+    }
+    visiting.delete(key); done.add(key); order.push(key);
+  };
+  for (const key of [...definitions.keys()].sort()) visit(key);
+  return { formulas: [...definitions.values()].sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0), dependencies, order };
+}
+export function evaluateFormulaGraph(formulas, inputs = {}) {
+  formulaObject(inputs, 'formula inputs');
+  const values = new Map(Object.entries(inputs).map(([key, value]) => [key, Decimal.from(value)]));
+  const graph = compileFormulaGraph(formulas);
+  const definitions = new Map(graph.formulas.map(item => [item.key, item.expression]));
+  const results = new Map(); const visiting = new Set();
+  const resolve = key => {
+    if (results.has(key)) return results.get(key);
+    if (!definitions.has(key)) {
+      if (!values.has(key)) throw formulaError('MISSING_INPUT', `missing input: ${key}`, { fieldId: key });
+      return values.get(key);
+    }
+    if (visiting.has(key)) throw formulaError('FORMULA_CYCLE', `formula cycle at ${key}`);
+    visiting.add(key); const value = evaluateNode(definitions.get(key), resolve); visiting.delete(key); results.set(key, value); return value;
+  };
+  return Object.fromEntries(graph.formulas.map(item => [item.key, resolve(item.key).toString()]));
+}