reploid 0.0.0-stage → 0.1.0

package/packages/reploid/src/artifacts/identity.js

@@ -0,0 +1,91 @@
+import { toBase64Url, fromBase64Url } from './binary.js';
+import { canonicalize as stableJson } from './canonical-json.js';
+import { sha256HexUnprefixed } from './signatures.js';
+const encoder = new TextEncoder();
+
+
+const getCryptoApi = (cryptoApi) => {
+  const api = cryptoApi || globalThis.crypto;
+  if (!api?.subtle) {
+    throw new Error('WebCrypto unavailable');
+  }
+  return api;
+};
+
+
+function inferIdentityAlgorithm(bundleOrJwk = {}) {
+  const algorithm = String(bundleOrJwk?.algorithm || '').trim();
+  const crv = String(bundleOrJwk?.crv || bundleOrJwk?.publicJwk?.crv || '').trim();
+  if (algorithm === 'Ed25519' || crv === 'Ed25519') {
+    return 'Ed25519';
+  }
+  return 'ECDSA';
+}
+
+export function getIdentityImportAlgorithm(bundleOrJwk = {}) {
+  return inferIdentityAlgorithm(bundleOrJwk) === 'Ed25519'
+    ? { name: 'Ed25519' }
+    : { name: 'ECDSA', namedCurve: 'P-256' };
+}
+
+export function getIdentitySignAlgorithm(bundleOrJwk = {}) {
+  return inferIdentityAlgorithm(bundleOrJwk) === 'Ed25519'
+    ? { name: 'Ed25519' }
+    : { name: 'ECDSA', hash: 'SHA-256' };
+}
+
+export async function createPeerIdFromPublicJwk(publicJwk, cryptoApi = globalThis.crypto) {
+  const publicShape = publicJwk ? {
+    kty: publicJwk.kty || null,
+    crv: publicJwk.crv || null,
+    x: publicJwk.x || null,
+    y: publicJwk.y || null,
+    n: publicJwk.n || null,
+    e: publicJwk.e || null
+  } : {};
+  const digest = await sha256HexUnprefixed(stableJson(publicShape), getCryptoApi(cryptoApi));
+  return `peer:${digest.slice(0, 24)}`;
+}
+
+export async function importSigningKey(bundle, cryptoApi = globalThis.crypto) {
+  if (!bundle?.privateJwk) {
+    throw new Error('Missing private JWK');
+  }
+  return getCryptoApi(cryptoApi).subtle.importKey(
+    'jwk',
+    bundle.privateJwk,
+    getIdentityImportAlgorithm(bundle),
+    false,
+    ['sign']
+  );
+}
+
+export async function importVerificationKey(bundleOrJwk, cryptoApi = globalThis.crypto) {
+  const publicJwk = bundleOrJwk?.publicJwk || bundleOrJwk;
+  if (!publicJwk) {
+    throw new Error('Missing public JWK');
+  }
+  return getCryptoApi(cryptoApi).subtle.importKey(
+    'jwk',
+    publicJwk,
+    getIdentityImportAlgorithm(publicJwk),
+    false,
+    ['verify']
+  );
+}
+
+export function encodeBytes(value) {
+  return encoder.encode(String(value || ''));
+}
+
+export { fromBase64Url, toBase64Url };
+
+
+export async function createSigningIdentity({ algorithm, cryptoApi = globalThis.crypto }) {
+  if (!['Ed25519', 'ECDSA'].includes(algorithm)) throw new TypeError('Explicit supported signing algorithm required');
+  const params = algorithm === 'Ed25519' ? { name: algorithm } : { name: algorithm, namedCurve: 'P-256' };
+  const keys = await cryptoApi.subtle.generateKey(params, true, ['sign', 'verify']);
+  const publicJwk = await cryptoApi.subtle.exportKey('jwk', keys.publicKey);
+  const privateJwk = await cryptoApi.subtle.exportKey('jwk', keys.privateKey);
+  return { version: 1, algorithm, peerId: await createPeerIdFromPublicJwk(publicJwk, cryptoApi), publicJwk, privateJwk };
+}

