@mnstry/atelier 0.2.0-alpha.12 → 0.2.0-alpha.14

package/src/ingestion/optional/evaluation/index.mjs

@@ -0,0 +1,219 @@
+import { createHash } from 'node:crypto'
+import { performance } from 'node:perf_hooks'
+
+// Private Q02 execution/assessment sidecar. Existing intake and knowledge owners
+// retain all authoritative records; this module grants no execution permission.
+export const PRESENCE_PROFILES = Object.freeze(['vanilla', 'graphify', 'lightrag', 'jev',
+  'graphify+lightrag', 'graphify+jev', 'lightrag+jev', 'graphify+lightrag+jev'])
+const digest = value => createHash('sha256').update(JSON.stringify(value)).digest('hex')
+const phases = new Set(['cold', 'incremental', 'warm', 'recovery'])
+const terminalStates = new Set(['completed', 'failed', 'unavailable', 'unsupported', 'not-run', 'uncertain'])
+const numberOrNull = value => value === null || Number.isFinite(value) && value >= 0
+const requiredPins = ['installedCandidate', 'corpusDigest', 'targetsDigest', 'routeDigest', 'questionOrderDigest']
+
+export function validateExecutionPlan(plan) {
+  if (!plan || requiredPins.some(key => typeof plan[key] !== 'string' || !plan[key]) ||
+    !Array.isArray(plan.tasks) || !plan.tasks.length) throw new TypeError('Pinned installed target, frozen inputs and explicit task cohort required')
+  const ids = new Set()
+  for (const task of plan.tasks) {
+    if (!task?.id || ids.has(task.id) || !PRESENCE_PROFILES.includes(task.profile) ||
+      !phases.has(task.phase) || !task.routeId || !Number.isSafeInteger(task.repetition) || task.repetition < 1 ||
+      !task.questionId || !task.cacheState) throw new TypeError('Unique tasks require profile, phase, route, repetition, question and cache state')
+    ids.add(task.id)
+  }
+  return Object.freeze(structuredClone(plan))
+}
+
+// Host returns all attempted components, including failures and fallback. Unknown
+// or omitted required charges remain unknown rather than becoming free work.
+export function accountComponents(components) {
+  if (!Array.isArray(components)) throw new TypeError('Explicit accounting components required')
+  const currencies = new Set(), ids = new Set()
+  let knownSubtotal = 0, unknown = false
+  for (const item of components) {
+    if (!item?.id || ids.has(item.id) || !item.kind || !numberOrNull(item.cost) ||
+      !numberOrNull(item.elapsedMs) || typeof item.complete !== 'boolean') throw new TypeError('Unique valid attempted cost components required')
+    ids.add(item.id)
+    if (item.currency !== null && !/^[A-Z]{3}$/.test(item.currency ?? '')) throw new TypeError('Explicit currency or null required')
+    if (item.cost === null || !item.complete) unknown = true
+    else knownSubtotal += item.cost
+    if (item.cost !== null && item.cost !== 0 && item.currency === null) unknown = true
+    if (item.currency !== null) currencies.add(item.currency)
+  }
+  if (!components.length || currencies.size > 1) unknown = true
+  return { totalCost: unknown ? null : knownSubtotal, knownSubtotal,
+    currency: currencies.size === 1 ? [...currencies][0] : null,
+    complete: !unknown, attemptedComponents: components.length,
+    incompleteComponents: components.filter(x => x.cost === null || !x.complete).map(x => x.id),
+    unknownOrMixedCurrency: currencies.size > 1 || components.some(x => x.cost !== null && x.cost !== 0 && x.currency === null) }
+}
+
+// Separate existing assessor receipts are verified by a trusted receiving host.
+// Producer-supplied assessment fields never enter the useful-answer numerator.
+export function assessmentBinding(record) {
+  return { taskId: record.taskId, planDigest: record.planDigest, questionId: record.questionId,
+    routeId: record.routeId, resultDigest: record.resultDigest }
+}
+function assessmentReceived(record, receipt, verifyAssessment) {
+  if (record.outcome !== 'completed' || typeof verifyAssessment !== 'function' || !receipt) return false
+  const binding = assessmentBinding(record)
+  if (Object.values(binding).some(x => typeof x !== 'string' || !x) ||
+    !receipt.receiptRef || !receipt.assessorRef || !receipt.rubricRef || receipt.bindingDigest !== digest(binding)) return false
+  try {
+    const verified = verifyAssessment(structuredClone(receipt), structuredClone(binding))
+    if (typeof verified?.then === 'function') { Promise.resolve(verified).catch(() => {}); return false }
+    return verified?.verified === true && verified?.current === true && !!verified.ownerRef &&
+      verified.receiptRef === receipt.receiptRef && verified.bindingDigest === receipt.bindingDigest &&
+      receipt.usefulAccepted === true && receipt.supportAccepted === true
+  } catch { return false }
+}
+
+export function summarizeCohort({ assignedTaskIds, records, sharedComponents = [], assessmentReceipts = [], verifyAssessment }) {
+  if (!Array.isArray(assignedTaskIds) || !assignedTaskIds.length || new Set(assignedTaskIds).size !== assignedTaskIds.length ||
+    !Array.isArray(records) || !Array.isArray(assessmentReceipts)) throw new TypeError('Complete assigned denominator required')
+  const assigned = new Set(assignedTaskIds), observed = new Set(), assessmentTasks = new Set()
+  for (const record of records) {
+    if (!assigned.has(record.taskId) || observed.has(record.taskId) || !terminalStates.has(record.outcome)) throw new TypeError('Records must uniquely match the assigned cohort')
+    observed.add(record.taskId)
+  }
+  for (const receipt of assessmentReceipts) {
+    if (!assigned.has(receipt?.taskId) || assessmentTasks.has(receipt.taskId)) throw new TypeError('Separate assessor receipts must uniquely match assigned tasks')
+    assessmentTasks.add(receipt.taskId)
+  }
+  const useful = records.filter(record => assessmentReceived(record, assessmentReceipts.find(x => x.taskId === record.taskId), verifyAssessment))
+  const costs = [...sharedComponents, ...records.flatMap(x => x.components ?? [])]
+  let accounting
+  try { accounting = accountComponents(costs) }
+  catch (error) {
+    // Retain malformed/colliding accounting for reconciliation without losing
+    // already executed tasks or treating unverified charges as free work.
+    accounting = { totalCost: null, knownSubtotal: null, currency: null, complete: false,
+      attemptedComponents: costs.length, accountingIssue: error.message, retainedComponents: costs }
+  }
+  const missing = assignedTaskIds.filter(id => !observed.has(id))
+  const complete = !missing.length && records.every(x => Array.isArray(x.components) && x.components.length)
+  const totalCost = complete ? accounting.totalCost : null
+  return { assigned: assigned.size, observed: observed.size, missing,
+    usefulAccepted: useful.length, usefulAcceptedFraction: useful.length / assigned.size,
+    failedOrUnavailable: assigned.size - useful.length, accounting: { ...accounting, complete: complete && accounting.complete, totalCost },
+    costPerUsefulAcceptedAnswer: totalCost === null || !useful.length ? null : totalCost / useful.length,
+    elapsedObservations: records.map(x => ({ taskId: x.taskId, outcome: x.outcome, elapsedMs: x.elapsedMs ?? null })),
+    semanticQualityQualified: false, humanAuthorityVerified: false }
+}
+
+export function amortizedCosts({ ingestionComponents, queryComponents, queryCounts = [1, 10, 100] }) {
+  const initial = accountComponents(ingestionComponents), query = accountComponents(queryComponents)
+  return queryCounts.map(count => {
+    if (!Number.isSafeInteger(count) || count < 1) throw new TypeError('Positive predeclared query counts required')
+    const compatible = initial.currency === query.currency || initial.totalCost === 0 || query.totalCost === 0
+    return { queryCount: count, totalCost: initial.totalCost === null || query.totalCost === null || !compatible ? null : initial.totalCost + count * query.totalCost,
+      costPerQuery: initial.totalCost === null || query.totalCost === null || !compatible ? null : initial.totalCost / count + query.totalCost,
+      assumedWorkload: true, observedDemand: false }
+  })
+}
+
+/**
+ * Admission, native effects, resource bounds and cleanup belong to injected
+ * existing host owners. The host enforces per-call provider/CPU/deadline limits.
+ * No automatic retry/fallback, provider construction or rubric loading occurs.
+ */
+export function createQualificationExecutor({ admit, openTrial, executeTask, closeTrial, appendSidecar,
+  receiveAssessment, verifyAssessment,
+  monotonic = () => performance.now(), now = () => new Date().toISOString() }) {
+  for (const fn of [admit, openTrial, executeTask, closeTrial, appendSidecar]) if (typeof fn !== 'function') throw new TypeError('Actual admission, execution, sidecar and cleanup owners required')
+  if ((receiveAssessment !== undefined || verifyAssessment !== undefined) &&
+    (typeof receiveAssessment !== 'function' || typeof verifyAssessment !== 'function')) throw new TypeError('Separate assessment receiving and receipt verification owners required together')
+  return Object.freeze({ async run(planInput, { signal } = {}) {
+    const plan = validateExecutionPlan(planInput), planDigest = digest(plan)
+    const admission = await admit({ plan: structuredClone(plan), planDigest, signal })
+    if (admission?.planDigest !== planDigest || admission?.executionAllowed !== true ||
+      !admission?.ownerRef || !admission?.limitsRef) throw new Error('Existing owner refused or did not bind actual execution admission')
+    const records = [], trials = new Map(), sharedComponents = [], terminalCleanup = [], assessmentReceipts = [], componentIds = new Set(), sidecarFailures = []
+    const retainComponents = components => {
+      accountComponents(components)
+      if (components.some(x => componentIds.has(x.id))) throw new Error('Duplicate attempted accounting component across the cohort')
+      for (const x of components) componentIds.add(x.id)
+    }
+    const unknownAttempt = (task, stage, attemptedResult, error) => {
+      let id = `${task.id}/${stage}/unreported-attempt`
+      while (componentIds.has(id)) id += '/unreported'
+      componentIds.add(id)
+      return { outcome: 'uncertain', effectStage: stage, attemptedResult,
+        reconciliationReason: error?.message ?? 'actual result unreceived',
+        components: [{ id, kind: 'unreported-native-attempt', cost: null, currency: null, elapsedMs: null, complete: false }] }
+    }
+    const save = async (task, result, started, startedAt) => {
+      const record = { outcome: result.outcome, components: result.components, effectStage: result.effectStage,
+        reconciliationReason: result.reconciliationReason, executionResult: result, resultDigest: null,
+        taskId: task.id, profile: task.profile, phase: task.phase, routeId: task.routeId, repetition: task.repetition,
+        questionId: task.questionId, cacheState: task.cacheState, planDigest, startedAt, endedAt: now(), elapsedMs: Math.max(0, monotonic() - started),
+        qualification: 'unscored-execution-sidecar', admissionOwnerRef: admission.ownerRef }
+      // Retain execution before invoking a separate assessor or sidecar sink.
+      records.push(record)
+      record.executionResult = structuredClone(result)
+      record.resultDigest = digest(record.executionResult)
+      if (record.outcome === 'completed' && receiveAssessment) {
+        try {
+          const receipt = await receiveAssessment({ binding: assessmentBinding(record), result: structuredClone(result), plan: structuredClone(plan), signal })
+          if (receipt) {
+            record.assessmentReceiving = structuredClone(receipt)
+            if (receipt.taskId === task.id && receipt.bindingDigest === digest(assessmentBinding(record)) &&
+              receipt.receiptRef && receipt.assessorRef && receipt.rubricRef) assessmentReceipts.push(structuredClone(receipt))
+          }
+        } catch (error) { record.assessmentReceivingError = error.message }
+      }
+      await appendSidecar(structuredClone(record))
+    }
+    let failure
+    try {
+      for (const task of plan.tasks) {
+        if (signal?.aborted) break
+        const trialKey = `${task.profile}/${task.routeId}/${task.phase}/${task.repetition}`
+        if (!trials.has(trialKey)) {
+          const started = monotonic(), startedAt = now(), entry = { handle: null, task: structuredClone(task) }
+          trials.set(trialKey, entry)
+          let opened
+          try {
+            opened = await openTrial({ task: structuredClone(task), trialKey, planDigest, admission, signal })
+            if (opened?.handle) entry.handle = opened.handle
+            if (!entry.handle || !Array.isArray(opened.components) || !opened.components.length) throw new Error('Trial owner must return an actual handle and explicit shared accounting')
+            retainComponents(opened.components)
+            sharedComponents.push(...opened.components)
+          } catch (error) {
+            await save(task, unknownAttempt(task, 'trial-open', opened ?? error.attemptedResult, error), started, startedAt)
+            break
+          }
+        }
+        const started = monotonic(), startedAt = now()
+        let result
+        try {
+          result = await executeTask({ task: structuredClone(task), trial: trials.get(trialKey).handle, planDigest, admission, signal })
+          if (!terminalStates.has(result?.outcome) || !Array.isArray(result.components) || !result.components.length) throw new Error('Incomplete host task receipt')
+          retainComponents(result.components)
+        } catch (error) {
+          result = unknownAttempt(task, 'task-execution', result ?? error.attemptedResult, error)
+        }
+        await save(task, result, started, startedAt)
+        if (result.outcome === 'uncertain') break
+      }
+    } catch (error) { failure = error }
+    finally {
+      for (const [trialKey, entry] of [...trials].reverse()) {
+        let cleanup
+        try { cleanup = await closeTrial({ trial: entry.handle, task: entry.task, trialKey, planDigest, admission }) }
+        catch (error) { cleanup = { verified: false, outcome: 'cleanup-uncertain', reason: error.message } }
+        terminalCleanup.push({ trialKey, ...cleanup })
+      }
+      try { await appendSidecar({ kind: 'trial-cleanup', planDigest, terminalCleanup, qualification: 'host-reported-not-independently-verified' }) }
+      catch (error) { sidecarFailures.push({ stage: 'trial-cleanup', error }); failure ??= error }
+    }
+    if (failure) {
+      // Original sidecar/cleanup failure retains all executed output and custody.
+      Object.assign(failure, { records, sharedComponents, assessmentReceipts, terminalCleanup, sidecarFailures, planDigest, retryAuthorized: false })
+      throw failure
+    }
+    return { planDigest, records, sharedComponents, assessmentReceipts, terminalCleanup,
+      cohort: summarizeCohort({ assignedTaskIds: plan.tasks.map(x => x.id), records, sharedComponents, assessmentReceipts, verifyAssessment }),
+      cleanupVerified: terminalCleanup.every(x => x.verified === true), nativeQualification: false, benefitQualified: false }
+  } })
+}

