@entrorove/skill 0.1.24 → 0.1.28

package/local-autocoord17-peers.mjs

@@ -0,0 +1,111 @@
+import { canonical, sha256 } from './local-integrity.mjs';
+import { canonicalSwarmPaths, SWARM_PRIORITIES, swarmPathsOverlap } from './local-swarm-state.mjs';
+import { readSwarmOwnership, swarmRepositoryStorage, validateSwarmOwnership } from './local-swarm-storage.mjs';
+import { readSwarmWriteIntentHistory } from './local-swarm-priority.mjs';
+import { coordDuration17, coordExact17, coordFail17, coordId17, coordMessage17, coordEvent17 } from './local-autocoord17-store.mjs';
+import { coordNative17 } from './local-autocoord17-authority.mjs';
+
+export async function physicalPeers17(task) {
+  const authority = await coordNative17(task.material, false), storage = await swarmRepositoryStorage(authority, 'read');
+  const index = await validateSwarmOwnership(await readSwarmOwnership(storage, authority, 'read'), authority);
+  return (await readSwarmWriteIntentHistory(index, authority)).index;
+}
+function earlier(left, right) {
+  const difference = SWARM_PRIORITIES.indexOf(left.priority) - SWARM_PRIORITIES.indexOf(right.priority);
+  return difference > 0 || difference === 0 && left.sequence < right.sequence;
+}
+export function registerIntent17(state, task, input) {
+  coordId17(input.intentId); coordDuration17(input.ttlMs); coordDuration17(input.coordinationTimeoutMs);
+  coordDuration17(input.fileLockTtlMs);
+  const paths = canonicalSwarmPaths(input.paths);
+  if (paths.some(target => !task.card.taskScope.includes(target)) || input.baselineHash !== task.card.baselineHash
+    || input.priority !== task.material.delegationGrant.priority) coordFail17('ENTROROVE_COORD_INTENT_BINDING', 'intent must retain original signed priority, paths and baseline');
+  const request = { intentId: input.intentId, taskId: task.taskId, agentId: task.agentId, chainId: task.chainId,
+    paths, baselineHash: input.baselineHash, ttlMs: input.ttlMs, coordinationTimeoutMs: input.coordinationTimeoutMs,
+    fileLockTtlMs: input.fileLockTtlMs, priority: input.priority };
+  const prior = state.intents.find(value => value.intentId === input.intentId);
+  if (prior) {
+    if (canonical(prior.request) !== canonical(request)) coordFail17('ENTROROVE_COORD_INTENT_CHANGED', 'intent ID cannot change its original content');
+    if (prior.status === 'expired') coordFail17('ENTROROVE_COORD_INTENT_EXPIRED', 'expired intent needs a new explicit identity');
+    return prior;
+  }
+  const now = Date.now(), expires = Math.min(now + input.ttlMs, Date.parse(task.material.delegationGrant.expiresAt));
+  const intent = { intentId: input.intentId, taskId: task.taskId, request, sequence: state.intents.length,
+    status: 'waiting', expiresAt: new Date(expires).toISOString(), deadlineAt: new Date(now + input.coordinationTimeoutMs).toISOString(),
+    readyPaths: [], blockedPaths: [], refetchPaths: [], spawnDepth: task.spawnOrigin ? 1 : 0, spawnRequestId: null };
+  state.intents.push(intent); return intent;
+}
+function spawnRequest(state, task, intent) {
+  if (intent.spawnDepth !== 0 || intent.spawnRequestId || !intent.blockedPaths.length) return;
+  const spawnRequestId = sha256(`entrorove.peer-spawn/1.0\0${intent.intentId}`);
+  intent.spawnRequestId = spawnRequestId;
+  const request = { schemaVersion: 'entrorove.peer-spawn-request/1.0', spawnRequestId, idempotencyKey: spawnRequestId,
+    status: 'pending', sourceTaskId: task.taskId, ownerId: task.material.delegationGrant.ownerId,
+    originalTask: structuredClone(task.originalTask), agentId: task.agentId, chainId: task.chainId,
+    paths: [...intent.blockedPaths], sourceIntentId: intent.intentId, spawnDepth: 1, spawnAllowed: false };
+  state.spawnRequests.push(request);
+  coordMessage17(state, task.taskId, 'peer-timeout', { spawnRequestId, paths: request.paths }, intent.intentId);
+}
+export function scanIntent17(state, task, intent, physical) {
+  const now = Date.now();
+  if (['completed', 'moved', 'expired'].includes(intent.status)) return peerView17(intent);
+  if (Date.parse(intent.expiresAt) <= now) {
+    intent.status = 'expired'; coordMessage17(state, task.taskId, 'peer-expired', { intentId: intent.intentId }, intent.intentId);
+    return peerView17(intent);
+  }
+  const ownGrant = sha256(canonical(task.material.delegationGrant));
+  const occupied = physical.records.filter(record => record.grantDigest !== ownGrant);
+  const nativeIntent = physical.intents.find(value => value.intentId === ownGrant);
+  const ahead = physical.intents.filter(value => value.status === 'waiting' && value.intentId !== ownGrant
+    && nativeIntent && earlier(value, nativeIntent));
+  const remaining = intent.request.paths.filter(target => !intent.movedPaths?.includes(target));
+  const blocked = remaining.filter(target => occupied.some(record => record.paths.some(scope => swarmPathsOverlap(scope, target)))
+    || ahead.some(value => value.paths.some(scope => swarmPathsOverlap(scope, target))));
+  const oldBlocked = intent.blockedPaths, ready = remaining.filter(target => !blocked.includes(target));
+  const refetch = oldBlocked.filter(target => !blocked.includes(target));
+  intent.blockedPaths = blocked; intent.readyPaths = ready;
+  intent.refetchPaths = [...new Set([...intent.refetchPaths, ...refetch])].sort();
+  intent.status = blocked.length ? ready.length ? 'partial' : 'waiting' : 'ready';
+  if (blocked.length) {
+    const urgent = intent.request.priority === 'urgent' && occupied.some(record => record.paths.some(scope => blocked.some(target => swarmPathsOverlap(scope, target))));
+    coordMessage17(state, task.taskId, 'peer-conflict', { intentId: intent.intentId, blockedPaths: blocked }, `${intent.intentId}:${canonical(blocked)}`);
+    for (const record of occupied.filter(record => record.paths.some(scope => blocked.some(target => swarmPathsOverlap(scope, target))))) {
+      const owner = state.tasks.find(value => value.material.flowId === record.flowId);
+      if (owner) coordMessage17(state, owner.taskId, 'peer-request', { intentId: intent.intentId, paths: blocked,
+        safeCheckpointRequested: urgent }, `${intent.intentId}:${record.grantDigest}`);
+    }
+    if (Date.parse(intent.deadlineAt) <= now) spawnRequest(state, task, intent);
+  }
+  if (refetch.length) {
+    coordMessage17(state, task.taskId, 'peer-ready', { intentId: intent.intentId, refetchPaths: refetch,
+      freshAimlockSnapshotRequired: true }, `${intent.intentId}:${canonical(refetch)}`);
+    coordEvent17(state, 'peer-ready', task.taskId, intent.intentId, { refetchPaths: refetch }, `${intent.intentId}:${canonical(refetch)}`);
+  }
+  return { ...peerView17(intent), safeCheckpointRequested: intent.request.priority === 'urgent' && blocked.length > 0 };
+}
+export function peerView17(intent) {
+  return { schemaVersion: 'entrorove.local-autocoord/1.0', intentId: intent.intentId, status: intent.status,
+    readyPaths: [...intent.readyPaths], blockedPaths: [...intent.blockedPaths], refetchPaths: [...intent.refetchPaths],
+    freshAimlockSnapshotRequired: intent.refetchPaths.length > 0, writeAuthorized: false, fileLockGranted: false,
+    lockRequest: { paths: [...intent.readyPaths], ttlMs: intent.request.fileLockTtlMs },
+    spawnRequestId: intent.spawnRequestId, spawnDepth: intent.spawnDepth, spawnAllowed: intent.spawnDepth === 0 };
+}
+export function bindSpawn17(state, source, input) {
+  coordExact17(input, ['spawnRequestId', 'targetTaskId']);
+  const request = state.spawnRequests.find(value => value.spawnRequestId === input.spawnRequestId && value.sourceTaskId === source.taskId);
+  const target = state.tasks.find(value => value.taskId === input.targetTaskId);
+  if (!request || !target || target.taskId === source.taskId || target.material.flowId === source.material.flowId
+    || target.material.delegationGrant.ownerId !== request.ownerId || canonical(target.originalTask) !== canonical(request.originalTask)
+    || request.paths.some(targetPath => !target.card.taskScope.includes(targetPath))) coordFail17('ENTROROVE_COORD_SPAWN_BINDING', 'spawn binding requires the actual newly registered same-owner original task and exact pending paths');
+  if (request.status === 'bound') {
+    if (request.targetTaskId !== target.taskId) coordFail17('ENTROROVE_COORD_SPAWN_CHANGED', 'original spawn request cannot be rebound');
+    return request;
+  }
+  if (target.spawnOrigin) coordFail17('ENTROROVE_COORD_RECURSION', 'a derived task cannot receive another spawn lineage');
+  request.status = 'bound'; request.targetTaskId = target.taskId; target.spawnOrigin = request.spawnRequestId;
+  const intent = state.intents.find(value => value.intentId === request.sourceIntentId);
+  intent.movedPaths = [...request.paths]; intent.status = intent.readyPaths.length ? 'ready' : 'moved'; intent.blockedPaths = [];
+  coordMessage17(state, source.taskId, 'peer-spawned', { spawnRequestId: request.spawnRequestId,
+    targetTaskId: target.taskId, paths: request.paths }, request.spawnRequestId);
+  return request;
+}

