@entrorove/skill 0.1.22 → 0.1.24

package/local-calctool.mjs

@@ -0,0 +1,103 @@
+import Ajv from 'ajv';
+import { CALCTOOL_LOCAL_NAMES, CALCTOOL_LOCAL_OPERATION_SCHEMAS } from './local-calctool-contracts.mjs';
+import { withBudgetReadContext } from './local-budget-reads.mjs';
+import { formulaError } from './local-decimal.mjs';
+import { buildFormulaEngine, compileFormulaEngine, verifyFormulaProgram, evaluateFormulaProgram, formulaImpact, formulaDigest } from './local-formula-engine.mjs';
+import { formulaFinalGate, readFormulaFile } from './local-formula.mjs';
+import { storeFormula, loadStoredFormula, formulaInventory, purgeStoredFormula } from './local-calctool-storage.mjs';
+import { loadCalctoolRuntime, calctoolRuntimeBytes } from './local-calctool-runtime.mjs';
+
+const schemaVersion = 'entrorove.local-execution/1.0';
+const ajv = new Ajv({ strict: true, strictRequired: false, allErrors: true });
+const validators = new Map(Object.entries(CALCTOOL_LOCAL_OPERATION_SCHEMAS).map(([name, schema]) => [name, ajv.compile(schema)]));
+export function validateCalctoolLocalInput(operation, input) {
+  if (typeof operation !== 'string') throw formulaError('ENTROROVE_OPERATION_UNKNOWN', 'Calctool operation must be a string');
+  const name = operation.startsWith('calctool-') ? operation : `calctool-${operation}`;
+  const validator = validators.get(name);
+  if (!validator) throw formulaError('ENTROROVE_OPERATION_UNKNOWN', 'unsupported Calctool operation');
+  if (!validator(input)) throw formulaError('ENTROROVE_INPUT_INVALID', `Invalid ${name} input: ${validator.errors.map(item => `${item.instancePath || '/'} ${item.message}`).join('; ')}`);
+  return input;
+}
+async function programFrom(input) {
+  if (input.program) return verifyFormulaProgram(input.program, input);
+  if (input.engineId) return (await loadStoredFormula(input)).program;
+  const engine = input.engine ?? (input.enginePath ? (await readFormulaFile(input)).engine : buildFormulaEngine(input.requirements));
+  return verifyFormulaProgram(compileFormulaEngine(engine), input);
+}
+function validatedPlan(plan, completed = []) {
+  if (!plan || !Array.isArray(plan.tasks)) throw formulaError('RUN_PLAN_INVALID', 'runPlan tasks are required');
+  const definitions = new Map();
+  for (const task of plan.tasks) {
+    if (!task || typeof task.workItemId !== 'string' || definitions.has(task.workItemId) || !Array.isArray(task.dependsOn)) throw formulaError('RUN_PLAN_INVALID', 'runPlan requires unique work items and explicit dependencies');
+    definitions.set(task.workItemId, task);
+  }
+  const visiting = new Set(); const done = new Set();
+  const visit = key => {
+    if (done.has(key)) return;
+    if (!definitions.has(key)) throw formulaError('RUN_PLAN_INVALID', 'runPlan contains an unknown dependency');
+    if (visiting.has(key)) throw formulaError('RUN_PLAN_INVALID', 'runPlan dependency cycle');
+    visiting.add(key); for (const dependency of definitions.get(key).dependsOn) visit(dependency); visiting.delete(key); done.add(key);
+  };
+  for (const key of definitions.keys()) visit(key);
+  for (const key of completed) if (!definitions.has(key)) throw formulaError('RUN_PLAN_INVALID', 'completed work item is not part of the runPlan');
+}
+const TOOL_SOURCE = `import { readFile } from 'node:fs/promises';
+import { evaluateCompiledProgram, verifyCompiledProgram } from './runtime.mjs';
+let input = ''; for await (const chunk of process.stdin) input += chunk;
+try { const program = JSON.parse(await readFile(new URL('./program.json', import.meta.url), 'utf8')); if(process.argv.includes('--verify')) { const result=verifyCompiledProgram(program); process.stdout.write(JSON.stringify(result)+'\\n'); process.exitCode=result.computationsPassed?0:2; } else { const values = evaluateCompiledProgram(program, JSON.parse(input)); process.stdout.write(JSON.stringify({status:'reported',programDigest:program.programDigest,values})+'\\n'); } }
+catch (error) { process.stderr.write(JSON.stringify({status:'blocked',code:error.code??'FORMULA_INPUT_INVALID',message:error instanceof SyntaxError?'Formula input or artifact must be valid JSON':error.message})+'\\n'); process.exitCode=2; }
+`;
+async function store(input, generate) {
+  const program = await programFrom(input);
+  const files = generate ? [{ path: 'runtime.mjs', bytes: await calctoolRuntimeBytes() }, { path: 'tool.mjs', bytes: Buffer.from(TOOL_SOURCE) }] : undefined;
+  const stored = await storeFormula(input, program, files);
+  return { schemaVersion, status: 'reported', engineId: program.engineId, engineVersion: program.engineVersion, runtimeVersion: program.runtimeVersion,
+    engineDigest: program.engineDigest, programDigest: program.programDigest, directory: stored.directory, files: stored.manifest.files,
+    ...(generate ? { executable: `${stored.directory}/tool.mjs`, validatorCommand: { executable: process.execPath, args: [`${stored.directory}/tool.mjs`, '--verify'] } } : {}), reused: stored.reused };
+}
+async function execute(operation, input) {
+  if (['compile', 'generate'].includes(operation)) return store(input, operation !== 'compile');
+  if (operation === 'compile-tool') {
+    const generated = await store(input, true); const stored = await loadStoredFormula({ ...input, engineId: generated.engineId, engineVersion: generated.engineVersion });
+    const runtime = await loadCalctoolRuntime(); const project = await runtime.runLocalCore('compile-tool', { engine: stored.program.engine });
+    return { ...generated, pages: project.pages, commands: project.commands, environment: project.environment,
+      projectFiles: project.files.map(file => file.kind === 'engine' ? { ...file, digest: stored.program.engineDigest } : file), projectStatus: 'planned' };
+  }
+  if (operation === 'inventory') return { schemaVersion, status: 'reported', engines: await formulaInventory(input) };
+  if (operation === 'purge') return { schemaVersion, status: 'reported', ...await purgeStoredFormula(input) };
+  if (operation === 'status') { const stored = await loadStoredFormula(input); return { schemaVersion, status: 'reported', ...stored.manifest }; }
+  if (operation === 'final-gate' && input.gateId) {
+    const { runFinalGate16 } = await import('./local-final-gate16.mjs');
+    return runFinalGate16(input);
+  }
+  if (['run', 'verify', 'final-gate', 'estimate', 'impact', 'blueprint-orchestrate'].includes(operation)) {
+    const program = await programFrom(input);
+    if (operation === 'run') {
+      const values = evaluateFormulaProgram(program, input.inputs, input);
+      return { schemaVersion, status: 'reported', engineId: program.engineId, engineVersion: program.engineVersion, programDigest: program.programDigest,
+        values, artifactSha256: formulaDigest({ programDigest: program.programDigest, inputs: input.inputs, values }) };
+    }
+    if (['verify', 'final-gate'].includes(operation)) return formulaFinalGate(program.engine, input);
+    if (operation === 'impact') return { schemaVersion, status: 'reported', programDigest: program.programDigest, affected: formulaImpact(program, input.changedKeys) };
+    if (operation === 'estimate') return { schemaVersion, status: 'reported', programDigest: program.programDigest, formulas: program.formulas.length,
+      fields: program.engine.fields.length, dependencies: Object.values(program.dependencies).reduce((total, refs) => total + refs.length, 0), order: program.order };
+    const core = await loadCalctoolRuntime(); const output = await core.runLocalCore(operation, { engine: program.engine, goal: input.goal });
+    return { ...output, status: 'reported', source: 'calctool-plan', executed: false };
+  }
+  const core = await loadCalctoolRuntime();
+  if (operation === 'probe-env') return { schemaVersion, status: 'reported', probe: core.probeLocalEnvironment() };
+  if (operation === 'adapt-config') return { schemaVersion, status: 'reported', adapted: core.adaptLocalEnvironment(input.probe ?? core.probeLocalEnvironment()) };
+  if (input.runPlan) validatedPlan(input.runPlan, input.completedWorkItemIds);
+  const output = await core.runLocalCore(operation, input);
+  if (output.status === 'blocked' || output.status === 'failed') return output;
+  if (output.status === 'incomplete') return { ...output, source: 'calctool-plan', executed: false };
+  if (output.runPlan) validatedPlan(output.runPlan);
+  return { ...output, status: 'reported', source: 'calctool-plan', executed: false, ...(operation === 'brain-handshake' ? { brainUsed: false } : {}) };
+}
+export async function runCalctoolLocal(operation, input = {}) {
+  if (typeof operation !== 'string') throw formulaError('ENTROROVE_OPERATION_UNKNOWN', 'Calctool operation must be a string');
+  const name = operation.replace(/^calctool-/, '');
+  validateCalctoolLocalInput(name, input);
+  return withBudgetReadContext(input, () => execute(name, input));
+}
+export const CALCTOOL_LOCAL_OPERATIONS = Object.freeze(Object.fromEntries(CALCTOOL_LOCAL_NAMES.map(name => [`calctool-${name}`, input => runCalctoolLocal(name, input)])));

