reploid 0.0.0-stage → 0.1.0

package/packages/reploid/src/mesh/partitions/automatic-partitions.js

@@ -0,0 +1,298 @@
+import { partitionAdapterIdentities, samePartitionAdapters, selectPartitionContribution } from './partition-contract.js';
+import { publicPreparationProgress, createPreparationProgressObserver } from '../preparation-progress.js';
+import { generationRequest, requireGenerationCapability } from './partition-generation-request.js';
+import { createAutomaticOrderedPartitions } from './automatic-ordered-partitions.js';
+import { createPartitionDiscovery } from './partition-discovery.js';
+import { selectPartitionPlacement, selectPartitionExecution } from './partition-placement.js';
+import { createPartitionPeer } from './partition-peer.js';
+import { createPartitionEntry } from './partition-entry.js';
+import { createPartitionChat } from './partition-chat.js';
+import { createPartitionGrantAuthority } from './partition-grants.js';
+import { canonicalPartitionJson, assertPartition as assert } from './partition-contract.js';
+
+/** Automatic placement over authenticated discovery. Only the supplied host
+ * loader may open Doppler, and only after local contribution approval. */
+export function createAutomaticPartitions({ identity, meshId, models, policy, peers, createNetwork,
+  loadProgram, canonical = null, ordered = null, onChange = () => {} }) {
+  if (ordered !== null) {
+    assert(canonical === null, 'Ordered automatic participation is distinct from canonical publication');
+    return createAutomaticOrderedPartitions({ identity, meshId, models, policy, peers, createNetwork, loadProgram, ordered, onChange });
+  }
+  const config = structuredClone(policy), catalog = structuredClone(models);
+  for (const model of catalog) assert(model.partitionContributionIndexes === undefined
+    || Array.isArray(model.partitionContributionIndexes) && model.partitionContributionIndexes.length > 0
+      && model.partitionContributionIndexes.every(index => index === 0 || index === 1), 'Invalid eligible partition indexes');
+  assert(identity?.peerId && typeof peers === 'function' && typeof createNetwork === 'function'
+    && typeof loadProgram === 'function' && Number.isSafeInteger(config.pollMs) && config.pollMs > 0,
+  'Automatic partitions require identity, discovery, loader and explicit policy');
+  if (canonical !== null) {
+    assert(canonical && /^[a-f0-9]{32}$/.test(canonical.coordinatorEpoch)
+      && /^[a-f0-9]{32}$/.test(canonical.participantEpoch)
+      && ['metadataDigest', 'canonicalGenerationIdentity', 'validateResidentAttemptIdentity', 'tokenDigest']
+        .every(name => typeof canonical.runtime?.[name] === 'function'), 'Explicit canonical runtime and epochs required');
+    canonical = { runtime: canonical.runtime, coordinatorEpoch: canonical.coordinatorEpoch, participantEpoch: canonical.participantEpoch };
+  }
+  const listeners = new Set(), admissions = new Map();
+  const lifetime = new AbortController();
+  let offer = null, program = null, execution = null, chat = null, executionPeer = null, preparing = null;
+  let contributionController = null;
+  let phase = 'idle', error = null, progress = null, placement = null, closed = false, ticking = null;
+  let placementDecision = null, closing = null, stopping = null;
+  const unsettledOwners = new Set(), settledCloseOwners = new Set();
+  const authority = createPartitionGrantAuthority({ identity, meshId,
+    maxGrants: config.limits.maxAttempts, maxTtlMs: config.grantMs, maxClockSkewMs: config.grantClockSkewMs, canonicalRuntime: canonical?.runtime });
+  const getModels = () => discovery.getModels().filter(model => !!model.canonical === !!canonical
+    && model.partition?.schema !== 'reploid.partition-selection/v2');
+  const getState = () => ({ phase, error, progress: structuredClone(progress), offering: !!offer, modelId: offer?.id || null,
+    placement: structuredClone(placement), placementDecision: structuredClone(placementDecision),
+    capabilities: discovery.getSnapshot(), descriptor: program?.resident.getState().descriptor || null,
+    acquisition: program?.getReceipt?.() || null, models: getModels(),
+    reservations: program?.resident.getState().reservations || null, attempts: chat?.getState().attempts || [],
+    unsettledOwners: unsettledOwners.size });
+  const notify = () => { onChange(getState()); for (const listener of listeners) listener(getModels()); };
+  const service = {
+    getModels: () => chat?.getModels() || [],
+    async refresh(options) { await tick(); return chat?.refresh(options); },
+    generate: (request, controls) => {
+      assert(chat && offer && !closed, 'Partition input owner unavailable');
+      return chat.generate(request, controls);
+    }
+  };
+  const entries = createNetwork({ label: 'reploid-partitions-input',
+    maxPeers: config.maxPeers, timeoutMs: config.connectTimeoutMs,
+    createEndpoint: ({ channel, remoteParticipantId }) => createPartitionEntry({ channel,
+      localParticipantId: identity.peerId, remoteParticipantId, service, canonical: !!canonical,
+      limits: config.inputChannel, inputLimits: config.inputLimits,
+      async authorize(input, { action }) {
+        if (input.requesterId === identity.peerId) {
+          const admitted = admissions.get(input.attemptId);
+          return !!admitted && canonicalPartitionJson(admitted) === canonicalPartitionJson(input);
+        }
+        return !!offer && program?.resident.index === 0 && !!chat
+          && input.requesterId === remoteParticipantId && input.participantA === identity.peerId
+          && input.participantB === placement?.[1] && input.modelIdentity === offer.identity
+          && input.planId === program.planId;
+      }
+    }) });
+  const discovery = createPartitionDiscovery({ identity, catalog, policy: config, peers, createNetwork,
+    onChange: notify,
+    describe: () => ({ participantId: identity.peerId, offer: offer && { id: offer.id, identity: offer.identity, adapters: offer.adapters || [] },
+      eligibleIndexes: offer?.partitionContributionIndexes ?? [0, 1],
+      phase, preparation: phase === 'loading' ? publicPreparationProgress(progress) : null, placement, index: program?.resident.index ?? placement?.indexOf(identity.peerId) ?? null,
+      planId: program?.planId ?? null, models: chat?.getModels() || [],
+      // Discovery advertises capacity only; attempt identities remain with their owners.
+      capacity: program ? (({ active, availableSlots, closed }) => ({ active, availableSlots, closed }))(
+        program.resident.getState().reservations) : null }) });
+  async function retire() {
+    for (const owner of [chat, execution, program?.resident]) if (owner) unsettledOwners.add(owner);
+    const owners = [...unsettledOwners];
+    chat = null; executionPeer = null; execution = null; program = null; placement = null;
+    const results = await Promise.allSettled(owners.map(owner => Promise.resolve().then(() => owner?.close())));
+    results.forEach((result, index) => { if (result.status === 'fulfilled') unsettledOwners.delete(owners[index]); });
+    const failures = results.filter(result => result.status === 'rejected').map(result => result.reason);
+    if (failures.length) {
+      phase = 'failed';
+      throw new AggregateError(failures, 'Partition contribution settlement failed');
+    }
+  }
+  async function reconcile() {
+    if (!offer || preparing || stopping || closed || phase === 'failed' || unsettledOwners.size) return;
+    placementDecision = selectPartitionPlacement({ participantId: identity.peerId, offer,
+      localIndex: program?.resident.index ?? null, previous: placement, capabilities: discovery.getSnapshot() });
+    // Discovery expires independently of the execution channel. Existing signed
+    // attempts own this route until settlement; a missing advertisement or a new
+    // replica must not cancel them or change their authorized recipients.
+    const reserved = program?.resident.getState().reservations.active > 0;
+    const activeInput = chat && (chat.getState().active > 0 || reserved)
+      && !executionPeer.getState().receipt.closed;
+    // Output stages have no chat runner. Their channel/receiver owns settlement;
+    // discovery cannot retire their shared resident while any state is charged.
+    if (activeInput || program?.resident.index === 1 && reserved) {
+      placementDecision = { ...placementDecision, participants: [...placement], reason: 'retain-active-execution' };
+      return;
+    }
+    const selected = placementDecision.participants;
+    if (selected.length !== 2) {
+      await chat?.close(); chat = null; executionPeer = null;
+      phase = 'waiting'; progress = { message: 'Waiting for another contributor' }; notify(); return;
+    }
+    if (placement && canonicalPartitionJson(placement) !== canonicalPartitionJson(selected)) {
+      await chat?.close(); chat = null; executionPeer = null;
+      if (program && program.resident.index !== selected.indexOf(identity.peerId)) await retire();
+    }
+    placement = selected;
+    if (!program) {
+      placement = selected; phase = 'loading'; error = null; notify();
+      const selectedOffer = offer, observeProgress = createPreparationProgressObserver();
+      let observingPreparation = true;
+      const preparationOwners = new Set();
+      preparing = Promise.resolve().then(() => loadProgram(selectedOffer, selected.indexOf(identity.peerId), {
+        signal: AbortSignal.any([lifetime.signal, contributionController.signal]), participantId: identity.peerId,
+        ...(canonical ? { canonical: { identity, participantEpoch: canonical.participantEpoch } } : {}),
+        registerCleanup(owner) {
+          assert(typeof owner?.close === 'function', 'Preparation cleanup owner must expose close');
+          preparationOwners.add(owner);
+          // The host releases this registration only after successful cleanup.
+          // A failed opening is not itself evidence of failed resource disposal.
+          return () => preparationOwners.delete(owner);
+        },
+        onProgress: value => { if (observingPreparation) { error = null; progress = observeProgress(value); notify(); } }
+      }));
+      try {
+        program = await preparing;
+        // A returned resident now owns successful preparation. Pending loading
+        // remains stoppable; only rejected cleanup becomes unsettled ownership.
+        // Stop/close own retirement after this tick settles. A late loader may
+        // not retire a newer contribution or race another cleanup caller.
+        if (closed || offer !== selectedOffer) return;
+        execution = createNetwork({ label: 'reploid-partitions', maxPeers: config.maxPeers,
+          timeoutMs: config.connectTimeoutMs,
+          createEndpoint: ({ channel, remoteParticipantId }) => createPartitionPeer({ channel,
+            localParticipantId: identity.peerId, remoteParticipantId, runtime: program.runtime,
+            modelIdentity: program.model.identity, plan: program.plan, planId: program.planId, authority,
+            canonical: !!canonical, contributor: program.resident.index === 1 ? program.resident : null, limits: config.executionChannel,
+            receiverLimits: config.receiver, descriptorTtlMs: config.inputLimits.descriptorTtlMs }) });
+        phase = 'ready'; progress = null; notify();
+      } catch (cause) {
+        for (const owner of preparationOwners) unsettledOwners.add(owner);
+        phase = 'failed'; error = cause.message; notify(); throw cause;
+      }
+      finally { observingPreparation = false; preparing = null; }
+    }
+    if (program && phase === 'waiting') { phase = 'ready'; progress = null; notify(); }
+    // A restarted contributor may return between discovery polls. Its identity
+    // and placement stay the same, but the old execution channel is retired.
+    if (chat && executionPeer.getState().receipt.closed) {
+      await chat.close(); chat = null; executionPeer = null;
+    }
+    if (program?.resident.index === 0 && !chat) {
+      const next = discovery.getSnapshot().find(peer => peer.available && peer.participantId === placement[1]
+        && peer.description?.phase === 'ready' && peer.description.index === 1
+        && peer.description.planId === program.planId);
+      if (!next) return;
+      const remote = await execution.connect(next.transportId);
+      executionPeer = remote;
+      chat = createPartitionChat({ runtime: program.runtime, local: program.resident, remote,
+        authority, model: program.model, plan: program.plan, planId: program.planId,
+        limits: config.limits, grantTtlMs: config.grantMs,
+        ...(canonical ? { canonical: { coordinatorEpoch: canonical.coordinatorEpoch } } : {}),
+        authorizeRequester: async () => !!offer && !closed });
+      await chat.refresh({ signal: lifetime.signal }); notify();
+    }
+  }
+  async function tick() {
+    if (closed) return;
+    if (ticking) return ticking;
+    ticking = (async () => {
+      await discovery.refresh();
+      notify(); await reconcile();
+    })();
+    try { await ticking; } catch (cause) { if (!closed) { error = cause.message; notify(); } }
+    finally { ticking = null; }
+  }
+  async function refreshEntry(entry, transportId, model, signal) {
+    let current;
+    try { current = await entry.refresh({ signal }); }
+    catch (cause) { if (!signal?.aborted) discovery.invalidateModel(transportId, model); throw cause; }
+    if (!current.ready || !current.descriptor.models.some(candidate => candidate.id === model.id
+      && candidate.identity === model.identity && samePartitionAdapters(candidate, model) && candidate.availability === 'ready')) {
+      discovery.invalidateModel(transportId, model);
+    }
+    return current;
+  }
+  const timer = setInterval(tick, config.pollMs);
+  return Object.freeze({ getState, getModels,
+    subscribe(listener) { listeners.add(listener); listener(getModels()); return () => listeners.delete(listener); },
+    async contribute(modelId, approved, adapters) {
+      assert(approved === true && !closed, 'Approve partition computation before contributing');
+      assert(!stopping && !unsettledOwners.size, 'Previous contribution must settle before replacement');
+      assert(!offer, 'Stop existing partition contribution first');
+      const selected = catalog.find(model => model.id === modelId);
+      assert(selected, 'No pinned partition model for this contribution');
+      offer = selectPartitionContribution(selected, adapters);
+      contributionController = new AbortController();
+      phase = 'waiting'; error = null; progress = { message: 'Waiting for another contributor' }; notify(); await tick();
+    },
+    stop() {
+      if (stopping) return stopping;
+      const pendingTick = ticking;
+      const operation = Promise.resolve().then(async () => {
+        await pendingTick?.catch(() => {});
+        try { await retire(); phase = 'idle'; error = null; progress = null; }
+        catch (cause) { phase = 'failed'; error = cause.message; throw cause; }
+        finally { notify(); }
+      }).finally(() => { if (stopping === operation) stopping = null; });
+      stopping = operation; offer = null; phase = 'stopping';
+      contributionController?.abort(new Error('Partition contribution stopped')); notify();
+      return operation;
+    },
+    async generate(request, controls) {
+      request = structuredClone(request);
+      const requested = generationRequest(request.generationRequest);
+      assert(!requested || requested.maxOutputTokens <= config.limits.maxTokens, 'Caller token limit exceeds route budget');
+      assert(!!controls.publication === !!canonical && (!canonical || typeof controls.onPublished === 'function'
+        && /^[a-f0-9]{32}$/.test(controls.publisherEpoch)), 'Canonical requester requires durable publication and explicit mesh capability');
+      const decision = selectPartitionExecution({ model: request.model, capabilities: discovery.getSnapshot() });
+      assert(decision.transportId, 'No prepared cooperative partition path is available');
+      const entry = await entries.connect(decision.transportId);
+      const refreshed = await refreshEntry(entry, decision.transportId, request.model, controls.signal);
+      const model = refreshed.descriptor.models.find(model => model.id === request.model.id
+        && model.identity === request.model.identity && samePartitionAdapters(model, request.model) && model.availability === 'ready');
+      assert(refreshed.ready && model, 'No prepared cooperative partition path is available');
+      assert(!!model.canonical === !!canonical, 'Prepared route has a different publication capability');
+      requireGenerationCapability(model, requested, !!canonical);
+      const messages = structuredClone(request.messages);
+      let expiresAt = Date.now() + config.grantMs;
+      const approved = await controls.requestApproval({ id: crypto.randomUUID(), threadId: request.threadId,
+        attemptId: request.attemptId, operation: 'generate-partition',
+        peerId: model.partition.participantA, recipientIdentity: model.partition.participantA,
+        ...model.partition, modelId: model.id, modelIdentity: model.identity,
+        disclosure: 'partition-activations-and-tokens', adapterIdentities: partitionAdapterIdentities(model), expiresAt, executionTimeoutMs: config.grantMs,
+        input: { messages: structuredClone(messages), ...(requested ? {generationRequest: requested} : {}), recipients: [model.partition.participantA, model.partition.participantB] } });
+      assert(approved === true, 'Partition input disclosure declined'); controls.signal.throwIfAborted();
+      expiresAt = Math.min(controls.authorizationExpiresAt?.() ?? expiresAt, Date.now() + config.grantMs);
+      assert(Date.now() < expiresAt, 'Partition input disclosure expired');
+      // Human review can outlive an availability descriptor. Refresh liveness,
+      // but never transfer reviewed input to a newly selected recipient or plan.
+      const current = await refreshEntry(entry, decision.transportId, model, controls.signal);
+      const same = current.descriptor.models.find(candidate => candidate.id === model.id
+        && candidate.identity === model.identity && samePartitionAdapters(candidate, model) && candidate.availability === 'ready'
+        && canonicalPartitionJson(candidate.partition) === canonicalPartitionJson(model.partition)
+        && canonicalPartitionJson(candidate.canonical ?? null) === canonicalPartitionJson(model.canonical ?? null));
+      assert(current.ready && same, 'Approved partition placement changed; review a new attempt');
+      assert(Date.now() < expiresAt, 'Partition input disclosure expired'); controls.signal.throwIfAborted();
+      const input = { schema: canonical ? 'reploid.partition-input/v2' : 'reploid.partition-input/v1', operation: 'generate', meshId,
+        requesterId: identity.peerId, ...model.partition, modelId: model.id, modelIdentity: model.identity,
+        threadId: request.threadId, attemptId: request.attemptId, placementGeneration: 0,
+        messages, ...(requested ? {generationRequest: requested} : {}), ...(canonical ? { canonical: { schema: 'reploid.partition-publication-context/v1',
+          ...structuredClone(model.canonical), publisherEpoch: controls.publisherEpoch, deadlineAt: expiresAt } } : {}) };
+      admissions.set(request.attemptId, input);
+      let sequence = 0;
+      controls.onState({ threadId: request.threadId, attemptId: request.attemptId, status: 'executing',
+        execution: { placement: 'two-device-layer-partition', ...model.partition } });
+      try {
+        const result = await entry.generate(input, { signal: controls.signal,
+          onUsage: usage => controls.onUsage?.({threadId: request.threadId, attemptId: request.attemptId, ...usage}),
+          ...(canonical ? { publication: controls.publication, onPublished: controls.onPublished } : {}),
+          onDelta: text => controls.onDelta({ threadId: request.threadId, attemptId: request.attemptId, sequence: sequence++, text }) });
+        return { ...result, threadId: request.threadId, attemptId: request.attemptId,
+          modelId: model.id, modelIdentity: model.identity, adapterIdentities: partitionAdapterIdentities(model),
+          execution: { ...result.execution, selection: decision } };
+      } finally { admissions.delete(request.attemptId); }
+    },
+    close() {
+      if (closing) return closing;
+      closed = true; clearInterval(timer); lifetime.abort(new Error('Partition mesh closed'));
+      closing = (async () => {
+        const results = await Promise.allSettled([...[entries, discovery].map(owner => Promise.resolve().then(async () => {
+          if (!settledCloseOwners.has(owner)) { await owner.close(); settledCloseOwners.add(owner); }
+        })), ticking, stopping]);
+        results.push(...await Promise.allSettled([retire()]));
+        authority.close(); listeners.clear(); admissions.clear();
+        const failures = results.filter(result => result.status === 'rejected').map(result => result.reason);
+        if (failures.length) throw new AggregateError(failures, 'Partition mesh settlement failed');
+      })().catch(error => { closing = null; throw error; });
+      return closing;
+    }
+  });
+}