package/local-autocoord17-store.mjs

@@ -0,0 +1,110 @@
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { withChainLock } from './local-chain-lock.mjs';
+import { chainControlFile } from './local-chain-bindings.mjs';
+import { canonical, sha256 } from './local-integrity.mjs';
+
+export const AUTOCORD17_SCHEMA = 'entrorove.local-autocoord/1.0';
+export function coordFail17(code, message) { throw Object.assign(new Error(message), { code }); }
+export function coordExact17(value, required, optional = []) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || required.some(key => !Object.hasOwn(value, key))
+    || Object.keys(value).some(key => !required.includes(key) && !optional.includes(key))) {
+    coordFail17('ENTROROVE_COORD_FIELDS', 'coordination input has missing or unknown fields');
+  }
+}
+export function coordId17(value) {
+  if (typeof value !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value)) {
+    coordFail17('ENTROROVE_COORD_ID', 'coordination identity must be an explicit safe ID');
+  }
+  return value;
+}
+export function coordDuration17(value, maximum = 3_600_000) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > maximum) coordFail17('ENTROROVE_COORD_DURATION', 'duration must be a positive bounded integer');
+  return value;
+}
+async function directory(value, privateMode) {
+  if (typeof value !== 'string' || !path.isAbsolute(value)) coordFail17('ENTROROVE_COORD_DIRECTORY', 'coordination directories must be explicit absolute paths');
+  const stat = await fs.lstat(value), actual = await fs.realpath(value);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || actual !== path.resolve(value)
+    || typeof process.getuid === 'function' && stat.uid !== process.getuid()
+    || privateMode && (stat.mode & 0o077)) coordFail17('ENTROROVE_COORD_DIRECTORY', 'coordination directory must be owned, real and private');
+  return actual;
+}
+async function location(input, create) {
+  const repositoryRoot = await directory(input.repositoryRoot, false), coordinationHome = await directory(input.coordinationHome, true);
+  let current = coordinationHome;
+  for (const name of ['.entrorove', 'autocoord17', sha256(repositoryRoot).slice(0, 32)]) {
+    current = path.join(current, name);
+    if (create) await fs.mkdir(current, { mode: 0o700 }).catch(error => { if (error.code !== 'EEXIST') throw error; });
+    await directory(current, true);
+  }
+  return { repositoryRoot, coordinationHome, file: path.join(current, 'journal.json') };
+}
+function initial(ctx) {
+  return { schemaVersion: AUTOCORD17_SCHEMA, repositoryRoot: ctx.repositoryRoot, coordinationHome: ctx.coordinationHome,
+    tasks: [], intents: [], waits: [], events: [], messages: [], decisions: [], spawnRequests: [], lockQueues: [] };
+}
+function checked(state, ctx) {
+  coordExact17(state, ['schemaVersion', 'repositoryRoot', 'coordinationHome', 'tasks', 'intents', 'waits', 'events',
+    'messages', 'decisions', 'spawnRequests', 'lockQueues']);
+  if (state.schemaVersion !== AUTOCORD17_SCHEMA || state.repositoryRoot !== ctx.repositoryRoot || state.coordinationHome !== ctx.coordinationHome
+    || ['tasks', 'intents', 'waits', 'events', 'messages', 'decisions', 'spawnRequests', 'lockQueues'].some(key => !Array.isArray(state[key]) || state[key].length > 1024)) {
+    coordFail17('ENTROROVE_COORD_JOURNAL', 'coordination controls lost their original identity or bounds');
+  }
+  return state;
+}
+async function load(ctx, create) {
+  let journal;
+  try { const value = await chainControlFile(ctx.file); if (value.stat.mode & 0o077) throw new Error(); journal = JSON.parse(value.bytes.toString()); }
+  catch (error) { if (error.code !== 'ENOENT' || !create) throw error; journal = { schemaVersion: AUTOCORD17_SCHEMA, records: [] }; }
+  coordExact17(journal, ['schemaVersion', 'records']);
+  if (journal.schemaVersion !== AUTOCORD17_SCHEMA || !Array.isArray(journal.records) || journal.records.length > 1024) {
+    coordFail17('ENTROROVE_COORD_JOURNAL', 'coordination journal is invalid');
+  }
+  let head = null, state = initial(ctx);
+  for (const [index, record] of journal.records.entries()) {
+    coordExact17(record, ['sequence', 'event', 'at', 'previousDigest', 'state', 'digest']);
+    const { digest, ...core } = record;
+    if (record.sequence !== index + 1 || record.previousDigest !== head || sha256(canonical(core)) !== digest) {
+      coordFail17('ENTROROVE_COORD_JOURNAL', 'coordination journal lineage changed');
+    }
+    head = digest; state = checked(record.state, ctx);
+  }
+  return { ctx, journal, state: structuredClone(state), sequence: journal.records.length, head };
+}
+async function commit(loaded, event) {
+  checked(loaded.state, loaded.ctx);
+  const core = { sequence: loaded.sequence + 1, event, at: new Date().toISOString(), previousDigest: loaded.head, state: loaded.state };
+  const journal = { schemaVersion: AUTOCORD17_SCHEMA, records: [...loaded.journal.records, { ...core, digest: sha256(canonical(core)) }] };
+  const bytes = Buffer.from(canonical(journal) + '\n');
+  if (bytes.length > 8 * 1024 * 1024 || journal.records.length > 1024) coordFail17('ENTROROVE_COORD_JOURNAL_LIMIT', 'coordination journal needs explicit archival');
+  const temporary = `${loaded.ctx.file}.${randomUUID()}.tmp`;
+  const handle = await fs.open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
+  try { await handle.writeFile(bytes); await handle.sync(); } finally { await handle.close(); }
+  try { await fs.rename(temporary, loaded.ctx.file); } finally { await fs.rm(temporary, { force: true }); }
+  const directory = await fs.open(path.dirname(loaded.ctx.file), constants.O_RDONLY);
+  try { await directory.sync(); } finally { await directory.close(); }
+  loaded.sequence = core.sequence; loaded.head = sha256(canonical(core));
+}
+export async function withCoordination17(input, event, action, create = false) {
+  const ctx = await location(input, create);
+  return withChainLock(ctx.file, async () => {
+    const loaded = await load(ctx, create), before = canonical(loaded.state), result = await action(loaded);
+    if (canonical(loaded.state) !== before) await commit(loaded, event);
+    return { ...result, sequence: loaded.sequence, head: loaded.head };
+  });
+}
+export async function readCoordination17(input) { return load(await location(input, false), false); }
+export function coordMessage17(state, taskId, type, detail, key) {
+  const messageId = sha256(`${type}\0${taskId}\0${key}`);
+  if (!state.messages.some(value => value.messageId === messageId)) state.messages.push({ messageId, taskId, type, detail, at: new Date().toISOString() });
+  return messageId;
+}
+export function coordEvent17(state, type, taskId, resource, detail, key) {
+  const eventId = sha256(`${type}\0${taskId}\0${key}`);
+  const existing = state.events.find(value => value.eventId === eventId);
+  if (existing && canonical(existing.detail) !== canonical(detail)) coordFail17('ENTROROVE_COORD_EVENT_CHANGED', 'same event identity cannot change its content');
+  if (!existing) state.events.push({ eventId, type, taskId, resource, detail, at: new Date().toISOString() });
+  return existing ?? state.events.at(-1);
+}