package/packages/reploid/src/artifacts/participant-proofs.js

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview Host-neutral participant identity proofs.
+ *
+ * A device's persistent participant identity (the Ed25519 or ECDSA P-256
+ * bundle browser and native hosts already keep) signs domain-separated
+ * canonical statements: device registration proofs and session bindings here, custody-key
+ * certificates in custody-certificate.js. WebCrypto only, so browser and
+ * native hosts can sign with the same code the server verifies with.
+ */
+
+import { canonicalize } from './canonical-json.js';
+import {
+  createPeerIdFromPublicJwk,
+  encodeBytes,
+  fromBase64Url,
+  getIdentitySignAlgorithm,
+  importSigningKey,
+  importVerificationKey,
+  toBase64Url
+} from './identity.js';
+
+export const REGISTRATION_PROOF_SCHEMA = 'reploid.device-registration-proof/v1';
+export const SESSION_BINDING_SCHEMA = 'reploid.device-session-binding/v1';
+export const DEVICE_HOSTS = Object.freeze(['browser', 'native']);
+
+const PROOF_KEYS = Object.freeze(['schema', 'challengeId', 'nonce', 'accountId', 'audience', 'participantId', 'publicJwk', 'host', 'signature']);
+const SESSION_BINDING_KEYS = Object.freeze(['schema', 'challengeId', 'nonce', 'accountId', 'sessionId', 'participantId', 'signature']);
+const COORDINATE = /^[A-Za-z0-9_-]{16,128}$/;
+
+const sameKeys = (value, keys) => Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+  && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+
+/**
+ * The public half of a participant identity: an Ed25519 or ECDSA P-256 JWK
+ * reduced to its coordinates. Returns null for anything else, including a
+ * JWK carrying private key material.
+ */
+export function normalizeParticipantPublicKey(jwk) {
+  if (!jwk || typeof jwk !== 'object' || Array.isArray(jwk) || Object.hasOwn(jwk, 'd')) return null;
+  if (jwk.kty === 'OKP' && jwk.crv === 'Ed25519' && COORDINATE.test(jwk.x ?? '') && jwk.y === undefined) {
+    return { kty: 'OKP', crv: 'Ed25519', x: jwk.x };
+  }
+  if (jwk.kty === 'EC' && jwk.crv === 'P-256' && COORDINATE.test(jwk.x ?? '') && COORDINATE.test(jwk.y ?? '')) {
+    return { kty: 'EC', crv: 'P-256', x: jwk.x, y: jwk.y };
+  }
+  return null;
+}
+
+/** The participant id every host derives from its identity public key. */
+export const participantIdFor = (publicJwk) => createPeerIdFromPublicJwk(publicJwk);
+
+const signedBytes = (domain, body) => encodeBytes(canonicalize({ signatureDomain: domain, payload: body }));
+
+/** Sign `body` under `domain` with a participant identity bundle ({ publicJwk, privateJwk, algorithm? }). */
+export async function signAsParticipant(identity, domain, body) {
+  const key = await importSigningKey(identity);
+  return toBase64Url(await crypto.subtle.sign(getIdentitySignAlgorithm(identity), key, signedBytes(domain, body)));
+}
+
+/** Verify a participant signature; malformed keys or signatures fail closed. */
+export async function verifyParticipantSignature(publicJwk, domain, body, signature) {
+  if (typeof signature !== 'string' || signature.length === 0 || signature.length > 256) return false;
+  try {
+    const key = await importVerificationKey(publicJwk);
+    return await crypto.subtle.verify(getIdentitySignAlgorithm(publicJwk), key, fromBase64Url(signature), signedBytes(domain, body));
+  } catch {
+    return false;
+  }
+}
+
+/** The statement a device signs to answer one registration challenge. */
+export const registrationProofBody = ({ challenge, participantId, publicJwk, host }) => ({
+  schema: REGISTRATION_PROOF_SCHEMA,
+  challengeId: challenge.challengeId,
+  nonce: challenge.nonce,
+  accountId: challenge.accountId,
+  audience: challenge.audience,
+  participantId,
+  publicJwk,
+  host
+});
+
+/** Device side: answer a server registration challenge with the persistent participant identity. */
+export async function createDeviceRegistrationProof({ identity, challenge, host }) {
+  const publicJwk = normalizeParticipantPublicKey(identity?.publicJwk);
+  if (!publicJwk || !identity.privateJwk) throw new TypeError('A persistent participant signing identity is required');
+  if (!DEVICE_HOSTS.includes(host)) throw new TypeError(`host must be one of ${DEVICE_HOSTS.join(', ')}`);
+  const body = registrationProofBody({ challenge, participantId: await participantIdFor(publicJwk), publicJwk, host });
+  return { ...body, signature: await signAsParticipant(identity, REGISTRATION_PROOF_SCHEMA, body) };
+}
+
+/**
+ * The statement a device signs to make the session that asked for
+ * `challenge` act as that device. Only a host holding that session signs it;
+ * a device registered from another session's challenge signs only the proof.
+ */
+export const sessionBindingBody = ({ challenge, participantId }) => ({
+  schema: SESSION_BINDING_SCHEMA,
+  challengeId: challenge.challengeId,
+  nonce: challenge.nonce,
+  accountId: challenge.accountId,
+  sessionId: challenge.sessionId,
+  participantId
+});
+
+/** Device side: bind the challenge's session to this persistent participant identity. */
+export async function createSessionBinding({ identity, challenge }) {
+  const publicJwk = normalizeParticipantPublicKey(identity?.publicJwk);
+  if (!publicJwk || !identity.privateJwk) throw new TypeError('A persistent participant signing identity is required');
+  if (typeof challenge?.sessionId !== 'string' || challenge.sessionId.length === 0) throw new TypeError('The challenge must name its session');
+  const body = sessionBindingBody({ challenge, participantId: await participantIdFor(publicJwk) });
+  return { ...body, signature: await signAsParticipant(identity, SESSION_BINDING_SCHEMA, body) };
+}
+
+/** Whether `binding` is `publicJwk`'s signed statement binding `challenge.sessionId` to it. */
+export async function checkSessionBinding(binding, { publicJwk, challenge }) {
+  if (!sameKeys(binding, SESSION_BINDING_KEYS) || binding.schema !== SESSION_BINDING_SCHEMA) return false;
+  const participantId = await participantIdFor(publicJwk);
+  const { signature, ...body } = binding;
+  const expected = sessionBindingBody({ challenge, participantId });
+  if (Object.keys(expected).some((key) => body[key] !== expected[key])) return false;
+  return verifyParticipantSignature(publicJwk, SESSION_BINDING_SCHEMA, body, signature);
+}
+
+/**
+ * Check a registration proof's form, key-to-participant binding and
+ * signature. Challenge freshness and ownership are the store's checks.
+ * Returns { problem, publicJwk, participantId }; problem is null when valid.
+ */
+export async function checkDeviceRegistrationProof(proof) {
+  if (!sameKeys(proof, PROOF_KEYS) || proof.schema !== REGISTRATION_PROOF_SCHEMA) return { problem: 'proof_malformed' };
+  const publicJwk = normalizeParticipantPublicKey(proof.publicJwk);
+  if (!publicJwk || !sameKeys(proof.publicJwk, Object.keys(publicJwk))) return { problem: 'proof_malformed' };
+  if (!DEVICE_HOSTS.includes(proof.host)) return { problem: 'proof_malformed' };
+  for (const key of ['challengeId', 'nonce', 'accountId', 'audience', 'participantId']) {
+    if (typeof proof[key] !== 'string' || proof[key].length === 0 || proof[key].length > 256) return { problem: 'proof_malformed' };
+  }
+  const participantId = await participantIdFor(publicJwk);
+  if (participantId !== proof.participantId) return { problem: 'participant_key_mismatch' };
+  const { signature, ...body } = proof;
+  if (!await verifyParticipantSignature(publicJwk, REGISTRATION_PROOF_SCHEMA, body, signature)) return { problem: 'proof_signature_invalid' };
+  return { problem: null, publicJwk, participantId };
+}
+
+export default {
+  REGISTRATION_PROOF_SCHEMA,
+  SESSION_BINDING_SCHEMA,
+  DEVICE_HOSTS,
+  normalizeParticipantPublicKey,
+  participantIdFor,
+  signAsParticipant,
+  verifyParticipantSignature,
+  registrationProofBody,
+  createDeviceRegistrationProof,
+  checkDeviceRegistrationProof,
+  sessionBindingBody,
+  createSessionBinding,
+  checkSessionBinding
+};