package/packages/reploid/src/mesh/partitions/partition-attempt-evidence.js

@@ -0,0 +1,282 @@
+/**
+ * Signed execution evidence for one charged ordered-route attempt.
+ *
+ * The requester binds the attempt to its reservation with a signed
+ * acknowledgment of zero outputs (the charge binding) before dispatch. Every
+ * stage that admits the attempt signs cumulative stage receipts with its
+ * persistent participant identity: reservation and route binding, steps
+ * executed, tokens processed, timing, and its closing status. The final stage
+ * also commits to its outputs as a hash chain over every step's delta. The
+ * requester acknowledges each output it received by signing the cumulative
+ * chain; it acknowledges only a receipt whose chain matches what it received.
+ * Under the receiver policy's bound K, no stage computes step s unless it holds
+ * the requester's verified acknowledgment of at least s - K outputs, so a
+ * requester that stops acknowledging leaves at most K + 1 outputs of work
+ * unacknowledged, whatever the coordinator does.
+ * Signatures establish who asserted what; they do not prove honest or correct
+ * computation, and verification against registered devices is the service's.
+ * WebCrypto only, so browser and native hosts sign with the code the service
+ * verifies with.
+ */
+import { canonicalPartitionJson, canonicalRouteAttemptBinding } from './partition-contract.js';
+import { sha256Hex as digestText } from '../../artifacts/signatures.js';
+import { normalizeParticipantPublicKey, participantIdFor, signAsParticipant, verifyParticipantSignature } from '../../artifacts/participant-proofs.js';
+import receiverPolicy from './partition-receiver-policy.json' with { type: 'json' };
+
+export const STAGE_RECEIPT_SCHEMA = 'reploid.stage-receipt/v1';
+export const OUTPUT_ACKNOWLEDGMENT_SCHEMA = 'reploid.output-acknowledgment/v1';
+export const OUTPUT_CHAIN_SCHEMA = 'reploid.output-chain/v1';
+export const ATTEMPT_EVIDENCE_SCHEMA = 'reploid.attempt-evidence/v1';
+export const STAGE_RECEIPT_STATUSES = Object.freeze(['executing', 'settled', 'failed']);
+export const ACKNOWLEDGMENT_OVERDUE = 'ACKNOWLEDGMENT_OVERDUE';
+
+/** K: the most outputs a charged attempt may run ahead of the requester's verified acknowledgments. */
+export const MAX_UNACKNOWLEDGED_OUTPUTS = receiverPolicy.maxUnacknowledgedOutputs;
+if (!Number.isSafeInteger(MAX_UNACKNOWLEDGED_OUTPUTS) || MAX_UNACKNOWLEDGED_OUTPUTS < 0) {
+  throw new Error('partition-receiver-policy.json must declare maxUnacknowledgedOutputs as a non-negative integer');
+}
+/** A step refused or abandoned because the requester's acknowledgments fell more than K outputs behind. */
+export const acknowledgmentOverdue = (message = 'The requester\'s output acknowledgments are overdue') => Object.assign(new Error(message), { code: ACKNOWLEDGMENT_OVERDUE });
+
+const RECEIPT_KEYS = Object.freeze(['schema', 'reservationId', 'attemptId', 'routeHash', 'partitionIndex', 'participantId',
+  'sequence', 'status', 'steps', 'tokens', 'timing', 'output', 'signedAt']);
+const ACKNOWLEDGMENT_KEYS = Object.freeze(['schema', 'reservationId', 'attemptId', 'routeHash', 'requesterId', 'count', 'chain', 'signedAt']);
+const TIMING_KEYS = Object.freeze(['reservedAt', 'firstStepAt', 'lastStepAt', 'closedAt']);
+const OUTPUT_KEYS = Object.freeze(['count', 'chain', 'done', 'stopReason']);
+const BUNDLE_KEYS = Object.freeze(['schema', 'reservationId', 'attemptId', 'identity', 'receipts', 'acknowledged']);
+const DIGEST = /^sha256:[a-f0-9]{64}$/;
+
+const assert = (ok, message) => { if (!ok) throw new Error(message); };
+const exact = (value, keys) => Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+  && Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
+const text = (value, max) => typeof value === 'string' && value.length > 0 && value.length <= max;
+const count = value => Number.isSafeInteger(value) && value >= 0;
+const isoOrNull = value => value === null || typeof value === 'string' && value.length <= 40 && Number.isFinite(Date.parse(value));
+const iso = ms => new Date(ms).toISOString();
+const sameJson = (a, b) => canonicalPartitionJson(a) === canonicalPartitionJson(b);
+
+/** The ledger's route hash: sha256 over the canonical route attempt binding. */
+export const attemptRouteHash = identity => digestText(canonicalPartitionJson(canonicalRouteAttemptBinding(identity)));
+/** Chain value before any output, bound to the reservation and route. */
+export const outputChainGenesis = ({ reservationId, routeHash }) => digestText(canonicalPartitionJson({ schema: OUTPUT_CHAIN_SCHEMA, reservationId, routeHash }));
+/** One step's output appended to the chain; `delta` is that step's text, empty when it published none. */
+export const extendOutputChain = (previous, { step, delta }) => digestText(canonicalPartitionJson({ previous, step, delta }));
+
+/** Signing port over a host's persistent participant identity and its clock; the host keeps the identity. */
+export function createAttemptEvidenceSigner({ identity, now = Date.now }) {
+  const publicJwk = normalizeParticipantPublicKey(identity?.publicJwk);
+  if (!publicJwk || !identity.privateJwk || typeof identity.peerId !== 'string') throw new TypeError('A persistent participant signing identity is required');
+  const bundle = structuredClone(identity);
+  let checked = null;
+  if (typeof now !== 'function') throw new TypeError('The signing host clock must be a function');
+  return Object.freeze({
+    participantId: bundle.peerId,
+    now,
+    async sign(domain, body) {
+      checked ??= participantIdFor(publicJwk).then(id => assert(id === bundle.peerId, 'Signing identity does not derive its participant id'));
+      await checked;
+      return { ...structuredClone(body), publicJwk: structuredClone(publicJwk), signature: await signAsParticipant(bundle, domain, body) };
+    }
+  });
+}
+
+function receiptProblem(body) {
+  if (!exact(body, RECEIPT_KEYS) || body.schema !== STAGE_RECEIPT_SCHEMA || !text(body.reservationId, 160) || !text(body.attemptId, 256)
+    || !DIGEST.test(body.routeHash) || !count(body.partitionIndex) || !text(body.participantId, 256)
+    || !Number.isSafeInteger(body.sequence) || body.sequence < 1 || !STAGE_RECEIPT_STATUSES.includes(body.status) || !count(body.steps)
+    || !exact(body.tokens, ['prompt', 'processed']) || !(body.tokens.prompt === null || count(body.tokens.prompt)) || !count(body.tokens.processed)
+    || !exact(body.timing, TIMING_KEYS) || !TIMING_KEYS.every(key => isoOrNull(body.timing[key]))
+    || !isoOrNull(body.signedAt) || body.signedAt === null) return 'receipt_malformed';
+  if (body.output !== null && !(exact(body.output, OUTPUT_KEYS) && count(body.output.count) && body.output.count === body.steps
+    && DIGEST.test(body.output.chain) && typeof body.output.done === 'boolean'
+    && (body.output.stopReason === null || text(body.output.stopReason, 64)))) return 'receipt_malformed';
+  return null;
+}
+
+function acknowledgmentProblem(body) {
+  return exact(body, ACKNOWLEDGMENT_KEYS) && body.schema === OUTPUT_ACKNOWLEDGMENT_SCHEMA && text(body.reservationId, 160)
+    && text(body.attemptId, 256) && DIGEST.test(body.routeHash) && text(body.requesterId, 256) && count(body.count)
+    && DIGEST.test(body.chain) && isoOrNull(body.signedAt) && body.signedAt !== null ? null : 'acknowledgment_malformed';
+}
+
+async function verifySigned(record, { domain, problemOf, signerOf, publicJwk }) {
+  if (!record || typeof record !== 'object' || Array.isArray(record)) return { ok: false, problem: problemOf(null) };
+  const { publicJwk: carried, signature, ...body } = record;
+  const problem = problemOf(body);
+  if (problem) return { ok: false, problem };
+  const key = normalizeParticipantPublicKey(carried);
+  if (!key || !exact(carried, Object.keys(key)) || typeof signature !== 'string') return { ok: false, problem: problemOf(null) };
+  if (publicJwk && !sameJson(normalizeParticipantPublicKey(publicJwk), key)) return { ok: false, problem: 'signer_key_mismatch' };
+  if (await participantIdFor(key) !== signerOf(body)) return { ok: false, problem: 'signer_key_mismatch' };
+  if (!await verifyParticipantSignature(key, domain, body, signature)) return { ok: false, problem: 'signature_invalid' };
+  return { ok: true, body };
+}
+
+/** Form, key-to-participant binding and signature of a stage receipt; `publicJwk`, when given, must be the signing key. */
+export const verifyStageReceipt = (receipt, { publicJwk = null } = {}) => verifySigned(receipt, {
+  domain: STAGE_RECEIPT_SCHEMA, problemOf: body => (body ? receiptProblem(body) : 'receipt_malformed'), signerOf: body => body.participantId, publicJwk });
+
+/** Form, key-to-requester binding and signature of an output acknowledgment. */
+export const verifyOutputAcknowledgment = (acknowledgment, { publicJwk = null } = {}) => verifySigned(acknowledgment, {
+  domain: OUTPUT_ACKNOWLEDGMENT_SCHEMA, problemOf: body => (body ? acknowledgmentProblem(body) : 'acknowledgment_malformed'),
+  signerOf: body => body.requesterId, publicJwk });
+
+/**
+ * Form of a charge binding carried with an ordered input: the requester's
+ * acknowledgment of zero outputs of this attempt. Stages verify the signature.
+ */
+export function isChargeBindingShape(charge, { attemptId, requesterId }) {
+  if (!exact(charge, [...ACKNOWLEDGMENT_KEYS, 'publicJwk', 'signature']) || typeof charge.signature !== 'string' || charge.signature.length > 256) return false;
+  const { publicJwk, signature: _signature, ...body } = charge;
+  return acknowledgmentProblem(body) === null && body.count === 0 && body.attemptId === attemptId && body.requesterId === requesterId
+    && normalizeParticipantPublicKey(publicJwk) !== null;
+}
+
+/** Check the bundle's form; signatures and registrations are the verifier's. */
+export function checkAttemptEvidenceBundle(bundle) {
+  if (!exact(bundle, BUNDLE_KEYS) || bundle.schema !== ATTEMPT_EVIDENCE_SCHEMA || !text(bundle.reservationId, 160)
+    || !text(bundle.attemptId, 256) || !Array.isArray(bundle.receipts)
+    || !(bundle.acknowledged === null || exact(bundle.acknowledged, ['acknowledgment', 'receipt']))) return 'evidence_malformed';
+  try { if (canonicalRouteAttemptBinding(bundle.identity).attemptId !== bundle.attemptId) return 'evidence_malformed'; }
+  catch { return 'evidence_malformed'; }
+  return null;
+}
+
+/** The charge binding a requester signs after binding its attempt and before any input leaves the device. */
+async function checkChargeBinding(charge, binding, routeHash) {
+  const checked = await verifyOutputAcknowledgment(charge);
+  const body = checked.body;
+  assert(checked.ok && body.count === 0 && body.attemptId === binding.attemptId && body.routeHash === routeHash
+    && body.requesterId === binding.requesterId && body.chain === await outputChainGenesis({ reservationId: body.reservationId, routeHash }),
+  'Attempt charge binding is not the requester\'s signed binding of this route');
+  return { reservationId: body.reservationId, requesterKey: normalizeParticipantPublicKey(charge.publicJwk) };
+}
+
+/**
+ * Stage side: cumulative signed receipts of one charged attempt at one stage.
+ * A repeated step never advances the tally twice; a closed tally signs nothing new.
+ */
+export async function openStageReceipts({ signer, identity, partitionIndex, charge, now = signer?.now ?? Date.now }) {
+  const binding = canonicalRouteAttemptBinding(identity);
+  const stage = binding.route.stages[partitionIndex];
+  assert(stage && typeof signer?.sign === 'function' && signer.participantId === stage.participantId, 'Stage receipts need this stage\'s own signing identity');
+  const routeHash = await attemptRouteHash(binding);
+  const { reservationId, requesterKey } = await checkChargeBinding(charge, binding, routeHash);
+  const finalStage = binding.route.stages.at(-1);
+  const final = partitionIndex === finalStage.index;
+  const state = { sequence: 0, steps: 0, prompt: null, processed: 0, timing: { reservedAt: iso(now()), firstStepAt: null, lastStepAt: null, closedAt: null },
+    output: final ? { count: 0, chain: await outputChainGenesis({ reservationId, routeHash }), done: false, stopReason: null } : null,
+    receipt: null, acknowledged: null, closed: false };
+  let queue = Promise.resolve();
+  const serial = task => { const run = queue.then(task); queue = run.catch(() => {}); return run; };
+  const sign = async status => {
+    state.sequence += 1;
+    state.receipt = await signer.sign(STAGE_RECEIPT_SCHEMA, { schema: STAGE_RECEIPT_SCHEMA, reservationId, attemptId: binding.attemptId, routeHash,
+      partitionIndex, participantId: stage.participantId, sequence: state.sequence, status, steps: state.steps,
+      tokens: { prompt: state.prompt, processed: state.processed }, timing: structuredClone(state.timing),
+      output: state.output && structuredClone(state.output), signedAt: iso(now()) });
+    return structuredClone(state.receipt);
+  };
+  return Object.freeze({
+    reservationId, routeHash,
+    /** Record one executed step and sign the cumulative receipt. */
+    step: ({ step, inputTokenCount, delta = '', done = false, stopReason = null }) => serial(async () => {
+      if (state.closed || step !== state.steps || !count(inputTokenCount)) return state.receipt && structuredClone(state.receipt);
+      const at = iso(now());
+      if (step === 0) { state.prompt = inputTokenCount; state.timing.firstStepAt = at; }
+      state.steps += 1; state.processed += inputTokenCount; state.timing.lastStepAt = at;
+      if (state.output) {
+        assert(typeof delta === 'string', 'Final stage output delta required');
+        state.output = { count: state.steps, chain: await extendOutputChain(state.output.chain, { step, delta }), done: done === true,
+          stopReason: done === true && typeof stopReason === 'string' ? stopReason.slice(0, 64) : null };
+      }
+      return sign('executing');
+    }),
+    /** Keep the latest requester acknowledgment and the final-stage receipt it acknowledged, as forwarded by the coordinator. */
+    /**
+     * Keep a newer acknowledgment only when the requester's key from the charge
+     * binding signed it and the final stage signed the receipt it pairs with.
+     */
+    async acknowledge(pair) {
+      const ack = pair?.acknowledgment, receipt = pair?.receipt;
+      if (!ack || ack.count <= (state.acknowledged?.acknowledgment.count ?? 0)) return false;
+      const [signed, committed] = await Promise.all([verifyOutputAcknowledgment(ack, { publicJwk: requesterKey }), verifyStageReceipt(receipt)]);
+      if (!signed.ok || !committed.ok || ack.reservationId !== reservationId || ack.attemptId !== binding.attemptId || ack.routeHash !== routeHash
+        || ack.requesterId !== binding.requesterId || ack.count < 1 || committed.body.reservationId !== reservationId
+        || committed.body.attemptId !== binding.attemptId || committed.body.routeHash !== routeHash
+        || committed.body.partitionIndex !== finalStage.index || committed.body.participantId !== finalStage.participantId
+        || committed.body.output?.count !== ack.count || committed.body.output.chain !== ack.chain) return false;
+      if (ack.count > (state.acknowledged?.acknowledgment.count ?? 0)) state.acknowledged = structuredClone({ acknowledgment: ack, receipt });
+      return true;
+    },
+    /** Refuse step `step` unless the verified acknowledgments cover at least step - K outputs. */
+    async authorizeStep({ step, acknowledged = null }) {
+      if (acknowledged) await this.acknowledge(acknowledged);
+      if ((state.acknowledged?.acknowledgment.count ?? 0) < step - MAX_UNACKNOWLEDGED_OUTPUTS) {
+        throw acknowledgmentOverdue(`Step ${step} needs the requester's acknowledgment of ${step - MAX_UNACKNOWLEDGED_OUTPUTS} outputs`);
+      }
+    },
+    /** Sign the closing receipt once: settled, or failed when the stage recorded a failure. */
+    close: ({ failed = false } = {}) => serial(async () => {
+      if (state.closed) return state.receipt && structuredClone(state.receipt);
+      state.closed = true; state.timing.closedAt = iso(now());
+      return sign(failed ? 'failed' : 'settled');
+    }),
+    /** This stage's evidence for its own submission: its latest receipt and the latest acknowledgment it holds. */
+    evidence: () => ({ schema: ATTEMPT_EVIDENCE_SCHEMA, reservationId, attemptId: binding.attemptId, identity: structuredClone(binding),
+      receipts: state.receipt ? [structuredClone(state.receipt)] : [], acknowledged: state.acknowledged && structuredClone(state.acknowledged) })
+  });
+}
+
+/**
+ * Requester side: the charge binding, then one signed acknowledgment per
+ * received output whose final-stage receipt commits to exactly the chain of
+ * deltas this device received. A receipt that does not match is not
+ * acknowledged, and nothing after it can be.
+ */
+export async function openOutputAcknowledgments({ signer, identity, reservationId, now = signer?.now ?? Date.now, restore = null }) {
+  const binding = canonicalRouteAttemptBinding(identity);
+  assert(typeof signer?.sign === 'function' && signer.participantId === binding.requesterId && text(reservationId, 160),
+    'Acknowledgments need the requester\'s own signing identity and reservation');
+  const routeHash = await attemptRouteHash(binding);
+  const finalStage = binding.route.stages.at(-1);
+  const sign = (outputs, chain) => signer.sign(OUTPUT_ACKNOWLEDGMENT_SCHEMA, { schema: OUTPUT_ACKNOWLEDGMENT_SCHEMA, reservationId,
+    attemptId: binding.attemptId, routeHash, requesterId: binding.requesterId, count: outputs, chain, signedAt: iso(now()) });
+  const state = restore && restore.reservationId === reservationId && restore.attemptId === binding.attemptId ? structuredClone(restore)
+    : { reservationId, attemptId: binding.attemptId, count: 0, chain: await outputChainGenesis({ reservationId, routeHash }),
+      charge: null, acknowledged: null, latestReceipt: null, broken: false };
+  state.charge ??= await sign(0, state.chain);
+  let queue = Promise.resolve();
+  const serial = task => { const run = queue.then(task); queue = run.catch(() => {}); return run; };
+  return Object.freeze({
+    routeHash,
+    charge: structuredClone(state.charge),
+    /** Acknowledge one step's output: `{ step, delta, receipt }` from the route. Returns the pair, or null when not acknowledged. */
+    observe: ({ step, delta, receipt }) => serial(async () => {
+      if (!state.broken && step === state.count - 1 && state.lastObserved
+        && sameJson(state.lastObserved, { step, delta, receipt })) return structuredClone(state.acknowledged);
+      if (state.broken || step !== state.count || typeof delta !== 'string') { state.broken = true; return null; }
+      const checked = await verifyStageReceipt(receipt);
+      const body = checked.body;
+      const chain = await extendOutputChain(state.chain, { step, delta });
+      if (!checked.ok || body.reservationId !== reservationId || body.attemptId !== binding.attemptId || body.routeHash !== routeHash
+        || body.partitionIndex !== finalStage.index || body.participantId !== finalStage.participantId
+        || body.output?.count !== step + 1 || body.output.chain !== chain) { state.broken = true; return null; }
+      const acknowledgment = await sign(step + 1, chain);
+      Object.assign(state, { count: step + 1, chain, acknowledged: { acknowledgment, receipt: structuredClone(receipt) }, latestReceipt: structuredClone(receipt),
+        lastObserved: structuredClone({ step, delta, receipt }) });
+      return structuredClone(state.acknowledged);
+    }),
+    /** Durable state for a restarted host. */
+    state: () => structuredClone(state),
+    /** The requester's evidence for its report: the latest final-stage receipt and its acknowledgment. */
+    evidence: () => ({ schema: ATTEMPT_EVIDENCE_SCHEMA, reservationId, attemptId: binding.attemptId, identity: structuredClone(binding),
+      receipts: state.latestReceipt ? [structuredClone(state.latestReceipt)] : [], acknowledged: state.acknowledged && structuredClone(state.acknowledged) })
+  });
+}
+
+export default {
+  STAGE_RECEIPT_SCHEMA, OUTPUT_ACKNOWLEDGMENT_SCHEMA, OUTPUT_CHAIN_SCHEMA, ATTEMPT_EVIDENCE_SCHEMA,
+  attemptRouteHash, outputChainGenesis, extendOutputChain, createAttemptEvidenceSigner,
+  verifyStageReceipt, verifyOutputAcknowledgment, checkAttemptEvidenceBundle, openStageReceipts, openOutputAcknowledgments
+};

package/packages/reploid/src/mesh/partitions/partition-attempt-queue-policy.json

@@ -0,0 +1,6 @@
+{
+  "schema": "reploid.partition-attempt-queue-policy/v1",
+  "maxQueuedAttempts": 4,
+  "maxQueuedPerRequester": 2,
+  "maxQueueWaitMs": 300000
+}