package/local-autocoord17-tasks.mjs

@@ -0,0 +1,68 @@
+import { canonical } from './local-integrity.mjs';
+import { canonicalSwarmPaths, swarmPathsOverlap } from './local-swarm-state.mjs';
+import { coordDuration17, coordExact17, coordFail17, coordId17, coordMessage17 } from './local-autocoord17-store.mjs';
+
+export function taskCard17(value, native) {
+  coordExact17(value, ['taskScope', 'plannedActions', 'deployTarget', 'eta', 'baselineHash', 'archConstraints']);
+  const taskScope = canonicalSwarmPaths(value.taskScope);
+  if (taskScope.some(target => !native.paths.includes(target)) || value.baselineHash !== native.grant.frozenManifestDigest
+    || !Array.isArray(value.plannedActions) || !value.plannedActions.length || value.plannedActions.some(item => typeof item !== 'string' || !item || item.length > 500)
+    || value.deployTarget !== null && (typeof value.deployTarget !== 'string' || !value.deployTarget || value.deployTarget.length > 500)
+    || !Number.isFinite(Date.parse(value.eta)) || !Array.isArray(value.archConstraints)
+    || value.archConstraints.some(item => typeof item !== 'string' || !/^(?:forbid-scope:[^\s]+|requirement:[^=\s]+=[^\s]+)$/.test(item))) {
+    coordFail17('ENTROROVE_COORD_TASKCARD', 'taskcard must preserve the original signed scope, baseline and explicit constraints');
+  }
+  return { ...structuredClone(value), taskScope };
+}
+export function taskConflicts17(state, task) {
+  return state.tasks.filter(other => other.taskId !== task.taskId).flatMap(other => {
+    const reasons = [];
+    if (other.card.taskScope.some(scope => task.card.taskScope.some(target => swarmPathsOverlap(scope, target)))) reasons.push('scope-overlap');
+    if (task.card.deployTarget && task.card.deployTarget === other.card.deployTarget) reasons.push('deploy-target');
+    for (const [left, right] of [[task, other], [other, task]]) for (const constraint of left.card.archConstraints) {
+      if (constraint.startsWith('forbid-scope:') && right.card.taskScope.some(target => swarmPathsOverlap(constraint.slice(13), target))) reasons.push('architecture-scope');
+      if (constraint.startsWith('requirement:')) {
+        const prefix = constraint.slice(0, constraint.indexOf('=') + 1);
+        if (right.card.archConstraints.some(value => value.startsWith(prefix) && value !== constraint)) reasons.push('decision-conflict');
+      }
+    }
+    return reasons.length ? [{ taskId: other.taskId, reasons: [...new Set(reasons)] }] : [];
+  });
+}
+export function registerTask17(state, input, native, cloud) {
+  coordId17(input.taskId); coordId17(input.agentId); coordId17(input.chainId);
+  if (input.taskId !== native.grant.taskId || input.chainId !== native.step.executionPlan.chainId
+    || input.material.repositoryRoot !== state.repositoryRoot) coordFail17('ENTROROVE_COORD_TASK_BINDING', 'taskcard changed its original signed task, chain or repository');
+  const card = taskCard17(input.card, native), task = { taskId: input.taskId, agentId: input.agentId, chainId: input.chainId,
+    material: structuredClone(input.material), card, ...cloud, registeredAt: new Date().toISOString() };
+  const existing = state.tasks.find(value => value.taskId === task.taskId);
+  if (existing) {
+    if (canonical({ ...existing, registeredAt: null }) !== canonical({ ...task, registeredAt: null })) coordFail17('ENTROROVE_COORD_TASK_CHANGED', 'same taskcard cannot change its original identity or contents');
+    return existing;
+  }
+  state.tasks.push(task);
+  for (const conflict of taskConflicts17(state, task)) for (const target of [task.taskId, conflict.taskId]) {
+    coordMessage17(state, target, 'task-conflict', { otherTaskId: target === task.taskId ? conflict.taskId : task.taskId,
+      reasons: conflict.reasons }, [task.taskId, conflict.taskId].sort().join(':'));
+  }
+  return task;
+}
+export function enqueueResource17(state, task, input) {
+  coordId17(input.queueId); coordId17(input.resource); coordDuration17(input.queueTimeoutMs);
+  if (!['file', 'build', 'deploy'].includes(input.kind) || input.baselineHash !== task.card.baselineHash) {
+    coordFail17('ENTROROVE_COORD_BASELINE', 'resource queue requires the original current taskcard baseline');
+  }
+  const paths = input.kind === 'file' ? canonicalSwarmPaths(input.paths) : [];
+  if (paths.some(target => !task.card.taskScope.includes(target))) coordFail17('ENTROROVE_COORD_SCOPE', 'queue paths exceed its original taskcard');
+  const request = { queueId: input.queueId, taskId: task.taskId, agentId: task.agentId, chainId: task.chainId,
+    kind: input.kind, resource: input.resource, paths, baselineHash: input.baselineHash, queueTimeoutMs: input.queueTimeoutMs };
+  const existing = state.lockQueues.find(value => value.queueId === request.queueId);
+  if (existing) {
+    if (canonical(existing.request) !== canonical(request)) coordFail17('ENTROROVE_COORD_QUEUE_CHANGED', 'queue identity cannot change its original request');
+    return existing;
+  }
+  const now = Date.now(), entry = { request, queueId: request.queueId, taskId: task.taskId, status: 'waiting',
+    registeredAt: new Date(now).toISOString(), deadlineAt: new Date(now + input.queueTimeoutMs).toISOString(),
+    grant: null, consumerAvailable: false, unsupported: input.kind === 'file' ? 'restrictive-native-subset-adapter' : `${input.kind}-consumer` };
+  state.lockQueues.push(entry); return entry;
+}