package/packages/reploid/src/artifacts/receipt.js

@@ -0,0 +1,131 @@
+import { canonicalize as stableJson } from './canonical-json.js';
+import { wholeModelReceiptFields } from './whole-model-receipt.js';
+import { sha256HexUnprefixed } from './signatures.js';
+/**
+ * @fileoverview Signed receipt primitives for swarm contribution proof.
+ */
+
+import {
+  encodeBytes,
+  getIdentitySignAlgorithm,
+  importSigningKey,
+  importVerificationKey,
+  toBase64Url,
+  fromBase64Url,
+  createPeerIdFromPublicJwk
+} from './identity.js';
+
+
+
+const getCryptoApi = (cryptoApi) => {
+  const api = cryptoApi || globalThis.crypto;
+  if (!api?.subtle) {
+    throw new Error('WebCrypto unavailable');
+  }
+  return api;
+};
+
+
+export function getReceiptPayload(receipt = {}) {
+  return {
+    version: Number(receipt.version || 1),
+    receiptId: String(receipt.receiptId || ''),
+    provider: String(receipt.provider || ''),
+    consumer: String(receipt.consumer || ''),
+    jobHash: String(receipt.jobHash || ''),
+    model: String(receipt.model || ''),
+    inputTokens: Math.max(0, Number(receipt.inputTokens || 0)),
+    outputTokens: Math.max(0, Number(receipt.outputTokens || 0)),
+    status: String(receipt.status || 'completed'),
+    timestamp: Number(receipt.timestamp || Date.now()),
+    ...(Number(receipt.version) === 2 ? wholeModelReceiptFields({ ...receipt, version: 2 }) : {})
+  };
+}
+
+export function canonicalizeReceiptPayload(receipt = {}) {
+  return stableJson(getReceiptPayload(receipt));
+}
+
+export async function createReceiptDraft(input = {}, cryptoApi = globalThis.crypto) {
+  const payload = getReceiptPayload({
+    ...input,
+    receiptId: ''
+  });
+  const digest = await sha256HexUnprefixed(canonicalizeReceiptPayload(payload), getCryptoApi(cryptoApi));
+
+  return {
+    ...payload,
+    receiptId: String(input.receiptId || `receipt:${digest.slice(0, 24)}`)
+  };
+}
+
+async function signPayload(payload, bundle, cryptoApi = globalThis.crypto) {
+  const subtle = getCryptoApi(cryptoApi).subtle;
+  const signingKey = await importSigningKey(bundle, cryptoApi);
+  const signature = await subtle.sign(
+    getIdentitySignAlgorithm(bundle),
+    signingKey,
+    encodeBytes(canonicalizeReceiptPayload(payload))
+  );
+  return toBase64Url(signature);
+}
+
+async function verifyPayload(payload, signature, publicJwk, cryptoApi = globalThis.crypto) {
+  const subtle = getCryptoApi(cryptoApi).subtle;
+  const verificationKey = await importVerificationKey(publicJwk, cryptoApi);
+  return subtle.verify(
+    getIdentitySignAlgorithm(publicJwk),
+    verificationKey,
+    fromBase64Url(signature),
+    encodeBytes(canonicalizeReceiptPayload(payload))
+  );
+}
+
+export async function signReceiptDraft(draft, providerBundle, cryptoApi = globalThis.crypto) {
+  const payload = getReceiptPayload(draft);
+  return {
+    ...payload,
+    providerSignature: await signPayload(payload, providerBundle, cryptoApi),
+    providerKey: providerBundle.publicJwk
+  };
+}
+
+export async function countersignReceipt(receipt, consumerBundle, cryptoApi = globalThis.crypto) {
+  const payload = getReceiptPayload(receipt);
+  return {
+    ...receipt,
+    consumerSignature: await signPayload(payload, consumerBundle, cryptoApi),
+    consumerKey: consumerBundle.publicJwk
+  };
+}
+
+export async function verifyReceipt(receipt, cryptoApi = globalThis.crypto) {
+  const payload = getReceiptPayload(receipt);
+  if (payload.version === 2 && (await createPeerIdFromPublicJwk(receipt.providerKey, cryptoApi) !== receipt.provider
+    || receipt.consumerSignature && await createPeerIdFromPublicJwk(receipt.consumerKey, cryptoApi) !== receipt.consumer)) {
+    return { providerValid: false, consumerValid: false, valid: false };
+  }
+
+  const providerValid = receipt?.providerSignature && receipt?.providerKey
+    ? await verifyPayload(payload, receipt.providerSignature, receipt.providerKey, cryptoApi)
+    : false;
+
+  const consumerValid = !receipt?.consumerSignature || !receipt?.consumerKey
+    ? false
+    : await verifyPayload(payload, receipt.consumerSignature, receipt.consumerKey, cryptoApi);
+
+  return {
+    providerValid,
+    consumerValid,
+    valid: providerValid && (!receipt?.consumerSignature || consumerValid)
+  };
+}
+
+export default {
+  canonicalizeReceiptPayload,
+  countersignReceipt,
+  createReceiptDraft,
+  getReceiptPayload,
+  signReceiptDraft,
+  verifyReceipt
+};