package/local-cli.mjs

@@ -1,58 +1,91 @@
+import { withLocalInvocation } from './local-invocations.mjs';
+import { peerCoordinate, spawnBind, completePeer, verifyCoordinationLease } from './local-swarm.mjs';
+import { attestMutationSnapshot14 } from './local-mutation-binding.mjs';
+import { recordMutationDenied14 } from './local-mutation-audit.mjs';
 import {
   LOCAL_CAPABILITIES, budgetContext, budgetExtend, budgetInit, budgetRead, budgetStatus,
-  completePeer, finalGate, guardedWrite, issueMutationPass, mergeVerified, mutateGate,
-  peerCoordinate, rollback, signEvidence, snapshotPlan, snapshotVerify, spawnBind,
-  verifyCoordinationLease, verifyEvidence, verifyMutationPass,
-  evaluateFormula, evaluateFormulaGraph, formulaFinalGate, formulaFinalGateFile, runApprovedPlan,
+  finalGate, guardedWrite, issueMutationPass, mergeVerified, mutateGate,
+  rollback, signEvidence, snapshotPlan, snapshotVerify,
+  verifyEvidence, verifyMutationPass,
+  evaluateFormula, evaluateFormulaGraph, formulaFinalGate, formulaFinalGateFile, runApprovedPlan, runWorkflowLocalStep,
   LOCAL_LEDGER_OPERATIONS,
   LOCAL_RENEWAL_OPERATIONS, LOCAL_PROBE_OPERATIONS,
   LOCAL_TASK_ROUTING_OPERATIONS,
 } from './local-execution.mjs';
