@holoscript/core 7.0.0 → 8.0.1

package/dist/world-model/index.cjs

@@ -0,0 +1,1446 @@
+'use strict';
+
+require('../chunk-HCCQLAA4.cjs');
+
+// src/world-model/AdversarialTrajectory.ts
+function isCurriculumEligible(trajectory) {
+  return trajectory.status !== "invalid" && trajectory.priority.priority > 0;
+}
+function hasReplayEvidence(trajectory) {
+  const contract = trajectory.simulationContract;
+  const handle = trajectory.replayHandle;
+  return contract.contractId.trim().length > 0 && handle.simulationContractId === contract.contractId && handle.replayCommand.trim().length > 0 && (contract.replayDigestMode === "unsigned-observed" || contract.fieldQuantization.length > 0);
+}
+function asTrajectoryId(s) {
+  return s;
+}
+function asSceneHash(s) {
+  return s;
+}
+function asCaelReceiptHash(s) {
+  return s;
+}
+
+// src/world-model/HardwareReceiptMetadata.ts
+var HARDWARE_RECEIPT_METADATA_SCHEMA_VERSION = "holoscript.hardware-receipt-metadata.v1";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasText(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function requireText(record, key, path, errors) {
+  if (!hasText(record[key])) {
+    errors.push(`Missing ${path}.${key}`);
+  }
+}
+function requireObject(record, key, errors) {
+  const value = record[key];
+  if (!isRecord(value)) {
+    errors.push(`Missing ${key}`);
+    return null;
+  }
+  return value;
+}
+function requireArray(record, key, errors) {
+  const value = record[key];
+  if (!Array.isArray(value)) {
+    errors.push(`Missing ${key}`);
+    return null;
+  }
+  return value;
+}
+function validateConstraints(items, errors) {
+  for (const [index, item] of items.entries()) {
+    if (!isRecord(item)) {
+      errors.push(`constraints[${index}] must be an object`);
+      continue;
+    }
+    requireText(item, "id", `constraints[${index}]`, errors);
+    requireText(item, "description", `constraints[${index}]`, errors);
+    if (!["string", "number", "boolean"].includes(typeof item.limit)) {
+      errors.push(`Missing constraints[${index}].limit`);
+    }
+  }
+}
+function validateMeasuredResults(items, errors) {
+  if (items.length === 0) {
+    errors.push("measuredResults must include at least one measurement");
+  }
+  for (const [index, item] of items.entries()) {
+    if (!isRecord(item)) {
+      errors.push(`measuredResults[${index}] must be an object`);
+      continue;
+    }
+    requireText(item, "metric", `measuredResults[${index}]`, errors);
+    if (typeof item.value !== "number" || !Number.isFinite(item.value)) {
+      errors.push(`Missing measuredResults[${index}].value`);
+    }
+    requireText(item, "unit", `measuredResults[${index}]`, errors);
+    requireText(item, "method", `measuredResults[${index}]`, errors);
+  }
+}
+function validateReplayInputs(items, errors) {
+  if (items.length === 0) {
+    errors.push("replayInputs must include at least one replay input");
+  }
+  for (const [index, item] of items.entries()) {
+    if (!isRecord(item)) {
+      errors.push(`replayInputs[${index}] must be an object`);
+      continue;
+    }
+    requireText(item, "kind", `replayInputs[${index}]`, errors);
+    requireText(item, "uri", `replayInputs[${index}]`, errors);
+    requireText(item, "sha256", `replayInputs[${index}]`, errors);
+  }
+}
+function validatePortableHardwareReceiptMetadata(receipt) {
+  const errors = [];
+  if (!isRecord(receipt)) {
+    return { valid: false, errors: ["Hardware receipt metadata must be an object"] };
+  }
+  if (receipt.schemaVersion !== HARDWARE_RECEIPT_METADATA_SCHEMA_VERSION) {
+    errors.push(
+      `schemaVersion must be ${HARDWARE_RECEIPT_METADATA_SCHEMA_VERSION}`
+    );
+  }
+  const target = requireObject(receipt, "target", errors);
+  if (target) {
+    requireText(target, "id", "target", errors);
+    requireText(target, "kind", "target", errors);
+    requireText(target, "architecture", "target", errors);
+    requireText(target, "artifactKind", "target", errors);
+  }
+  const device = requireObject(receipt, "device", errors);
+  if (device) {
+    requireText(device, "vendor", "device", errors);
+    requireText(device, "model", "device", errors);
+    if (device.accelerator !== null && device.accelerator !== void 0) {
+      requireText(device, "accelerator", "device", errors);
+    }
+  }
+  const runtime = requireObject(receipt, "runtime", errors);
+  if (runtime) {
+    requireText(runtime, "name", "runtime", errors);
+    requireText(runtime, "version", "runtime", errors);
+    requireText(runtime, "hostOS", "runtime", errors);
+  }
+  requireText(receipt, "compilerVersion", "receipt", errors);
+  const constraints = requireArray(receipt, "constraints", errors);
+  if (constraints) validateConstraints(constraints, errors);
+  const measuredResults = requireArray(receipt, "measuredResults", errors);
+  if (measuredResults) validateMeasuredResults(measuredResults, errors);
+  const replayInputs = requireArray(receipt, "replayInputs", errors);
+  if (replayInputs) validateReplayInputs(replayInputs, errors);
+  const provenance = requireObject(receipt, "provenance", errors);
+  if (provenance) {
+    requireText(provenance, "capturedAt", "provenance", errors);
+    requireText(provenance, "sourceCompositionHash", "provenance", errors);
+  }
+  const owner = requireObject(receipt, "owner", errors);
+  if (owner) {
+    requireText(owner, "agent", "owner", errors);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isPortableHardwareReceiptMetadata(receipt) {
+  return validatePortableHardwareReceiptMetadata(receipt).valid;
+}
+
+// src/world-model/AdversarialTrajectoryReport.ts
+function buildAdversarialTrajectoryReport(trajectories, sceneHash, generatedAtMs, topPriorityLimit = 10) {
+  for (const t of trajectories) {
+    if (t.sceneHash !== sceneHash) {
+      throw new Error(
+        `buildAdversarialTrajectoryReport: trajectory ${t.id} has sceneHash ${t.sceneHash} but report sceneHash is ${sceneHash}`
+      );
+    }
+  }
+  const countBy = (status) => trajectories.filter((t) => t.status === status).length;
+  const topPriority = [...trajectories].filter((t) => t.status !== "invalid" && t.priority.priority > 0).sort((a, b) => {
+    if (a.priority.priority !== b.priority.priority) {
+      return b.priority.priority - a.priority.priority;
+    }
+    return a.priority.tieBreaker - b.priority.tieBreaker;
+  }).slice(0, topPriorityLimit).map((t) => t.id);
+  return {
+    generatedAtMs,
+    sceneHash,
+    trajectories,
+    counts: {
+      open: countBy("open"),
+      solved: countBy("solved"),
+      unresolved: countBy("unresolved"),
+      invalid: countBy("invalid"),
+      archived: countBy("archived")
+    },
+    topPriority,
+    failureClusters: buildFailureClusters(trajectories),
+    scoreSummary: buildScoreSummary(trajectories),
+    replaySummary: buildReplaySummary(trajectories)
+  };
+}
+function serializeReport(report) {
+  return JSON.stringify(report, canonicalReplacer);
+}
+function canonicalReplacer(_key, value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const sorted = {};
+    for (const k of Object.keys(value).sort()) {
+      sorted[k] = value[k];
+    }
+    return sorted;
+  }
+  return value;
+}
+function isReportCountsConsistent(report) {
+  const re = (status) => report.trajectories.filter((t) => t.status === status).length;
+  return report.counts.open === re("open") && report.counts.solved === re("solved") && report.counts.unresolved === re("unresolved") && report.counts.invalid === re("invalid") && report.counts.archived === re("archived");
+}
+function buildFailureClusters(trajectories) {
+  const clusters = /* @__PURE__ */ new Map();
+  for (const t of trajectories) {
+    const dominant = dominantPredicate(t);
+    const key = `${t.status}::${dominant ?? "none"}`;
+    const existing = clusters.get(key);
+    if (existing) {
+      clusters.set(key, {
+        ...existing,
+        count: existing.count + 1,
+        trajectoryIds: [...existing.trajectoryIds, t.id]
+      });
+    } else {
+      clusters.set(key, {
+        label: `${t.status}${dominant ? ` (${dominant})` : ""}`,
+        status: t.status,
+        count: 1,
+        trajectoryIds: [t.id],
+        dominantPredicate: dominant
+      });
+    }
+  }
+  return Array.from(clusters.values()).sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+}
+function dominantPredicate(trajectory) {
+  const scores = trajectory.predicateScore;
+  if (trajectory.status === "invalid") return "invalidity";
+  let maxKey = null;
+  let maxValue = -Infinity;
+  for (const key of ["violation", "novelty", "learnability", "regression"]) {
+    if (scores[key] > maxValue) {
+      maxValue = scores[key];
+      maxKey = key;
+    }
+  }
+  return maxKey;
+}
+function buildScoreSummary(trajectories) {
+  const keys = ["violation", "novelty", "learnability", "regression", "invalidity"];
+  const summary = {};
+  for (const key of keys) {
+    const values = trajectories.map((t) => t.predicateScore[key]);
+    const min = values.length > 0 ? Math.min(...values) : 0;
+    const max = values.length > 0 ? Math.max(...values) : 0;
+    const avg = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+    summary[key] = { avg: round4(avg), min: round4(min), max: round4(max) };
+  }
+  return summary;
+}
+function buildReplaySummary(trajectories) {
+  let withEvidence = 0;
+  let withoutEvidence = 0;
+  for (const t of trajectories) {
+    if (t.replayHandle.replayCommand.trim().length > 0 && t.replayHandle.simulationContractId === t.simulationContract.contractId) {
+      withEvidence += 1;
+    } else {
+      withoutEvidence += 1;
+    }
+  }
+  return { withEvidence, withoutEvidence };
+}
+function round4(value) {
+  return Math.round(value * 1e4) / 1e4;
+}
+
+// src/world-model/PredicateScorer.ts
+function clamp01(x) {
+  if (!Number.isFinite(x)) return 0;
+  if (x < 0) return 0;
+  if (x > 1) return 1;
+  return x;
+}
+function actionTypeSet(actions) {
+  const s = /* @__PURE__ */ new Set();
+  for (const a of actions) s.add(a.type);
+  return s;
+}
+function jaccardOverlap(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersect = 0;
+  for (const x of a) if (b.has(x)) intersect += 1;
+  const union = a.size + b.size - intersect;
+  return union === 0 ? 0 : intersect / union;
+}
+function scoreTrajectory(inputs) {
+  const {
+    trajectory,
+    hardAnchors,
+    softAnchors,
+    historyActionTypes,
+    learnabilityEstimate = 0.5,
+    previousStatus
+  } = inputs;
+  let invalidity = 0;
+  for (const anchor of hardAnchors) {
+    if (!anchor.evaluate(trajectory)) {
+      invalidity = 1;
+      break;
+    }
+  }
+  let violation = 0;
+  for (const anchor of softAnchors) {
+    const v = clamp01(anchor.evaluate(trajectory));
+    if (v > violation) violation = v;
+  }
+  const trajActionTypes = actionTypeSet(trajectory.actionTrace);
+  const novelty = clamp01(1 - jaccardOverlap(trajActionTypes, historyActionTypes));
+  const learnability = clamp01(learnabilityEstimate);
+  const regression = previousStatus === "solved" && (violation > 0 || invalidity > 0) ? 1 : 0;
+  const predicateScore = {
+    violation,
+    novelty,
+    learnability,
+    regression,
+    invalidity
+  };
+  let priority = 0;
+  let rationale = "invalid";
+  if (invalidity === 0) {
+    const base = Math.max(violation, regression);
+    const noveltyWeight = 0.5 + 0.5 * novelty;
+    const learnWeight = 0.5 + 0.5 * learnability;
+    priority = clamp01(base * noveltyWeight * learnWeight);
+    rationale = regression > 0 ? `regression detected (violation=${violation.toFixed(2)})` : `violation=${violation.toFixed(2)} \xD7 novelty=${novelty.toFixed(2)} \xD7 learn=${learnability.toFixed(2)}`;
+  }
+  const tieBreaker = trajectory.actionTrace.length;
+  return {
+    predicateScore,
+    priority: { priority, tieBreaker, rationale }
+  };
+}
+
+// src/world-model/DeterministicFailureScene.ts
+var SCENE_ID = "deterministic-contact-v1";
+var DEFAULT_SEED = 1337;
+var DEFAULT_DISCOVERED_AT_MS = 17e11;
+var STEP_MS = 100;
+var DETERMINISTIC_FAILURE_CONTRACT = {
+  contractId: "world-model-deterministic-contact-v1",
+  hashMode: "fnv1a",
+  adapterFingerprint: "core-world-model-deterministic-scene-v1",
+  replayDigestMode: "strict-same-adapter",
+  fieldQuantization: [
+    { fieldPattern: "objects.*.center", quantum: 1e-6, units: "m" },
+    { fieldPattern: "camera.position", quantum: 1e-6, units: "m" },
+    { fieldPattern: "camera.lookAt", quantum: 1e-6, units: "m" }
+  ]
+};
+var DEFAULT_DETERMINISTIC_FAILURE_ACTIONS = [
+  {
+    type: "place-object",
+    object: {
+      id: "probe-block",
+      kind: "block",
+      center: { x: -0.6, y: 0.15, z: 0 },
+      halfExtents: { x: 0.15, y: 0.15, z: 0.15 },
+      movable: true
+    }
+  },
+  {
+    type: "move-camera",
+    position: { x: 0, y: 1.25, z: 2.2 },
+    lookAt: { x: 0, y: 0.2, z: 0 }
+  },
+  {
+    type: "move-object",
+    objectId: "probe-block",
+    center: { x: 0, y: 0.15, z: 0 }
+  },
+  {
+    type: "move-object",
+    objectId: "probe-block",
+    center: { x: 0.55, y: 0.15, z: 0 }
+  }
+];
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const obj = value;
+  return `{${Object.keys(obj).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
+}
+function hashDeterministicSceneValue(value) {
+  const input = stableStringify(value);
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return `fnv1a-${hash.toString(16).padStart(8, "0")}`;
+}
+function cloneVec3(v) {
+  return { x: v.x, y: v.y, z: v.z };
+}
+function cloneObject(o) {
+  return {
+    id: o.id,
+    kind: o.kind,
+    center: cloneVec3(o.center),
+    halfExtents: cloneVec3(o.halfExtents),
+    movable: o.movable
+  };
+}
+function cloneCamera(camera) {
+  return {
+    position: cloneVec3(camera.position),
+    lookAt: cloneVec3(camera.lookAt)
+  };
+}
+function sceneHashFor(seed, objects) {
+  return asSceneHash(hashDeterministicSceneValue({ sceneId: SCENE_ID, seed, objects }));
+}
+function createDeterministicFailureDiscoveryScene(seed = DEFAULT_SEED) {
+  const objects = [
+    {
+      id: "contact-pillar",
+      kind: "obstacle",
+      center: { x: 0, y: 0.35, z: 0 },
+      halfExtents: { x: 0.16, y: 0.35, z: 0.45 },
+      movable: false
+    },
+    {
+      id: "target-pad",
+      kind: "target",
+      center: { x: 0.55, y: 0.05, z: 0 },
+      halfExtents: { x: 0.32, y: 0.05, z: 0.32 },
+      movable: false
+    }
+  ];
+  return {
+    sceneId: SCENE_ID,
+    seed,
+    objects,
+    camera: {
+      position: { x: -0.25, y: 1.1, z: 2 },
+      lookAt: { x: 0, y: 0.2, z: 0 }
+    },
+    sceneHash: sceneHashFor(seed, objects)
+  };
+}
+function overlaps(a, b) {
+  return Math.abs(a.center.x - b.center.x) <= a.halfExtents.x + b.halfExtents.x && Math.abs(a.center.y - b.center.y) <= a.halfExtents.y + b.halfExtents.y && Math.abs(a.center.z - b.center.z) <= a.halfExtents.z + b.halfExtents.z;
+}
+function actionPayload(action) {
+  switch (action.type) {
+    case "place-object":
+      return { object: action.object };
+    case "move-object":
+      return { objectId: action.objectId, center: action.center };
+    case "move-camera":
+      return { position: action.position, lookAt: action.lookAt };
+    case "wait":
+      return { durationMs: action.durationMs };
+  }
+}
+function snapshotObservationPayload(objects, camera, events, contactCount, predicateViolationCount, invalidActionCount) {
+  return {
+    objects: objects.map((o) => ({
+      id: o.id,
+      kind: o.kind,
+      center: o.center
+    })),
+    camera,
+    eventTypes: events.map((e) => e.type),
+    contactCount,
+    predicateViolationCount,
+    invalidActionCount
+  };
+}
+function runDeterministicFailureDiscoveryScene(actions = DEFAULT_DETERMINISTIC_FAILURE_ACTIONS, options = {}) {
+  const scene = createDeterministicFailureDiscoveryScene(options.seed ?? DEFAULT_SEED);
+  let objects = scene.objects.map(cloneObject);
+  let camera = cloneCamera(scene.camera);
+  let timestampMs = 0;
+  let contactCount = 0;
+  let predicateViolationCount = 0;
+  let invalidActionCount = 0;
+  const events = [];
+  const actionTrace = [];
+  const observationTrace = [];
+  for (let stepIndex = 0; stepIndex < actions.length; stepIndex += 1) {
+    const action = actions[stepIndex];
+    const stepEvents = [];
+    const emit = (type, payload) => {
+      const event = { stepIndex, timestampMs, type, payload };
+      stepEvents.push(event);
+      events.push(event);
+    };
+    actionTrace.push({
+      stepIndex,
+      timestampMs,
+      type: action.type,
+      payload: actionPayload(action)
+    });
+    if (action.type === "place-object") {
+      if (objects.some((o) => o.id === action.object.id)) {
+        invalidActionCount += 1;
+        emit("invalid_action", {
+          reason: "duplicate-object-id",
+          objectId: action.object.id
+        });
+      } else {
+        const placed = cloneObject(action.object);
+        objects = [...objects, placed];
+        emit("object_placed", { objectId: placed.id, center: placed.center });
+      }
+    } else if (action.type === "move-camera") {
+      camera = {
+        position: cloneVec3(action.position),
+        lookAt: cloneVec3(action.lookAt)
+      };
+      emit("camera_moved", { position: camera.position, lookAt: camera.lookAt });
+    } else if (action.type === "move-object") {
+      const object = objects.find((o) => o.id === action.objectId);
+      if (!object) {
+        invalidActionCount += 1;
+        emit("invalid_action", {
+          reason: "unknown-object",
+          objectId: action.objectId
+        });
+      } else if (!object.movable) {
+        invalidActionCount += 1;
+        emit("invalid_action", {
+          reason: "object-not-movable",
+          objectId: action.objectId
+        });
+      } else {
+        const moved = { ...object, center: cloneVec3(action.center) };
+        const obstacle = objects.find((o) => o.kind === "obstacle" && overlaps(moved, o));
+        if (obstacle) {
+          contactCount += 1;
+          predicateViolationCount += 1;
+          emit("contact", {
+            objectId: object.id,
+            otherObjectId: obstacle.id,
+            blocked: true
+          });
+          emit("predicate_violation", {
+            predicate: "no-block-obstacle-overlap",
+            objectId: object.id,
+            otherObjectId: obstacle.id
+          });
+        } else {
+          objects = objects.map((o) => o.id === object.id ? moved : o);
+          emit("object_moved", { objectId: moved.id, center: moved.center });
+          for (const target of objects.filter((o) => o.kind === "target")) {
+            if (overlaps(moved, target)) {
+              contactCount += 1;
+              emit("target_contact", {
+                objectId: moved.id,
+                targetId: target.id
+              });
+            }
+          }
+        }
+      }
+    } else {
+      emit("wait", { durationMs: action.durationMs });
+    }
+    observationTrace.push({
+      stepIndex,
+      timestampMs,
+      type: "deterministic-scene-snapshot",
+      payload: snapshotObservationPayload(
+        objects,
+        camera,
+        stepEvents,
+        contactCount,
+        predicateViolationCount,
+        invalidActionCount
+      )
+    });
+    timestampMs += action.type === "wait" ? action.durationMs : STEP_MS;
+  }
+  const eventLogHash = hashDeterministicSceneValue({
+    sceneHash: scene.sceneHash,
+    seed: scene.seed,
+    actionTrace,
+    observationTrace,
+    events
+  });
+  return {
+    sceneId: scene.sceneId,
+    seed: scene.seed,
+    sceneHash: scene.sceneHash,
+    objects,
+    camera,
+    events,
+    actionTrace,
+    observationTrace,
+    contactCount,
+    predicateViolationCount,
+    invalidActionCount,
+    eventLogHash
+  };
+}
+function buildDeterministicFailureTrajectory(actions = DEFAULT_DETERMINISTIC_FAILURE_ACTIONS, options = {}) {
+  const result = runDeterministicFailureDiscoveryScene(actions, options);
+  const id = asTrajectoryId(
+    hashDeterministicSceneValue({
+      sceneHash: result.sceneHash,
+      seed: result.seed,
+      actionTrace: result.actionTrace
+    })
+  );
+  const replayCommand = `holoscript world-model replay --scene ${SCENE_ID} --trajectory ${id} --seed ${result.seed}`;
+  const baseline = {
+    id,
+    sceneHash: result.sceneHash,
+    seed: result.seed,
+    trustTier: "replayable",
+    caelReceiptHash: asCaelReceiptHash(result.eventLogHash),
+    simulationContract: DETERMINISTIC_FAILURE_CONTRACT,
+    actionTrace: result.actionTrace,
+    observationTrace: result.observationTrace,
+    predicateScore: {
+      violation: 0,
+      novelty: 0,
+      learnability: 0,
+      regression: 0,
+      invalidity: 0
+    },
+    priority: { priority: 0, tieBreaker: 0, rationale: "unscored" },
+    replayHandle: {
+      trajectoryId: id,
+      sceneHash: result.sceneHash,
+      simulationContractId: DETERMINISTIC_FAILURE_CONTRACT.contractId,
+      seed: result.seed,
+      replayCommand
+    },
+    status: "open",
+    discoveredAtMs: options.discoveredAtMs ?? DEFAULT_DISCOVERED_AT_MS,
+    lastReplayedAtMs: null
+  };
+  const collisionAnchor = {
+    id: "blocked-contact",
+    description: "blocked obstacle contact in deterministic scene",
+    evaluate: () => Math.min(1, result.predicateViolationCount)
+  };
+  const score = scoreTrajectory({
+    trajectory: baseline,
+    hardAnchors: [
+      {
+        id: "valid-actions-only",
+        description: "all deterministic scene actions reference valid movable objects",
+        evaluate: () => result.invalidActionCount === 0
+      }
+    ],
+    softAnchors: [collisionAnchor],
+    historyActionTypes: /* @__PURE__ */ new Set(),
+    learnabilityEstimate: 0.9
+  });
+  const status = score.predicateScore.invalidity > 0 ? "invalid" : result.predicateViolationCount > 0 ? "unresolved" : "open";
+  return {
+    result,
+    trajectory: {
+      ...baseline,
+      predicateScore: score.predicateScore,
+      priority: score.priority,
+      status
+    }
+  };
+}
+
+// src/world-model/AdversarialMutator.ts
+var BUILT_IN_PROFILES = [
+  { name: "gentle-perturb", strategy: "perturb-positions", intensity: 0.15 },
+  { name: "strong-perturb", strategy: "perturb-positions", intensity: 0.55 },
+  { name: "skip-one", strategy: "skip-step", intensity: 0.3 },
+  { name: "duplicate-one", strategy: "duplicate-step", intensity: 0.3 },
+  { name: "swap-pair", strategy: "swap-consecutive", intensity: 0.3 },
+  { name: "insert-pause", strategy: "insert-wait", intensity: 0.3 },
+  { name: "push-obstacle", strategy: "push-toward-obstacle", intensity: 0.6 },
+  { name: "camera-drift", strategy: "camera-drift", intensity: 0.5 }
+];
+function makeRng(seed) {
+  let state = seed >>> 0 || 1;
+  const float = () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 4294967296;
+  };
+  const int = (min, max) => min + Math.floor(float() * (max - min + 1));
+  const bool = (bias = 0.5) => float() < bias;
+  return { float, int, bool };
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function jitterPosition(pos, intensity, rng) {
+  const scale = intensity * 0.4;
+  return {
+    x: clamp(pos.x + (rng.float() - 0.5) * 2 * scale, -2, 2),
+    y: clamp(pos.y + (rng.float() - 0.5) * 2 * scale, -0.5, 2.5),
+    z: clamp(pos.z + (rng.float() - 0.5) * 2 * scale, -2, 2)
+  };
+}
+function mutatePerturbPositions(base, intensity, rng) {
+  return base.map((action) => {
+    switch (action.type) {
+      case "place-object":
+        return {
+          ...action,
+          object: {
+            ...action.object,
+            center: jitterPosition(action.object.center, intensity, rng)
+          }
+        };
+      case "move-object":
+        return {
+          ...action,
+          center: jitterPosition(action.center, intensity, rng)
+        };
+      case "move-camera":
+        return {
+          ...action,
+          position: jitterPosition(action.position, intensity, rng),
+          lookAt: jitterPosition(action.lookAt, intensity, rng)
+        };
+      case "wait":
+      default:
+        return action;
+    }
+  });
+}
+function mutateSkipStep(base, _intensity, rng) {
+  if (base.length <= 1) return base;
+  const idx = rng.int(0, base.length - 1);
+  return [...base.slice(0, idx), ...base.slice(idx + 1)];
+}
+function mutateDuplicateStep(base, _intensity, rng) {
+  if (base.length === 0) return base;
+  const idx = rng.int(0, base.length - 1);
+  const dup = base[idx];
+  return [...base.slice(0, idx + 1), dup, ...base.slice(idx + 1)];
+}
+function mutateSwapConsecutive(base, _intensity, rng) {
+  if (base.length < 2) return base;
+  const idx = rng.int(0, base.length - 2);
+  const copy = [...base];
+  [copy[idx], copy[idx + 1]] = [copy[idx + 1], copy[idx]];
+  return copy;
+}
+function mutateInsertWait(base, intensity, rng) {
+  const durationMs = Math.round(50 + rng.float() * 400 * (1 + intensity));
+  const idx = rng.int(0, base.length);
+  const wait = { type: "wait", durationMs };
+  return [...base.slice(0, idx), wait, ...base.slice(idx)];
+}
+function mutatePushTowardObstacle(base, intensity, rng) {
+  const obstacleCenter = { x: 0, z: 0 };
+  return base.map((action) => {
+    if (action.type === "move-object" && action.objectId === "probe-block") {
+      const toward = {
+        x: action.center.x + (obstacleCenter.x - action.center.x) * intensity * (0.5 + rng.float()),
+        y: action.center.y,
+        z: action.center.z + (obstacleCenter.z - action.center.z) * intensity * (0.5 + rng.float())
+      };
+      return { ...action, center: toward };
+    }
+    return action;
+  });
+}
+function mutateCameraDrift(base, intensity, rng) {
+  return base.map((action) => {
+    if (action.type === "move-camera") {
+      const drift = {
+        x: clamp(action.position.x + (rng.float() - 0.5) * 4 * intensity, -3, 3),
+        y: clamp(action.position.y + (rng.float() - 0.5) * 2 * intensity, 0.5, 3),
+        z: clamp(action.position.z + (rng.float() - 0.5) * 4 * intensity, -3, 5)
+      };
+      return { ...action, position: drift };
+    }
+    return action;
+  });
+}
+function applyMutation(base, profile, seed) {
+  const rng = makeRng(seed);
+  let actions;
+  switch (profile.strategy) {
+    case "perturb-positions":
+      actions = mutatePerturbPositions(base, profile.intensity, rng);
+      break;
+    case "skip-step":
+      actions = mutateSkipStep(base, profile.intensity, rng);
+      break;
+    case "duplicate-step":
+      actions = mutateDuplicateStep(base, profile.intensity, rng);
+      break;
+    case "swap-consecutive":
+      actions = mutateSwapConsecutive(base, profile.intensity, rng);
+      break;
+    case "insert-wait":
+      actions = mutateInsertWait(base, profile.intensity, rng);
+      break;
+    case "push-toward-obstacle":
+      actions = mutatePushTowardObstacle(base, profile.intensity, rng);
+      break;
+    case "camera-drift":
+      actions = mutateCameraDrift(base, profile.intensity, rng);
+      break;
+    default:
+      actions = base;
+  }
+  return {
+    actions,
+    profile: profile.name,
+    rationale: `${profile.strategy} at intensity ${profile.intensity.toFixed(2)}`
+  };
+}
+function buildAdversarialTrajectoryFromResult(result, mutatorName, contract, discoveredAtMs) {
+  const id = asTrajectoryId(
+    hashDeterministicSceneValue({
+      sceneHash: result.sceneHash,
+      seed: result.seed,
+      actionTrace: result.actionTrace,
+      mutator: mutatorName
+    })
+  );
+  const replayCommand = `holoscript world-model replay --scene ${result.sceneId} --trajectory ${id} --seed ${result.seed}`;
+  return {
+    id,
+    sceneHash: asSceneHash(result.sceneHash),
+    seed: result.seed,
+    trustTier: "replayable",
+    caelReceiptHash: asCaelReceiptHash(result.eventLogHash),
+    simulationContract: contract,
+    actionTrace: result.actionTrace,
+    observationTrace: result.observationTrace,
+    predicateScore: {
+      violation: 0,
+      novelty: 0,
+      learnability: 0,
+      regression: 0,
+      invalidity: 0
+    },
+    priority: { priority: 0, tieBreaker: 0, rationale: "unscored" },
+    replayHandle: {
+      trajectoryId: id,
+      sceneHash: asSceneHash(result.sceneHash),
+      simulationContractId: contract.contractId,
+      seed: result.seed,
+      replayCommand
+    },
+    status: "open",
+    discoveredAtMs,
+    lastReplayedAtMs: null
+  };
+}
+function makeHardAnchors() {
+  return [
+    {
+      id: "valid-actions-only",
+      description: "all deterministic scene actions reference valid movable objects",
+      evaluate: (_trajectory) => true
+    }
+  ];
+}
+function makeSoftAnchors(result) {
+  return [
+    {
+      id: "blocked-contact",
+      description: "blocked obstacle contact in deterministic scene",
+      evaluate: () => Math.min(1, result.predicateViolationCount)
+    },
+    {
+      id: "target-contact",
+      description: "contact with target pad",
+      evaluate: () => result.events.some((e) => e.type === "target_contact") ? 0.5 : 0
+    },
+    {
+      id: "invalid-action-rate",
+      description: "proportion of invalid actions in trace",
+      evaluate: () => result.actionTrace.length > 0 ? Math.min(1, result.invalidActionCount / result.actionTrace.length) : 0
+    }
+  ];
+}
+function mutateTrace(base, profile, seed) {
+  return applyMutation(base, profile, seed);
+}
+function exploreAdversarialTraces(options = {}) {
+  const {
+    baseActions,
+    seed = 1337,
+    maxTraces = 16,
+    sceneOptions,
+    profiles = BUILT_IN_PROFILES,
+    learnabilityEstimate = 0.7,
+    discoveredAtMs = Date.now()
+  } = options;
+  const base = baseActions ?? [];
+  const contract = DETERMINISTIC_FAILURE_CONTRACT;
+  const hardAnchors = makeHardAnchors();
+  const historyActionTypes = /* @__PURE__ */ new Set();
+  const trajectories = [];
+  for (let i = 0; i < maxTraces; i += 1) {
+    const profile = profiles[i % profiles.length];
+    const traceSeed = seed + i * 7919;
+    const mutated = applyMutation(base, profile, traceSeed);
+    const result = runDeterministicFailureDiscoveryScene(mutated.actions, sceneOptions);
+    const trajectory = buildAdversarialTrajectoryFromResult(
+      result,
+      profile.name,
+      contract,
+      discoveredAtMs
+    );
+    const softAnchors = makeSoftAnchors(result);
+    const score = scoreTrajectory({
+      trajectory,
+      hardAnchors,
+      softAnchors,
+      historyActionTypes,
+      learnabilityEstimate,
+      previousStatus: void 0
+    });
+    const status = score.predicateScore.invalidity > 0 ? "invalid" : result.predicateViolationCount > 0 ? "unresolved" : "open";
+    const scored = {
+      ...trajectory,
+      predicateScore: score.predicateScore,
+      priority: score.priority,
+      status
+    };
+    trajectories.push(scored);
+    for (const a of scored.actionTrace) {
+      historyActionTypes.add(a.type);
+    }
+  }
+  return trajectories.sort((a, b) => {
+    if (a.priority.priority !== b.priority.priority) {
+      return b.priority.priority - a.priority.priority;
+    }
+    return a.priority.tieBreaker - b.priority.tieBreaker;
+  });
+}
+
+// src/world-model/HumanoidRockThrowScene.ts
+var HUMANOID_ROCK_THROW_SCENE_ID = "humanoid-rock-throw-v1";
+var DEFAULT_SEED2 = 4242;
+var DEFAULT_DISCOVERED_AT_MS2 = 17e11;
+var STEP_MS2 = 100;
+var GRAVITY = -9.81;
+var RELEASE_VELOCITY = { x: 5.2, y: 3.4, z: 0 };
+var RELEASE_POSITION = { x: -0.95, y: 1.62, z: 0.02 };
+var HUMANOID_ROCK_THROW_CONTRACT = {
+  contractId: "world-model-humanoid-rock-throw-v1",
+  hashMode: "fnv1a",
+  adapterFingerprint: "core-world-model-humanoid-rock-throw-v1",
+  replayDigestMode: "strict-same-adapter",
+  fieldQuantization: [
+    { fieldPattern: "rock.position", quantum: 1e-6, units: "m" },
+    { fieldPattern: "hand.position", quantum: 1e-6, units: "m" },
+    { fieldPattern: "release.velocity", quantum: 1e-6, units: "m/s" }
+  ]
+};
+function addVec3(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function scaleVec3(v, scale) {
+  return { x: v.x * scale, y: v.y * scale, z: v.z * scale };
+}
+function rockPositionAt(timeSeconds) {
+  return addVec3(addVec3(RELEASE_POSITION, scaleVec3(RELEASE_VELOCITY, timeSeconds)), {
+    x: 0,
+    y: 0.5 * GRAVITY * timeSeconds * timeSeconds,
+    z: 0
+  });
+}
+function sceneHashFor2(seed, objects) {
+  return asSceneHash(
+    hashDeterministicSceneValue({ sceneId: HUMANOID_ROCK_THROW_SCENE_ID, seed, objects })
+  );
+}
+function createHumanoidRockThrowScene(seed = DEFAULT_SEED2) {
+  const objects = [
+    { id: "avatar", kind: "avatar", center: { x: -3, y: 1.25, z: 0 } },
+    { id: "right-hand", kind: "hand", center: { x: -2.72, y: 1.22, z: 0.16 } },
+    { id: "rock", kind: "rock", center: { x: -2.35, y: 0.22, z: 0.12 }, radiusM: 0.13, massKg: 1.8 },
+    { id: "target", kind: "target", center: { x: 2.55, y: 0.85, z: 0 }, radiusM: 0.42, massKg: 20 },
+    { id: "stage", kind: "stage", center: { x: 0, y: 0, z: 0 } }
+  ];
+  return {
+    sceneId: HUMANOID_ROCK_THROW_SCENE_ID,
+    seed,
+    objects,
+    sceneHash: sceneHashFor2(seed, objects)
+  };
+}
+function makeAction(stepIndex, timestampMs, type, payload) {
+  return { stepIndex, timestampMs, type, payload };
+}
+function makeObservation(stepIndex, timestampMs, event) {
+  return {
+    stepIndex,
+    timestampMs,
+    type: "humanoid-rock-throw-event",
+    payload: {
+      eventType: event.type,
+      payload: event.payload
+    }
+  };
+}
+function runHumanoidRockThrowReplay(options = {}) {
+  const scene = createHumanoidRockThrowScene(options.seed ?? DEFAULT_SEED2);
+  const events = [];
+  const actionTrace = [];
+  const observationTrace = [];
+  const emit = (type, payload) => {
+    const stepIndex = events.length;
+    const timestampMs = stepIndex * STEP_MS2;
+    const event = { stepIndex, timestampMs, type, payload };
+    events.push(event);
+    actionTrace.push(makeAction(stepIndex, timestampMs, type, payload));
+    observationTrace.push(makeObservation(stepIndex, timestampMs, event));
+  };
+  emit("scene_loaded", {
+    avatarId: "avatar",
+    rockId: "rock",
+    targetId: "target"
+  });
+  emit("avatar_approached", {
+    avatarId: "avatar",
+    from: { x: -3, y: 1.25, z: 0 },
+    to: { x: -2.35, y: 1.25, z: 0 }
+  });
+  emit("hand_reached", {
+    handId: "right-hand",
+    rockId: "rock",
+    handPosition: { x: -2.35, y: 0.9, z: 0.12 },
+    clearanceM: 0.03
+  });
+  emit("grab_constraint_attached", {
+    handId: "right-hand",
+    rockId: "rock",
+    constraint: "hand-rock-fixed"
+  });
+  emit("lift_pose", {
+    rockId: "rock",
+    rockPosition: { x: -2.15, y: 1.2, z: 0.12 }
+  });
+  emit("windup_pose", {
+    avatarId: "avatar",
+    rockId: "rock",
+    shoulderYawDeg: -38,
+    rockPosition: { x: -1.45, y: 1.55, z: 0.08 }
+  });
+  emit("release", {
+    rockId: "rock",
+    releasePosition: RELEASE_POSITION,
+    releaseVelocity: RELEASE_VELOCITY
+  });
+  for (const t of [0.18, 0.36, 0.54]) {
+    emit("ballistic_sample", {
+      rockId: "rock",
+      timeSeconds: t,
+      rockPosition: rockPositionAt(t),
+      gravity: GRAVITY
+    });
+  }
+  emit("target_contact", {
+    rockId: "rock",
+    targetId: "target",
+    rockPosition: { x: 2.55, y: 0.85, z: 0 },
+    impulseNs: 8.6
+  });
+  emit("aftermath", {
+    targetId: "target",
+    observedImpact: true,
+    provenancePanel: true
+  });
+  const eventLogHash = hashDeterministicSceneValue({
+    sceneHash: scene.sceneHash,
+    seed: scene.seed,
+    actionTrace,
+    observationTrace,
+    events
+  });
+  return {
+    sceneId: scene.sceneId,
+    seed: scene.seed,
+    sceneHash: scene.sceneHash,
+    objects: scene.objects,
+    events,
+    actionTrace,
+    observationTrace,
+    contactCount: 1,
+    predicateViolationCount: 0,
+    invalidActionCount: 0,
+    eventLogHash
+  };
+}
+function buildHumanoidRockThrowTrajectory(options = {}) {
+  const result = runHumanoidRockThrowReplay(options);
+  const id = asTrajectoryId(
+    hashDeterministicSceneValue({
+      sceneHash: result.sceneHash,
+      seed: result.seed,
+      actionTrace: result.actionTrace
+    })
+  );
+  const replayCommand = `holoscript world-model replay --scene ${HUMANOID_ROCK_THROW_SCENE_ID} --trajectory ${id} --seed ${result.seed}`;
+  const baseline = {
+    id,
+    sceneHash: result.sceneHash,
+    seed: result.seed,
+    trustTier: "replayable",
+    caelReceiptHash: asCaelReceiptHash(result.eventLogHash),
+    simulationContract: HUMANOID_ROCK_THROW_CONTRACT,
+    actionTrace: result.actionTrace,
+    observationTrace: result.observationTrace,
+    predicateScore: {
+      violation: 0,
+      novelty: 0,
+      learnability: 0,
+      regression: 0,
+      invalidity: 0
+    },
+    priority: { priority: 0, tieBreaker: 0, rationale: "unscored" },
+    replayHandle: {
+      trajectoryId: id,
+      sceneHash: result.sceneHash,
+      simulationContractId: HUMANOID_ROCK_THROW_CONTRACT.contractId,
+      seed: result.seed,
+      replayCommand
+    },
+    status: "open",
+    discoveredAtMs: options.discoveredAtMs ?? DEFAULT_DISCOVERED_AT_MS2,
+    lastReplayedAtMs: null
+  };
+  const impactAnchor = {
+    id: "target-impact",
+    description: "rock reaches target contact in deterministic replay",
+    evaluate: () => result.events.some((event) => event.type === "target_contact") ? 0 : 1
+  };
+  const score = scoreTrajectory({
+    trajectory: baseline,
+    hardAnchors: [
+      {
+        id: "valid-replay",
+        description: "humanoid rock throw replay has no invalid actions",
+        evaluate: () => result.invalidActionCount === 0
+      }
+    ],
+    softAnchors: [impactAnchor],
+    historyActionTypes: /* @__PURE__ */ new Set(),
+    learnabilityEstimate: 0.7
+  });
+  return {
+    result,
+    trajectory: {
+      ...baseline,
+      predicateScore: score.predicateScore,
+      priority: score.priority,
+      status: result.predicateViolationCount > 0 ? "unresolved" : "open"
+    }
+  };
+}
+
+// src/world-model/TwoAgentHandoffCatchScene.ts
+var TWO_AGENT_HANDOFF_CATCH_SCENE_ID = "two-agent-handoff-catch-v1";
+var DEFAULT_SEED3 = 5151;
+var DEFAULT_DISCOVERED_AT_MS3 = 17e11;
+var STEP_MS3 = 100;
+var GRAVITY2 = -9.81;
+var RELEASE_POSITION2 = { x: -1.48, y: 1.32, z: 0.08 };
+var RELEASE_VELOCITY2 = { x: 4.4, y: 1.5, z: 0 };
+var TWO_AGENT_HANDOFF_CATCH_CONTRACT = {
+  contractId: "world-model-two-agent-handoff-catch-v1",
+  hashMode: "fnv1a",
+  adapterFingerprint: "core-world-model-two-agent-handoff-catch-v1",
+  replayDigestMode: "strict-same-adapter",
+  fieldQuantization: [
+    { fieldPattern: "tool.position", quantum: 1e-6, units: "m" },
+    { fieldPattern: "hands.*.position", quantum: 1e-6, units: "m" },
+    { fieldPattern: "release.velocity", quantum: 1e-6, units: "m/s" },
+    { fieldPattern: "ownership.ownerId", quantum: 1, units: "symbol" }
+  ]
+};
+function addVec32(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function scaleVec32(v, scale) {
+  return { x: v.x * scale, y: v.y * scale, z: v.z * scale };
+}
+function toolPositionAt(timeSeconds) {
+  return addVec32(addVec32(RELEASE_POSITION2, scaleVec32(RELEASE_VELOCITY2, timeSeconds)), {
+    x: 0,
+    y: 0.5 * GRAVITY2 * timeSeconds * timeSeconds,
+    z: 0
+  });
+}
+function sceneHashFor3(seed, objects) {
+  return asSceneHash(
+    hashDeterministicSceneValue({ sceneId: TWO_AGENT_HANDOFF_CATCH_SCENE_ID, seed, objects })
+  );
+}
+function createTwoAgentHandoffCatchScene(seed = DEFAULT_SEED3) {
+  const objects = [
+    { id: "thrower", kind: "agent", center: { x: -2.2, y: 1.1, z: 0 } },
+    { id: "catcher", kind: "agent", center: { x: 2.2, y: 1.1, z: 0 } },
+    {
+      id: "thrower-hand",
+      kind: "hand",
+      center: { x: -1.72, y: 1.32, z: 0.08 },
+      ownerId: "thrower"
+    },
+    {
+      id: "catcher-hand",
+      kind: "hand",
+      center: { x: 1.74, y: 1.28, z: 0.08 },
+      ownerId: "catcher"
+    },
+    {
+      id: "shared-tool",
+      kind: "tool",
+      center: RELEASE_POSITION2,
+      radiusM: 0.16,
+      ownerId: "thrower",
+      massKg: 0.65
+    },
+    {
+      id: "catch-volume",
+      kind: "catch-volume",
+      center: { x: 1.74, y: 1.28, z: 0.08 },
+      radiusM: 0.35,
+      ownerId: "catcher"
+    },
+    { id: "stage", kind: "stage", center: { x: 0, y: 0, z: 0 } }
+  ];
+  return {
+    sceneId: TWO_AGENT_HANDOFF_CATCH_SCENE_ID,
+    seed,
+    objects,
+    sceneHash: sceneHashFor3(seed, objects)
+  };
+}
+function makeAction2(stepIndex, timestampMs, type, payload) {
+  return { stepIndex, timestampMs, type, payload };
+}
+function makeObservation2(stepIndex, timestampMs, event) {
+  return {
+    stepIndex,
+    timestampMs,
+    type: "two-agent-handoff-catch-event",
+    payload: {
+      eventType: event.type,
+      payload: event.payload
+    }
+  };
+}
+function runTwoAgentHandoffCatchReplay(options = {}) {
+  const scene = createTwoAgentHandoffCatchScene(options.seed ?? DEFAULT_SEED3);
+  const events = [];
+  const actionTrace = [];
+  const observationTrace = [];
+  let ownerId = "thrower";
+  const emit = (type, payload) => {
+    const stepIndex = events.length;
+    const timestampMs = stepIndex * STEP_MS3;
+    const event = { stepIndex, timestampMs, type, payload };
+    events.push(event);
+    actionTrace.push(makeAction2(stepIndex, timestampMs, type, payload));
+    observationTrace.push(makeObservation2(stepIndex, timestampMs, event));
+  };
+  emit("scene_loaded", {
+    throwerId: "thrower",
+    catcherId: "catcher",
+    toolId: "shared-tool",
+    ownerId
+  });
+  emit("agents_aligned", {
+    throwerHandId: "thrower-hand",
+    catcherHandId: "catcher-hand",
+    toolId: "shared-tool",
+    facing: true
+  });
+  ownerId = null;
+  emit("release_constraint_detached", {
+    toolId: "shared-tool",
+    fromHandId: "thrower-hand",
+    previousOwnerId: "thrower",
+    ownerId,
+    releasePosition: RELEASE_POSITION2,
+    releaseVelocity: RELEASE_VELOCITY2
+  });
+  for (const t of [0.18, 0.36, 0.54]) {
+    emit("ballistic_sample", {
+      toolId: "shared-tool",
+      timeSeconds: t,
+      toolPosition: toolPositionAt(t),
+      gravity: GRAVITY2,
+      ownerId
+    });
+  }
+  emit("catch_volume_entered", {
+    toolId: "shared-tool",
+    catchVolumeId: "catch-volume",
+    toolPosition: { x: 1.74, y: 1.28, z: 0.08 },
+    clearanceM: 0.04
+  });
+  ownerId = "catcher";
+  emit("catch_constraint_attached", {
+    toolId: "shared-tool",
+    handId: "catcher-hand",
+    constraint: "hand-tool-fixed",
+    ownerId
+  });
+  emit("ownership_transferred", {
+    objectId: "shared-tool",
+    from: "thrower",
+    to: "catcher",
+    transferMode: "release-flight-catch"
+  });
+  emit("receipt_emitted", {
+    objectId: "shared-tool",
+    ownerId,
+    releaseConfirmed: true,
+    catchConfirmed: true,
+    provenancePanel: true
+  });
+  const eventLogHash = hashDeterministicSceneValue({
+    sceneHash: scene.sceneHash,
+    seed: scene.seed,
+    actionTrace,
+    observationTrace,
+    events
+  });
+  return {
+    sceneId: scene.sceneId,
+    seed: scene.seed,
+    sceneHash: scene.sceneHash,
+    objects: scene.objects,
+    events,
+    actionTrace,
+    observationTrace,
+    contactCount: 1,
+    predicateViolationCount: 0,
+    invalidActionCount: 0,
+    eventLogHash
+  };
+}
+function buildTwoAgentHandoffCatchTrajectory(options = {}) {
+  const result = runTwoAgentHandoffCatchReplay(options);
+  const id = asTrajectoryId(
+    hashDeterministicSceneValue({
+      sceneHash: result.sceneHash,
+      seed: result.seed,
+      actionTrace: result.actionTrace
+    })
+  );
+  const replayCommand = `holoscript world-model replay --scene ${TWO_AGENT_HANDOFF_CATCH_SCENE_ID} --trajectory ${id} --seed ${result.seed}`;
+  const baseline = {
+    id,
+    sceneHash: result.sceneHash,
+    seed: result.seed,
+    trustTier: "replayable",
+    caelReceiptHash: asCaelReceiptHash(result.eventLogHash),
+    simulationContract: TWO_AGENT_HANDOFF_CATCH_CONTRACT,
+    actionTrace: result.actionTrace,
+    observationTrace: result.observationTrace,
+    predicateScore: {
+      violation: 0,
+      novelty: 0,
+      learnability: 0,
+      regression: 0,
+      invalidity: 0
+    },
+    priority: { priority: 0, tieBreaker: 0, rationale: "unscored" },
+    replayHandle: {
+      trajectoryId: id,
+      sceneHash: result.sceneHash,
+      simulationContractId: TWO_AGENT_HANDOFF_CATCH_CONTRACT.contractId,
+      seed: result.seed,
+      replayCommand
+    },
+    status: "open",
+    discoveredAtMs: options.discoveredAtMs ?? DEFAULT_DISCOVERED_AT_MS3,
+    lastReplayedAtMs: null
+  };
+  const ownershipAnchor = {
+    id: "ownership-transfer",
+    description: "tool ownership transfers from thrower to catcher",
+    evaluate: () => result.events.some((event) => event.type === "ownership_transferred") ? 0 : 1
+  };
+  const catchAnchor = {
+    id: "catch-constraint",
+    description: "catcher hand receives fixed tool constraint",
+    evaluate: () => result.events.some((event) => event.type === "catch_constraint_attached") ? 0 : 1
+  };
+  const score = scoreTrajectory({
+    trajectory: baseline,
+    hardAnchors: [
+      {
+        id: "valid-handoff-replay",
+        description: "handoff catch replay has no invalid actions",
+        evaluate: () => result.invalidActionCount === 0
+      }
+    ],
+    softAnchors: [ownershipAnchor, catchAnchor],
+    historyActionTypes: /* @__PURE__ */ new Set(),
+    learnabilityEstimate: 0.75
+  });
+  return {
+    result,
+    trajectory: {
+      ...baseline,
+      predicateScore: score.predicateScore,
+      priority: score.priority,
+      status: result.predicateViolationCount > 0 ? "unresolved" : "open"
+    }
+  };
+}
+
+exports.BUILT_IN_PROFILES = BUILT_IN_PROFILES;
+exports.DEFAULT_DETERMINISTIC_FAILURE_ACTIONS = DEFAULT_DETERMINISTIC_FAILURE_ACTIONS;
+exports.DETERMINISTIC_FAILURE_CONTRACT = DETERMINISTIC_FAILURE_CONTRACT;
+exports.HARDWARE_RECEIPT_METADATA_SCHEMA_VERSION = HARDWARE_RECEIPT_METADATA_SCHEMA_VERSION;
+exports.HUMANOID_ROCK_THROW_CONTRACT = HUMANOID_ROCK_THROW_CONTRACT;
+exports.HUMANOID_ROCK_THROW_SCENE_ID = HUMANOID_ROCK_THROW_SCENE_ID;
+exports.TWO_AGENT_HANDOFF_CATCH_CONTRACT = TWO_AGENT_HANDOFF_CATCH_CONTRACT;
+exports.TWO_AGENT_HANDOFF_CATCH_SCENE_ID = TWO_AGENT_HANDOFF_CATCH_SCENE_ID;
+exports.asCaelReceiptHash = asCaelReceiptHash;
+exports.asSceneHash = asSceneHash;
+exports.asTrajectoryId = asTrajectoryId;
+exports.buildAdversarialTrajectoryReport = buildAdversarialTrajectoryReport;
+exports.buildDeterministicFailureTrajectory = buildDeterministicFailureTrajectory;
+exports.buildHumanoidRockThrowTrajectory = buildHumanoidRockThrowTrajectory;
+exports.buildTwoAgentHandoffCatchTrajectory = buildTwoAgentHandoffCatchTrajectory;
+exports.createDeterministicFailureDiscoveryScene = createDeterministicFailureDiscoveryScene;
+exports.createHumanoidRockThrowScene = createHumanoidRockThrowScene;
+exports.createTwoAgentHandoffCatchScene = createTwoAgentHandoffCatchScene;
+exports.exploreAdversarialTraces = exploreAdversarialTraces;
+exports.hasReplayEvidence = hasReplayEvidence;
+exports.hashDeterministicSceneValue = hashDeterministicSceneValue;
+exports.isCurriculumEligible = isCurriculumEligible;
+exports.isPortableHardwareReceiptMetadata = isPortableHardwareReceiptMetadata;
+exports.isReportCountsConsistent = isReportCountsConsistent;
+exports.mutateTrace = mutateTrace;
+exports.runDeterministicFailureDiscoveryScene = runDeterministicFailureDiscoveryScene;
+exports.runHumanoidRockThrowReplay = runHumanoidRockThrowReplay;
+exports.runTwoAgentHandoffCatchReplay = runTwoAgentHandoffCatchReplay;
+exports.scoreTrajectory = scoreTrajectory;
+exports.serializeReport = serializeReport;
+exports.validatePortableHardwareReceiptMetadata = validatePortableHardwareReceiptMetadata;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map