reploid 0.0.0-stage → 0.1.1

package/apps/poolday/host/partition-release.js

@@ -0,0 +1,33 @@
+import policy from '../config/partition-releases.json' with { type: 'json' };
+import { canonicalPartitionJson, partitionAdapterIdentities } from '../../../shared/vendor/reploid/mesh/partitions/partition-contract.js';
+
+/** Owner-reviewed public releases, never peer-advertised qualification. An approval
+ * binds the exact artifact, adapters and route descriptor (including stage identities).
+ * Evidence from diagnostic/test-signing journeys does not approve public service.
+ * Empty policy intentionally leaves public partition execution closed. */
+export function qualifiedPartitionRoute(model, approvals = policy.approvals) {
+  if (!model?.partition || !model.identity) return false;
+  const partition = model.partition;
+  const ids = partition.route?.schema === 'reploid.partition-route/v1'
+    ? Array.isArray(partition.route.stages) && partition.route.stages.map(stage => stage?.participantId)
+    : [partition.participantA, partition.participantB];
+  if (!ids || ids.length < 2 || ids.some(id => typeof id !== 'string' || !id) || new Set(ids).size !== ids.length) return false;
+  let adapterIdentities;
+  try { adapterIdentities = partitionAdapterIdentities(model); }
+  catch { return false; } // Malformed discovery is ineligible, not a catalog outage.
+  return Array.isArray(approvals) && approvals.some(approval => approval?.partition && Array.isArray(approval.adapterIdentities) && approval.modelId === model.id && approval.modelIdentity === model.identity
+    && typeof approval.evidence === 'string' && approval.evidence.trim()
+    && canonicalPartitionJson(approval.adapterIdentities) === canonicalPartitionJson(adapterIdentities)
+    && canonicalPartitionJson(approval.partition) === canonicalPartitionJson(partition));
+}
+
+export const availablePartitionRoute = (model, approvals) => qualifiedPartitionRoute(model, approvals)
+  && ['ready', 'busy'].includes(model.networkAvailability ?? model.availability);
+
+/** Saved selections must still name the currently admitted route. Never substitute. */
+export function currentPartitionRoute(model, models, approvals) {
+  return qualifiedPartitionRoute(model, approvals) && models.some(current => availablePartitionRoute(current, approvals)
+    && current.id === model.id && current.identity === model.identity
+    && canonicalPartitionJson(partitionAdapterIdentities(current)) === canonicalPartitionJson(partitionAdapterIdentities(model))
+    && canonicalPartitionJson(current.partition) === canonicalPartitionJson(model.partition));
+}

package/apps/poolday/host/work-partition-artifact-source.js

@@ -0,0 +1,37 @@
+/** Resolve signed Capsule paths against their declared manifest location and pinned source. */
+export function resolvePartitionArtifactSource(model, manifest, files, artifact) {
+  const reject = () => { throw new Error('Capsule artifact differs from the pinned catalog source'); };
+  let sourcePath = artifact?.path;
+  if (model.capsule !== undefined) {
+    const capsule = model.capsule;
+    const signed = capsule.artifacts?.find(row => row.artifactId === artifact?.artifactId);
+    const signedManifest = capsule.artifacts?.find(row => row.artifactId === capsule.program?.manifestArtifactId);
+    if (!signed || !signedManifest || signedManifest.role !== 'manifest'
+      || signedManifest.hash !== model.identity
+      || ['artifactId', 'role', 'path', 'hash', 'sizeBytes'].some(key => signed[key] !== artifact[key])) reject();
+    const origin = 'https://reploid-capsule.invalid/';
+    const manifestURL = new URL(signedManifest.path, origin), artifactURL = new URL(artifact.path, origin);
+    for (const [url, path] of [[manifestURL, signedManifest.path], [artifactURL, artifact.path]]) {
+      if (url.origin !== new URL(origin).origin || url.search || url.hash || url.pathname.slice(1) !== path) reject();
+    }
+    const directory = signedManifest.path.slice(0, signedManifest.path.lastIndexOf('/') + 1);
+    // Metadata outside the manifest directory needs an exact catalog path.
+    // Model-local files keep their exact manifest-relative path, never a basename alias.
+    if (artifact.path.startsWith(directory)) sourcePath = artifact.path.slice(directory.length);
+  }
+  const shard = manifest.shards.find(row => row.filename === sourcePath);
+  const file = files.find(row => row.path === sourcePath)
+    || (shard && { path: shard.filename, role: 'model-weights', sizeBytes: shard.size,
+      hash: shard.hash, hashAlgorithm: manifest.hashAlgorithm });
+  // Signed pieces authenticate the selected ranges. The Capsule's SHA256
+  // whole-artifact identity and the source manifest's BLAKE3 shard identity
+  // are distinct; retain the latter for custody instead of relabeling it.
+  if (model.capsule && shard && manifest.hashAlgorithm === 'blake3'
+    && artifact.role === 'weight-shard' && model.capsule.program.weightArtifactIds?.includes(artifact.artifactId)
+    && /^sha256:[a-f0-9]{64}$/.test(artifact.hash) && /^[a-f0-9]{64}$/.test(shard.hash)
+    && file?.role === 'model-weights' && file.hashAlgorithm === manifest.hashAlgorithm
+    && file.hash === shard.hash && file.sizeBytes === shard.size && artifact.sizeBytes === shard.size) return file;
+  if (!file || file.sizeBytes !== artifact.sizeBytes || 'sha256:' + file.hash !== artifact.hash
+    || file.hashAlgorithm !== 'sha256') reject();
+  return file;
+}