package/local-autocoord17-waits.mjs

@@ -0,0 +1,118 @@
+import { canonical, sha256 } from './local-integrity.mjs';
+import { canonicalSwarmPaths } from './local-swarm-state.mjs';
+import { coordDuration17, coordExact17, coordFail17, coordId17, coordEvent17, coordMessage17 } from './local-autocoord17-store.mjs';
+
+const ACTIVE = ['waiting', 'need-human'];
+const EVENT_TYPES = ['signal', 'peer-ready', 'task-reported', 'task-failed', 'lease-expired', 'lock-released'];
+export function requestDecision17(state, task, reason, key, paths = []) {
+  const decisionId = sha256(`${reason}\0${task.taskId}\0${key}`);
+  const existing = state.decisions.find(value => value.decisionId === decisionId);
+  if (existing) return existing;
+  const decision = { schemaVersion: 'entrorove.coordination-decision/1.0', decisionId, taskId: task.taskId,
+    agentId: task.agentId, chainId: task.chainId, status: 'need-human', reason, paths,
+    risk: 'high', request: { type: 'confirm', question: `Resolve coordination ${reason} for the original task ${task.taskId}.`,
+      riskDescription: 'Unresolved coordination may conflict with another original task; no engineering authority is granted.',
+      options: [{ id: 'resume', label: 'Resume this coordination wait' }, { id: 'cancel', label: 'Cancel this coordination wait' }],
+      callback: { operation: 'coordination-resolve-human', payload: { decisionId } } }, createdAt: new Date().toISOString(), audit: null };
+  state.decisions.push(decision); coordMessage17(state, task.taskId, 'need-human', { decisionId, reason }, key);
+  return decision;
+}
+function match(wait, event) {
+  return wait.request.waitFor.taskId === event.taskId && wait.request.event.type === event.type
+    && wait.request.event.resource === event.resource;
+}
+function cycle(state, start, current, seen = new Set()) {
+  if (current === start) return true;
+  if (seen.has(current)) return false;
+  seen.add(current);
+  return state.waits.filter(value => ACTIVE.includes(value.status) && value.taskId === current)
+    .some(value => cycle(state, start, value.request.waitFor.taskId, seen));
+}
+export function registerWait17(state, task, input) {
+  coordId17(input.waitId); coordDuration17(input.expectedWithinMs);
+  coordExact17(input.waitFor, ['taskId']); coordId17(input.waitFor.taskId);
+  coordExact17(input.event, ['type', 'resource']); coordId17(input.event.resource);
+  if (!EVENT_TYPES.includes(input.event.type) || !state.tasks.some(value => value.taskId === input.waitFor.taskId)
+    || !['resume', 'notify'].includes(input.onArrival) || !['cancel', 'notify', 'escalate-need-human'].includes(input.onTimeout)) {
+    coordFail17('ENTROROVE_COORD_WAIT', 'wait must name a registered original task, structured event and explicit policies');
+  }
+  const refetchPaths = input.refetchPaths.length ? canonicalSwarmPaths(input.refetchPaths) : [];
+  if (refetchPaths.some(target => !task.card.taskScope.includes(target))) coordFail17('ENTROROVE_COORD_SCOPE', 'wait refetch paths exceed the original taskcard');
+  const request = { waitId: input.waitId, waiter: { taskId: task.taskId, agentId: task.agentId, chainId: task.chainId },
+    waitFor: input.waitFor, event: input.event, expectedWithinMs: input.expectedWithinMs,
+    onArrival: input.onArrival, onTimeout: input.onTimeout, refetchPaths };
+  const previous = state.waits.find(value => value.waitId === input.waitId);
+  if (previous) {
+    if (canonical(previous.request) !== canonical(request)) coordFail17('ENTROROVE_COORD_WAIT_CHANGED', 'same wait ID cannot change its original dependency');
+    return previous;
+  }
+  const now = Date.now(), wait = { waitId: input.waitId, taskId: task.taskId, request, status: 'waiting',
+    registeredAt: new Date(now).toISOString(), deadlineAt: new Date(now + input.expectedWithinMs).toISOString(),
+    wakeup: null, decisionId: null };
+  state.waits.push(wait);
+  const existing = state.events.find(value => match(wait, value));
+  if (existing) arrive(state, task, wait, existing);
+  else if (cycle(state, task.taskId, input.waitFor.taskId)) {
+    const involved = state.waits.filter(value => ACTIVE.includes(value.status)
+      && (cycle(state, value.taskId, value.request.waitFor.taskId)));
+    for (const value of involved) {
+      const owner = state.tasks.find(item => item.taskId === value.taskId);
+      value.status = 'need-human'; value.decisionId = requestDecision17(state, owner, 'dependency-cycle', value.waitId, value.request.refetchPaths).decisionId;
+    }
+  }
+  return wait;
+}
+function arrive(state, task, wait, event) {
+  if (wait.status === 'need-human') return;
+  wait.status = ['task-failed', 'lease-expired'].includes(event.type) ? 'terminated' : 'arrived';
+  wait.wakeup = { event: structuredClone(event), refetchPaths: [...wait.request.refetchPaths],
+    freshAimlockSnapshotRequired: wait.request.refetchPaths.length > 0, receivedAt: new Date().toISOString() };
+  task.consecutiveTimeouts = 0;
+  coordMessage17(state, task.taskId, 'dependency-wakeup', { waitId: wait.waitId, ...wait.wakeup }, wait.waitId);
+}
+export function scanWaits17(state) {
+  const now = Date.now();
+  for (const wait of state.waits.filter(value => value.status === 'waiting')) {
+    const task = state.tasks.find(value => value.taskId === wait.taskId), event = state.events.find(value => match(wait, value));
+    const terminal = state.events.find(value => value.taskId === wait.request.waitFor.taskId
+      && ['task-failed', 'lease-expired'].includes(value.type));
+    if (event || terminal) { arrive(state, task, wait, event ?? terminal); continue; }
+    if (Date.parse(wait.deadlineAt) > now) continue;
+    task.consecutiveTimeouts = (task.consecutiveTimeouts ?? 0) + 1;
+    const human = wait.request.onTimeout === 'escalate-need-human' || task.consecutiveTimeouts >= 2;
+    wait.status = human ? 'need-human' : 'timed-out';
+    coordMessage17(state, task.taskId, 'dependency-timeout', { waitId: wait.waitId, consecutive: task.consecutiveTimeouts }, wait.waitId);
+    if (human) wait.decisionId = requestDecision17(state, task, 'dependency-timeout', wait.waitId, wait.request.refetchPaths).decisionId;
+  }
+  return state.waits;
+}
+export function cancelWait17(state, task, waitId) {
+  const wait = state.waits.find(value => value.waitId === waitId && value.taskId === task.taskId);
+  if (!wait) coordFail17('ENTROROVE_COORD_WAIT_BINDING', 'cancel must name this original task wait');
+  if (wait.status === 'need-human') coordFail17('ENTROROVE_COORD_HUMAN_REQUIRED', 'cancellation cannot bypass an unresolved real human decision');
+  if (wait.status === 'waiting') {
+    wait.status = 'cancelled'; coordEvent17(state, 'wait-cancelled', task.taskId, waitId, { waitId }, waitId);
+  }
+  return wait;
+}
+export function scanQueues17(state) {
+  const now = Date.now(), decisions = [];
+  for (const queue of state.lockQueues.filter(value => value.status === 'waiting')) {
+    if (!Number.isFinite(Date.parse(queue.deadlineAt))) coordFail17('ENTROROVE_COORD_QUEUE_DEADLINE', 'queue cannot borrow an ETA or lock TTL');
+    if (Date.parse(queue.deadlineAt) > now) continue;
+    queue.status = 'timed-out';
+    const task = state.tasks.find(value => value.taskId === queue.taskId);
+    coordMessage17(state, task.taskId, 'lock-denied', { queueId: queue.queueId, resource: queue.request.resource }, queue.queueId);
+    decisions.push(requestDecision17(state, task, 'lock-queue-timeout', queue.queueId, queue.request.paths));
+  }
+  return decisions;
+}
+export function coordinationBlocked17(state, task, paths = []) {
+  const waits = state.waits.filter(value => value.taskId === task.taskId && ACTIVE.includes(value.status));
+  const decisions = state.decisions.filter(value => value.taskId === task.taskId && value.status === 'need-human');
+  const peers = state.intents.filter(value => value.taskId === task.taskId && ['waiting', 'partial'].includes(value.status)
+    && (!paths.length || paths.some(target => value.blockedPaths.includes(target))));
+  return { blocked: waits.length > 0 || decisions.length > 0 || peers.length > 0,
+    waitIds: waits.map(value => value.waitId), decisionIds: decisions.map(value => value.decisionId),
+    intentIds: peers.map(value => value.intentId), writeAuthorized: false };
+}

