@entrorove/skill 0.1.23 → 0.1.25

package/local-chain-human.mjs

@@ -0,0 +1,48 @@
+import { createInterface } from 'node:readline/promises';
+import { chainCanonical as canonical, chainFail as fail, chainSha as sha } from './local-chain-bindings.mjs';
+import { inspectLocalChainResult } from './local-chain-plan.mjs';
+
+export function originalChainInteraction(step, state, resumed) {
+  const value = step.output, current = resumed.result;
+  if (!value?.interaction || !value.interactionId || value.interactionDigest !== sha(canonical(value.interaction))
+    || current?.interactionId !== value.interactionId || current.interactionDigest !== value.interactionDigest
+    || canonical(current.interaction) !== canonical(value.interaction)
+    || resumed.nextStep?.operation !== 'continue' || resumed.nextStep.input?.flowId !== state.identity.flowId
+    || resumed.nextStep.input.operation !== 'interaction-answer') {
+    fail('ENTROROVE_CHAIN_INTERACTION_BINDING', 'answer must address the exact original live interaction');
+  }
+  const interaction = value.interaction;
+  if (interaction.callback?.operation !== 'interaction-answer' || canonical(interaction.callback.payload) !== '{}') {
+    fail('ENTROROVE_CHAIN_CALLBACK_UNSUPPORTED', 'this fixed host accepts only the original workflow interaction-answer callback');
+  }
+  return value;
+}
+export async function readChainTerminalAnswer(value) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) fail('ENTROROVE_CHAIN_TTY_REQUIRED', 'a real interactive terminal is required; redirected answers are rejected');
+  const interaction = value.interaction, ids = interaction.options?.map(option => option.id);
+  if (!['confirm', 'choice', 'multi', 'input'].includes(interaction.type) || !Array.isArray(ids)
+    || new Set(ids).size !== ids.length || (interaction.type !== 'input' && ids.length < 2)) {
+    fail('ENTROROVE_CHAIN_INTERACTION_BINDING', 'original interaction option contract is invalid');
+  }
+  process.stdout.write(`${interaction.question}\n${interaction.riskDescription ?? ''}\n`);
+  for (const option of interaction.options) process.stdout.write(`${option.id}: ${option.label}\n`);
+  const terminal = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  let answer; try { answer = (await terminal.question('Answer with the exact option ID: ')).trim(); } finally { terminal.close(); }
+  if (interaction.type === 'multi') answer = answer.split(',').map(value => value.trim());
+  if (interaction.type === 'input' ? !answer : Array.isArray(answer)
+    ? !answer.length || new Set(answer).size !== answer.length || answer.some(value => !ids.includes(value)) : !ids.includes(answer)) {
+    fail('ENTROROVE_CHAIN_ANSWER_INVALID', 'terminal answer must match explicit original option IDs');
+  }
+  return { interactionId: value.interactionId, interactionDigest: value.interactionDigest, answer, remembered: false };
+}
+export function inspectChainHumanResponse(original, state, step, response) {
+  const native = response.result, audit = native?.auditEntry, question = step.output.interaction;
+  if (response.flowId !== state.identity.flowId || native?.interactionId !== step.output.interactionId
+    || native.interactionDigest !== step.output.interactionDigest || audit?.schemaVersion !== 'confirm.audit-entry/1.0'
+    || audit.actorId !== state.identity.ownerId || audit.requestId !== question.requestId || audit.question !== question.question
+    || canonical(audit.answer) !== canonical(step.request.input.payload.answer) || audit.risk !== question.risk
+    || !audit.auditId || !Number.isFinite(Date.parse(audit.answeredAt))) {
+    fail('ENTROROVE_CHAIN_ANSWER_BINDING', 'answer has no matching original server-persisted audit and callback result');
+  }
+  return inspectLocalChainResult(original, { ...response, result: { ...native, answer: audit.answer } });
+}

package/local-chain-lock.mjs