package/apps/poolday/host/work-partition-capsule.js

@@ -0,0 +1,39 @@
+/** Exact signed resident admission; complete-job receipt rules remain unchanged. */
+import { hashDopplerEvidence, validateExecutablePack } from '../../../shared/pool/executable-pack.js';
+import { resolveDopplerExecutionContract } from '../../../shared/config/doppler-execution-contracts.js';
+
+export async function assertWorkResidentCapsule(model, session) {
+  const binding = model.executablePack, validation = validateExecutablePack(binding);
+  if (!validation.ok) throw new Error(validation.reasons.join('; '));
+  const contract = resolveDopplerExecutionContract(binding.schema);
+  if (contract.openMethod !== 'openCapsule' || binding.requiredOperation !== 'residentPartition'
+    || session?.schema !== contract.sessionSchema || !session.loaded || !session.residentPartition) {
+    throw new Error('Exact public Capsule resident session required');
+  }
+  if (await hashDopplerEvidence(binding.artifacts) !== binding.artifactClosureDigest
+    || contract.identityFields.some(field => binding[field] !== session[contract.sessionIdentity]?.[field])) {
+    throw new Error('Resident Capsule identity differs from the approved binding');
+  }
+  if (!binding.acceptedTargetPlanDigests.includes(session.selectedTargetPlanDigest)) {
+    throw new Error('Resident Capsule selected an unaccepted TargetPlan');
+  }
+  const verification = session.verification, capsule = verification?.capsule;
+  if (capsule?.schema !== binding.schema || capsule.modelId !== model.id
+    || session.manifestHash !== model.identity || verification.lifecycle?.authorization?.mode === 'retained-local') {
+    throw new Error('Resident Capsule model or delegation authorization differs');
+  }
+  const pieces = verification.pieceVerification;
+  const index = binding.artifacts.find(row => row.artifactId === capsule.program.pieceIndexArtifactId);
+  if (verification.artifactVerificationScope !== 'resident-pieces' || pieces?.mode !== 'signed-piece-index'
+    || index?.role !== 'piece-index' || pieces.indexArtifactId !== index.artifactId
+    || pieces.indexIdentity !== index.hash || pieces.manifestIdentity !== model.identity) {
+    throw new Error('Resident Capsule requires exact signed piece verification');
+  }
+  const full = binding.artifacts.filter(row => row.role !== 'weight-shard')
+    .map(({ artifactId, hash, sizeBytes }) => ({ artifactId, hash, sizeBytes }));
+  if (await hashDopplerEvidence(full) !== await hashDopplerEvidence(verification.artifactReceipts)
+    || await hashDopplerEvidence(pieces.declaredWeightArtifactIds)
+      !== await hashDopplerEvidence(capsule.program.weightArtifactIds)) {
+    throw new Error('Resident Capsule verification does not cover its declared closure');
+  }
+}

package/apps/poolday/host/work-partition-plan.js