package/packages/reploid/src/artifacts/signatures.js

@@ -0,0 +1,94 @@
+import { bytesToBase64, base64ToBytes } from './binary.js';
+import { canonicalize } from './canonical-json.js';
+import { sha256Bytes, sha256HexUnprefixed, sha256Hex } from '../hashing.js';
+
+export { sha256Bytes, sha256HexUnprefixed, sha256Hex };
+
+const textEncoder = new TextEncoder();
+
+export async function hashJson(value, cryptoApi = globalThis.crypto) {
+  return sha256Hex(canonicalize(value), cryptoApi);
+}
+
+export async function createSigningKeyPair() {
+  return crypto.subtle.generateKey(
+    { name: 'ECDSA', namedCurve: 'P-256' },
+    true,
+    ['sign', 'verify']
+  );
+}
+
+export async function exportPublicKey(publicKey) {
+  const spki = await crypto.subtle.exportKey('spki', publicKey);
+  return bytesToBase64(new Uint8Array(spki));
+}
+
+export async function exportPrivateKey(privateKey) {
+  const pkcs8 = await crypto.subtle.exportKey('pkcs8', privateKey);
+  return bytesToBase64(new Uint8Array(pkcs8));
+}
+
+export async function importPublicKey(publicKeyBase64) {
+  const bytes = base64ToBytes(publicKeyBase64);
+  return crypto.subtle.importKey(
+    'spki',
+    bytes,
+    { name: 'ECDSA', namedCurve: 'P-256' },
+    true,
+    ['verify']
+  );
+}
+
+export async function importPrivateKey(privateKeyBase64) {
+  const bytes = base64ToBytes(privateKeyBase64);
+  return crypto.subtle.importKey(
+    'pkcs8',
+    bytes,
+    { name: 'ECDSA', namedCurve: 'P-256' },
+    true,
+    ['sign']
+  );
+}
+
+export async function importSigningKeyPair({ privateKey, publicKey } = {}) {
+  if (!privateKey || !publicKey) throw new Error('privateKey and publicKey are required');
+  return {
+    privateKey: await importPrivateKey(privateKey),
+    publicKey: await importPublicKey(publicKey)
+  };
+}
+
+export function domainSeparatedPayload(domain, payload) {
+  const normalized = String(domain || '').trim();
+  if (!normalized) throw new Error('signature domain is required');
+  return {
+    signatureDomain: normalized,
+    payload
+  };
+}
+
+export async function signCanonical(value, privateKey, { domain = null } = {}) {
+  const signingValue = domain ? domainSeparatedPayload(domain, value) : value;
+  const payload = textEncoder.encode(canonicalize(signingValue));
+  const signature = await crypto.subtle.sign(
+    { name: 'ECDSA', hash: 'SHA-256' },
+    privateKey,
+    payload
+  );
+  return bytesToBase64(new Uint8Array(signature));
+}
+
+export async function verifyCanonicalSignature(value, publicKeyBase64, signatureBase64, { domain = null, allowLegacy = false } = {}) {
+  const publicKey = await importPublicKey(publicKeyBase64);
+  const verifyValue = async (candidate) => crypto.subtle.verify(
+    { name: 'ECDSA', hash: 'SHA-256' },
+    publicKey,
+    base64ToBytes(signatureBase64),
+    textEncoder.encode(canonicalize(candidate))
+  );
+  if (!domain) return verifyValue(value);
+  const domainOk = await verifyValue(domainSeparatedPayload(domain, value));
+  if (domainOk || !allowLegacy) return domainOk;
+  return verifyValue(value);
+}
+