package/src/ingestion/optional/graphify/composition-binding.mjs

@@ -0,0 +1,60 @@
+/** Private existing-host dispatch receiving; no SDK, process or receipt owner.
+ * The dispatcher owns a single selected query, canonical evidence receiving and
+ * independently verified host step receipt receiving, including no-hit output.
+ */
+export class GraphifyCompositionBindingError extends Error {
+  constructor(message, received, cause) {
+    super(message, { cause })
+    this.name = 'GraphifyCompositionBindingError'
+    // Native failures and rejected bridges retain actual outputs/costs. A failed
+    // snapshot keeps the original producer object explicitly in error custody.
+    try { this.supplierResult = structuredClone(received); this.snapshotState = 'received' }
+    catch (snapshotError) { this.supplierResult = received; this.snapshotState = 'failed'; this.snapshotError = snapshotError }
+    this.retryAuthorized = false
+  }
+}
+
+const same = (left, right) => JSON.stringify(left) === JSON.stringify(right)
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+const artifact = value => object(value) && Object.keys(value).sort().join(',') === 'bytes,path,sha256' &&
+  typeof value.path === 'string' && value.path.length > 0 && /^[a-f0-9]{64}$/.test(value.sha256) && Number.isSafeInteger(value.bytes) && value.bytes >= 0
+const sources = value => object(value) && Object.entries(value).every(([id, source]) => id.length > 0 && object(source) &&
+  source.sourceId === id && typeof source.path === 'string' && source.path.length > 0 && /^[a-f0-9]{64}$/.test(source.sourceDigest))
+export function createGraphifyCompositionBinding({ dispatch }) {
+  if (typeof dispatch !== 'function') throw new TypeError('Existing host Graphify dispatch required')
+  const retrieve = async payload => {
+    let received
+    try { received = await dispatch({ operation: 'retrieve', payload }) }
+    catch (cause) { throw new GraphifyCompositionBindingError('Selected Graphify host dispatch failed; reconcile original custody', cause?.supplierResult ?? cause?.receipt ?? null, cause) }
+    const envelope = received?.envelope
+    const binding = received?.hostVerificationOriginal?.binding
+    if (received?.operation !== 'receive-composition' || received.outcome !== 'composition-envelope-received' ||
+        !envelope || envelope.provider !== 'graphify' || envelope.nativeOperation !== 'query' ||
+        typeof envelope.generation !== 'string' || !envelope.generation || envelope.generation !== received.generationId || !envelope.receiptRef || !envelope.bridgeReceipt ||
+        envelope.receiptAssurance !== 'explicit-verified-existing-host-bridge' ||
+        !Array.isArray(envelope.hits) || !Array.isArray(envelope.unresolved) ||
+        !artifact(envelope.artifactRef) || !artifact(received.compositionArtifact) ||
+        !artifact(envelope.supplierQueryReceipt) || !artifact(received.supplierQueryReceipt) ||
+        !artifact(envelope.supplierReceivingReceipt) || !artifact(received.supplierReceivingReceipt) ||
+        !sources(envelope.sourceBindings) || !sources(binding?.sourceBindings) ||
+        !artifact(binding?.queryArtifact) || !artifact(binding?.queryReceiptArtifact) || !artifact(binding?.receivingArtifact) ||
+        !same(envelope.supplierQueryReceipt, received.supplierQueryReceipt) ||
+        !same(envelope.supplierReceivingReceipt, received.supplierReceivingReceipt) ||
+        !same(envelope.receiptRef, received.receiptBridgeOriginal?.receiptRef) ||
+        !same(envelope.bridgeReceipt, received.receiptBridgeOriginal?.bridgeReceipt) ||
+        received.hostVerificationOriginal?.verified !== true || received.hostVerificationOriginal?.current !== true ||
+        binding?.provider !== 'graphify' || binding.generation !== envelope.generation ||
+        !same(binding.sourceBindings, envelope.sourceBindings) || !same(binding.queryArtifact, envelope.artifactRef) ||
+        !same(binding.queryReceiptArtifact, envelope.supplierQueryReceipt) || !same(binding.receivingArtifact, envelope.supplierReceivingReceipt) ||
+        !same(binding.receiptRef, envelope.receiptRef) || !same(binding.bridgeReceipt, envelope.bridgeReceipt) ||
+        !Object.hasOwn(binding, 'bridgeUsage') || !Object.hasOwn(received.receiptBridgeOriginal ?? {}, 'usage') ||
+        !object(envelope.usage?.bridge) || !Object.hasOwn(envelope.usage.bridge, 'usage') ||
+        !same(binding.bridgeUsage, received.receiptBridgeOriginal.usage) || !same(binding.bridgeUsage, envelope.usage.bridge.usage)) {
+      throw new GraphifyCompositionBindingError('Original Graphify receiving and actual verified host receipt bridge required', received)
+    }
+    return structuredClone(envelope)
+  }
+  return Object.freeze({ bindings: Object.freeze({ retrieve }), operationRoles: Object.freeze({ retrieve: 'retrieve' }),
+    hostRequired: Object.freeze(['single-selected-query', 'existing-canonical-evidence-hydration',
+      'independent-current-quote-eligibility', 'actual-verified-existing-host-step-receipt']) })
+}