@@ -0,0 +1,167 @@
+/** Hosts carry an explicit Doppler plan; Doppler validates its geometry and storage. */
+import { freezeJson } from '../../../shared/vendor/reploid/config/index.js';
+import { partitionActivationContract } from '../../../shared/vendor/reploid/mesh/partitions/partition-contract.js';
+import { validateRouteCostPolicy } from '../../../shared/vendor/reploid/mesh/partitions/partition-route-ranking.js';
+import { selectWorkAdapters } from '../providers/work-adapter.js';
+import partitionPolicy from '../config/partition-policy.json' with { type: 'json' };
+
+export function snapshotWorkPartitionSelection(selected) {
+  const adapters = selectWorkAdapters(selected);
+  selected = { ...selected, adapters };
+  if (selected.partitionPlan === undefined) return selected;
+  const plan = selected.partitionPlan;
+  if (!plan || plan.modelId !== selected.id
+    || selected.partitionSplitLayer !== undefined && plan.splitLayer !== selected.partitionSplitLayer) {
+    throw new Error('Declared partition plan differs from the selected model or split');
+  }
+  return { ...selected, partitionPlan: freezeJson({ ...structuredClone(plan), ...(adapters.length ? { adapterIdentities: adapters.map(adapter => adapter.identity) } : {}) }) };
+}
+
+/** A catalog model participates in ordered routes only through its declared Doppler plan version. */
+export const isWorkOrderedModel = model => model?.partitionPlan?.schema === 'doppler.layer-partition-contract/v3';
+
+/** Host stage identity is explicit; discovery cannot invent a resident session. */
+export function snapshotWorkPartitionStage(selected, index, participantId, ordered, canonical) {
+  const isOrdered = selected.partitionPlan?.schema === 'doppler.layer-partition-contract/v3';
+  if (!isOrdered && !ordered) return null;
+  const stage = ordered?.stage;
+  if (!isOrdered || canonical || !stage || !Number.isSafeInteger(index) || index < 0
+    || index >= selected.partitionPlan.stageCount || stage.index !== index || stage.participantId !== participantId
+    || !['participantId', 'transportId', 'residentId', 'executionId'].every(key => typeof stage[key] === 'string' && stage[key].length > 0)
+    || Object.keys(stage).some(key => !['index', 'participantId', 'transportId', 'residentId', 'executionId'].includes(key))) {
+    throw new Error('Ordered contribution requires an explicit matching host stage and ordinary execution');
+  }
+  return freezeJson(structuredClone(stage));
+}
+
+export function workOrderedResidentOptions(runtime, stage) {
+  if (!stage) return {};
+  if (runtime.ORDERED_LAYER_PARTITION_SCHEMA !== 'doppler.layer-partition-contract/v3'
+    || !['validateOrderedLayerPartitionPlan', 'resolveLayerPartition', 'hashLayerPartitionPlan',
+      'hashPartitionGeneration', 'getPartitionActivationContract'].every(key => typeof runtime[key] === 'function')) {
+    throw new Error('Installed Doppler does not support the ordered resident contract');
+  }
+  return { ordered: { runtime, stage } };
+}
+
+export function createWorkPartitionPlan(runtime, manifest, selected, index = 0) {
+  selected = snapshotWorkPartitionSelection(selected);
+  if (selected.partitionPlan === undefined) {
+    return runtime.createLayerPartitionPlan({ modelId: manifest.modelId, ...manifest.architecture,
+      splitLayer: selected.partitionSplitLayer,
+      ...(selected.adapters.length ? { adapterIdentities: selected.adapters.map(adapter => adapter.identity) } : {}),
+      activationDtype: manifest.inference.session.compute.defaults.activationDtype });
+  }
+  if (manifest.modelId !== selected.id || typeof runtime.resolveLayerPartition !== 'function') {
+    throw new Error('Declared partition plan requires the matching manifest and Doppler plan validator');
+  }
+  const plan = selected.partitionPlan;
+  if (plan.schema === 'doppler.layer-partition-contract/v3') {
+    if (runtime.ORDERED_LAYER_PARTITION_SCHEMA !== plan.schema
+      || typeof runtime.validateOrderedLayerPartitionPlan !== 'function') {
+      throw new Error('Installed Doppler does not support the declared ordered plan');
+    }
+    runtime.validateOrderedLayerPartitionPlan(manifest, plan);
+  }
+  runtime.resolveLayerPartition(manifest, { plan, index });
+  partitionActivationContract(runtime, plan);
+  return plan;
+}
+
+/** Launch 3 policy members; each stays off unless the operator configures it. */
+const positiveInteger = value => Number.isSafeInteger(value) && value > 0;
+const exactKeys = (value, keys) => !!value && typeof value === 'object' && !Array.isArray(value)
+  && Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
+const validCostPolicy = value => { try { validateRouteCostPolicy(value); return true; } catch { return false; } };
+const ORCHESTRATION_POLICIES = Object.freeze({
+  autoStage: value => exactKeys(value, ['dwellMs']) && Number.isSafeInteger(value.dwellMs) && value.dwellMs >= 0,
+  // Prices, priors and reserves come only from the operator's versioned cost policy.
+  routeRanking: value => exactKeys(value, ['margin', 'smoothing', 'maxObservations', 'workload', 'costs'])
+    && typeof value.margin === 'number' && value.margin >= 0 && value.margin < 1
+    && typeof value.smoothing === 'number' && value.smoothing > 0 && value.smoothing <= 1 && positiveInteger(value.maxObservations)
+    && exactKeys(value.workload, ['promptTokens', 'expectedTokens']) && positiveInteger(value.workload.promptTokens)
+    && positiveInteger(value.workload.expectedTokens) && validCostPolicy(value.costs),
+  // Never above the operator's explicit stage budget (legacy hosts keep their ceiling).
+  admission: (value, maxGpuBufferBytes) => exactKeys(value, ['maxBytes', 'maxConcurrentAttempts', 'attemptBytes', ...(value?.queue === undefined ? [] : ['queue'])])
+    && positiveInteger(value.maxBytes) && value.maxBytes <= maxGpuBufferBytes
+    && positiveInteger(value.maxConcurrentAttempts) && positiveInteger(value.attemptBytes) && value.attemptBytes <= value.maxBytes
+    // A queued reservation must be answered before the execution channel's request timeout.
+    && (value.queue === undefined || exactKeys(value.queue, ['maxQueued', 'maxQueuedPerRequester', 'maxWaitMs'])
+      && positiveInteger(value.queue.maxQueued) && positiveInteger(value.queue.maxQueuedPerRequester)
+      && positiveInteger(value.queue.maxWaitMs) && value.queue.maxWaitMs < partitionPolicy.executionChannel.timeoutMs),
+  replicas: value => exactKeys(value, ['queueBound', 'bottleneckRatio']) && Number.isSafeInteger(value.queueBound)
+    && value.queueBound >= 0 && typeof value.bottleneckRatio === 'number' && Number.isFinite(value.bottleneckRatio) && value.bottleneckRatio > 1
+});
+const isAutoStage = stage => stage?.assignment === 'auto';
+
+/** Snapshot operator-selected geometry and limits before host connection awaits. */
+export function snapshotWorkOrderedParticipation(ordered, canonical, models) {
+  if (ordered === null) return null;
+  if (!ordered || canonical) throw new Error('Ordered participation requires an explicit ordinary host configuration');
+  const copy = structuredClone(ordered);
+  const selected = models.find(model => model.id === copy.stage?.modelId);
+  const budgets = selected?.partitionRuntime?.maxGpuBufferBytes;
+  let maxGpuBufferBytes = partitionPolicy.maxGpuBufferBytes;
+  if (budgets !== undefined) {
+    if (!Array.isArray(budgets) || budgets.length !== selected.partitionPlan?.stageCount || !budgets.every(positiveInteger)) {
+      throw new Error('Ordered model requires one explicit positive GPU budget per stage');
+    }
+    // Automatic reassignment may pick any stage, so its shared admission bound
+    // must fit the smallest of the authorized stage budgets.
+    maxGpuBufferBytes = isAutoStage(copy.stage) ? Math.min(...budgets) : budgets[copy.stage.index];
+  }
+  for (const key of ['maxStages', 'maxStageOffersPerPeer', 'maxRouteBytes', 'maxSelectionSteps', 'maxRoutes']) {
+    if (!Number.isSafeInteger(copy[key]) || copy[key] <= 0) throw new Error('Explicit ordered host limit required: ' + key);
+  }
+  if (copy.orchestration !== undefined) {
+    const policy = copy.orchestration;
+    if (!policy || typeof policy !== 'object' || Array.isArray(policy)
+      || Object.entries(policy).some(([key, value]) => !Object.hasOwn(ORCHESTRATION_POLICIES, key) || !ORCHESTRATION_POLICIES[key](value, maxGpuBufferBytes))) {
+      throw new Error('Ordered orchestration policy must name known, explicitly bounded mechanisms');
+    }
+  }
+  if (isAutoStage(copy.stage) !== (copy.orchestration?.autoStage !== undefined)
+    || copy.orchestration?.replicas !== undefined && !isAutoStage(copy.stage)) {
+    throw new Error('Automatic ordered stage requires both the operator auto choice and its orchestration policy');
+  }
+  if (isAutoStage(copy.stage)) {
+    // The operator authorizes this contributor's own policy to pick a stage of this model.
+    const stage = copy.stage, selected = models.find(model => model.id === stage.modelId);
+    if (!selected || selected.partitionPlan?.schema !== 'doppler.layer-partition-contract/v3'
+      || selected.partitionPlan.stageCount > copy.maxStages
+      || Object.keys(stage).some(key => !['modelId', 'assignment'].includes(key))) {
+      throw new Error('Ordered host stage requires a matching declared model plan and allocation identity');
+    }
+  } else if (copy.stage !== null) {
+    const stage = copy.stage, selected = models.find(model => model.id === stage?.modelId);
+    if (!selected || selected.partitionPlan?.schema !== 'doppler.layer-partition-contract/v3'
+      || !Number.isSafeInteger(stage.index) || stage.index < 0 || stage.index >= selected.partitionPlan.stageCount
+      || selected.partitionPlan.stageCount > copy.maxStages
+      || !['residentId', 'executionId'].every(key => typeof stage[key] === 'string' && stage[key].length > 0)
+      || Object.keys(stage).some(key => !['modelId', 'index', 'residentId', 'executionId', 'participantId', 'transportId'].includes(key))) {
+      throw new Error('Ordered host stage requires a matching declared model plan and allocation identity');
+    }
+  }
+  return freezeJson(copy);
+}
+
+/** Bind identity from the authenticated host, never from discovery or a caller route. */
+export function bindWorkOrderedParticipation(options, participantId, transportId, policy) {
+  if (!options) return { ordered: null, policy };
+  const configured = options.stage;
+  if (![participantId, transportId].every(value => typeof value === 'string' && value.length > 0)
+    || configured && (configured.participantId !== undefined && configured.participantId !== participantId
+      || configured.transportId !== undefined && configured.transportId !== transportId)) {
+    throw new Error('Ordered host identity differs from the authenticated transport');
+  }
+  const stage = configured === null || isAutoStage(configured) ? null : { index: configured.index, participantId, transportId,
+    residentId: configured.residentId, executionId: configured.executionId };
+  // Absent orchestration keeps the Launch 1 binding unchanged.
+  const orchestration = options.orchestration === undefined ? null : structuredClone(options.orchestration);
+  if (orchestration?.autoStage) orchestration.autoStage = { ...orchestration.autoStage, transportId };
+  return { ordered: { stage, maxRouteBytes: options.maxRouteBytes, maxSelectionSteps: options.maxSelectionSteps, maxRoutes: options.maxRoutes,
+    ...(orchestration ? { orchestration } : {}) },
+  // Every ordered stage, the coordinator's own included, runs under the declared execution-channel bound.
+  policy: { ...policy, maxStageOffersPerPeer: options.maxStageOffersPerPeer,
+    limits: { ...policy.limits, maxStages: options.maxStages, stageTimeoutMs: policy.executionChannel?.timeoutMs } } };
+}

