reploid 0.0.0-stage → 0.1.0

package/shared/vendor/reploid/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/shared/vendor/reploid/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/shared/vendor/reploid/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
+  }
+}

package/shared/vendor/reploid/config/index.js

@@ -0,0 +1,209 @@
+import defaults from './defaults.json' with { type: 'json' };
+import requestPolicy from './request-overrides.json' with { type: 'json' };
+import routing from '../rules/routing.rules.json' with { type: 'json' };
+import { sha256Hex } from '../hashing.js';
+
+const resolvedConfigurations = new WeakSet();
+const forbiddenKeys = new Set(['__proto__', 'prototype', 'constructor']);
+
+export class ConfigurationError extends TypeError {
+  constructor(path, message) {
+    super(`Reploid configuration ${path}: ${message}`);
+    this.name = 'ConfigurationError';
+    this.path = path;
+  }
+}
+
+export function snapshotJson(value, path = '$') {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (Array.isArray(value)) return value.map((entry, index) => snapshotJson(entry, `${path}[${index}]`));
+  if (value && Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.fromEntries(Object.keys(value).sort().map(key => {
+      if (forbiddenKeys.has(key)) throw new ConfigurationError(path, 'unsafe object key');
+      return [key, snapshotJson(value[key], `${path}.${key}`)];
+    }));
+  }
+  throw new ConfigurationError(path, 'expected JSON data; inject functions, resources and credentials as ports');
+}
+
+export function freezeJson(value) {
+  if (value && typeof value === 'object') {
+    Object.values(value).forEach(freezeJson);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+function merge(target, patch, source, provenance, path = '') {
+  for (const [key, value] of Object.entries(patch)) {
+    const field = path ? `${path}.${key}` : key;
+    if (!Object.hasOwn(target, key)) throw new ConfigurationError(field, 'unknown field');
+    const old = target[key];
+    if (old && typeof old === 'object' && !Array.isArray(old) && value && typeof value === 'object' && !Array.isArray(value)) {
+      merge(old, value, source, provenance, field);
+    } else {
+      target[key] = value;
+      provenance[field] = source;
+    }
+  }
+}
+
+function recordSources(value, sources, path = '') {
+  for (const [key, item] of Object.entries(value)) {
+    const field = path ? `${path}.${key}` : key;
+    if (item && typeof item === 'object' && !Array.isArray(item)) recordSources(item, sources, field);
+    else sources[field] = 'schema-defaults';
+  }
+}
+
+function requireType(value, expected, path) {
+  if (typeof value !== expected) throw new ConfigurationError(path, `expected ${expected}`);
+}
+
+function validate(config) {
+  if (config.schema !== defaults.schema) throw new ConfigurationError('schema', 'unsupported schema');
+  for (const section of Object.keys(defaults).filter(key => key !== 'schema')) {
+    if (!config[section] || typeof config[section] !== 'object' || Array.isArray(config[section])) {
+      throw new ConfigurationError(section, 'expected object');
+    }
+  }
+  for (const section of ['agent', 'legacyAgent', 'memory', 'mesh', 'webrtc', 'artifacts']) {
+    for (const [key, value] of Object.entries(defaults[section])) {
+      if (typeof value === 'number' && (!Number.isSafeInteger(config[section][key]) || config[section][key] < 1)) {
+        throw new ConfigurationError(`${section}.${key}`, 'expected positive safe integer');
+      }
+    }
+  }
+  if (config.legacyAgent.settings !== null) {
+    const settings = config.legacyAgent.settings;
+    if (!settings || typeof settings !== 'object' || Array.isArray(settings)
+      || Object.keys(settings).some(key => !['providerThrottle', 'cycleIntervalMs', 'functionGemma'].includes(key))
+      || !Number.isSafeInteger(settings.cycleIntervalMs) || settings.cycleIntervalMs < 0) {
+      throw new ConfigurationError('legacyAgent.settings', 'invalid attempt settings');
+    }
+  }
+  for (const key of ['enabled', 'executeJobs', 'supplyArtifacts', 'shareCandidates']) requireType(config.mesh[key], 'boolean', `mesh.${key}`);
+  requireType(config.tools.allowDynamic, 'boolean', 'tools.allowDynamic');
+  requireType(config.webrtc.dataChannelOptions?.ordered, 'boolean', 'webrtc.dataChannelOptions.ordered');
+  const retransmits = config.webrtc.dataChannelOptions?.maxRetransmits;
+  if (retransmits !== null && (!Number.isSafeInteger(retransmits) || retransmits < 0 || retransmits > 65535)) {
+    throw new ConfigurationError('webrtc.dataChannelOptions.maxRetransmits', 'expected uint16 or explicit null');
+  }
+  requireType(config.webrtc.dataChannelLabel, 'string', 'webrtc.dataChannelLabel');
+  if (!config.webrtc.dataChannelLabel) throw new ConfigurationError('webrtc.dataChannelLabel', 'must not be empty');
+  for (const [key, value] of Object.entries(config.webrtc.signaling)) {
+    if (!Number.isSafeInteger(value) || value < 1) throw new ConfigurationError(`webrtc.signaling.${key}`, 'expected positive safe integer');
+  }
+  if (Object.keys(config.webrtc.signaling).length !== Object.keys(defaults.webrtc.signaling).length) {
+    throw new ConfigurationError('webrtc.signaling', 'missing required policy');
+  }
+  requireType(config.improvement.enabled, 'boolean', 'improvement.enabled');
+  requireType(config.observation.enabled, 'boolean', 'observation.enabled');
+  for (const field of ['allowed', 'parallelSafe', 'ordered', 'exclusive']) {
+    if (!Array.isArray(config.tools[field]) || config.tools[field].some(value => typeof value !== 'string' || !value.trim())
+      || new Set(config.tools[field]).size !== config.tools[field].length) {
+      throw new ConfigurationError(`tools.${field}`, 'expected unique non-empty string array');
+    }
+  }
+  for (const [section, key] of [['tools','loaderId'],['memory','storeId'],['models','providerId'],
+    ['mesh','roomId'],['webrtc','signalingUrl'],['webrtc','sessionId'],['webrtc','broadcastRoomId'],
+    ['improvement','evaluatorId'],['improvement','approvalId'],['improvement','isolationId']]) {
+    const value = config[section][key];
+    if (value !== null && (typeof value !== 'string' || !value.trim())) {
+      throw new ConfigurationError(`${section}.${key}`, 'expected non-empty identifier or explicit null');
+    }
+  }
+  if (config.models.contract !== null && (!config.models.contract || typeof config.models.contract !== 'object' || Array.isArray(config.models.contract))) {
+    throw new ConfigurationError('models.contract', 'expected exact model contract or null');
+  }
+  if (!routing.rules.some(rule => rule.id === config.mesh.routing)) throw new ConfigurationError('mesh.routing', 'unknown routing rule');
+  if (!['assignment/v1', 'swarm/v1'].includes(config.webrtc.protocol)) throw new ConfigurationError('webrtc.protocol', 'unknown wire protocol');
+  if (!Array.isArray(config.webrtc.transportOrder) || !config.webrtc.transportOrder.length
+    || config.webrtc.transportOrder.some(type => !['webrtc', 'broadcast'].includes(type))) {
+    throw new ConfigurationError('webrtc.transportOrder', 'expected explicit transport order');
+  }
+  if (config.mesh.enabled && config.webrtc.transportOrder.includes('broadcast') && config.webrtc.broadcastRoomId === null) {
+    throw new ConfigurationError('webrtc.broadcastRoomId', 'BroadcastChannel requires its explicit protocol room');
+  }
+  const rtc = config.webrtc.rtcConfig;
+  if (!rtc || !Array.isArray(rtc.iceServers) || !['all', 'relay'].includes(rtc.iceTransportPolicy)) {
+    throw new ConfigurationError('webrtc.rtcConfig', 'ICE servers and transport policy are required');
+  }
+  for (const server of rtc.iceServers) {
+    if (!server || typeof server !== 'object' || Object.keys(server).some(key => key !== 'urls')) {
+      throw new ConfigurationError('webrtc.rtcConfig.iceServers', 'JSON carries URLs only; inject TURN credentials through RTC ports');
+    }
+    const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
+    if (!urls.length || urls.some(url => typeof url !== 'string' || !/^(stun|stuns|turn|turns):/.test(url))) {
+      throw new ConfigurationError('webrtc.rtcConfig.iceServers.urls', 'invalid ICE URL');
+    }
+  }
+  if (config.mesh.enabled && config.mesh.roomId === null) throw new ConfigurationError('mesh.roomId', 'enabled networking requires an explicit room');
+  if (config.improvement.enabled && ['evaluatorId', 'approvalId', 'isolationId'].some(key => config.improvement[key] === null)) {
+    throw new ConfigurationError('improvement', 'enabled improvement requires evaluator, approval and isolation ports');
+  }
+  for (const [section,key] of [['artifacts','root'],['memory','checkpointPrefix']]) {
+    const value = config[section][key];
+    if (typeof value !== 'string' || !value.startsWith('/') || value.split('/').includes('..')) {
+      throw new ConfigurationError(`${section}.${key}`, 'expected absolute logical path without traversal');
+    }
+  }
+  const secrets = new Set(['apiKey', 'accessToken', 'refreshToken', 'authorization', 'privateKey', 'privateJwk', 'password', 'credential']);
+  const rejectSecrets = (value, path) => {
+    if (!value || typeof value !== 'object') return;
+    for (const [key, item] of Object.entries(value)) {
+      if (secrets.has(key)) throw new ConfigurationError(`${path}.${key}`, 'credentials belong in host ports');
+      rejectSecrets(item, `${path}.${key}`);
+    }
+  };
+  rejectSecrets(config, '$');
+  if (config.webrtc.signalingUrl !== null) {
+    let url;
+    try { url = new URL(config.webrtc.signalingUrl); } catch { throw new ConfigurationError('webrtc.signalingUrl', 'expected absolute WebSocket URL'); }
+    if (!['ws:', 'wss:'].includes(url.protocol) || url.username || url.password
+      || [...url.searchParams.keys()].some(key => secrets.has(key) || key === 'token')) {
+      throw new ConfigurationError('webrtc.signalingUrl', 'use a credential-free WebSocket URL and host credential ports');
+    }
+  }
+  return config;
+}
+
+export function resolveConfig({ chain = [], profile = null, overrides = {}, request = {} } = {}) {
+  if (!Array.isArray(chain)) throw new ConfigurationError('chain', 'expected array');
+  const value = snapshotJson(defaults);
+  const provenance = {};
+  recordSources(value, provenance);
+  chain.forEach((layer, index) => merge(value, snapshotJson(layer), `chain[${index}]`, provenance));
+  if (profile !== null) {
+    const selected = snapshotJson(profile);
+    if (selected.schema !== 'reploid.profile/v1' || typeof selected.id !== 'string' || !selected.config) {
+      throw new ConfigurationError('profile', 'expected versioned profile');
+    }
+    merge(value, selected.config, `profile:${selected.id}`, provenance);
+  }
+  merge(value, snapshotJson(overrides), 'application-overrides', provenance);
+  const requestLayer = snapshotJson(request);
+  const paths = {};
+  recordSources(requestLayer, paths);
+  for (const field of Object.keys(paths)) {
+    if (!requestPolicy.paths.includes(field)) throw new ConfigurationError(field, 'request override is not allowlisted');
+  }
+  merge(value, requestLayer, 'request-overrides', provenance);
+  validate(value);
+  // Canonical JSON is the full identity, not an unverified short checksum.
+  const identity = `reploid.config/v1:${JSON.stringify(snapshotJson(value))}`;
+  const resolved = freezeJson({ value, provenance, identity });
+  resolvedConfigurations.add(resolved);
+  return resolved;
+}
+
+export function requireResolvedConfig(config) {
+  if (!resolvedConfigurations.has(config)) throw new ConfigurationError('$', 'call resolveConfig() before construction');
+  return config.value;
+}
+
+export async function hashConfiguration(config, cryptoApi = globalThis.crypto) {
+  requireResolvedConfig(config);
+  return sha256Hex(config.identity, cryptoApi);
+}

package/shared/vendor/reploid/config/request-overrides.json

@@ -0,0 +1,9 @@
+{
+  "schema": "reploid.request-overrides/v1",
+  "paths": [
+    "agent.maxCycles",
+    "agent.maxBatchTools",
+    "agent.timeoutMs",
+    "agent.maxContextChars"
+  ]
+}

package/shared/vendor/reploid/hashing.js

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview The library's one browser SHA-256 over Web Crypto. It lives at the library
+ * root, outside artifacts/, so modules any surface ships (including the Zero source
+ * image, which never exports artifacts paths) can import it.
+ */
+const textEncoder = new TextEncoder();
+const bytesToHex = (bytes) => Array.from(bytes)
+  .map((byte) => byte.toString(16).padStart(2, '0'))
+  .join('');
+
+/**
+ * The library's one SHA-256 over Web Crypto, as the raw ArrayBuffer digest: a
+ * Uint8Array is hashed as is, any other value as the UTF-8 bytes of
+ * String(value). Hosted services use their node:crypto twin, server/hashing.js.
+ */
+export async function sha256Bytes(value, cryptoApi = globalThis.crypto) {
+  const subtle = (cryptoApi || globalThis.crypto)?.subtle;
+  if (!subtle) throw new Error('WebCrypto unavailable');
+  return subtle.digest('SHA-256', value instanceof Uint8Array ? value : textEncoder.encode(String(value)));
+}
+
+/** Lowercase hex form of sha256Bytes, with no prefix. */
+export async function sha256HexUnprefixed(value, cryptoApi = globalThis.crypto) {
+  return bytesToHex(new Uint8Array(await sha256Bytes(value, cryptoApi)));
+}
+
+/** `sha256:`-prefixed form of sha256HexUnprefixed. */
+export async function sha256Hex(value, cryptoApi = globalThis.crypto) {
+  return `sha256:${await sha256HexUnprefixed(value, cryptoApi)}`;
+}