@@ -0,0 +1,54 @@
+import { promises as fs } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { chainControlFile, chainFail } from './local-chain-bindings.mjs';
+
+function alive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) chainFail('ENTROROVE_CHAIN_LOCK_INVALID', 'chain lock PID is invalid');
+  try { process.kill(pid, 0); return true; } catch (error) { return error.code !== 'ESRCH'; }
+}
+async function owner(lock) {
+  const stat = await fs.lstat(lock);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 0o777) !== 0o700
+    || (typeof process.getuid === 'function' && stat.uid !== process.getuid())) {
+    chainFail('ENTROROVE_CHAIN_LOCK_INVALID', 'chain lock must be owned, private and real');
+  }
+  let value; try { value = JSON.parse((await chainControlFile(`${lock}/owner.json`, 1024)).bytes.toString()); }
+  catch { chainFail('ENTROROVE_CHAIN_LOCK_INVALID', 'chain lock owner is invalid'); }
+  if (!value || typeof value.token !== 'string' || !Number.isSafeInteger(value.pid)) {
+    chainFail('ENTROROVE_CHAIN_LOCK_INVALID', 'chain lock owner is invalid');
+  }
+  return { stat, value };
+}
+async function recover(lock) {
+  let original; try { original = await owner(lock); } catch (error) { if (error.code === 'ENOENT') return; throw error; }
+  if (alive(original.value.pid)) return;
+  const removed = `${lock}.dead-${randomUUID()}`;
+  try { await fs.rename(lock, removed); } catch (error) { if (error.code === 'ENOENT') return; throw error; }
+  const moved = await owner(removed);
+  if (moved.stat.ino !== original.stat.ino || moved.stat.dev !== original.stat.dev
+    || moved.value.token !== original.value.token) chainFail('ENTROROVE_CHAIN_LOCK_CHANGED', 'chain lock changed during recovery');
+  await fs.rm(removed, { recursive: true });
+}
+export async function withChainLock(file, action) {
+  const lock = `${file}.lock`, staging = `${lock}.private-${randomUUID()}`, token = randomUUID();
+  await fs.mkdir(staging, { mode: 0o700 });
+  const handle = await fs.open(`${staging}/owner.json`, 'wx', 0o600);
+  try { await handle.writeFile(JSON.stringify({ pid: process.pid, token })); await handle.sync(); } finally { await handle.close(); }
+  const deadline = Date.now() + 10_000;
+  try {
+    while (true) {
+      try { await fs.rename(staging, lock); break; }
+      catch (error) {
+        if (!['ENOTEMPTY', 'EEXIST'].includes(error.code)) throw error;
+        await recover(lock);
+        if (Date.now() >= deadline) chainFail('ENTROROVE_CHAIN_BUSY', 'the original chain is running in another live host');
+        await new Promise(resolve => setTimeout(resolve, 25));
+      }
+    }
+    try { return await action(); }
+    finally {
+      if ((await owner(lock)).value.token !== token) chainFail('ENTROROVE_CHAIN_LOCK_CHANGED', 'chain lock ownership changed');
+      await fs.rm(lock, { recursive: true });
+    }
+  } finally { await fs.rm(staging, { recursive: true, force: true }); }
+}

package/local-chain-operations.mjs

@@ -0,0 +1,7 @@
+import { initLocalChain, resumeLocalChain, statusLocalChain, answerLocalChain, LOCAL_CHAIN_CONTROLLER_SCHEMA } from './local-chain-controller.mjs';
+export const LOCAL_CHAIN_OPERATIONS = Object.freeze({ 'chain-init': initLocalChain, 'chain-resume': resumeLocalChain,
+  'chain-status': statusLocalChain, 'chain-answer': answerLocalChain });
+export const LOCAL_CHAIN_CAPABILITIES = Object.freeze({ schemaVersion: LOCAL_CHAIN_CONTROLLER_SCHEMA,
+  operations: Object.keys(LOCAL_CHAIN_OPERATIONS), authority: 'original-workflow-step-results',
+  taskCompletionVerified: false, coordinatorStatus: 'adapter-pending', answerRequiresInteractiveTerminal: true,
+  legacyLedger: { operations: ['chain-ledger-init', 'chain-ledger-status', 'chain-ledger-query'], claimsExecution: false } });

package/local-chain-plan.mjs