package/local-calctool-cli.mjs

@@ -2,6 +2,7 @@ import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runCalctoolLocal } from './local-calctool.mjs';
 import { CALCTOOL_LOCAL_OPERATION_SCHEMAS } from './local-calctool-contracts.mjs';
+import { localErrorEnvelope } from './local-error.mjs';
 
 export async function runCalctoolCli(args = process.argv.slice(2)) {
   let source = ''; for await (const chunk of process.stdin) source += chunk;
@@ -17,6 +18,7 @@ if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.ur
     const result = await runCalctoolCli(); process.stdout.write(JSON.stringify(result) + '\n');
     if (['blocked', 'failed', 'incomplete'].includes(result.status)) process.exitCode = 2;
   } catch (cause) {
-    process.stderr.write(JSON.stringify({ status: 'blocked', code: cause.code ?? 'CALCTOOL_INPUT_INVALID', message: cause.message }) + '\n'); process.exitCode = 2;
+    const error = localErrorEnvelope(cause, 'CALCTOOL_INPUT_INVALID');
+    process.stderr.write(`${JSON.stringify(error)}\n`); process.exitCode = error.status === 'blocked' ? 2 : 1;
   }
 }

package/local-calctool-composition17.mjs

@@ -0,0 +1,50 @@
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { runCalctoolLocal } from './local-calctool.mjs';
+import { verifyFormulaProgram } from './local-formula-engine.mjs';
+import { runWorkflowLocalStep } from './workflow-local-runner.mjs';
+
+const sha = bytes => createHash('sha256').update(bytes).digest('hex');
+function fail(message) { throw Object.assign(new Error(message), { code: 'ENTROROVE_CALCTOOL_COMPOSITION' }); }
+export async function compileCalctoolArtifacts17(program) {
+  verifyFormulaProgram(program);
+  const root = await fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), 'entrorove-calctool17-control-')));
+  try {
+    const repositoryRoot = path.join(root, 'repository'); const home = path.join(root, 'home');
+    await fs.mkdir(repositoryRoot, { mode: 0o700 }); await fs.mkdir(home, { mode: 0o700 });
+    const output = await runCalctoolLocal('generate', { repositoryRoot, home, program });
+    const files = await Promise.all(output.files.map(async entry => {
+      const bytes = await fs.readFile(path.join(output.directory, entry.path));
+      if (sha(bytes) !== entry.sha256) fail('Native generated Calctool bytes changed');
+      return { path: entry.path, sha256: entry.sha256 };
+    }));
+    if (files.map(file => file.path).sort().join('|') !== 'program.json|runtime.mjs|tool.mjs') fail('Native Calctool triplet is incomplete');
+    return files.sort((a, b) => a.path.localeCompare(b.path));
+  } finally { await fs.rm(root, { recursive: true, force: true }); }
+}
+export function assertCalctoolStep17(composition, step) {
+  verifyFormulaProgram(composition.program, composition);
+  if (composition.schemaVersion !== 'entrorove.calctool-composition/1.0' || !Array.isArray(composition.files)
+    || composition.files.length !== 3) fail('Original Calctool composition is required');
+  for (const file of composition.files) if (!step.executionPlan.files.some(entry => entry.path === file.path && entry.sha256 === file.sha256)) {
+    fail('Calctool generated bytes must be in the original frozen execution manifest');
+  }
+  const tool = composition.files.find(file => file.path.endsWith('/tool.mjs'));
+  if (!tool || JSON.stringify(step.executionPlan.policy.args) !== JSON.stringify([tool.path, '--verify'])
+    || !step.executionPlan.tests.some(test => test.path === tool.path)) fail('Calctool step must execute its original Decimal sample verifier');
+}
+export async function runCalctoolCompositionStep17(input) {
+  const { composition, ...managed } = input;
+  const native = await compileCalctoolArtifacts17(composition.program);
+  const expected = native.map(file => ({ ...file, path: `${composition.directory}/${file.path}` }));
+  if (JSON.stringify(expected) !== JSON.stringify(composition.files)) fail('Composition differs from actual native Calctool generation');
+  const step = managed.acceptedPlan?.steps.find(item => item.stepId === managed.stepId);
+  if (!step || managed.acceptedPlan.flowId !== composition.flowId || managed.acceptedPlan.ownerId !== composition.ownerId
+    || managed.acceptedPlan.taskDigest !== composition.taskDigest || managed.acceptedPlan.chainDigest !== composition.chainDigest) {
+    fail('Calctool composition must preserve its original accepted task and chain');
+  }
+  assertCalctoolStep17(composition, step);
+  return runWorkflowLocalStep(managed);
+}