package/apps/poolday/host/work-partition-tokenizer-guard.js

@@ -0,0 +1,21 @@
+/** Keep an authoritative tokenizer acquisition failure visible during resident opening. */
+export function createPartitionTokenizerGuard(storage) {
+  let failure = null, guarded = storage;
+  for (const name of ['loadTokenizerJson', 'loadTokenizerModel']) {
+    if (typeof storage[name] !== 'function') continue;
+    if (guarded === storage) guarded = { ...storage };
+    guarded[name] = async (...args) => {
+      try { return await storage[name](...args); }
+      catch (error) { failure ||= { error }; throw error; }
+    };
+  }
+  return Object.freeze({
+    storage: guarded,
+    assertAvailable() { if (failure) throw failure.error; },
+    explain(error) {
+      if (!failure || error === failure.error) return error;
+      const cause = failure.error;
+      return new AggregateError([cause, error], cause?.message || String(cause), { cause });
+    }
+  });
+}

package/apps/poolday/infrastructure/model-storage-lock.js

@@ -0,0 +1,22 @@
+/** Origin-wide cache use. A failed cleanup retains its lease until cleanup succeeds. */
+export const MODEL_STORAGE_LOCK = 'reploid:model-storage-use';
+
+export function retainModelStorage({ signal, locks = globalThis.navigator?.locks } = {}) {
+  // Hosts without browser storage can still execute injected models. Removal requires locks.
+  if (!locks?.request) return Promise.resolve(() => {});
+  return new Promise((resolve, reject) => {
+    const holding = locks.request(MODEL_STORAGE_LOCK, { mode: 'shared', ...(signal ? { signal } : {}) },
+      () => new Promise(release => resolve(() => { release(); return holding; })));
+    holding.catch(reject);
+  });
+}
+
+export function withUnusedModelStorage(operation, locks = globalThis.navigator?.locks) {
+  if (!locks?.request) throw new Error('Safe storage removal is unavailable in this browser.');
+  const names = [MODEL_STORAGE_LOCK, 'reploid:model-acquisition', 'reploid-chat-artifacts-v1:write'];
+  const enter = index => index === names.length ? operation() : locks.request(names[index], { ifAvailable: true }, lock => {
+    if (!lock) throw new Error('Model files are in use. Stop local models, downloads and file sharing in all Reploid tabs first.');
+    return enter(index + 1);
+  });
+  return enter(0);
+}