+import { validateLocalInput } from './local-contracts.mjs';
+import { prepareMergeArtifacts } from './local-merge-artifacts.mjs';
+import { produceMergeArchguardPreflight } from './local-merge-archguard.mjs';
+import { produceMergeJournalHead } from './local-merge-head.mjs';
+import { CALCTOOL_LOCAL_OPERATIONS } from './local-calctool.mjs';
+import { withBudgetReadContext } from './local-budget-reads.mjs';
+import { LOCAL_BUDGET_TRANSITION_OPERATIONS } from './local-budget-transition.mjs';
+import { ARCHGUARD_LOCAL_OPERATIONS } from './local-archguard-operations.mjs';
+import { LOCAL_BUDGET_HANDOFF_OPERATIONS } from './local-budget-handoff.mjs';
+import { runManagedWorkflowLocalStep } from './workflow-local-client.mjs';
 
 async function stdinJson() {
   let raw = '';
   for await (const chunk of process.stdin) raw += chunk;
   if (!raw.trim()) return {};
-  const value = JSON.parse(raw);
+  let value;
+  try { value = JSON.parse(raw); } catch { throw new Error('Local input must be valid JSON'); }
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('local input must be a JSON object');
   return value;
 }
 
 const operations = {
-  'snapshot-plan': snapshotPlan, 'snapshot-verify': snapshotVerify, 'mutate-gate': mutateGate,
+  '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,
   'budget-extend': budgetExtend, 'peer-coordinate': peerCoordinate, coordinate: peerCoordinate,
   'spawn-bind': spawnBind, 'peer-complete': completePeer, complete: completePeer,
   'lease-verify': verifyCoordinationLease,
   'evidence-sign': signEvidence, 'evidence-verify': verifyEvidence, 'merge-verified': mergeVerified,
-  rollback, 'final-gate': finalGate,
-  'formula-evaluate': input => ({ schemaVersion: 'entrorove.local-execution/1.0', status: 'verified', value: evaluateFormula(input.formula, input.values ?? {}).toString() }),
-  'formula-graph': input => ({ schemaVersion: 'entrorove.local-execution/1.0', status: 'verified', values: evaluateFormulaGraph(input.formulas, input.inputs ?? {}) }),
-  'formula-final-gate': input => formulaFinalGate(input.engine), 'calculation-final-gate': formulaFinalGateFile,
+  rollback, 'merge-freeze': prepareMergeArtifacts, 'merge-preflight': produceMergeArchguardPreflight,
+  'merge-journal-head': produceMergeJournalHead, 'final-gate': finalGate,
+  'formula-evaluate': input => ({ schemaVersion: 'entrorove.local-execution/1.0', status: 'reported', value: evaluateFormula(input.formula, input.values ?? {}).toString() }),
+  'formula-graph': input => ({ schemaVersion: 'entrorove.local-execution/1.0', status: 'reported', values: evaluateFormulaGraph(input.formulas, input.inputs ?? {}) }),
+  'formula-final-gate': input => formulaFinalGate(input.engine, input), 'calculation-final-gate': formulaFinalGateFile,
   'run-approved-plan': runApprovedPlan,
-  ...LOCAL_LEDGER_OPERATIONS,
+  'workflow-run-step': runManagedWorkflowLocalStep,
+  ...LOCAL_LEDGER_OPERATIONS, ...LOCAL_BUDGET_TRANSITION_OPERATIONS,
   ...LOCAL_RENEWAL_OPERATIONS, ...LOCAL_PROBE_OPERATIONS,
   ...LOCAL_TASK_ROUTING_OPERATIONS,
+  ...ARCHGUARD_LOCAL_OPERATIONS,
+  ...LOCAL_BUDGET_HANDOFF_OPERATIONS,
+  ...CALCTOOL_LOCAL_OPERATIONS,
 };
 
 export const LOCAL_OPERATIONS = Object.freeze(operations);
 
+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);
+    throw cause;
+  }
+}
+
 export async function runLocal(args = []) {
   const operation = args[0];
-  if (operation === 'capabilities' || operation === 'help') { process.stdout.write(`${JSON.stringify(LOCAL_CAPABILITIES)}\n`); return; }
+  if (operation === 'capabilities' || operation === 'help') {
+    validateLocalInput(operation, process.stdin.isTTY ? {} : await stdinJson());
+    process.stdout.write(`${JSON.stringify(LOCAL_CAPABILITIES)}\n`); return;
+  }
   const handler = operations[operation];
   if (!handler) throw new Error(`Usage: entrorove local <${['capabilities', ...Object.keys(operations)].join('|')}> [repositoryRoot]`);
   const input = await stdinJson();
   if (args[1] && input.repositoryRoot === undefined) input.repositoryRoot = args[1];
-  const output = await handler(input);
+  const validated = await checkedLocalInput(operation, input);
+  const output = await withLocalInvocation(operation, validated, () => withBudgetReadContext(validated, () => handler(validated)));
   process.stdout.write(`${JSON.stringify(output)}\n`);
   if (output?.status === 'blocked' || output?.status === 'failed' || output?.status === 'incomplete') process.exitCode = 2;
 }
 