package/packages/reploid/src/artifacts/whole-model-receipt.js

@@ -0,0 +1,42 @@
+/** Measured whole-model receipt fields. Signatures bind observations; they do not
+ * establish answer quality or independent correctness of the provider's GPU. */
+import { hashJson, sha256Hex } from './signatures.js';
+import { canonicalize } from './canonical-json.js';
+
+const digest = value => typeof value === 'string' && /^sha256:[a-f0-9]{64}$/.test(value);
+const count = value => Number.isSafeInteger(value) && value >= 0;
+const requireValue = (ok, message) => { if (!ok) throw Error(message); };
+
+export function wholeModelReceiptFields(receipt) {
+  requireValue(receipt.version === 2 && receipt.status === 'completed' && receipt.usage === 'raw-model-tokens/v1'
+    && receipt.cleanup === 'settled' && digest(receipt.modelIdentity) && digest(receipt.inputDigest) && digest(receipt.outputDigest)
+    && count(receipt.inputTokens) && count(receipt.outputTokens)
+    && Array.isArray(receipt.adapterIdentities) && receipt.adapterIdentities.length <= 1 && receipt.adapterIdentities.every(digest)
+    && (receipt.ownerPolicyDigest === null || digest(receipt.ownerPolicyDigest))
+    && typeof receipt.stopReason === 'string' && receipt.stopReason.length > 0 && receipt.stopReason.length <= 64,
+  'Invalid measured whole-model receipt');
+  return { modelIdentity: receipt.modelIdentity, adapterIdentities: [...receipt.adapterIdentities],
+    inputDigest: receipt.inputDigest, outputDigest: receipt.outputDigest, usage: receipt.usage,
+    stopReason: receipt.stopReason, cleanup: receipt.cleanup, ownerPolicyDigest: receipt.ownerPolicyDigest };
+}
+
+/** Missing measurements stay missing. Never infer token counts from text. */
+export async function measureWholeModelReceipt(messages, result) {
+  const completion = result.completion ?? result.evidence?.output?.completion;
+  if (!completion) return null;
+  requireValue(completion.schema === 'doppler.generation-completion/v1'
+    && count(completion.promptTokenCount) && count(completion.generatedTokenCount)
+    && typeof result.content === 'string', 'Measured generation completion required');
+  const measured = { version: 2, status: 'completed', modelIdentity: result.modelIdentity,
+    adapterIdentities: result.adapterIdentities || [], inputDigest: await hashJson(messages),
+    outputDigest: await sha256Hex(result.content), inputTokens: completion.promptTokenCount,
+    outputTokens: completion.generatedTokenCount, usage: 'raw-model-tokens/v1',
+    stopReason: completion.stopReason, cleanup: 'settled', ownerPolicyDigest: result.ownerPolicyDigest ?? null };
+  wholeModelReceiptFields(measured);
+  return measured;
+}
+
+export async function matchesWholeModelReceipt(receipt, messages, result) {
+  const measured = await measureWholeModelReceipt(messages, result);
+  return measured !== null && Object.keys(measured).every(key => canonicalize(receipt[key]) === canonicalize(measured[key]));
+}