package/apps/poolday/infrastructure/pack-release-storage.js

@@ -0,0 +1,52 @@
+/** Browser-owned monotonic release checkpoints. Doppler verifies signed history. */
+const requireValue = (value, message) => { if (!value) throw new Error(`Pack release storage: ${message}`); };
+const valid = checkpoint => Number.isSafeInteger(checkpoint?.sequence) && checkpoint.sequence >= 0
+  && (checkpoint.sequence === 0 ? checkpoint.digest === null : /^sha256:[a-f0-9]{64}$/.test(checkpoint.digest));
+const same = (left, right) => left.sequence === right.sequence && left.digest === right.digest;
+
+export async function openPackReleaseCheckpoints({ name = 'reploid-pack-releases-v1', indexedDB = globalThis.indexedDB } = {}) {
+  requireValue(indexedDB, 'IndexedDB unavailable');
+  const opening = indexedDB.open(name, 1);
+  opening.onupgradeneeded = () => opening.result.createObjectStore('checkpoints');
+  const db = await new Promise((resolve, reject) => {
+    opening.onsuccess = () => resolve(opening.result);
+    opening.onerror = () => reject(opening.error);
+  });
+  let closed = false;
+  db.onversionchange = () => { closed = true; db.close(); };
+  const transact = (key, update) => new Promise((resolve, reject) => {
+    requireValue(!closed, 'store closed');
+    requireValue(/^sha256:[a-f0-9]{64}$/.test(key), 'bounded namespace digest required');
+    const transaction = db.transaction('checkpoints', 'readwrite');
+    const store = transaction.objectStore('checkpoints');
+    let result;
+    let failure;
+    transaction.oncomplete = () => resolve(result);
+    transaction.onabort = () => reject(failure || transaction.error || new Error('Pack release checkpoint transaction aborted'));
+    transaction.onerror = () => {};
+    const read = store.get(key);
+    read.onsuccess = () => {
+      try {
+        const current = read.result ?? { sequence: 0, digest: null };
+        requireValue(valid(current), 'stored checkpoint is invalid');
+        result = update(current);
+        store.put(result, key);
+      } catch (error) { failure = error; transaction.abort(); }
+    };
+  });
+  return {
+    read: key => transact(key, current => current),
+    advance(key, expected, next) {
+      requireValue(valid(expected) && valid(next) && next.sequence > 0, 'valid checkpoints required');
+      const prior = structuredClone(expected);
+      const observed = structuredClone(next);
+      return transact(key, current => {
+        if (same(current, observed)) return current;
+        requireValue(same(current, prior), 'checkpoint changed during verification');
+        requireValue(observed.sequence > current.sequence, 'rollback or fork rejected');
+        return observed;
+      });
+    },
+    close() { closed = true; db.close(); }
+  };
+}