@@ -0,0 +1,232 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+
+export const LOCAL_CHAIN_PLAN_SCHEMA = 'entrorove.execution-plan/1.0';
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const KINDS = ['skill', 'coordinator', 'command'];
+const EVIDENCE_KINDS = ['test', 'build', 'lint', 'security', 'benchmark'];
+const RESERVED_ENV = /(?:TOKEN|SECRET|PASSWORD|PRIVATE.?KEY|AUTHORIZATION|CREDENTIAL)/i;
+const UNSAFE_TARGET = new Set(['__proto__', 'prototype', 'constructor']);
+function fail(code, message) { throw Object.assign(new Error(message), { code }); }
+function object(value, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || ![null, Object.prototype].includes(Object.getPrototypeOf(value))) fail('ENTROROVE_CHAIN_JSON', `${label} must be a JSON object`);
+  return value;
+}
+function fields(value, required, optional, label) {
+  object(value, label);
+  if (required.some(key => !Object.hasOwn(value, key))
+    || Object.keys(value).some(key => !required.includes(key) && !optional.includes(key))) {
+    fail('ENTROROVE_CHAIN_FIELDS', `${label} has missing or unknown fields`);
+  }
+}
+function identifier(value, label) {
+  if (typeof value !== 'string' || !ID.test(value)) fail('ENTROROVE_CHAIN_ID', `${label} must be a safe identifier`);
+}
+function jsonCopy(value) {
+  const seen = new WeakSet(); let entries = 0;
+  function visit(item, depth = 0) {
+    if (depth > 128) fail('ENTROROVE_CHAIN_JSON', 'plan JSON exceeds its nesting bound');
+    if (++entries > 100000) fail('ENTROROVE_CHAIN_JSON', 'plan JSON exceeds its control bound');
+    if (item === null || typeof item === 'string' || typeof item === 'boolean') return;
+    if (typeof item === 'number' && Number.isFinite(item)) return;
+    if (typeof item !== 'object' || seen.has(item)) fail('ENTROROVE_CHAIN_JSON', 'values must be finite acyclic JSON');
+    if (!Array.isArray(item)) object(item, 'value');
+    seen.add(item);
+    for (const child of Object.values(item)) visit(child, depth + 1);
+    seen.delete(item);
+  }
+  visit(value);
+  const bytes = JSON.stringify(value);
+  if (Buffer.byteLength(bytes) > 1024 * 1024) fail('ENTROROVE_CHAIN_JSON', 'plan JSON exceeds its control byte bound');
+  return JSON.parse(bytes);
+}
+function freeze(value) {
+  if (value && typeof value === 'object') { for (const child of Object.values(value)) freeze(child); Object.freeze(value); }
+  return value;
+}
+function pointer(value, target = false) {
+  if (typeof value !== 'string' || (value !== '' && !value.startsWith('/')) || /~(?![01])/u.test(value)) {
+    fail('ENTROROVE_CHAIN_POINTER', 'binding must use a valid RFC 6901 JSON Pointer');
+  }
+  const parts = value === '' ? [] : value.slice(1).split('/').map(part => part.replace(/~1/g, '/').replace(/~0/g, '~'));
+  if (target && (!parts.length || parts.some(part => UNSAFE_TARGET.has(part)))) {
+    fail('ENTROROVE_CHAIN_POINTER', 'binding target must name a declared safe input property');
+  }
+  return parts;
+}
+function position(value, part) {
+  if (Array.isArray(value)) {
+    if (!/^(0|[1-9][0-9]*)$/.test(part) || !Number.isSafeInteger(Number(part)) || Number(part) >= value.length) {
+      fail('ENTROROVE_CHAIN_POINTER', 'binding array index must identify an existing element');
+    }
+  } else object(value, 'pointer parent');
+  if (!Object.hasOwn(value, part)) fail('ENTROROVE_CHAIN_POINTER', 'binding pointer value is missing');
+  return part;
+}
+function readPointer(value, parts) {
+  let current = value;
+  for (const part of parts) current = current[position(current, part)];
+  return current;
+}
+function setPointer(value, parts, replacement) {
+  const parent = readPointer(value, parts.slice(0, -1));
+  const key = position(parent, parts.at(-1));
+  Object.defineProperty(parent, key, { value: jsonCopy(replacement), enumerable: true, configurable: true, writable: true });
+}
+function commandInput(input) {
+  fields(input, ['executable', 'args', 'workingDirectory', 'timeoutMs', 'evidenceKind', 'environment'], [], 'command input');
+  if (typeof input.executable !== 'string' || !input.executable || input.executable.includes('\0')
+    || !Array.isArray(input.args) || input.args.some(arg => typeof arg !== 'string' || arg.includes('\0'))
+    || typeof input.workingDirectory !== 'string' || !input.workingDirectory || input.workingDirectory.includes('\0')
+    || !Number.isSafeInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 3600000
+    || !EVIDENCE_KINDS.includes(input.evidenceKind)) fail('ENTROROVE_CHAIN_COMMAND', 'command policy is invalid');
+  object(input.environment, 'command environment');
+  for (const [key, value] of Object.entries(input.environment)) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || RESERVED_ENV.test(key) || typeof value !== 'string' || value.includes('\0')) {
+      fail('ENTROROVE_CHAIN_ENVIRONMENT', 'command environment must contain explicit non-secret strings');
+    }
+  }
+  if (!path.isAbsolute(input.executable) && !input.environment.PATH) fail('ENTROROVE_CHAIN_COMMAND', 'relative executable requires an explicit PATH');
+  const directory = path.normalize(input.workingDirectory);
+  if (!path.isAbsolute(directory) && (directory === '..' || directory.startsWith(`..${path.sep}`))) {
+    fail('ENTROROVE_CHAIN_COMMAND', 'working directory cannot escape the original repository');
+  }
+}
+function validateBindings(step, previous) {
+  if (!Array.isArray(step.bindings)) fail('ENTROROVE_CHAIN_BINDING', 'step bindings must be an array');
+  if (step.kind === 'command' && step.bindings.length) fail('ENTROROVE_CHAIN_BINDING', 'command input cannot receive dynamic bindings');
+  const targets = [];
+  for (const binding of step.bindings) {
+    fields(binding, ['stepId', 'source', 'target'], [], 'binding');
+    if (!previous.has(binding.stepId)) fail('ENTROROVE_CHAIN_BINDING', 'binding source must name an earlier declared step');
+    pointer(binding.source);
+    const target = pointer(binding.target, true);
+    readPointer(step.input, target);
+    if (targets.some(parts => parts.every((part, index) => target[index] === part)
+      || target.every((part, index) => parts[index] === part))) fail('ENTROROVE_CHAIN_BINDING', 'binding targets cannot overlap');
+    targets.push(target);
+  }
+}
+function validateStep(step, previous, skills) {
+  fields(step, ['stepId', 'kind', 'skillId', 'operation', 'input', 'dependsOn', 'bindings'], ['continueWhen'], 'step');
+  identifier(step.stepId, 'stepId'); identifier(step.operation, 'operation'); object(step.input, 'step input');
+  if (previous.has(step.stepId) || !KINDS.includes(step.kind) || !Array.isArray(step.dependsOn)
+    || new Set(step.dependsOn).size !== step.dependsOn.length || step.dependsOn.some(id => !previous.has(id))) {
+    fail('ENTROROVE_CHAIN_TOPOLOGY', 'steps must have unique IDs and only earlier dependencies');
+  }
+  if (step.kind === 'skill' ? !skills.has(step.skillId) : step.skillId !== null) fail('ENTROROVE_CHAIN_SKILL', 'step skillId must match its declared kind and installed package declaration');
+  if (step.kind === 'command') {
+    if (step.operation !== 'exec') fail('ENTROROVE_CHAIN_COMMAND', 'command operation must be exec');
+    commandInput(step.input);
+  }
+  if (step.kind === 'coordinator' && step.operation === 'resolve-human') fail('ENTROROVE_CHAIN_DECISION', 'human resolution cannot be injected by a plan');
+  if (step.continueWhen !== undefined) {
+    if (step.kind !== 'skill' || step.skillId !== 'confirm-protocol' || step.operation !== 'interaction-request') {
+      fail('ENTROROVE_CHAIN_DECISION', 'continueWhen applies only to a declared confirmation request');
+    }
+    fields(step.continueWhen, ['answer'], [], 'continueWhen');
+    const answer = step.continueWhen.answer;
+    if (!(typeof answer === 'string' && answer.trim()) && !(Array.isArray(answer) && answer.length
+      && answer.every(item => typeof item === 'string' && item.trim()) && new Set(answer).size === answer.length)) {
+      fail('ENTROROVE_CHAIN_DECISION', 'continueWhen must declare an explicit string or unique choice IDs');
+    }
+  }
+  validateBindings(step, previous);
+}
+
+// Metadata validation never verifies installed packages, approves commands or
+// confers execution authority. The managed dispatcher retains those checks.
+export function validateLocalChainPlan(value) {
+  const plan = jsonCopy(value);
+  fields(plan, ['schemaVersion', 'chainId', 'skills', 'steps'], [], 'plan');
+  identifier(plan.chainId, 'chainId');
+  if (plan.schemaVersion !== LOCAL_CHAIN_PLAN_SCHEMA || !Array.isArray(plan.skills)
+    || !Array.isArray(plan.steps) || !plan.steps.length) fail('ENTROROVE_CHAIN_PLAN_INVALID', 'chain plan schema, skills and steps are required');
+  const skills = new Set();
+  for (const skill of plan.skills) {
+    fields(skill, ['skillId', 'packageRoot'], [], 'skill'); identifier(skill.skillId, 'skillId');
+    if (skills.has(skill.skillId) || typeof skill.packageRoot !== 'string' || !path.isAbsolute(skill.packageRoot)
+      || skill.packageRoot.includes('\0')) fail('ENTROROVE_CHAIN_SKILL', 'skills require unique IDs and absolute package declarations');
+    skills.add(skill.skillId);
+  }
+  const previous = new Set();
+  for (const step of plan.steps) { validateStep(step, previous, skills); previous.add(step.stepId); }
+  return freeze(plan);
+}
+
+// completed must come from the dispatcher's original durable outcomes. This
+// resolver does not authenticate caller-supplied results or advance a journal.
+export function bindLocalChainStepInput(value, stepId, completed) {
+  const plan = validateLocalChainPlan(value), index = plan.steps.findIndex(step => step.stepId === stepId);
+  if (index < 0) fail('ENTROROVE_CHAIN_STEP_UNKNOWN', 'binding target is outside the immutable plan');
+  if (!Array.isArray(completed)) fail('ENTROROVE_CHAIN_RESULT', 'completed outcomes must be an array');
+  const earlier = new Set(plan.steps.slice(0, index).map(step => step.stepId)), results = new Map();
+  for (const result of completed) {
+    fields(result, ['stepId', 'status', 'output'], [], 'completed outcome');
+    if (!earlier.has(result.stepId) || results.has(result.stepId)) fail('ENTROROVE_CHAIN_RESULT', 'outcomes must belong to unique earlier steps');
+    results.set(result.stepId, jsonCopy(result));
+  }
+  const step = plan.steps[index];
+  for (const dependency of new Set([...step.dependsOn, ...step.bindings.map(binding => binding.stepId)])) {
+    if (results.get(dependency)?.status !== 'succeeded') fail('ENTROROVE_CHAIN_DEPENDENCY', 'binding requires the original successful dependency outcome');
+  }
+  const input = jsonCopy(step.input);
+  for (const binding of step.bindings) setPointer(input, pointer(binding.target, true), readPointer(results.get(binding.stepId).output, pointer(binding.source)));
+  return input;
+}
+
+function statuses(value, found = new Set()) {
+  if (value && typeof value === 'object') {
+    if (typeof value.status === 'string') found.add(value.status);
+    for (const child of Object.values(value)) statuses(child, found);
+  }
+  return found;
+}
+function equal(left, right) { return JSON.stringify(left) === JSON.stringify(right); }
+function gate(state, code) { return Object.freeze({ state, code, eligible: state === 'eligible', executionVerified: false, authority: 'protocol-shape-only' }); }
+
+// A protocol-success envelope is necessary, never proof of actual execution.
+// The dispatcher must authenticate its broker/runner result before committing.
+export function inspectLocalChainResult(step, observed) {
+  object(step, 'step'); const response = jsonCopy(observed);
+  if (!KINDS.includes(step.kind)) fail('ENTROROVE_CHAIN_STEP_INVALID', 'result gate requires a declared step kind');
+  object(response, 'response');
+  const output = response.output ?? response.result ?? response;
+  object(output, 'protocol output');
+  const states = new Set([response.status, output.status]);
+  if (states.has('uncertain') || output.process?.status === 'uncertain') return gate('uncertain', 'ENTROROVE_CHAIN_OUTCOME_UNCERTAIN');
+  if (states.has('failed')) return gate('failed', 'ENTROROVE_CHAIN_RESULT_FAILED');
+  if (states.has('blocked')) return gate('blocked', 'ENTROROVE_CHAIN_RESULT_BLOCKED');
+  if (['waiting', 'pending', 'pending-execution', 'incomplete'].some(state => states.has(state))
+    || statuses(output).has('pending-execution')) return gate('waiting', 'ENTROROVE_CHAIN_RESULT_PENDING');
+  if (response.status !== 'succeeded') return gate('waiting', 'ENTROROVE_CHAIN_RESULT_UNVERIFIED');
+  if (step.kind === 'command') {
+    const process = output.process ?? output;
+    if (!Number.isInteger(process.exitCode)) return gate('uncertain', 'ENTROROVE_CHAIN_PROCESS_UNKNOWN');
+    if (process.exitCode !== 0 || process.signal || process.timedOut || process.outputLimitExceeded) return gate('failed', 'ENTROROVE_CHAIN_PROCESS_FAILED');
+  }
+  if (step.kind === 'skill' && step.skillId === 'validator') {
+    const verdict = output.report?.verdict ?? output.verdict;
+    if (step.operation === 'verdict' && !['pass', 'pass-with-risk'].includes(verdict)) return gate(verdict === 'blocked' ? 'blocked' : 'waiting', 'ENTROROVE_CHAIN_VALIDATOR_VERDICT');
+    if (step.operation === 'functional-verify') {
+      if (output.summary?.failed > 0 || output.evidence?.some(item => item.exitCode !== 0)) return gate('blocked', 'ENTROROVE_CHAIN_VALIDATOR_FAILED');
+      if (!Array.isArray(output.evidence) || !output.evidence.length || output.evidence.some(item => item.runner !== 'trusted-runner' || !item.receipt)) return gate('waiting', 'ENTROROVE_CHAIN_VALIDATOR_INCOMPLETE');
+    }
+  }
+  if (step.kind === 'skill' && step.skillId === 'confirm-protocol' && step.operation === 'interaction-request') {
+    if (!step.continueWhen || !Object.hasOwn(output, 'answer')) return gate('waiting', 'ENTROROVE_CHAIN_DECISION_REQUIRED');
+    if (!equal(output.answer, step.continueWhen.answer)) return gate('blocked', 'ENTROROVE_CHAIN_DECISION_DENIED');
+  }
+  return gate('eligible', 'ENTROROVE_CHAIN_AUTHENTICATION_REQUIRED');
+}
+
+export function localChainPlanDigest(plan) {
+  const value = validateLocalChainPlan(plan);
+  function canonical(item) {
+    if (Array.isArray(item)) return `[${item.map(canonical).join(',')}]`;
+    if (item && typeof item === 'object') return `{${Object.keys(item).sort().map(key => `${JSON.stringify(key)}:${canonical(item[key])}`).join(',')}}`;
+    return JSON.stringify(item);
+  }
+  return createHash('sha256').update(canonical(value)).digest('hex');
+}