-export async function runLocalInput(operation, input) {
-  if (operation === 'capabilities' || operation === 'help') return LOCAL_CAPABILITIES;
+export async function runLocalInput(operation, input, dependencies) {
+  if (operation === 'capabilities' || operation === 'help') { validateLocalInput(operation, input); return LOCAL_CAPABILITIES; }
   const handler = operations[operation];
   if (!handler) throw new Error(`Unsupported local operation: ${operation}`);
-  return handler(input);
+  const validated = await checkedLocalInput(operation, input);
+  return withLocalInvocation(operation, validated, () => withBudgetReadContext(validated, () => handler(validated, operation === 'workflow-run-step' ? dependencies : undefined)));
 }

package/local-contract-types.mjs

@@ -0,0 +1,46 @@
+export const text = { type: 'string', minLength: 1 };
+export const identifier = { ...text, pattern: '^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$' };
+export const ledgerIdentifier = { ...text, pattern: '^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$' };
+export const sha256 = { type: 'string', pattern: '^[0-9a-f]{64}$' };
+export const nullable = schema => ({ anyOf: [schema, { type: 'null' }] });
+export const array = (items, minItems = 0) => ({ type: 'array', items, minItems });
+export const integer = (minimum, maximum = Number.MAX_SAFE_INTEGER) => ({ type: 'integer', minimum, maximum });
+export const enumeration = values => ({ enum: values });
+export const object = (properties, required = []) => ({ type: 'object', properties, required, additionalProperties: false });
+export const record = { type: 'object' };
+export const relativePath = { ...text, pattern: '^(?!/)(?![A-Za-z]:)(?!.*[\\u0000-\\u001f\\u007f])(?!.*\\\\)(?!.*(?:^|/)(?:\\.\\.?)(?:/|$))[^/]+(?:/[^/]+)*$', $comment: 'Paths must also be NFC; filesystem authority validates normalization and symlink boundaries.' };
+export const paths = { ...array(relativePath, 1), uniqueItems: true };
+export const modes = enumeration(['lock', 'probe', 'swarm']);
+export const priority = enumeration(['urgent', 'normal', 'dependency', 'background']);
+export const executionContext = { oneOf: [
+  object({ executionIsolation: { const: 'local' } }, ['executionIsolation']),
+  object({ executionIsolation: { const: 'direct' }, cloudSandboxEnabled: { type: 'boolean' } }, ['executionIsolation', 'cloudSandboxEnabled']),
+  object({ executionIsolation: { const: 'sandbox' }, cloudSandboxEnabled: { const: true } }, ['executionIsolation', 'cloudSandboxEnabled']),
+] };
+export const confirmation = object({ answer: { const: 'approve' }, requestId: identifier }, ['answer', 'requestId']);
+export const binding = { flowId: identifier, stepId: identifier, snapshotDigest: sha256, contractDigest: sha256, receiptPublicKey: text };
+export const evidence = object({
+  schemaVersion: { const: 'entrorove.test-evidence/2.0' }, evidenceId: { ...text, maxLength: 200, pattern: '\\S' },
+  kind: enumeration(['test', 'build', 'lint', 'security', 'benchmark']), runner: enumeration(['local', 'trusted-runner', 'sandbox']),
+  command: { ...text, maxLength: 2000, pattern: '\\S' }, exitCode: integer(-128, 255), durationMs: integer(0, 86400000),
+  summary: { ...text, maxLength: 4000, pattern: '\\S' }, artifactSha256: sha256,
+  subject: {}, subjectDigest: sha256, receipt: record, flowId: { ...text, maxLength: 200 }, stepId: { ...text, maxLength: 200 },
+}, ['schemaVersion', 'evidenceId', 'kind', 'runner', 'command', 'exitCode', 'durationMs', 'summary', 'artifactSha256']);
+export const evidenceArray = array(evidence, 1);
+export const change = object({ gatePassPath: text, targetPath: relativePath, content: {}, expectedSha256: nullable(sha256), workerId: identifier, leaseId: identifier }, ['gatePassPath', 'targetPath', 'content']);
+export const decimal = { anyOf: [{ type: 'string', pattern: '^\\s*[+-]?(?:[0-9]+(?:\\.[0-9]*)?|\\.[0-9]+)\\s*$' }, { type: 'number' }] };
+export const formula = { $ref: '#/$defs/formula' };
+function expression(operators, minItems, maxItems) {
+  return object({ op: enumeration(operators), args: { ...array(formula, minItems), ...(maxItems === undefined ? {} : { maxItems }) } }, ['op', 'args']);
+}
+export const formulaDefinitions = { formula: { oneOf: [
+  object({ ref: text }, ['ref']), object({ lit: decimal }, ['lit']),
+  expression(['add', 'mul'], 0), expression(['sub', 'div', 'safeDivide', 'percentOf'], 2, 2),
+  expression(['round'], 1, 1), expression(['if'], 3, 3),
+] } };
+export const decimalValues = { type: 'object', additionalProperties: decimal };
+export const formulaEntry = { type: 'object', properties: { key: text, expression: formula }, required: ['key', 'expression'] };
+export const executionPlan = { type: 'object', properties: {
+  schemaVersion: { const: 'entrorove.execution-plan/1.0' }, chainId: ledgerIdentifier,
+  steps: array({ type: 'object', properties: { stepId: ledgerIdentifier, kind: enumeration(['command', 'skill', 'coordinator', 'decision']) }, required: ['stepId', 'kind'] }, 1),
+}, required: ['schemaVersion', 'chainId', 'steps'] };

package/local-contracts.mjs

@@ -0,0 +1,124 @@
+import { FINAL_GATE16_INPUT_SCHEMA, FINAL_GATE16_READ_INPUT_SCHEMA } from './local-final-gate16-contract.mjs';
+import { SWARM_LOCAL_OPERATION_SCHEMAS } from './local-swarm-contracts.mjs';
+import Ajv from 'ajv';
+import { CALCTOOL_LOCAL_OPERATION_SCHEMAS } from './local-calctool-contracts.mjs';
+import { HANDOFF_BUDGET_INIT_PROPERTIES, HANDOFF_BUDGET_INIT_CONDITION, handoffBudgetOperationSchema } from './local-budget-handoff-contracts.mjs';
+import { ARCHGUARD_LOCAL_OPERATION_SCHEMAS } from './local-archguard-contracts.mjs';
+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 { 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';
+
+const schemas = {};
+const base = { repositoryRoot: text, home: text };
+const flow = { ...base, flowId: identifier };
+const step = { ...flow, stepId: identifier };
+function add(names, properties, required = [], alternatives) {
+  const schema = object(properties, required);
+  if (JSON.stringify(properties).includes('#/$defs/formula')) schema.$defs = formulaDefinitions;
+  if (alternatives) schema.anyOf = alternatives.map(field => ({ required: [field] }));
+  for (const name of names.split('|')) schemas[name] = schema;
+}
+add('capabilities|help', {});
+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('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']);
+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']);
+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 },
+['repositoryRoot', 'flowId', 'stepId', 'targetPath', 'content', 'handoffId', 'epoch', 'handoffPass', 'provisionalLease'])] };
+add('budget-init', { ...flow, mode: modes, executionContext, grant: record, ...HANDOFF_BUDGET_INIT_PROPERTIES }, ['repositoryRoot', 'flowId', 'mode', 'executionContext']);
+schemas['budget-init'].allOf = [{ if: { type: 'object', properties: { executionContext: { type: 'object', properties: { executionIsolation: { const: 'sandbox' } }, required: ['executionIsolation'] } }, required: ['executionContext'] }, then: { type: 'object', required: ['grant'] } }];
+schemas['budget-init'].allOf.push(HANDOFF_BUDGET_INIT_CONDITION);
+schemas['budget-handoff'] = handoffBudgetOperationSchema(flow, modes, executionContext);
+add('budget-context', { ...flow, executionContext }, ['repositoryRoot', 'flowId', 'executionContext']);
+add('budget-read', { ...flow, path: relativePath }, ['repositoryRoot', 'flowId', 'path']);
+add('budget-status', flow, ['repositoryRoot', 'flowId']);
+add('budget-extend', { ...flow, confirmation, grant: record, additions: object({ files: integer(0), tokenEstimate: integer(0), durationMs: integer(0) }, ['files', 'tokenEstimate', 'durationMs']) }, ['repositoryRoot', 'flowId', 'additions'], ['grant', 'confirmation']);
+add('budget-transition', { ...flow, grant: record }, ['repositoryRoot', 'flowId', 'grant']);
+schemas['budget-extend'].properties.additions.anyOf = ['files', 'tokenEstimate', 'durationMs'].map(field => ({ type: 'object', properties: { [field]: integer(1) }, required: [field] }));
+Object.assign(schemas, SWARM_LOCAL_OPERATION_SCHEMAS);
+const signableEvidence = { ...evidence, required: evidence.required.filter(field => !['schemaVersion', 'runner'].includes(field)) };
+add('evidence-sign', { ...base, evidence: signableEvidence }, ['repositoryRoot', 'evidence']);
+add('evidence-verify', { ...base, evidence, receiptPublicKey: text }, ['evidence']);
+add('merge-verified', { ...step, sourceRef: text, targetRef: text, snapshotReceipt: record, evidence: evidenceArray, preflight: record, receiptPublicKey: text, changes: array(change) }, ['repositoryRoot', 'flowId', 'stepId', 'sourceRef', 'targetRef', 'snapshotReceipt', 'evidence', 'preflight']);
+add('rollback', { ...step, snapshotId: identifier }, ['repositoryRoot', 'flowId', 'snapshotId']);
+const check = { anyOf: [{ type: 'boolean' }, { type: 'object', properties: { status: text }, required: ['status'] }] };
+add('final-gate', { ...base, ...binding, audit: check, test: check, operations: check, evidence: array(evidence), preflight: record }, ['audit', 'test', 'operations', 'evidence']);
+schemas['final-gate'] = { oneOf: [schemas['final-gate'], FINAL_GATE16_INPUT_SCHEMA, FINAL_GATE16_READ_INPUT_SCHEMA] };
+add('formula-evaluate', { formula, values: decimalValues }, ['formula']);
+add('formula-graph', { formulas: array(formulaEntry), inputs: decimalValues }, ['formulas']);
+add('formula-final-gate', { engine: record, flowId: identifier, stepId: identifier }, ['engine']);
+add('calculation-final-gate', { ...step, enginePath: relativePath }, ['repositoryRoot', 'enginePath']);
+add('run-approved-plan', { repositoryRoot: text, planPath: relativePath, approvalPath: text, signerConfigPath: nullable(text) }, ['repositoryRoot', 'planPath', 'approvalPath', 'signerConfigPath']);
+schemas['run-approved-plan'] = { oneOf: [schemas['run-approved-plan'], object({ ...flow, planPath: relativePath, approvalPath: text, signerConfigPath: nullable(text) },
+  ['repositoryRoot', 'home', 'flowId', 'planPath', 'approvalPath', 'signerConfigPath'])] };
+schemas['workflow-run-step'] = WORKFLOW_LOCAL_OPERATION_SCHEMA;
+add('branch-create|branch-create-virtual', { ...base, name: ledgerIdentifier, branchName: ledgerIdentifier, fromRef: text, description: { type: 'string' }, snapshotId: nullable(ledgerIdentifier) }, ['repositoryRoot'], ['name', 'branchName']);
+add('branch-list', base, ['repositoryRoot']);
+add('branch-switch', { ...base, branchName: ledgerIdentifier, name: ledgerIdentifier }, ['repositoryRoot'], ['branchName', 'name']);
+add('diff-report', { ...base, baseRef: text, targetRef: nullable(text), limit: integer(1, 500) }, ['repositoryRoot']);
+add('preflight', { ...base, ...binding, archguard: record, preflight: record, evidence: array(evidence) }, ['repositoryRoot']);
+add('ledger-query|chain-ledger-query', { ...base, limit: integer(1, 500) }, ['repositoryRoot']);
+add('chain-init|chain-ledger-init', { ...base, plan: executionPlan, executionPlan }, ['repositoryRoot'], ['plan', 'executionPlan']);
+const chain = { ...base, chainId: ledgerIdentifier };
+add('chain-resume', { ...chain, stepId: ledgerIdentifier, status: enumeration(['running', 'waiting', 'reported', 'verified', 'blocked', 'failed']), output: {}, error: {} }, ['repositoryRoot', 'chainId']);
+add('chain-status|chain-ledger-status', chain, ['repositoryRoot', 'chainId']);
+add('chain-answer', { ...chain, stepId: ledgerIdentifier, answer: { anyOf: [text, object({ id: text }, ['id'])] }, accepted: { type: 'boolean' }, actorId: nullable(text) }, ['repositoryRoot', 'chainId', 'answer']);
+const renewal = { ...flow, requestId: identifier, scope: object({ goal: text, allowedPaths: paths, forbiddenPaths: paths }, ['goal', 'allowedPaths']), policy: object({ intervalMs: integer(1), maxRenewals: integer(1, 100) }, ['intervalMs', 'maxRenewals']) };
+add('budget-auto-renew-request', renewal, ['repositoryRoot', 'flowId', 'requestId', 'scope', 'policy']);
+add('budget-auto-renew', { ...renewal, confirmation, grant: record }, ['repositoryRoot', 'flowId', 'requestId', 'scope', 'policy'], ['grant', 'confirmation']);
+add('budget-auto-renew-stop', { ...flow, reason: enumeration(['revoked', 'completed']) }, ['repositoryRoot', 'flowId', 'reason']);
+const probePaths = { anyOf: [paths, { const: ['.'] }] };
+const scopeRequirement = object({ id: ledgerIdentifier, description: { ...text, pattern: '\\S', maxLength: 12000 } }, ['id', 'description']);
+const scopeInteraction = object({ type: enumeration(['confirm', 'choice', 'multi', 'input']), question: text,
+  options: array(object({ id: ledgerIdentifier, label: text, hint: { type: 'string' } }, ['id', 'label'])), riskDescription: { type: 'string' },
+  callback: object({ operation: ledgerIdentifier, payload: record }, ['operation', 'payload']) }, ['type', 'question', 'options', 'callback']);
+const scopeTask = object({ goal: { ...text, pattern: '\\S', maxLength: 12000 }, workType: enumeration(['implementation', 'documentation', 'calculation', 'merge', 'review', 'decision', 'diagnosis']),
+  difficulty: enumeration(['low', 'medium', 'high']), risk: enumeration(['low', 'medium', 'high']), crossModule: { type: 'boolean' }, parallel: { type: 'boolean' }, needParallel: { type: 'boolean' },
+  unclear: { type: 'boolean' }, architectureContract: { type: 'boolean' }, explicitAimlockRequested: { type: 'boolean' }, explicitEntroroveRequested: { type: 'boolean' }, userSpecifiedSkills: array(text),
+  requirements: { ...array(scopeRequirement, 1), maxItems: 500 }, phase: enumeration(['plan', 'coordinate', 'architecture', 'verify', 'merge', 'decision']), baselineRef: text, interaction: scopeInteraction }, ['goal', 'workType', 'difficulty', 'risk']);
+const probe = { ...step, paths: probePaths, targetPaths: probePaths, task: scopeTask, baselineRef: text, snapshotId: identifier,
+  targetSymbols: array(text, 1), contextMapPath: relativePath, signerConfigPath: nullable(text), taskDigest: sha256, ownerId: ledgerIdentifier, chainDigest: sha256, repositoryId: identifier, challenge: ledgerIdentifier };
+add('probe', { ...probe, handoffCandidate: HANDOFF_SNAPSHOT_CANDIDATE_SCHEMA }, ['repositoryRoot']);
+schemas.probe.allOf = [{ if: { type: 'object', anyOf: ['flowId', 'stepId', 'snapshotId'].map(field => ({ required: [field] })) },
+  then: { type: 'object', required: ['flowId', 'stepId', 'snapshotId'], anyOf: ['paths', 'targetPaths', 'targetSymbols'].map(field => ({ required: [field] })) } },
+  { if: { type: 'object', properties: { signerConfigPath: text }, required: ['signerConfigPath'] },
+    then: { type: 'object', required: ['flowId', 'stepId', 'snapshotId', 'taskDigest', 'ownerId', 'chainDigest', 'repositoryId', 'challenge'] } },
+  { if: { type: 'object', required: ['handoffCandidate'] }, then: { type: 'object', required: ['flowId', 'stepId', 'snapshotId', 'paths', 'taskDigest', 'ownerId', 'chainDigest', 'repositoryId', 'challenge', 'signerConfigPath'],
+    properties: { signerConfigPath: text } } },
+  { if: { type: 'object', required: ['targetSymbols'] }, then: { type: 'object', required: ['contextMapPath'] } }];
+add('reassess', { ...probe, snapshotId: nullable(identifier), currentMode: modes, expectedRevision: integer(1) }, ['repositoryRoot']);
+schemas.reassess.allOf = [{ if: { type: 'object', anyOf: [
+  ...['flowId', 'stepId', 'expectedRevision', 'taskDigest', 'ownerId', 'chainDigest', 'repositoryId', 'challenge'].map(field => ({ required: [field] })),
+  ...['snapshotId', 'signerConfigPath'].map(field => ({ properties: { [field]: text }, required: [field] }))] },
+  then: { type: 'object', required: ['flowId', 'stepId', 'snapshotId', 'expectedRevision'], properties: { snapshotId: identifier },
+    anyOf: ['paths', 'targetPaths', 'targetSymbols'].map(field => ({ required: [field] })) } },
+  { if: { type: 'object', required: ['targetSymbols'] }, then: { type: 'object', required: ['contextMapPath'] } }];
+const task = { ...base, taskId: ledgerIdentifier };
+add('task-describe', { ...task, goal: { ...text, pattern: '\\S' }, ownerId: nullable(text), checkpoint: {}, createdAt: text }, ['repositoryRoot', 'goal']);
+add('message-route', { ...task, messageId: ledgerIdentifier, body: {}, destination: nullable(text) }, ['repositoryRoot', 'taskId']);
+add('message-accept', { ...task, messageId: ledgerIdentifier, ownerId: nullable(text) }, ['repositoryRoot', 'taskId', 'messageId']);
+add('task-resume', task, ['repositoryRoot', 'taskId']);
+
+Object.assign(schemas, ARCHGUARD_LOCAL_OPERATION_SCHEMAS, CALCTOOL_LOCAL_OPERATION_SCHEMAS, MERGE_LOCAL_OPERATION_SCHEMAS);
+export const LOCAL_OPERATION_SCHEMAS = Object.freeze(schemas);
+const ajv = new Ajv({ strict: true, strictRequired: false, allErrors: true });
+const validators = new Map(Object.entries(schemas).map(([operation, schema]) => [operation, ajv.compile(schema)]));
+export function validateLocalInput(operation, input) {
+  const validate = validators.get(operation);
+  if (!validate) throw Object.assign(new Error(`Unsupported local operation: ${operation}`), { code: 'ENTROROVE_OPERATION_UNKNOWN' });
+  if (!validate(input)) {
+    const details = validate.errors.map(error => `${error.instancePath || '/'} ${error.message}`).join('; ');
+    throw Object.assign(new Error(`Invalid ${operation} input: ${details}`), { code: 'ENTROROVE_INPUT_INVALID' });
+  }
+  return input;
+}
+export const operationSchemasFor = operations => Object.freeze(Object.fromEntries(Object.keys(operations).map(name => [name, schemas[name]])));