package/apps/poolday/pool/pack-operation.js

@@ -0,0 +1,161 @@
+/** Local execution/evidence bridge. This module neither sends inputs nor authorizes delegation. */
+import { assertPackSession, assertPackExecutionEvidence, hashDopplerEvidence } from '../../../shared/pool/executable-pack.js';
+import { createPackOperationRegistry } from '../../../shared/pool/pack-operation-adapters.js';
+import { assertOperationLimits } from '../../../shared/pool/pack-operation-policy.js';
+import { resolveDopplerOperationContract } from '../../../shared/config/doppler-execution-contracts.js';
+import { assertDopplerGenerationContract, DopplerRuntimeService } from '../../../shared/infrastructure/doppler-runtime-service.js';
+import { dopplerOperationEvents } from '../../../shared/vendor/reploid/adapters/doppler-session.js';
+
+const requireValue = (value, message) => { if (!value) throw new Error(`Pack operation: ${message}`); };
+const equal = async (left, right) => await hashDopplerEvidence(left) === await hashDopplerEvidence(right);
+
+export function snapshotPackOperationData(value, depth = 0) {
+  requireValue(depth <= 64, 'observation depth exceeded');
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number') { requireValue(Number.isFinite(value), 'non-finite observation'); return value; }
+  requireValue(value && typeof value === 'object', 'JSON observation required');
+  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) value = Array.from(value);
+  requireValue(Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null, 'unsupported observation object');
+  return Object.freeze(Array.isArray(value)
+    ? Array.from(value, (item) => snapshotPackOperationData(item, depth + 1))
+    : Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshotPackOperationData(item, depth + 1)])));
+}
+
+function operationAdapter(registry, operation) {
+  requireValue(operation && Object.hasOwn(registry, operation.name) && registry[operation.name].version === operation.version, 'unknown operation or version');
+  return registry[operation.name];
+}
+
+export async function assertPackOperationReceipt(binding, receipt, { request, output, runtimeVersion }) {
+  await assertPackExecutionEvidence(binding, receipt);
+  requireValue(receipt.schema === resolveDopplerOperationContract(binding.schema, request.schema).receiptSchema, 'receipt schema mismatch');
+  const { receiptDigest, ...payload } = receipt;
+  requireValue(receiptDigest === await hashDopplerEvidence(payload), 'receipt digest mismatch');
+  requireValue(typeof runtimeVersion === 'string' && runtimeVersion.length > 0 && receipt.runtimeVersion === runtimeVersion, 'runtime version mismatch');
+  requireValue(binding.requiredOperation === request.operation.name && await equal(receipt.operation, request.operation), 'receipt operation mismatch');
+  requireValue(receipt.requestHash === await hashDopplerEvidence(request), 'request mismatch');
+  requireValue(receipt.assignmentHash === (request.assignment === null ? null : await hashDopplerEvidence(request.assignment)), 'assignment mismatch');
+  requireValue(receipt.inputHash === await hashDopplerEvidence({ input: request.input, options: request.options }), 'input mismatch');
+  requireValue(receipt.outputHash === await hashDopplerEvidence(output), 'output mismatch');
+  if (request.adapterSet?.length) {
+    requireValue(Array.isArray(receipt.adapterReceipts) && receipt.adapterReceipts.length === request.adapterSet.length, 'adapter execution evidence required');
+    for (const [index, entry] of request.adapterSet.entries()) {
+      const observed = receipt.adapterReceipts[index];
+      requireValue(observed.identity === entry.identity && observed.sourceDigest === entry.artifact.hash
+        && observed.requestDigest === await hashDopplerEvidence(entry)
+        && observed.runtimeIdentity?.schema === 'doppler.lora-execution-identity/v1'
+        && /^sha256:[a-f0-9]{64}$/.test(observed.runtimeIdentity.digest), 'adapter execution identity mismatch');
+    }
+  } else requireValue(!receipt.adapterReceipts?.length, 'unexpected active adapter');
+}
+
+export function assertPackOperationRequest(binding, request, registry = createPackOperationRegistry()) {
+  const adapter = operationAdapter(registry, request.operation);
+  requireValue(request.schema === resolveDopplerOperationContract(binding.schema, request.schema).requestSchema && binding.requiredOperation === request.operation.name, 'request operation binding mismatch');
+  requireValue(Object.keys(request).every((key) => ['schema', 'operation', 'input', 'options', 'assignment', 'limits', 'adapterSet'].includes(key)), 'unknown request field');
+  requireValue(request.assignment === null || (request.assignment && typeof request.assignment === 'object' && !Array.isArray(request.assignment)), 'explicit assignment or null required');
+  for (const key of ['maxInputBytes', 'maxOutputBytes', 'deadlineAt']) requireValue(Number.isSafeInteger(request.limits?.[key]) && request.limits[key] > 0, `${key} required`);
+  assertOperationLimits(request.limits, adapter.definition);
+  requireValue(new TextEncoder().encode(JSON.stringify({ input: request.input, options: request.options })).length <= request.limits.maxInputBytes, 'input byte limit exceeded');
+  adapter.validateRequest(request);
+}
+
+export async function createPackOperationStream(binding, request, runtimeVersion, runtimeService = DopplerRuntimeService) {
+  return resolveDopplerOperationContract(binding.schema, request.schema).incremental
+    ? runtimeService.createStreamAccumulator(request, { bindingSchema: binding.schema, runtimeVersion }) : null;
+}
+
+/** Shared stream verifier for local execution and signed remote delivery. */
+export async function assertPackOperationEvent({ binding, request, runtimeVersion, event,
+  eventIndex, previousEventDigest, registry = createPackOperationRegistry(), streamAccumulator = null }) {
+  const adapter = operationAdapter(registry, request.operation);
+  const contract = resolveDopplerOperationContract(binding.schema, request.schema);
+  const { eventDigest, ...payload } = event;
+  requireValue(event.schema === contract.eventSchema && ['partial', 'completed'].includes(event.status), 'event schema or status mismatch');
+  requireValue(event.status !== 'partial' || adapter.definition.streaming.partial, 'operation policy forbids partial output');
+  if (contract.incremental) {
+    requireValue(streamAccumulator, 'incremental stream reconstruction is required');
+    requireValue(event.eventIndex === eventIndex && event.previousEventDigest === previousEventDigest, 'duplicate, missing, or reordered event');
+    streamAccumulator.accept(event);
+    if (event.status === 'completed') {
+      adapter.validateOutput(event.output, request, { completed: true });
+      await assertPackOperationReceipt(binding, event.receipt, { request, output: event.output, runtimeVersion });
+    }
+    return;
+  }
+  requireValue(eventDigest === await hashDopplerEvidence(payload), 'event digest mismatch');
+  requireValue(event.eventIndex === eventIndex && event.previousEventDigest === previousEventDigest, 'duplicate, missing, or reordered event');
+  requireValue(event.requestHash === await hashDopplerEvidence(request)
+    && event.assignmentHash === (request.assignment === null ? null : await hashDopplerEvidence(request.assignment))
+    && await equal(event.operation, request.operation), 'event belongs to another request');
+  requireValue(new TextEncoder().encode(JSON.stringify(event.output)).length <= request.limits.maxOutputBytes, 'output byte limit exceeded');
+  adapter.validateOutput(event.output, request, { completed: event.status === 'completed' });
+  if (event.status === 'completed') await assertPackOperationReceipt(binding, event.receipt, { request, output: event.output, runtimeVersion });
+  else requireValue(!Object.hasOwn(event, 'receipt'), 'partial output cannot carry completion evidence');
+}
+
+export async function runPackOperation({ binding: bindingInput, session, request: requestInput, runtimeVersion,
+  registry = createPackOperationRegistry(), signal = null, adapterArtifactStore = null, onPartial = null, beforeExecute = null, assertCurrent = async () => {}, runtimeService = DopplerRuntimeService }) {
+  const binding = snapshotPackOperationData(bindingInput);
+  const request = snapshotPackOperationData(requestInput);
+  assertPackOperationRequest(binding, request, registry);
+  const definition = operationAdapter(registry, request.operation).definition;
+  requireValue(request.limits.deadlineAt - Date.now() <= definition.maximumLimits.maxJobMs, 'deadline exceeds configured operation limit');
+  requireValue(typeof runtimeVersion === 'string' && runtimeVersion.length > 0, 'runtime version required');
+  const current = async () => {
+    signal?.throwIfAborted();
+    requireValue(Date.now() < request.limits.deadlineAt, 'deadline exceeded');
+    await assertCurrent();
+    signal?.throwIfAborted();
+    requireValue(Date.now() < request.limits.deadlineAt, 'deadline exceeded');
+  };
+  await current();
+  await assertPackSession(binding, session);
+  if (request.operation.name === 'generate') assertDopplerGenerationContract(session);
+  requireValue(typeof session.executeOperation === 'function', 'public executeOperation is required; no legacy operation fallback');
+  const streamAccumulator = await createPackOperationStream(binding, request, runtimeVersion, runtimeService);
+  await beforeExecute?.();
+  await current();
+  let previousEventDigest = null;
+  let eventCount = 0;
+  let streamBytes = 0;
+  let completed = null;
+  for await (const received of dopplerOperationEvents(session, request, { signal, ...(request.adapterSet?.length ? { adapterArtifactStore } : {}) })) {
+    await current();
+    requireValue(!completed, 'output after completion');
+    const event = snapshotPackOperationData(received);
+    streamBytes += new TextEncoder().encode(JSON.stringify(event)).length;
+    requireValue(eventCount < definition.maximumLimits.maxEvents && streamBytes <= definition.maximumLimits.maxStreamBytes,
+      'configured operation stream limit exceeded');
+    await assertPackOperationEvent({ binding, request, runtimeVersion, event, eventIndex: eventCount, previousEventDigest, registry, streamAccumulator });
+    await current();
+    if (event.status === 'completed') {
+      completed = event;
+    } else {
+      await onPartial?.(event);
+    }
+    eventCount++;
+    previousEventDigest = event.eventDigest;
+  }
+  // Do not expose completion until iterator cleanup and the current-attempt check finish.
+  await current();
+  requireValue(completed, 'stream ended without completion');
+  streamAccumulator?.finish();
+  return Object.freeze({ request, output: completed.output, receipt: completed.receipt, eventCount, finalEventDigest: previousEventDigest, completion: completed });
+}
+
+export async function assessPackOperation({ execution, reference: referenceInput, policy: policyInput, registry = createPackOperationRegistry() }) {
+  const policy = snapshotPackOperationData(policyInput);
+  const reference = snapshotPackOperationData(referenceInput);
+  const adapter = operationAdapter(registry, execution.request.operation);
+  requireValue(policy.schema === 'poolday.operation-comparison/v1' && await equal(policy.operation, execution.request.operation), 'comparison operation mismatch');
+  const policyDigest = await hashDopplerEvidence(policy);
+  requireValue(execution.request.assignment?.comparisonPolicyDigest === policyDigest, 'comparison policy was not frozen in the assignment');
+  requireValue(policy.referenceDigest === await hashDopplerEvidence(reference), 'reference digest mismatch');
+  adapter.validateOutput(reference, execution.request, { completed: true });
+  adapter.validateOutput(execution.output, execution.request, { completed: true });
+  const accepted = adapter.compare(execution.output, reference, policy);
+  requireValue(typeof accepted === 'boolean', 'comparison must return a decision');
+  return Object.freeze({ schema: 'poolday.operation-assessment/v1', accepted, policyDigest,
+    receiptDigest: execution.receipt.receiptDigest, claim: 'bounded-reference-comparison' });
+}