package/local-chain-release-labels.mjs

@@ -0,0 +1,12 @@
+export const chainReleaseLabels = Object.freeze({
+  'local-chain-plan.mjs': { zh: '原链严格计划与结果门禁', en: 'strict original-chain plan and result gates' },
+  'local-chain-bindings.mjs': { zh: '原链安装元数据与执行映射', en: 'original-chain installed metadata and execution bindings' },
+  'local-chain-lock.mjs': { zh: '原链宿主锁与中断恢复', en: 'original-chain host locks and interruption recovery' },
+  'local-chain-broker.mjs': { zh: '原链同流程技能调用', en: 'original-chain skill calls on the same workflow' },
+  'local-chain-human.mjs': { zh: '原链终端确认与真实回调', en: 'original-chain terminal confirmation and original callbacks' },
+  'local-chain-controller.mjs': { zh: '原链持久受控执行器', en: 'durable original-chain controlled executor' },
+  'local-chain-contracts.mjs': { zh: '原链本地严格操作契约', en: 'strict original-chain local operation contracts' },
+  'local-chain-operations.mjs': { zh: '原链受控操作入口', en: 'original-chain controlled operation entry points' },
+  'local-chain-release-labels.mjs': { zh: '原链独立更新说明', en: 'independent original-chain release descriptions' },
+  'local-chain-results.mjs': { zh: '原链结果与退出状态', en: 'original-chain results and exit states' },
+});