package/local-credential.mjs

@@ -0,0 +1,101 @@
+import { constants, promises as fs } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import os from 'node:os';
+import { withStateLock } from './local-state-lock.mjs';
+import path from 'node:path';
+
+const SCHEMA = 'entrorove.credential/1.0';
+const TOKEN = /^ent_[A-Za-z0-9_-]{43}$/;
+const error = (code, message) => Object.assign(new Error(message), { code });
+
+export function credentialPath(home = os.homedir()) {
+  if (typeof home !== 'string' || !path.isAbsolute(home)) throw error('ENTROROVE_CREDENTIAL_HOME', 'Credential home must be absolute');
+  if (process.platform === 'win32') {
+    const appData = process.env.LOCALAPPDATA;
+    if (!appData || !path.isAbsolute(appData)) throw error('ENTROROVE_CREDENTIAL_HOME', 'LOCALAPPDATA must be absolute');
+    return path.join(appData, 'Entrorove', 'credential.json');
+  }
+  const parts = process.platform === 'darwin' ? ['Library', 'Application Support', 'Entrorove']
+    : process.platform === 'win32' ? ['AppData', 'Local', 'Entrorove'] : ['.local', 'share', 'entrorove'];
+  return path.join(home, ...parts, 'credential.json');
+}
+
+function owned(stat) {
+  return process.platform === 'win32' || stat.uid === process.getuid();
+}
+
+export async function credentialDirectory(home = os.homedir(), create = false) {
+  const homeStat = await fs.lstat(home).catch(() => { throw error('ENTROROVE_CREDENTIAL_HOME', 'Credential home is unavailable'); });
+  if (!homeStat.isDirectory() || homeStat.isSymbolicLink() || !owned(homeStat)) {
+    throw error('ENTROROVE_CREDENTIAL_DIRECTORY', 'Credential home must be an owned real directory');
+  }
+  const root = process.platform === 'win32' ? path.parse(credentialPath(home)).root : await fs.realpath(home);
+  let current = root;
+  const relative = path.relative(process.platform === 'win32' ? root : home, path.dirname(credentialPath(home)));
+  for (const part of relative.split(path.sep)) {
+    current = path.join(current, part);
+    if (create) await fs.mkdir(current, { mode: 0o700 }).catch(cause => { if (cause.code !== 'EEXIST') throw cause; });
+    const stat = await fs.lstat(current).catch(() => { throw error('ENTROROVE_CREDENTIAL_MISSING', 'Stored credential is unavailable; configure the account key privately'); });
+    if (!stat.isDirectory() || stat.isSymbolicLink() || !owned(stat)) {
+      throw error('ENTROROVE_CREDENTIAL_DIRECTORY', 'Credential directory must be an owned real directory');
+    }
+  }
+  if (create && process.platform !== 'win32') await fs.chmod(current, 0o700);
+  const stat = await fs.lstat(current);
+  if (process.platform !== 'win32' && (stat.mode & 0o077)) throw error('ENTROROVE_CREDENTIAL_PERMISSIONS', 'Credential directory permissions must be 0700');
+  return current;
+}
+
+function privateFile(stat) {
+  if (!stat.isFile() || stat.nlink !== 1 || !owned(stat)) throw error('ENTROROVE_CREDENTIAL_FILE', 'Credential path must be an owned private regular file');
+  if (process.platform !== 'win32' && (stat.mode & 0o777) !== 0o600) throw error('ENTROROVE_CREDENTIAL_PERMISSIONS', 'Credential permissions must be 0600');
+}
+
+export async function readCredential(home = os.homedir()) {
+  const directory = await credentialDirectory(home);
+  let handle;
+  try {
+    handle = await fs.open(path.join(directory, 'credential.json'), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const stat = await handle.stat(); privateFile(stat);
+    if (stat.size > 4096) throw error('ENTROROVE_CREDENTIAL_INVALID', 'Invalid credential file');
+    let value;
+    try { value = JSON.parse(await handle.readFile('utf8')); }
+    catch { throw error('ENTROROVE_CREDENTIAL_INVALID', 'Invalid credential file'); }
+    if (!value || value.schemaVersion !== SCHEMA || !TOKEN.test(value.token)
+      || Object.keys(value).sort().join(',') !== 'schemaVersion,token') throw error('ENTROROVE_CREDENTIAL_INVALID', 'Invalid credential file');
+    return value.token;
+  } catch (cause) {
+    if (cause.code?.startsWith('ENTROROVE_CREDENTIAL_')) throw cause;
+    throw error('ENTROROVE_CREDENTIAL_MISSING', 'Stored credential is unavailable; configure the account key privately');
+  } finally { await handle?.close(); }
+}
+
+export async function writeCredential(token, home = os.homedir()) {
+  if (typeof token !== 'string' || !TOKEN.test(token)) throw error('ENTROROVE_CREDENTIAL_INVALID', 'Invalid entrorove key');
+  const directory = await credentialDirectory(home, true);
+  const file = path.join(directory, 'credential.json');
+  const prior = await fs.lstat(file).catch(cause => { if (cause.code !== 'ENOENT') throw cause; return null; });
+  if (prior) privateFile(prior);
+  return withStateLock(file, async () => {
+  const locked = await fs.lstat(file).catch(cause => { if (cause.code !== 'ENOENT') throw cause; return null; });
+  if (locked) privateFile(locked);
+  if (Boolean(locked) !== Boolean(prior) || locked && (locked.ino !== prior.ino || locked.dev !== prior.dev)) {
+    throw error('ENTROROVE_CREDENTIAL_CHANGED', 'Credential changed before the private rotation lock was acquired');
+  }
+  const stage = path.join(directory, `.credential-${randomUUID()}.tmp`);
+  let handle;
+  try {
+    handle = await fs.open(stage, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0), 0o600);
+    await handle.writeFile(`${JSON.stringify({ schemaVersion: SCHEMA, token })}\n`);
+    await handle.sync(); await handle.close(); handle = undefined;
+    const current = await fs.lstat(file).catch(cause => { if (cause.code !== 'ENOENT') throw cause; return null; });
+    if (current) privateFile(current);
+    if (Boolean(current) !== Boolean(prior) || current && (current.ino !== prior.ino || current.dev !== prior.dev)) {
+      throw error('ENTROROVE_CREDENTIAL_CHANGED', 'Credential changed during configuration; read the current credential before replacing it');
+    }
+    await fs.rename(stage, file);
+    const parent = await fs.open(directory, constants.O_RDONLY);
+    try { await parent.sync(); } finally { await parent.close(); }
+  } finally { await handle?.close(); await fs.rm(stage, { force: true }); }
+  });
+}