package/packages/reploid/src/cancellation.js

@@ -0,0 +1,44 @@
+/**
+ * The library's one abort race. Agent execution, transport, custody, retrieval
+ * and hosts stop awaiting borrowed work when its signal aborts; the borrowed
+ * work itself may keep running until its owner settles it.
+ */
+
+/** @template T @param {() => T | Promise<T>} operation @param {AbortSignal} signal @returns {Promise<T>} */
+export function abortable(operation, signal) {
+  if (signal.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener('abort', abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener('abort', abort, { once: true });
+    Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return operation();
+    }).then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+  });
+}
+
+/**
+ * abortable() that also stops waiting at `deadline` (epoch milliseconds),
+ * rejecting with `expired()`; the operation itself is not cancelled.
+ * @template T @param {() => T | Promise<T>} operation @param {AbortSignal} signal
+ * @param {{ deadline: number, expired: () => unknown }} limit @returns {Promise<T>}
+ */
+export function abortableBefore(operation, signal, { deadline, expired }) {
+  const timeout = new AbortController();
+  const timer = setTimeout(() => timeout.abort(expired()), Math.max(0, deadline - Date.now()));
+  return abortable(operation, AbortSignal.any([signal, timeout.signal])).finally(() => clearTimeout(timer));
+}
+
+/**
+ * Awaits work that has already started unless `signal` aborts first. A failure
+ * the work reports after the abort stays handled.
+ * @template T @param {T | Promise<T>} pending @param {AbortSignal} signal @returns {Promise<T>}
+ */
+export function untilAborted(pending, signal) {
+  const started = Promise.resolve(pending);
+  started.catch(() => {});
+  return abortable(() => started, signal);
+}