package/src/ingestion/optional/graphify/composition_receiving.py

@@ -0,0 +1,185 @@
+"""Private existing-host step receipt receiving. No native dispatch or canonical.
+
+Evidence eligibility and a selected operation's actual host receipt are separate.
+The trusted host owns both callbacks; caller JSON cannot supply their authority.
+"""
+from __future__ import annotations
+import copy
+import fcntl
+import hashlib
+import json
+import os
+import stat
+import uuid
+from pathlib import Path
+from graphify_supplier import SupplierError, digest, json_safe, require
+from query_receiving import _reference
+
+
+def _read_artifact(supplier, directory, artifact):
+    require(isinstance(artifact, dict) and set(artifact) == {"path", "sha256", "bytes"},
+            "COMPOSITION_ARTIFACT", "Original artifact descriptor required")
+    path = Path(artifact["path"])
+    require(path.parent == directory and not directory.is_symlink()
+            and directory.parent == supplier.artifacts and not supplier.artifacts.is_symlink()
+            and path.is_file() and not path.is_symlink(), "COMPOSITION_ARTIFACT", "Original owned artifact required")
+    # Original op-directory files only; no symlink traversal at any open step.
+    root_fd = os.open(supplier.artifacts, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
+    directory_fd, file_fd = None, None
+    try:
+        directory_fd = os.open(directory.name, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=root_fd)
+        file_fd = os.open(path.name, os.O_RDONLY | os.O_NOFOLLOW, dir_fd=directory_fd)
+        before = os.fstat(file_fd)
+        require(stat.S_ISREG(before.st_mode), "COMPOSITION_ARTIFACT", "Regular original artifact required")
+        with os.fdopen(file_fd, "rb", closefd=False) as stream:
+            raw = stream.read()
+        after = os.fstat(file_fd)
+        require((before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns, before.st_ctime_ns)
+                == (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns),
+                "ARTIFACT_DRIFT", "Original artifact changed during readback")
+    finally:
+        if file_fd is not None: os.close(file_fd)
+        if directory_fd is not None: os.close(directory_fd)
+        os.close(root_fd)
+    require(len(raw) == artifact["bytes"] and hashlib.sha256(raw).hexdigest() == artifact["sha256"],
+            "ARTIFACT_DRIFT", "Original artifact differs from retained receiving")
+    return json.loads(raw)
+
+
+def receive_composition(supplier, received_query, *, receipt_bridge, verify_receipt_bridge):
+    """Receive exact retained query output through actual existing host receipts.
+
+    Returns an explicit unreceived result with original output/unknown costs on a
+    host callback or late freshness failure. It never substitutes a supplier hash
+    for a receipt owner. The JS binding retains that result on its error cause.
+    """
+    require(callable(receipt_bridge) and callable(verify_receipt_bridge), "COMPOSITION_OWNER",
+            "Actual host receipt bridge and independent verifier required")
+    require(supplier.lock.acquire(blocking=False), "WRITER_BUSY", "A supplier operation owns receiving")
+    lease, details, directory = None, None, None
+    try:
+        lease = (supplier.artifacts / ".writer.lock").open("a+b")
+        try:
+            fcntl.flock(lease, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError as exc:
+            raise SupplierError("WRITER_BUSY", "Another process owns this supplier destination") from exc
+        received = json_safe(copy.deepcopy(received_query))
+        require(isinstance(received, dict) and isinstance(received.get("receivingArtifact"), dict),
+                "COMPOSITION_RECEIVING", "Exact retained query receiving required")
+        directory = Path(received["receivingArtifact"]["path"]).parent
+        original = _read_artifact(supplier, directory, received["receivingArtifact"])
+        require(original.get("envelope") == {k: v for k, v in received.items() if k != "receivingArtifact"},
+                "COMPOSITION_RECEIVING", "Original receiving envelope readback must agree")
+        operation_id = original["queryOperationId"]
+        query = supplier.read_capture(operation_id)["receipt"]
+        context = original["queryBinding"]
+        require(directory == supplier.artifacts / operation_id and query["operation"] == "query"
+                and query["status"] == "complete" and received["provider"] == "graphify"
+                and received["generation"] == context["generation"] == query["graphGeneration"]
+                and context["sourceBindings"] == query["sourceBindings"]
+                and received["artifactRef"] == context["queryArtifact"]
+                and isinstance(received["hits"], list) and isinstance(received["unresolved"], list),
+                "COMPOSITION_RECEIVING", "Original successful query/source/generation required")
+        native = _read_artifact(supplier, directory, context["queryArtifact"])
+        original_query_receipt = _read_artifact(supplier, directory, context["queryReceiptArtifact"])
+        require(query == original_query_receipt and received["usage"] == query.get("usage"),
+                "COMPOSITION_RECEIVING", "Original query receipt and usage must agree")
+        payload = {**copy.deepcopy(received), "nativeOperation": "query", "nativeResult": native,
+                   "sourceBindings": copy.deepcopy(context["sourceBindings"]),
+                   "supplierQueryReceipt": copy.deepcopy(context["queryReceiptArtifact"]),
+                   "supplierReceivingReceipt": copy.deepcopy(received["receivingArtifact"]),
+                   "evidenceReceiptRef": copy.deepcopy(received["receiptRef"]), "receiptRef": None,
+                   "queryUsage": copy.deepcopy(query.get("usage")),
+                   "usage": {"query": {"receiptArtifact": copy.deepcopy(context["queryReceiptArtifact"]),
+                                        "usage": copy.deepcopy(query.get("usage")), "assurance": query.get("usageAssurance")},
+                             "receiving": {"artifact": copy.deepcopy(received["receivingArtifact"]), "usage": None},
+                             "bridge": {"usage": None}},
+                   "semanticAcceptance": "existing-owner-only", "canonicalMutation": False}
+        details = {"operation": "receive-composition", "queryOperationId": operation_id,
+                   "generationId": context["generation"], "outcome": "composition-envelope-unreceived",
+                   "originalQueryEnvelope": copy.deepcopy(received), "envelope": payload,
+                   "supplierQueryReceipt": copy.deepcopy(context["queryReceiptArtifact"]),
+                   "supplierReceivingReceipt": copy.deepcopy(received["receivingArtifact"]),
+                   "receiptBridgeOriginal": None, "hostVerificationOriginal": None,
+                   "authority": "none", "canonicalMutation": False}
+        for name in ("historyDigest", "activationRef"):
+            if name in context: payload[name] = copy.deepcopy(context[name])
+        try:
+            supplier._fresh(context["generation"], "graph")
+            bridged = json_safe(receipt_bridge(copy.deepcopy(payload), copy.deepcopy(query), copy.deepcopy(original)))
+            details["receiptBridgeOriginal"] = copy.deepcopy(bridged)
+            require(isinstance(bridged, dict) and _reference(bridged.get("receiptRef"))
+                    and _reference(bridged.get("bridgeReceipt")) and "usage" in bridged,
+                    "COMPOSITION_RECEIPT", "Original actual host step/bridge receipts and known or unknown usage required")
+            # This local exact-value guard is not owner authentication. It refuses
+            # listed paths and bare/sha256:-prefixed lower-case content hashes;
+            # other aliases/case/format variants remain the actual verifier's job.
+            identifiers = {digest(query), digest(original), digest(native), digest(payload)}
+            artifacts = query["artifacts"] + [context["queryReceiptArtifact"], received["receivingArtifact"]]
+            for artifact in artifacts:
+                identifiers.update((artifact["path"], artifact["sha256"], "sha256:" + artifact["sha256"]))
+            for name in ("receiptRef", "bridgeReceipt"):
+                reference = bridged[name]
+                require(reference["id"] not in identifiers and reference["id"].removeprefix("sha256:") not in identifiers
+                        and reference["digest"] not in identifiers
+                        and reference["digest"].removeprefix("sha256:") not in identifiers,
+                        "COMPOSITION_RECEIPT", "Supplier artifact digests cannot become existing host receipts")
+            binding = {"provider": "graphify", "generation": context["generation"],
+                       "sourceBindings": copy.deepcopy(context["sourceBindings"]),
+                       "queryArtifact": copy.deepcopy(context["queryArtifact"]),
+                       "queryReceiptArtifact": copy.deepcopy(context["queryReceiptArtifact"]),
+                       "receivingArtifact": copy.deepcopy(received["receivingArtifact"]),
+                       "envelopeDigest": digest(payload), "receiptRef": copy.deepcopy(bridged["receiptRef"]),
+                       "bridgeReceipt": copy.deepcopy(bridged["bridgeReceipt"]), "bridgeUsage": copy.deepcopy(bridged["usage"])}
+            for name in ("historyDigest", "activationRef"):
+                if name in context: binding[name] = copy.deepcopy(context[name])
+            verdict = json_safe(verify_receipt_bridge(copy.deepcopy(binding), copy.deepcopy(payload), copy.deepcopy(bridged)))
+            details["hostVerificationOriginal"] = copy.deepcopy(verdict)
+            require(isinstance(verdict, dict) and verdict.get("binding") == binding
+                    and verdict.get("verified") is True and verdict.get("current") is True,
+                    "COMPOSITION_BRIDGE_UNVERIFIED", "Independent existing host must bind exact original query/receiving/source/generation/envelope/receipts")
+            supplier._fresh(context["generation"], "graph")
+            require(supplier.read_capture(operation_id)["receipt"] == query
+                    and _read_artifact(supplier, directory, received["receivingArtifact"]) == original
+                    and _read_artifact(supplier, directory, context["queryReceiptArtifact"]) == query,
+                    "ARTIFACT_DRIFT", "Original query or receiving changed during host receipt receiving")
+            payload.update(receiptRef=copy.deepcopy(bridged["receiptRef"]), bridgeReceipt=copy.deepcopy(bridged["bridgeReceipt"]),
+                           receiptAssurance="explicit-verified-existing-host-bridge")
+            payload["usage"]["bridge"] = {"receiptRef": copy.deepcopy(bridged["bridgeReceipt"]), "usage": copy.deepcopy(bridged["usage"])}
+            details["outcome"] = "composition-envelope-received"
+        except BaseException as exc:
+            details["error"] = {"type": type(exc).__name__, "code": getattr(exc, "code", "COMPOSITION_HOST_FAILURE")}
+            # Original potentially stale hits remain diagnostic under the original
+            # envelope. Refused bridging cannot provide any composition hit.
+            payload["hits"] = []
+            payload["receiptRef"] = None
+            payload["unresolved"].append({"reason": details["error"]["code"], "type": type(exc).__name__})
+            if isinstance(details["receiptBridgeOriginal"], dict):
+                payload["usage"]["bridge"] = {"receiptRef": copy.deepcopy(details["receiptBridgeOriginal"].get("bridgeReceipt")),
+                                               "usage": copy.deepcopy(details["receiptBridgeOriginal"].get("usage"))}
+            if not isinstance(exc, Exception):
+                # Control signals remain control signals; preserve originals and
+                # costs, capture cancellation if possible, then let finally clean
+                # both leases before the same exception reaches the host.
+                details["controlSignal"] = {"type": type(exc).__name__, "propagated": True}
+                try:
+                    details["compositionArtifact"] = supplier._write(directory, f"composition-{uuid.uuid4().hex}.json", details)
+                except BaseException as capture_error:
+                    details["captureError"] = {"type": type(capture_error).__name__, "code": getattr(capture_error, "code", "CAPTURE_FAILURE")}
+                exc.receipt = copy.deepcopy(details)
+                raise
+        capture = supplier._write(directory, f"composition-{uuid.uuid4().hex}.json", details)
+        return {**details, "compositionArtifact": capture}
+    except Exception as exc:
+        if isinstance(exc, SupplierError):
+            exc.receipt = copy.deepcopy(details) if details else copy.deepcopy(received_query)
+            raise
+        raise SupplierError("COMPOSITION_RECEIVING_FAILURE", "Host receiving failed; original custody retained", copy.deepcopy(details)) from exc
+    except BaseException as exc:
+        if not hasattr(exc, "receipt"):
+            exc.receipt = copy.deepcopy(details) if details else copy.deepcopy(received_query)
+        raise
+    finally:
+        if lease:
+            lease.close()
+        supplier.lock.release()