@entrorove/skill 0.1.23 → 0.1.25

package/local-swarm.mjs

@@ -0,0 +1,179 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { readSwarmCloudAuthority, verifyStoredSwarmGrant } from './local-swarm-authority.mjs';
+import { appendSwarmWorker, reportSwarmWorker, validateSwarmState } from './local-swarm-state.mjs';
+import { readSwarmOwnership, readSwarmJson, swarmOwnershipRecord, swarmStorage, validateSwarmOwnership, writeSwarmJson } from './local-swarm-storage.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { withTaskHandoffIssueFence, withTaskHandoffReadFence } from './local-task-handoff-fence.mjs';
+import { captureSwarmCompletion, captureSwarmOwnershipCompletions, revalidateSwarmCompletion } from './local-swarm-completion.mjs';
+import { claimSwarmWriteIntent, closeSwarmWriteIntent, readSwarmCheckpointRequests,
+  registerSwarmWriteIntent, validateSwarmWriteIntents } from './local-swarm-priority.mjs';
+
+function fail(code, message, details = {}) { throw Object.assign(new Error(message), { code, ...details }); }
+function freshState(authority) {
+  return { schemaVersion: 'entrorove.coordination/1.0', flowId: authority.plan.flowId,
+    repositoryDigest: authority.repositoryDigest, maxWorkers: 0, workers: [], leases: [], events: [], delegationGrants: [] };
+}
+function registration(state, authority, input) {
+  const grants = state.delegationGrants;
+  if (!Array.isArray(grants) || grants.length > 50) fail('ENTROROVE_SWARM_STATE_INVALID', 'registered delegation grants are missing or exceed the worker bound');
+  const ids = new Set();
+  for (const value of grants) {
+    const grant = verifyStoredSwarmGrant(value, true);
+    if (grant.flowId !== authority.plan.flowId || grant.localRepositoryDigest !== authority.repositoryDigest || ids.has(grant.workerId)) {
+      fail('ENTROROVE_SWARM_STATE_INVALID', 'registered grant changed its worker or original flow binding');
+    }
+    ids.add(grant.workerId);
+  }
+  const existing = grants.find(value => value.workerId === authority.grant.workerId);
+  if (existing && canonical(existing) !== canonical(input.delegationGrant)) fail('ENTROROVE_SWARM_WORKER_DUPLICATE', 'workerId is frozen to its original exact grant');
+  const updated = existing ? grants : [...grants, input.delegationGrant];
+  const authorized = updated.filter(value => Date.parse(value.expiresAt) > Date.now()).length;
+  if (authorized > 50 || (input.workerCount !== undefined && (!Number.isSafeInteger(input.workerCount)
+    || input.workerCount < 0 || input.workerCount > 50))) fail('ENTROROVE_SWARM_WORKER_LIMIT', 'caller workerCount must be a bounded conservative limit');
+  const retainedActive = state.workers.filter(value => value.status === 'active').length;
+  return { ...state, maxWorkers: Math.max(retainedActive, Math.min(authorized, input.workerCount ?? 50)), delegationGrants: updated };
+}
+function validateStoredWorkers(state, authority) {
+  validateSwarmState(state, { flowId: authority.plan.flowId, repositoryDigest: authority.repositoryDigest });
+  for (const worker of state.workers) {
+    const grant = verifyStoredSwarmGrant(worker.delegationGrant, true);
+    if (worker.grantDigest !== sha256(canonical(worker.delegationGrant)) || grant.flowId !== state.flowId
+      || grant.localRepositoryDigest !== state.repositoryDigest || grant.workerId !== worker.workerId || grant.leaseId !== worker.leaseId
+      || grant.priority !== worker.priority || canonical(grant.paths) !== canonical(worker.paths) || grant.expiresAt !== worker.expiresAt) {
+      fail('ENTROROVE_SWARM_STATE_INVALID', 'worker metadata differs from its actual signed delegation grant');
+    }
+  }
+  return state;
+}
+function workerRecord(authority, input) {
+  return { workerId: authority.grant.workerId, leaseId: authority.lease.leaseId, flowId: authority.plan.flowId,
+    handoffEpoch: authority.epoch, paths: authority.paths, priority: authority.grant.priority, status: 'active',
+    createdAt: new Date().toISOString(), expiresAt: authority.grant.expiresAt,
+    grantDigest: sha256(canonical(input.delegationGrant)), delegationGrant: input.delegationGrant };
+}
+function exactWorker(state, authority, input) {
+  const worker = state.workers.find(value => value.workerId === authority.grant.workerId && value.leaseId === authority.lease.leaseId);
+  if (!worker || (input.leaseId !== undefined && input.leaseId !== worker.leaseId)
+    || worker.grantDigest !== sha256(canonical(input.delegationGrant)) || worker.handoffEpoch !== authority.epoch) {
+    fail('ENTROROVE_SWARM_LEASE_INVALID', 'caller does not hold the original exact worker/cloud lease');
+  }
+  return worker;
+}
+async function completionIdle(authority, input, fence, proof) {
+  if (fence.activities.some(value => value.leaseId === authority.lease.leaseId)) fail('ENTROROVE_SWARM_EXECUTION_ACTIVE', 'actual in-flight execution must reach its original completed checkpoint');
+  for (const target of authority.paths) {
+    const lock = path.join(authority.home, '.entrorove', 'write-locks', authority.repositoryDigest, `${sha256(target)}.lock`);
+    try { await fs.lstat(lock); fail('ENTROROVE_SWARM_EXECUTION_ACTIVE', 'an actual target write lock prevents peer completion'); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  const result = await revalidateSwarmCompletion(proof, authority, input);
+  if (!result || !['reported', 'failed'].includes(result.status)) fail('ENTROROVE_SWARM_EXECUTION_UNKNOWN', 'actual original workflow result is not completed');
+  if (!result.receipt || !Number.isInteger(result.process?.exitCode)) fail('ENTROROVE_SWARM_EXECUTION_UNKNOWN', 'interrupted unsigned outcome cannot release the original signed reservation');
+  const started = Date.parse(result.process?.startedAt), finished = Date.parse(result.process?.finishedAt);
+  if (!Number.isFinite(started) || !Number.isFinite(finished) || started < Date.parse(authority.lease.issuedAt)
+    || started < Date.parse(authority.grant.issuedAt) || started >= Date.parse(authority.grant.expiresAt)
+    || finished < started || finished > Date.parse(authority.lease.expiresAt)) fail('ENTROROVE_SWARM_EXECUTION_UNKNOWN', 'completed process started outside its actual grant or exceeded the original cloud lease');
+  return result;
+}
+async function observeCoordination(input) {
+  const original = await readSwarmCloudAuthority(input, 'verify'), storage = await swarmStorage(original, 'read');
+  return withStateLock(storage.ownershipFile, () => withStateLock(storage.stateFile, async () => {
+    const authority = await readSwarmCloudAuthority(input, 'verify');
+    const ownership = await validateSwarmOwnership(await readSwarmOwnership(storage, authority, 'read'), authority);
+    const state = validateStoredWorkers(await readSwarmJson(storage.stateFile, null), authority);
+    const worker = exactWorker(state, authority, input);
+    const reservation = ownership.records.find(value => value.flowId === authority.plan.flowId
+      && value.workerId === worker.workerId && value.leaseId === worker.leaseId);
+    if (worker.status !== 'active' || !reservation || reservation.grantDigest !== worker.grantDigest) {
+      fail('ENTROROVE_SWARM_LEASE_INVALID', 'actual worker lease is inactive or unreserved');
+    }
+    const checkpointRequests = await readSwarmCheckpointRequests(ownership, authority, input);
+    await readSwarmCloudAuthority(input, 'verify');
+    return { schemaVersion: 'entrorove.local-execution/1.0', verified: true, workerId: worker.workerId,
+      leaseId: worker.leaseId, paths: worker.paths, expiresAt: worker.expiresAt,
+      grantDigest: worker.grantDigest, executionStatus: 'running', checkpointRequests };
+  }));
+}
+async function operate(rawInput, operation) {
+  let input; try { input = structuredClone(rawInput); } catch { fail('ENTROROVE_SWARM_AUTHORITY_INVALID', 'peer input must be finite JSON data'); }
+  if (operation === 'verify') return observeCoordination(input);
+  const purpose = operation === 'complete' ? 'report' : 'issue';
+  const original = await readSwarmCloudAuthority(input, purpose);
+  const storage = await swarmStorage(original);
+  const beforeOwnership = await readSwarmJson(storage.ownershipFile, null);
+  const completionProofs = await captureSwarmOwnershipCompletions(beforeOwnership, original.root);
+  const completionProof = purpose === 'report' ? await captureSwarmCompletion(input) : null;
+  const fenceInput = { repositoryRoot: original.root, home: original.home, flowId: original.plan.flowId,
+    epoch: original.epoch, leaseId: original.lease.leaseId, paths: original.paths };
+  const hold = purpose === 'issue' ? withTaskHandoffIssueFence : withTaskHandoffReadFence;
+  return hold(fenceInput, async fence => {
+    const authority = await readSwarmCloudAuthority(input, purpose);
+    if (fence.epoch !== authority.epoch) fail('ENTROROVE_SWARM_LEASE_INVALID', 'worker grant epoch changed while acquiring its original fence');
+    return withStateLock(storage.ownershipFile, () => withStateLock(storage.stateFile, async () => {
+      await readSwarmCloudAuthority(input, purpose);
+      const checkedOwnership = await validateSwarmOwnership(await readSwarmOwnership(storage, authority), authority, completionProofs);
+      const ownership = await validateSwarmWriteIntents(checkedOwnership, authority, completionProofs);
+      const state = validateStoredWorkers(await readSwarmJson(storage.stateFile, freshState(authority)), authority);
+      if (operation === 'coordinate') {
+        if (input.priority !== undefined && input.priority !== authority.grant.priority) fail('ENTROROVE_SWARM_PRIORITY_INVALID', 'caller priority cannot replace the signed assignment priority');
+        const updated = registration(state, authority, input);
+        const queued = await registerSwarmWriteIntent(ownership, authority, input, completionProofs);
+        await writeSwarmJson(storage.ownershipFile, queued.index);
+        await writeSwarmJson(storage.stateFile, { ...updated, events: [...updated.events, { event: 'peer-coordinate', workerId: authority.grant.workerId, at: new Date().toISOString() }] });
+        return { schemaVersion: 'entrorove.local-execution/1.0', status: 'reported', maxWorkers: updated.maxWorkers,
+          workerId: authority.grant.workerId, priority: authority.grant.priority,
+          grantDigest: sha256(canonical(input.delegationGrant)), intentId: queued.intent.intentId, intentSequence: queued.intent.sequence };
+      }
+      if (operation === 'spawn') {
+        if (input.parentWorkerId !== undefined && input.parentWorkerId !== null) fail('ENTROROVE_RECURSION_FORBIDDEN', 'a derived worker cannot spawn another worker');
+        if (input.priority !== undefined && input.priority !== authority.grant.priority) fail('ENTROROVE_SWARM_PRIORITY_INVALID', 'caller priority cannot replace the signed assignment priority');
+        if (!state.delegationGrants?.some(value => canonical(value) === canonical(input.delegationGrant))) fail('ENTROROVE_SWARM_CLOUD_AUTHORITY_REQUIRED', 'the exact cloud assignment must be coordinated first');
+        if (state.workers.some(value => value.workerId === authority.grant.workerId)) fail('ENTROROVE_SWARM_WORKER_DUPLICATE', 'workerId is already bound and cannot be reused');
+        if (state.leases.some(value => value.leaseId === authority.lease.leaseId)) fail('ENTROROVE_SWARM_LEASE_INVALID', 'leaseId is already bound');
+        const decision = await claimSwarmWriteIntent(ownership, authority, input, completionProofs);
+        await writeSwarmJson(storage.ownershipFile, decision.index);
+        if (!decision.mayAcquire) {
+          const active = decision.blockedBy.some(value => value.kind === 'active');
+          const unknown = decision.blockedBy.some(value => value.reconcileRequired);
+          fail(unknown ? 'ENTROROVE_SWARM_RECONCILE_REQUIRED' : active ? 'ENTROROVE_SWARM_PATH_CONFLICT' : 'ENTROROVE_SWARM_PRIORITY_WAIT',
+            unknown ? 'original execution outcome is unknown; reconcile before releasing its paths' : 'the original signed worker must wait for its overlapping path turn',
+            { status: 'waiting', intentId: decision.intentId, readyPaths: decision.readyPaths, blockedPaths: decision.blockedPaths,
+              blockedBy: decision.blockedBy, safeCheckpointRequested: decision.safeCheckpointRequested, freshAimlockSnapshotRequired: true });
+        }
+        const record = swarmOwnershipRecord(authority, input);
+        const updated = appendSwarmWorker(state, workerRecord(authority, input));
+        const reserved = await validateSwarmWriteIntents({ ...decision.index, records: [...decision.index.records, record] }, authority, completionProofs);
+        // Reserve first: an interrupted publication can only retain an extra
+        // conservative reservation, never publish an unreserved active worker.
+        await writeSwarmJson(storage.ownershipFile, reserved);
+        await writeSwarmJson(storage.stateFile, updated);
+        return { schemaVersion: 'entrorove.local-execution/1.0', status: 'running', workerId: authority.grant.workerId,
+          leaseId: authority.lease.leaseId, paths: authority.paths, expiresAt: authority.grant.expiresAt,
+          delegationGrant: input.delegationGrant, grantDigest: record.grantDigest };
+      }
+      const worker = exactWorker(state, authority, input);
+      const reservation = ownership.records.find(value => value.flowId === authority.plan.flowId && value.workerId === worker.workerId && value.leaseId === worker.leaseId);
+      const actual = await completionIdle(authority, input, fence, completionProof);
+      const outcome = actual.status === 'reported' ? 'completed' : 'failed';
+      if (input.status !== undefined && input.status !== outcome) fail('ENTROROVE_SWARM_REPORT_INVALID', 'caller report conflicts with its actual signed process result');
+      const closed = await closeSwarmWriteIntent(ownership, authority, input, completionProof, completionProofs);
+      if (worker.status !== 'active') {
+        if (worker.outcome !== outcome || !['reported', 'failed', 'blocked'].includes(worker.status)) fail('ENTROROVE_SWARM_REPORT_INVALID', 'completion replay changed its original reported outcome');
+        await writeSwarmJson(storage.ownershipFile, { ...closed, records: closed.records.filter(value => value !== reservation) });
+        return { schemaVersion: 'entrorove.local-execution/1.0', status: worker.status, trafficLight: worker.status === 'reported' ? 'yellow' : 'red', workerId: worker.workerId, leaseId: worker.leaseId };
+      }
+      const reported = reportSwarmWorker(state, { workerId: worker.workerId, leaseId: worker.leaseId, outcome }, true);
+      // Close the worker first; a crash before index cleanup cannot leave a
+      // live old worker after the same paths have been reassigned.
+      await writeSwarmJson(storage.stateFile, reported.state);
+      await writeSwarmJson(storage.ownershipFile, { ...closed, records: closed.records.filter(value => value !== reservation) });
+      return { schemaVersion: 'entrorove.local-execution/1.0', ...reported.result };
+    }));
+  });
+}
+export async function peerCoordinate(input) { return operate(input, 'coordinate'); }
+export async function spawnBind(input) { return operate(input, 'spawn'); }
+export async function completePeer(input) { return operate(input, 'complete'); }
+export async function verifyCoordinationLease(input) { return operate(input, 'verify'); }

package/local-task-handoff-completion-wire.mjs

@@ -0,0 +1,71 @@
+import { createPublicKey, verify } from 'node:crypto';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { canonicalHandoffSignature, overlayAuthority, receiverClaim } from './local-task-handoff-overlay-wire.mjs';
+import { verifyWriteReceipt } from './local-task-handoff-write-wire.mjs';
+
+const ORIGINAL = ['challengeId', 'handoffId', 'messageRequestId', 'taskId', 'flowId', 'ownerId', 'taskDigest', 'chainDigest',
+  'checkpointReceiptId', 'checkpointDigest', 'originalScopeDigest', 'localRepositoryDigest', 'epoch', 'previousOwnerEpoch',
+  'paths', 'passId', 'passDigest', 'leaseId', 'leaseDigest', 'generation', 'scopeContractDigest',
+  'sourceReleaseReceiptDigest', 'claimReceiptDigest'];
+export const HANDOFF_COMPLETION_FIELDS = ['schemaVersion', ...ORIGINAL, 'runnerKeyId', 'issuedAt', 'expiresAt'];
+const RECEIPT_FIELDS = ['schemaVersion', 'receiptId', 'purpose', 'status', ...ORIGINAL, 'challengeDigest', 'files',
+  'scopeFingerprintDigest', 'workflowStateDigest', 'revokedPassIds', 'revokedLeaseIds', 'keyId', 'nonce', 'issuedAt', 'expiresAt', 'signature'];
+const WRITE_FIELDS = ['architectureAuthorityDigest', 'writeCheckpointReceipts', 'writeCheckpointReceiptsDigest'];
+function fail(message) { const error = new Error(message); error.code = 'ENTROROVE_HANDOFF_COMPLETION'; throw error; }
+export function completionChallenge(value, claim, ctx, live = true) {
+  const payload = overlayAuthority(value, HANDOFF_COMPLETION_FIELDS, 'entrorove.task-handoff-completion-challenge/1.0', live);
+  const { pass, lease, challenge } = receiverClaim(claim, ctx, false);
+  if (['handoffId', 'messageRequestId', 'ownerId', 'flowId', 'taskDigest', 'chainDigest', 'runnerKeyId', 'localRepositoryDigest', 'scopeContractDigest'].some(key => payload[key] !== pass[key])
+    || payload.taskId !== pass.receiverTaskId || payload.originalScopeDigest !== pass.receiverOriginalScopeDigest
+    || payload.epoch !== pass.receiverEpoch || payload.previousOwnerEpoch !== pass.epoch || payload.passId !== pass.passId
+    || payload.passDigest !== sha256(canonical(claim.pass)) || payload.leaseId !== lease.leaseId
+    || payload.leaseDigest !== sha256(canonical(claim.lease)) || payload.generation !== lease.generation
+    || payload.sourceReleaseReceiptDigest !== challenge.baselineReceiptDigest
+    || canonical(payload.paths) !== canonical(pass.paths)) fail('completion challenge is outside its actual receiver takeover, scope or grant binding');
+  return payload;
+}
+export function completionReceipt(bundle, claim, ctx, live = false) {
+  const challenge = completionChallenge(bundle?.challenge, claim, ctx, live), receipt = bundle?.receipt;
+  const present = WRITE_FIELDS.filter(field => Object.hasOwn(receipt ?? {}, field));
+  if (present.length !== 3 && (present.length || live)) fail('live completion requires the full original trusted write receipt batch; legacy evidence is history only');
+  if (!receipt || Object.keys(receipt).sort().join('\0') !== [...RECEIPT_FIELDS, ...present].sort().join('\0')) fail('completion idle receipt fields are invalid');
+  if (present.length) {
+    const authority = claim.pass.architectureAuthority;
+    if (receipt.architectureAuthorityDigest !== (authority ? sha256(canonical(authority)) : null)
+      || !Array.isArray(receipt.writeCheckpointReceipts) || receipt.writeCheckpointReceipts.length > 4096
+      || Buffer.byteLength(canonical(receipt.writeCheckpointReceipts)) > 768_000
+      || receipt.writeCheckpointReceiptsDigest !== sha256(canonical(receipt.writeCheckpointReceipts))) fail('completion changed its original authority or complete write receipt batch');
+    for (const item of receipt.writeCheckpointReceipts) verifyWriteReceipt(item, claim, ctx);
+  }
+  if (receipt.schemaVersion !== 'entrorove.task-handoff-completion-idle-receipt/1.0' || receipt.purpose !== 'completion' || receipt.status !== 'paused'
+    || receipt.challengeDigest !== sha256(canonical(challenge)) || ORIGINAL.some(key => canonical(receipt[key]) !== canonical(challenge[key]))
+    || !Array.isArray(receipt.files) || !receipt.files.length || receipt.files.length > 512
+    || canonical(receipt.files.map(file => file.path)) !== canonical(challenge.paths) || receipt.scopeFingerprintDigest !== sha256(canonical(receipt.files))
+    || !Array.isArray(receipt.revokedPassIds) || !receipt.revokedPassIds.includes(challenge.passId)
+    || !Array.isArray(receipt.revokedLeaseIds) || !receipt.revokedLeaseIds.includes(challenge.leaseId)) fail('completion receipt lost its actual fingerprints and revoked takeover grants');
+  for (const file of receipt.files) {
+    const fields = ['path', 'sha256', 'bytes', 'lines', ...(Object.hasOwn(file, 'exists') ? ['exists'] : [])];
+    if (Object.keys(file).sort().join('\0') !== fields.sort().join('\0')
+      || !/^[0-9a-f]{64}$/.test(file.sha256) || !Number.isSafeInteger(file.bytes) || file.bytes < 0
+      || !Number.isSafeInteger(file.lines) || file.lines < 0 || (Object.hasOwn(file, 'exists')
+        && (file.exists !== false || file.sha256 !== sha256('') || file.bytes !== 0 || file.lines !== 0))) fail('completion fingerprint fields are invalid');
+  }
+  const issued = Date.parse(receipt.issuedAt), expires = Date.parse(receipt.expiresAt);
+  if (!Number.isFinite(issued) || !Number.isFinite(expires) || issued < Date.parse(challenge.issuedAt) || issued > Date.now()
+    || expires <= issued || expires > Date.parse(challenge.expiresAt) || (live && expires <= Date.now())) fail('completion idle receipt lifetime is invalid');
+  let key, der; const encoded = process.env.ENTROROVE_TASK_HANDOFF_RUNNER_PUBLIC_KEY;
+  try { der = Buffer.from(encoded ?? '', 'base64'); key = createPublicKey({ key: der, format: 'der', type: 'spki' }); }
+  catch { fail('completion trusted runner identity is unavailable'); }
+  const { signature, ...core } = receipt;
+  if (key.asymmetricKeyType !== 'ed25519' || key.export({ format: 'der', type: 'spki' }).toString('base64') !== encoded
+    || receipt.keyId !== sha256(der) || receipt.keyId !== challenge.runnerKeyId
+    || !verify(null, Buffer.from(canonical(core)), key, canonicalHandoffSignature(signature))) fail('completion idle receipt requires its trusted receiver signature');
+  return receipt;
+}
+export function completionReceiptCore(challenge, data, keyId, ttlMs) {
+  const now = Date.now(), original = Object.fromEntries(ORIGINAL.map(field => [field, challenge[field]]));
+  return { schemaVersion: 'entrorove.task-handoff-completion-idle-receipt/1.0', receiptId: data.receiptId,
+    purpose: 'completion', status: 'paused', ...original, challengeDigest: sha256(canonical(challenge)), ...data,
+    keyId, nonce: data.nonce, issuedAt: new Date(now).toISOString(),
+    expiresAt: new Date(Math.min(now + ttlMs, Date.parse(challenge.expiresAt))).toISOString() };
+}

package/local-task-handoff-contracts.mjs

@@ -0,0 +1,66 @@
+import { object, ledgerIdentifier, sha256, integer, paths, nullable, relativePath } from './local-contract-types.mjs';
+import { archguardOperationSchemas } from './local-archguard-evaluate.mjs';
+export const HANDOFF_PASS_FIELDS = ['schemaVersion', 'passId', 'handoffId', 'messageRequestId', 'ownerId', 'previousOwnerTaskId',
+  'previousOwnerFlowId', 'receiverTaskId', 'flowId', 'taskDigest', 'chainDigest', 'runnerKeyId', 'localRepositoryDigest', 'epoch',
+  'receiverEpoch', 'previousOwnerScopeDigest', 'receiverOriginalScopeDigest', 'scopeContractDigest', 'architectureContractDigest', 'nativeOutputDigest',
+  'scopeSnapshotDigest', 'snapshotId', 'scopeFingerprintDigest', 'paths', 'receiptId', 'issuedAt', 'expiresAt', 'previousOwnerScopeContract', 'scopeContract', 'architectureAuthority'];
+export const HANDOFF_LEASE_FIELDS = ['schemaVersion', 'purpose', 'leaseId', 'handoffId', 'messageRequestId', 'ownerId', 'taskId', 'flowId',
+  'stepId', 'taskDigest', 'chainDigest', 'challengeId', 'runnerKeyId', 'localRepositoryDigest', 'epoch', 'receiverEpoch', 'paths', 'generation',
+  'mutationAllowed', 'passId', 'passDigest', 'claimReceiptId', 'issuedAt', 'expiresAt'];
+export const HANDOFF_CANDIDATE_FIELDS = ['schemaVersion', 'challengeId', 'handoffId', 'messageRequestId', 'flowId', 'stepId', 'ownerId',
+  'taskDigest', 'chainDigest', 'runnerId', 'runnerKeyId', 'repositoryId', 'localRepositoryDigest', 'previousOwnerTaskId', 'previousOwnerFlowId',
+  'previousOwnerTaskDigest', 'previousOwnerChainDigest', 'previousOwnerAcceptanceReceiptId', 'receiverTaskId', 'receiverAcceptanceReceiptId',
+  'sourceCheckpointDigest', 'receiverCheckpointDigest', 'originalScopeDigest', 'receiverOriginalScopeDigest', 'paths', 'epoch',
+  'receiverEpoch', 'baselineReceiptDigest', 'issuedAt', 'expiresAt', 'nonce'];
+
+const native = await archguardOperationSchemas();
+const exact = properties => object(properties, Object.keys(properties));
+const string = { type: 'string' }, boolean = { type: 'boolean' };
+const timestamp = { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$' };
+const uuid = { type: 'string', pattern: '^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$' };
+const scopePaths = { type: 'array', items: relativePath, maxItems: 512 };
+export const HANDOFF_SCOPE_CONTRACT_SCHEMA = exact({ schemaVersion: { const: 'aimlock.scope-contract/1.0' },
+  allowedPaths: { ...scopePaths, minItems: 1 }, forbiddenPaths: scopePaths,
+  maxChangedLines: integer(1, 1_000_000), allowNewFiles: boolean, allowDeleteFiles: boolean });
+const reason = { type: 'string', maxLength: 1024, pattern: '\\S' };
+const intent = { oneOf: [exact({ action: { const: 'update' }, expectedDigest: sha256, reason,
+  patch: { ...native['contract-update'].input.properties.patch, minProperties: 1 } }),
+  exact({ action: { const: 'resume' }, expectedDigest: sha256, reason })] };
+const interaction = exact({ schemaVersion: { const: 'confirm.interaction/1.0' }, requestId: ledgerIdentifier,
+  type: { const: 'confirm' }, risk: { const: 'high' }, question: string, default: { type: 'null' }, timeout: { type: 'null' },
+  rememberable: { const: false }, memoryKey: { const: '' }, riskDescription: string, timeoutAction: { const: 'wait' },
+  options: { type: 'array', minItems: 2, maxItems: 2, additionalItems: false, items: [
+    exact({ id: { const: 'approve' }, label: { const: 'Approve' } }), exact({ id: { const: 'reject' }, label: { const: 'Reject' } })] },
+  callback: exact({ operation: { enum: ['contract-update', 'resume'] }, payload: intent }) });
+const decision = exact({ interactionId: ledgerIdentifier, interaction, interactionDigest: sha256, intent, ledgerDigest: sha256,
+  status: { enum: ['pending', 'answered'] }, actorId: nullable(uuid), answer: nullable({ enum: ['approve', 'reject'] }),
+  answerRequestId: nullable(ledgerIdentifier), batchable: { const: false }, consumed: boolean, createdAt: timestamp,
+  answeredAt: nullable(timestamp) });
+export const HANDOFF_ARCHITECTURE_AUTHORITY_SCHEMA = exact({ flowId: ledgerIdentifier, ownerId: uuid, taskDigest: sha256,
+  chainDigest: sha256, scopeArtifactDigest: sha256, contract: native['contract-get'].input.properties.contract,
+  contractDigest: sha256, revision: integer(1), ledger: native['drift-status'].input.properties.ledger,
+  ledgerDigest: sha256, driftEpochStart: integer(0), driftStatus: { enum: ['green', 'yellow', 'red'] },
+  interrupted: boolean, decisions: { type: 'array', items: decision }, sequence: integer(1), headDigest: sha256 });
+const authorityReceipt = object({ schemaVersion: { const: 'entrorove.workflow-authority-receipt/1.0' },
+  keyId: sha256, payloadDigest: sha256, signature: { type: 'string', pattern: '^[A-Za-z0-9_-]{86}$' } },
+['schemaVersion', 'keyId', 'payloadDigest', 'signature']);
+function field(name) {
+  if (['previousOwnerScopeContract', 'scopeContract'].includes(name)) return HANDOFF_SCOPE_CONTRACT_SCHEMA;
+  if (name === 'architectureAuthority') return nullable(HANDOFF_ARCHITECTURE_AUTHORITY_SCHEMA);
+  if (name === 'localRepositoryDigest') return { type: 'string', pattern: '^[0-9a-f]{32}$' };
+  if (name === 'architectureContractDigest') return nullable(sha256);
+  if (name.endsWith('Digest') || name === 'runnerKeyId') return sha256;
+  if (name === 'paths') return { ...paths, maxItems: 512 };
+  if (['epoch', 'receiverEpoch', 'previousEpoch', 'generation'].includes(name)) return integer(0, 2147483647);
+  if (name === 'mutationAllowed') return { const: true };
+  if (name === 'purpose') return { const: 'takeover-write' };
+  if (['issuedAt', 'expiresAt'].includes(name)) return { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$' };
+  return ledgerIdentifier;
+}
+function signed(fields, schemaVersion) {
+  const properties = { ...Object.fromEntries(fields.map(name => [name, field(name)])), schemaVersion: { const: schemaVersion }, authorityReceipt };
+  return object(properties, Object.keys(properties));
+}
+export const HANDOFF_WRITE_PASS_SCHEMA = signed(HANDOFF_PASS_FIELDS, 'entrorove.task-handoff-write-pass/1.0');
+export const HANDOFF_PROVISIONAL_LEASE_SCHEMA = signed(HANDOFF_LEASE_FIELDS, 'entrorove.task-handoff-provisional-lease/1.0');
+export const HANDOFF_SNAPSHOT_CANDIDATE_SCHEMA = signed(HANDOFF_CANDIDATE_FIELDS, 'entrorove.task-handoff-scope-challenge/1.0');