package/local-decimal.mjs

@@ -0,0 +1,85 @@
+export const DECIMAL_SCALE = 28;
+export const DECIMAL_POLICY = Object.freeze({ precision: 28, rounding: 'half-away-from-zero', representation: 'decimal-string' });
+const LITERAL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/;
+const MAX_DIGITS = 4096;
+
+export function formulaError(code, message, details = {}) {
+  return Object.assign(new Error(message), { code, ...details });
+}
+function scale(value, maximum = DECIMAL_SCALE) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw formulaError('DECIMAL_SCALE_INVALID', `decimal places must be 0..${maximum}`);
+  return value;
+}
+function ten(power) { return 10n ** BigInt(scale(power, MAX_DIGITS * 2)); }
+function normalize(coefficient, places) {
+  while (places > 0 && coefficient % 10n === 0n) { coefficient /= 10n; places -= 1; }
+  return { coefficient, scale: places };
+}
+function rounded(coefficient, fromScale, toScale) {
+  if (fromScale <= toScale) return coefficient * ten(toScale - fromScale);
+  const divisor = ten(fromScale - toScale);
+  let quotient = coefficient / divisor;
+  const remainder = coefficient % divisor;
+  if ((remainder < 0n ? -remainder : remainder) * 2n >= divisor) quotient += coefficient < 0n ? -1n : 1n;
+  return quotient;
+}
+function requireCoefficient(value) {
+  if (typeof value !== 'bigint') throw formulaError('INVALID_DECIMAL', 'decimal coefficient must be a bigint');
+  if (value.toString().replace('-', '').length > MAX_DIGITS) throw formulaError('DECIMAL_LIMIT', 'decimal exceeds the supported digit limit');
+}
+
+export class Decimal {
+  constructor(value) {
+    if (value instanceof Decimal) { this.coefficient = value.coefficient; this.scale = value.scale; }
+    else {
+      if (!['string', 'number', 'bigint'].includes(typeof value) || (typeof value === 'number' && (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))))) {
+        throw formulaError('INVALID_DECIMAL', 'decimal must be a finite, lossless number or decimal string');
+      }
+      const source = String(value).trim();
+      if (source.length > MAX_DIGITS || !LITERAL.test(source)) throw formulaError('INVALID_DECIMAL', 'invalid decimal literal');
+      const negative = source[0] === '-';
+      const [integer = '0', fraction = ''] = source.replace(/^[+-]/, '').split('.');
+      const coefficient = BigInt(`${integer || '0'}${fraction}`) * (negative ? -1n : 1n);
+      Object.assign(this, normalize(rounded(coefficient, fraction.length, Math.min(fraction.length, DECIMAL_SCALE)), Math.min(fraction.length, DECIMAL_SCALE)));
+    }
+    this.value = Decimal.format(this.coefficient, this.scale);
+    this.s = this.value;
+    Object.freeze(this);
+  }
+  static from(value) { return value instanceof Decimal ? value : new Decimal(value); }
+  static fromParts(coefficient, places) {
+    requireCoefficient(coefficient); scale(places, MAX_DIGITS);
+    const boundedScale = Math.min(places, DECIMAL_SCALE);
+    const parts = normalize(rounded(coefficient, places, boundedScale), boundedScale);
+    return new Decimal(Decimal.format(parts.coefficient, parts.scale));
+  }
+  static format(coefficient, places) {
+    requireCoefficient(coefficient); scale(places, MAX_DIGITS);
+    const digits = (coefficient < 0n ? -coefficient : coefficient).toString().padStart(places + 1, '0');
+    const value = places === 0 ? digits : `${digits.slice(0, -places)}.${digits.slice(-places)}`;
+    return coefficient < 0n ? `-${value}` : value;
+  }
+  plus(other) {
+    const right = Decimal.from(other); const places = Math.max(this.scale, right.scale);
+    return Decimal.fromParts(this.coefficient * ten(places - this.scale) + right.coefficient * ten(places - right.scale), places);
+  }
+  minus(other) { return this.plus(Decimal.from(other).negate()); }
+  negate() { return Decimal.fromParts(-this.coefficient, this.scale); }
+  times(other) { const right = Decimal.from(other); return Decimal.fromParts(this.coefficient * right.coefficient, this.scale + right.scale); }
+  div(other) {
+    const right = Decimal.from(other);
+    if (right.isZero()) throw formulaError('DIV_ZERO', 'division by zero', { nodeId: 'div' });
+    const numerator = this.coefficient * ten(right.scale + DECIMAL_SCALE);
+    const denominator = right.coefficient * ten(this.scale);
+    let quotient = numerator / denominator;
+    const remainder = numerator % denominator;
+    if ((remainder < 0n ? -remainder : remainder) * 2n >= (denominator < 0n ? -denominator : denominator)) quotient += (numerator < 0n) !== (denominator < 0n) ? -1n : 1n;
+    return Decimal.fromParts(quotient, DECIMAL_SCALE);
+  }
+  rounded(dp) { scale(dp); return this.scale <= dp ? this : Decimal.fromParts(rounded(this.coefficient, this.scale, dp), dp); }
+  toDecimalPlaces(dp) { return this.rounded(dp); }
+  isZero() { return this.coefficient === 0n; }
+  isNegative() { return this.coefficient < 0n; }
+  toString() { return this.value; }
+}
+export const Decimal28 = Decimal;