package/local-chain-results.mjs

@@ -0,0 +1,75 @@
+import { observeWorkflowLocalStep } from './workflow-local-runner.mjs';
+import { buildInvocation } from './remote-client.mjs';
+import { inspectChainSkillResponse } from './local-chain-broker.mjs';
+import { inspectChainHumanResponse } from './local-chain-human.mjs';
+import { bindLocalChainStepInput } from './local-chain-plan.mjs';
+import { chainCanonical as canonical, chainFail as fail, chainSha as sha } from './local-chain-bindings.mjs';
+
+function denied(message) { fail('ENTROROVE_CHAIN_RESULT_BINDING', message); }
+async function commandResult(state, original, step) {
+  const binding = state.commandBindings.find(value => value.stepId === original.stepId);
+  if (!binding || step.phase !== 'done' || !step.localResult?.receipt || !step.output || step.error !== null) {
+    denied('verified command has no original process receipt and result');
+  }
+  let actual;
+  try { actual = await observeWorkflowLocalStep(binding.workflowInput); }
+  catch { denied('verified command has no independently valid original native cache'); }
+  if (!actual?.receipt || actual.status !== 'reported' || actual.receipt.result?.passed !== true
+    || ['process', 'evidence', 'receipt', 'subject', 'statePath'].some(key => canonical(actual[key]) !== canonical(step.localResult[key]))) {
+    denied('verified command differs from its actual signed native process');
+  }
+  const output = step.output, lease = binding.workflowInput.lease;
+  if (output.status !== 'verified' || output.flowId !== state.identity.flowId || output.stepId !== step.stepId
+    || output.generation !== lease.generation || canonical(output.lease) !== canonical(lease)
+    || output.evidenceDigest !== sha(canonical(actual.evidence[0])) || canonical(output.evidence) !== canonical(actual.evidence[0])
+    || output.verification?.summary?.passed !== 1 || output.verification.summary.failed !== 0
+    || output.verification.findings?.length !== 0) denied('verified command has no matching independent verification of its exact original receipt');
+}
+function skillRequest(state, original, step) {
+  if (step.phase !== 'done' || !step.response || !step.request || step.error !== null) denied('verified skill has no original durable request result');
+  const preceding = state.steps.filter(value => value.status === 'verified' && value.stepId !== original.stepId)
+    .map(value => ({ stepId: value.stepId, status: 'succeeded', output: value.output }));
+  const bound = bindLocalChainStepInput(state.plan, original.stepId, preceding);
+  const answer = original.skillId === 'confirm-protocol' && original.operation === 'interaction-request' && step.response.result?.auditEntry;
+  const expected = answer ? buildInvocation('continue', step.request.input)
+    : buildInvocation('continue', { flowId: state.identity.flowId, operation: original.operation, payload: bound });
+  if (step.request.operation !== 'continue' || step.request.requestId !== expected.requestId || step.response.requestId !== expected.requestId
+    || canonical(step.request.input) !== canonical(expected.body.input)) denied('verified skill lost its exact original canonical request');
+  if (answer) {
+    const saved = { ...step, output: step.originalInteraction };
+    if (!saved.output?.interaction || saved.output.interactionDigest !== sha(canonical(saved.output.interaction))
+      || step.request.input.flowId !== state.identity.flowId || step.request.input.operation !== 'interaction-answer'
+      || step.request.input.payload.interactionId !== saved.output.interactionId
+      || step.request.input.payload.interactionDigest !== saved.output.interactionDigest
+      || !inspectChainHumanResponse(original, state, saved, step.response).eligible) denied('verified answer lacks its original audited callback');
+    if (canonical(step.output) !== canonical({ ...step.response.result, answer: step.response.result.auditEntry.answer })) denied('verified answer changed its original audited output');
+  } else if (!inspectChainSkillResponse(original, state, step.response).eligible || canonical(step.output) !== canonical(step.response.result)) {
+    denied('verified skill changed its actual original protocol result');
+  }
+  return expected.requestId;
+}
+export async function validateArchivedChainResults(state) {
+  for (const original of state.plan.steps) {
+    const step = state.steps.find(value => value.stepId === original.stepId);
+    if (step.status !== 'verified') continue;
+    if (original.kind === 'command') await commandResult(state, original, step);
+    else if (original.kind === 'skill') skillRequest(state, original, step);
+    else denied('local ledger cannot manufacture a verified coordinator result');
+  }
+}
+export async function revalidateArchivedChainSkill(state, original, step, client) {
+  const requestId = skillRequest(state, original, step);
+  let observed;
+  try { observed = await client.status(requestId); } catch { denied('original verified skill result is unavailable; never replay its operation'); }
+  if (canonical(observed) !== canonical(step.response)) denied('archived skill differs from the actual durable original request result');
+}
+export async function revalidateArchivedChainCommand(state, original, step, client) {
+  await commandResult(state, original, step);
+  const request = buildInvocation('continue', { flowId: state.identity.flowId,
+    operation: 'execution-verify', payload: { stepId: original.stepId } });
+  let observed;
+  try { observed = await client.status(request.requestId); }
+  catch { denied('the original command has no actual durable independent verification; never manufacture or replay it'); }
+  if (observed.requestId !== request.requestId || !['succeeded', 'reported'].includes(observed.status)
+    || canonical(observed.result) !== canonical(step.output)) denied('archived command differs from the actual independently verified original request');
+}