package/local-calctool-runtime.mjs

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 const runtimeUrl = new URL('./runtime/calctool-runtime-v7.0.43.mjs', import.meta.url);
-const expectedSha256 = '5d3506320d6baba4a8ca42cf55d062ae2b10f186741896c8cc93e536734f961f';
+const expectedSha256 = '5473427c350411f62c16ac5239fa0db7b96e7b2c19458f9046768dcb4ada87d1';
 export async function calctoolRuntimeBytes() {
   const bytes = await readFile(runtimeUrl);
   if (createHash('sha256').update(bytes).digest('hex') !== expectedSha256) throw Object.assign(new Error('Calctool packaged runtime digest mismatch'), { code: 'FORMULA_RUNTIME_INTEGRITY' });

package/local-calctool.mjs

@@ -45,7 +45,7 @@ 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; }
+catch (error) { const code=error.code??'FORMULA_INPUT_INVALID'; const status=/(?:AUTHORITY_REQUIRED|LEASE_EXPIRED|NOT_ACCEPTED|REVOKED)$/.test(code)?'blocked':'failed'; process.stderr.write(JSON.stringify({schemaVersion:'entrorove.local-error/1.0',status,code,message:error instanceof SyntaxError?'Formula input or artifact must be valid JSON':error.message})+'\\n'); process.exitCode=status==='blocked'?2:1; }
 `;
 async function store(input, generate) {
   const program = await programFrom(input);

package/local-chain-bindings.mjs

@@ -0,0 +1,93 @@
+import { createHash } from 'node:crypto';
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { validateLocalInput } from './local-contracts.mjs';
+import { observeWorkflowLocalStep } from './workflow-local-runner.mjs';
+import { validateLocalChainPlan } from './local-chain-plan.mjs';
+
+export const CHAIN_PACKAGE_ROOT = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = await fs.realpath(CHAIN_PACKAGE_ROOT);
+const SKILLS = ['aimlock', 'archguard', 'blueprint', 'calctool', 'confirm-protocol', 'mergeguard', 'swarm', 'validator'];
+export function chainFail(code, message) { throw Object.assign(new Error(message), { code }); }
+export function chainCanonical(value) {
+  if (Array.isArray(value)) return `[${value.map(chainCanonical).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${chainCanonical(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}
+export const chainSha = value => createHash('sha256').update(value).digest('hex');
+export function chainExact(value, required, optional = []) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || required.some(key => !Object.hasOwn(value, key))
+    || Object.keys(value).some(key => !required.includes(key) && !optional.includes(key))) {
+    chainFail('ENTROROVE_CHAIN_FIELDS', 'chain input has missing or unknown fields');
+  }
+}
+export async function chainControlFile(file, maximum = 8 * 1024 * 1024) {
+  const descriptor = await fs.open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const before = await descriptor.stat();
+    if (!before.isFile() || before.nlink !== 1 || before.size > maximum
+      || (typeof process.getuid === 'function' && before.uid !== process.getuid())) {
+      chainFail('ENTROROVE_CHAIN_CONTROL_INVALID', 'chain control must be a bounded owned regular file');
+    }
+    const bytes = await descriptor.readFile(), after = await descriptor.stat(), current = await fs.lstat(file);
+    if (bytes.length !== before.size || before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size
+      || before.mtimeMs !== after.mtimeMs || current.isSymbolicLink() || current.dev !== before.dev || current.ino !== before.ino) {
+      chainFail('ENTROROVE_CHAIN_CONTROL_CHANGED', 'chain control changed during its actual read');
+    }
+    return { bytes, stat: after };
+  } finally { await descriptor.close(); }
+}
+async function sourceNames() {
+  const rootNames = (await fs.readdir(ROOT)).filter(name => name.endsWith('.mjs'));
+  const runtimeNames = (await fs.readdir(path.join(ROOT, 'runtime'))).filter(name => name.endsWith('.mjs')).map(name => `runtime/${name}`);
+  return [...rootNames, ...runtimeNames, 'package.json', 'manifest.json'].sort();
+}
+export async function captureChainPackage(plan) {
+  for (const skill of plan.skills) {
+    if (!SKILLS.includes(skill.skillId) || await fs.realpath(skill.packageRoot) !== ROOT) {
+      chainFail('ENTROROVE_CHAIN_SKILL_PACKAGE', 'native chain skills must use the current fixed Entrorove package');
+    }
+  }
+  const files = [];
+  for (const name of await sourceNames()) files.push({ path: name, sha256: chainSha((await chainControlFile(path.join(ROOT, name))).bytes) });
+  const metadata = JSON.parse((await chainControlFile(path.join(ROOT, 'package.json'))).bytes.toString('utf8'));
+  if (metadata.name !== '@entrorove/skill') chainFail('ENTROROVE_CHAIN_SKILL_PACKAGE', 'installed native package identity is invalid');
+  return { packageRoot: ROOT, name: metadata.name, version: metadata.version, files,
+    authorityKeyDigest: chainSha(process.env.ENTROROVE_WORKFLOW_PLAN_PUBLIC_KEY ?? '') };
+}
+export async function checkChainPackage(snapshot) {
+  const current = await captureChainPackage(snapshot.plan);
+  if (chainCanonical(current) !== chainCanonical(snapshot.package)) chainFail('ENTROROVE_CHAIN_PACKAGE_CHANGED', 'installed source, metadata or authority changed after chain initialization');
+}
+export async function validateChainBindings(planValue, values, identity) {
+  const plan = validateLocalChainPlan(planValue);
+  if (!Array.isArray(values)) chainFail('ENTROROVE_CHAIN_BINDING', 'command bindings must be an explicit array');
+  const commands = plan.steps.filter(step => step.kind === 'command'), bindings = [];
+  if (values.length !== commands.length) chainFail('ENTROROVE_CHAIN_BINDING', 'every command requires exactly one original signed workflow mapping');
+  for (const step of commands) {
+    const selected = values.filter(value => value.stepId === step.stepId);
+    if (selected.length !== 1) chainFail('ENTROROVE_CHAIN_BINDING', 'command mapping must have a unique original step ID');
+    chainExact(selected[0], ['stepId', 'workflowInput']);
+    const input = validateLocalInput('workflow-run-step', structuredClone(selected[0].workflowInput));
+    const native = input.acceptedPlan.steps.find(value => value.stepId === input.stepId);
+    if (input.repositoryRoot !== identity.repositoryRoot || input.home !== identity.home || input.stepId !== step.stepId
+      || input.acceptedPlan.flowId !== identity.flowId || input.acceptedPlan.ownerId !== identity.ownerId
+      || input.lease.stepId !== step.stepId || !native || chainCanonical(native.dependsOn) !== chainCanonical(step.dependsOn)) {
+      chainFail('ENTROROVE_CHAIN_BINDING', 'command mapping changed its original home, repository, flow, owner or step dependencies');
+    }
+    const policy = native.executionPlan.policy;
+    if (chainCanonical([step.input.executable, step.input.args, step.input.environment, step.input.timeoutMs, step.input.evidenceKind])
+      !== chainCanonical([policy.executable, policy.args, policy.environment, policy.timeoutMs, native.executionPlan.evidencePolicy?.kind ?? 'test'])) {
+      chainFail('ENTROROVE_CHAIN_BINDING', 'command policy differs from its actual frozen workflow plan');
+    }
+    if (path.resolve(identity.repositoryRoot, step.input.workingDirectory) !== identity.repositoryRoot) {
+      chainFail('ENTROROVE_CHAIN_COMMAND_CWD_UNSUPPORTED', 'the fixed native workflow runner currently executes only at its original repository root');
+    }
+    // This real observer verifies the configured Ed25519 plan and lease without
+    // starting a process or inventing an execution authority.
+    await observeWorkflowLocalStep(input);
+    bindings.push({ stepId: step.stepId, workflowInput: input });
+  }
+  return bindings;
+}