package/packages/reploid/src/config/defaults.json

@@ -0,0 +1,110 @@
+{
+  "schema": "reploid.config/v1",
+  "agent": {
+    "maxCycles": 2048,
+    "maxBatchTools": 5,
+    "singleToolNudgeThreshold": 3,
+    "milestoneAutoparkThreshold": 3,
+    "maxContextChars": 2000000,
+    "timeoutMs": 300000,
+    "retryDelayMs": 30000,
+    "maxRetryDelayMs": 300000,
+    "rgrArchiveLimit": 24,
+    "requiredAnchorObservations": 3,
+    "toolStringPreviewChars": 2048,
+    "toolResultPayloadChars": 4096,
+    "toolBatchBodyChars": 12288,
+    "toolSanitizeMaxDepth": 4,
+    "toolSanitizeArrayLimit": 25
+  },
+  "tools": {
+    "allowed": [],
+    "parallelSafe": [
+      "ReadFile"
+    ],
+    "ordered": [
+      "WriteFile",
+      "LoadModule"
+    ],
+    "exclusive": [
+      "Promote"
+    ],
+    "loaderId": null,
+    "allowDynamic": false
+  },
+  "memory": {
+    "storeId": null,
+    "checkpointPrefix": "/checkpoints",
+    "maxCheckpointBytes": 16777216
+  },
+  "models": {
+    "providerId": null,
+    "contract": null
+  },
+  "mesh": {
+    "enabled": false,
+    "executeJobs": false,
+    "supplyArtifacts": false,
+    "shareCandidates": false,
+    "roomId": null,
+    "routing": "local-only",
+    "generationTimeoutMs": 45000,
+    "maxPendingJobs": 8,
+    "maxInboundJobs": 1,
+    "maxRetainedJobs": 32
+  },
+  "webrtc": {
+    "protocol": "assignment/v1",
+    "signalingUrl": null,
+    "rtcConfig": {
+      "iceServers": [],
+      "iceTransportPolicy": "all"
+    },
+    "dataChannelLabel": "reploid-pool",
+    "dataChannelOptions": {
+      "ordered": true,
+      "maxRetransmits": null
+    },
+    "maxPendingRemoteIceCandidates": 64,
+    "pendingRemoteIceTtlMs": 30000,
+    "maxMessageBytes": 65536,
+    "maxBufferedBytes": 1048576,
+    "connectTimeoutMs": 30000,
+    "reconnectBaseMs": 1000,
+    "maxBackoffMs": 30000,
+    "heartbeatIntervalMs": 30000,
+    "peerTimeoutMs": 60000,
+    "announceIntervalMs": 15000,
+    "signalingProbeTimeoutMs": 2000,
+    "transportOrder": [
+      "webrtc"
+    ],
+    "sessionId": null,
+    "signaling": {
+      "pollIntervalMs": 1000,
+      "pollTimeoutMs": 5000,
+      "failureThreshold": 3,
+      "backoffBaseMs": 1000,
+      "backoffMaxMs": 30000
+    },
+    "broadcastRoomId": null
+  },
+  "artifacts": {
+    "root": "/artifacts",
+    "maxBytes": 268435456
+  },
+  "improvement": {
+    "enabled": false,
+    "evaluatorId": null,
+    "approvalId": null,
+    "isolationId": null
+  },
+  "observation": {
+    "enabled": true
+  },
+  "legacyAgent": {
+    "discoveryLimit": 3,
+    "maxToolCalls": 8,
+    "settings": null
+  }
+}