package/local-cli.mjs

@@ -1,58 +1,99 @@
+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 { LOCAL_CHAIN_OPERATIONS } from './local-chain-operations.mjs';
+import { runManagedWorkflowLocalStep } from './workflow-local-client.mjs';
+import { localErrorEnvelope } from './local-error.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_CHAIN_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);
 
-export async function runLocal(args = []) {
-  const operation = args[0];
-  if (operation === 'capabilities' || operation === 'help') { 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);
-  process.stdout.write(`${JSON.stringify(output)}\n`);
-  if (output?.status === 'blocked' || output?.status === 'failed' || output?.status === 'incomplete') process.exitCode = 2;
+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 = [], dependencies) {
+  try {
+    const operation = args[0];
+    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 validated = await checkedLocalInput(operation, input);
+    const supplied = operation === 'workflow-run-step' || Object.hasOwn(LOCAL_CHAIN_OPERATIONS, operation) ? dependencies : undefined;
+    const output = await withLocalInvocation(operation, validated, () => withBudgetReadContext(validated, () => handler(validated, supplied)));
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+    if (['pending', 'blocked', 'failed', 'incomplete'].includes(output?.status)) process.exitCode = 2;
+  } catch (cause) {
+    const error = localErrorEnvelope(cause); process.stderr.write(`${JSON.stringify(error)}\n`); process.exitCode = error.status === 'blocked' ? 2 : 1;
+  }
 }
 
-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);
+  const supplied = operation === 'workflow-run-step' || Object.hasOwn(LOCAL_CHAIN_OPERATIONS, operation) ? dependencies : undefined;
+  return withLocalInvocation(operation, validated, () => withBudgetReadContext(validated, () => handler(validated, supplied)));
 }

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'], 1), 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'] };