package/apps/poolday/pool/pack-release-policy.js

@@ -0,0 +1,44 @@
+import { openPackReleaseCheckpoints } from '../infrastructure/pack-release-storage.js';
+import { hashDopplerEvidence } from '../../../shared/pool/executable-pack.js';
+import { snapshotPackOperationData } from './pack-operation.js';
+import { resolveDopplerExecutionContract } from '../../../shared/config/doppler-execution-contracts.js';
+
+const requireValue = (value, message) => { if (!value) throw new Error(`Pack release policy: ${message}`); };
+
+/** The application retains anti-rollback state; Doppler retains verification authority. */
+export async function prepareLocalPackRelease({ model, now = Date.now, openCheckpoints = openPackReleaseCheckpoints }) {
+  const options = model.packOpenOptions;
+  if (!resolveDopplerExecutionContract(model.executablePack.schema).releaseHistory) return { options, assertCurrent() {}, close() {} };
+  const authority = options.releaseEvents?.[0]?.signature?.authority;
+  const applicationId = model.application?.applicationId;
+  requireValue(typeof authority === 'string' && authority.length > 0 && typeof applicationId === 'string'
+    && applicationId.length > 0, 'explicit release authority and application required');
+  requireValue(Number.isSafeInteger(options.releasePolicy?.minimumSequence)
+    && options.releasePolicy.minimumSequence > 0, 'explicit minimum release sequence required');
+  const namespace = await hashDopplerEvidence({ authority, applicationId });
+  const storage = await openCheckpoints();
+  try {
+    let checkpoint = await storage.read(namespace);
+    const minimumSequence = Math.max(checkpoint.sequence, options.releasePolicy.minimumSequence);
+    const checkTime = session => {
+      const lifecycle = session.verification?.lifecycle;
+      requireValue(lifecycle && lifecycle.event.sequence >= minimumSequence, 'verified lifecycle required');
+      requireValue(Date.parse(lifecycle.event.issuedAtUtc) <= now(), 'release issuance is in the future');
+      requireValue(Date.parse(lifecycle.event.expiresAtUtc) > now(), 'release eligibility expired');
+      return lifecycle;
+    };
+    return {
+      options: { ...options, releasePolicy: { ...options.releasePolicy, minimumSequence,
+        now: new Date(now()).toISOString(), checkpoint: snapshotPackOperationData(checkpoint) },
+      async persistReleaseCheckpoint(next) { checkpoint = await storage.advance(namespace, checkpoint, next); } },
+      checkTime,
+      async assertCurrent(session) {
+        const lifecycle = checkTime(session);
+        const saved = await storage.read(namespace);
+        requireValue(lifecycle.checkpoint.sequence === saved.sequence && lifecycle.checkpoint.digest === saved.digest,
+          'release checkpoint changed; reopen with current signed history');
+      },
+      close: () => storage.close()
+    };
+  } catch (error) { storage.close(); throw error; }
+}