@corca-org/ceal-host-linux-arm64 1.0.18 → 1.0.20

package/libexec/ceal-host/relay.mjs

@@ -109,6 +109,9 @@ var client_wire_contract_default = {
       "document"
     ],
     optional_fields: [
+      "operation_id",
+      "visible_output_max_bytes",
+      "local_delivery",
       "verified_artifact"
     ],
     bare_document_fields: [
@@ -195,6 +198,7 @@ var CEAL_COMMAND_RESPONSE_FOCUSED_PROMPT_CONTINUATION_DOCUMENT_FIELDS = Object.f
 var CEAL_COMMAND_RESPONSE_DISCOVERY_COMMAND = response.discovery_command;
 var CEAL_COMMAND_RESPONSE_DISCOVERY_MANIFEST_SCHEMA_VERSION = response.discovery_manifest_schema_version;
 var CEAL_COMMAND_RESPONSE_DISCOVERY_MANIFEST_DOCUMENT_FIELDS = Object.freeze([...response.discovery_manifest_document_fields]);
+var CEAL_COMMAND_RESPONSE_MAX_BYTES = CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES;
 
 // packages/ceal-client-protocol/src/vocabulary.ts
 function vocabulary(words) {
@@ -225,6 +229,7 @@ var CEAL_WRITE_RECEIPT_PROVIDER_STATES = vocabulary(["outcome_unknown", "verifie
 var CEAL_WRITE_RECEIPT_PROVIDER_READBACKS = vocabulary(["outcome_unknown", "verified", "not_applied"]);
 var CEAL_PROTOCOL_VERSION = "1.4.0";
 var CEAL_OPERATION_ACCESS_SCHEMA_VERSION = "ceal.operation_access.v1";
+var CEAL_GATEWAY_CONTINUATION_CURSOR_PHASES = vocabulary(["scan", "delivery", "terminal"]);
 var CEAL_GATEWAY_ACTIVE_CALL_PHASES = vocabulary([
   "audited_call_pending",
   "continuation_read_pending",
@@ -248,6 +253,7 @@ var CEAL_GATEWAY_ORGANIZATION_ROUTE_FACT_CALL_KEYS = Object.freeze([
 // packages/ceal-client-protocol/src/operation-next-actions.ts
 var CEAL_REPEAT_REQUEST_NEXT_ACTION = "repeat_request";
 var CEAL_INSPECT_RECEIPT_NEXT_ACTION = "inspect_receipt";
+var CEAL_ANSWER_WITH_GAP_NEXT_ACTION = "answer_with_gap";
 var CALLER_RECOVERABLE_NEXT_ACTION_VALUES = [
   "select_did_you_mean",
   "choose_new_output_path",
@@ -301,10 +307,20 @@ var CALLER_RECOVERABLE_NEXT_ACTION_VALUES = [
   "retry_after",
   // The ref names a container of rows (a Notion database or data source), which
   // has no body of its own; the caller searches its rows instead of reading it.
-  "search_container_rows"
+  "search_container_rows",
+  // A settled unknown write names the exact receipt Operation that can inspect
+  // its outcome without issuing another provider mutation.
+  "write_receipt.get",
+  // Command resolution carries the exact required Operation sequence beside
+  // this action, so the caller can execute each declared input in order.
+  "follow_required_action_sequence",
+  // The command needs caller-owned local materialization (for example an
+  // @path file) before the Gateway can receive the argument.
+  "materialize_local_argument"
 ];
 var CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS = Object.freeze(CALLER_RECOVERABLE_NEXT_ACTION_VALUES);
 var NON_REMEDY_NEXT_ACTION_VALUES = [
+  CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
   // Only an administrator can take the named step -- approving a place for an
   // Operation, granting a withheld capability -- so a non-administrator asks
   // one. The refusal names the administrator step; this word is the ask.
@@ -352,7 +368,58 @@ var NON_REMEDY_NEXT_ACTION_VALUES = [
   "select_exact_approval"
 ];
 var CEAL_NON_REMEDY_NEXT_ACTIONS = Object.freeze(NON_REMEDY_NEXT_ACTION_VALUES);
-var DECLARED = /* @__PURE__ */ new Set([...CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS, ...CEAL_NON_REMEDY_NEXT_ACTIONS]);
+var CEAL_DECLARED_NEXT_ACTIONS = Object.freeze([...CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS, ...CEAL_NON_REMEDY_NEXT_ACTIONS]);
+var DECLARED = new Set(CEAL_DECLARED_NEXT_ACTIONS);
+function defineCealNonModelNextActions(actions) {
+  return actions;
+}
+var NON_MODEL_NEXT_ACTION_VALUES = defineCealNonModelNextActions([
+  CEAL_INSPECT_RECEIPT_NEXT_ACTION,
+  "await_pending_approval",
+  "inspect_gateway",
+  "operator_action",
+  "none",
+  "check_gateway",
+  "inspect_context_store",
+  "inspect_local_cache",
+  "inspect_local_client",
+  "inspect_local_command",
+  "inspect_local_output",
+  "inspect_local_route",
+  "inspect_request",
+  "reconcile",
+  "reconcile_occurrence",
+  "retry_after_owner_recovery",
+  "select_exact_approval"
+]);
+var NON_MODEL_NEXT_ACTIONS = new Set(NON_MODEL_NEXT_ACTION_VALUES);
+function isCealModelActionableNonRemedyNextAction(action) {
+  return !NON_MODEL_NEXT_ACTIONS.has(action);
+}
+var CEAL_MODEL_ACTIONABLE_NEXT_ACTIONS = Object.freeze([
+  ...CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS,
+  ...CEAL_NON_REMEDY_NEXT_ACTIONS.filter(isCealModelActionableNonRemedyNextAction)
+]);
+var MODEL_ACTIONABLE = new Set(CEAL_MODEL_ACTIONABLE_NEXT_ACTIONS);
+var NON_MODEL_ACTION_TO_MODEL_ACTION = Object.freeze({
+  [CEAL_INSPECT_RECEIPT_NEXT_ACTION]: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  await_pending_approval: "ask_admin",
+  inspect_gateway: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  operator_action: "ask_admin",
+  none: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  check_gateway: "ask_admin",
+  inspect_context_store: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_cache: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_client: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_command: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_output: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_route: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_request: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  reconcile: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  reconcile_occurrence: "ask_admin",
+  retry_after_owner_recovery: "ask_admin",
+  select_exact_approval: "ask_admin"
+});
 var RETRY_PROMISE_NEXT_ACTIONS = ["retry", "retry_after"];
 var RETRY_PROMISE = new Set(RETRY_PROMISE_NEXT_ACTIONS);
 var RECOVERABLE = new Set(CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS);
@@ -622,21 +689,15 @@ var CEAL_OPERATION_ACCESS_CLASSES = vocabulary(["read", "write"]);
 // packages/ceal-client-protocol/src/domain-vocabulary.ts
 var CEAL_CONNECTOR_STATUSES = vocabulary(["active", "disabled", "disconnected"]);
 var CEAL_CONNECTOR_CUSTODIES = vocabulary(["organization", "personal"]);
-var CEAL_PROVIDER_BOUNDARY_KINDS = vocabulary([
-  "github_account",
-  "github_organization",
-  "google_workspace_domain",
-  "notion_workspace",
-  "slack_workspace"
-]);
-var CEAL_PROVIDER_BOUNDARY_EVIDENCE = vocabulary(["provider_readback", "operator_stated"]);
 var CEAL_ACCESS_LEVELS = vocabulary(["none", "read", "read_write"]);
 var CEAL_PERSONAL_ACCESS_CEILINGS = vocabulary(["disabled", "read", "read_write"]);
 var CEAL_TARGET_REF_PATTERN = "^[^\\p{Cc}]+$";
 var TARGET_REF = new RegExp(CEAL_TARGET_REF_PATTERN, "u");
 var CEAL_TARGET_VISIBILITIES = vocabulary(["public", "private"]);
-var CEAL_PRINCIPAL_KINDS = vocabulary(["human", "service", "runtime"]);
+var CEAL_PRINCIPAL_KINDS = vocabulary(["human", "runtime"]);
+var CEAL_PERSISTED_PRINCIPAL_KINDS = vocabulary(["human", "service", "runtime"]);
 var CEAL_ORGANIZATION_ROLES = vocabulary(["member", "admin"]);
+var CEAL_CALENDAR_PERIODS = vocabulary(["day", "week", "month"]);
 var LABEL_EXPECTATION = `public-safe display text of at most ${CEAL_PUBLIC_DISPLAY_NAME_MAX_BYTES} bytes`;
 
 // packages/ceal-client-protocol/src/safe-json-budget.ts
@@ -812,7 +873,7 @@ var CEAL_SCHEMA_LITERALS = [
   "ceal.operation_receipt.v1",
   "ceal.operation_result.v1",
   "ceal.operation_result.compact.v1",
-  "ceal.local_result_materialization.v1",
+  "ceal.local_result_file.v1",
   "ceal.local_result_root.v1",
   "ceal.owner_bootstrap_exchange_request.v1",
   "ceal.owner_bootstrap_exchange_result.v1",
@@ -842,6 +903,9 @@ var CEAL_BOUNDED_SERIES_CATALOG = Object.freeze({
   gateway_personal_client_access_audit: (root) => join(root, "access-audit.jsonl")
 });
 
+// packages/ceal-client-protocol/src/canonical-http-boundary.ts
+var CEAL_CANONICAL_HTTP_MAX_RESPONSE_BYTES = CEAL_COMMAND_RESPONSE_MAX_BYTES;
+
 // packages/ceal-client-protocol/src/gateway-installation-activation.ts
 var CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_DATA_CHARACTERS = 32;
 var CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_CHECK_CHARACTERS = 8;
@@ -907,41 +971,6 @@ var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_JSON_SCHEMA = Object.freeze({
   }
 });
 
-// packages/ceal-client-protocol/src/provider-operation-vocabulary.ts
-var CEAL_FILE_TYPE_FAMILIES = vocabulary(["all", "image", "pdf"]);
-var CEAL_GITHUB_ISSUE_STATES = vocabulary(["open", "closed", "all"]);
-var CEAL_NOTION_UPDATABLE_BLOCK_TYPES = vocabulary([
-  "paragraph",
-  "heading_1",
-  "heading_2",
-  "heading_3",
-  "bulleted_list_item",
-  "numbered_list_item",
-  "to_do",
-  "code"
-]);
-var CEAL_NOTION_NEUTRAL_TYPES = vocabulary([
-  "text",
-  "number",
-  "boolean",
-  "date",
-  "select",
-  "multi_select",
-  "people",
-  "url",
-  "email",
-  "phone",
-  "unsupported"
-]);
-var CEAL_NOTION_IDENTITY_GAP_REASONS = vocabulary([
-  "identity_unavailable",
-  "identity_stale",
-  "identity_ambiguous",
-  "identity_revoked",
-  "identity_unlinked"
-]);
-var CEAL_NOTION_STRING_VALUE_TYPES = vocabulary(["text", "select", "url", "email", "phone"]);
-
 // packages/ceal-client-protocol/src/opaque-reference.ts
 var CEAL_OPAQUE_HANDLE_KINDS = vocabulary(["target", "message", "thread", "artifact", "document", "block", "object"]);
 var CEAL_OPAQUE_REF_KINDS = vocabulary([...CEAL_OPAQUE_HANDLE_KINDS, "result", "operation-receipt", "reply-receipt", "field", "notion-data-source"]);
@@ -951,6 +980,7 @@ var REQUIRED_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_f
 var OPTIONAL_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_optional_fields;
 
 // packages/ceal-client-protocol/src/resource-row.ts
+var CEAL_RESOURCE_ROW_TITLE_MATCH_DISPOSITIONS = vocabulary(["exact", "not_exact", "unknown"]);
 var CEAL_RESOURCE_SEARCH_ORDERS = vocabulary(["relevance", "modified", "viewed", "created"]);
 var CEAL_RESOURCE_SEARCH_DIRECTIONS = vocabulary(["ascending", "descending"]);
 var CEAL_RESOURCE_SEARCH_FILTERS = vocabulary(["query", "modified_since", "since", "until", "authored_by_me", "authored_by", "include_replies", "kinds", "container_ref", "container_refs", "container_names", "addressed_to_me", "unread"]);
@@ -974,6 +1004,7 @@ var CEAL_ACTIVITY_TIMESTAMP_BASES = vocabulary([
   "resource_modified"
 ]);
 var CEAL_ACTIVITY_CONNECTOR_KINDS = vocabulary(["slack", "github", "google-calendar", "google-drive", "notion"]);
+var CEAL_ACTIVITY_UNSUPPORTED_EVENT_KIND_CODE = "unsupported_event_kind";
 var CEAL_ACTIVITY_GAP_CODES = vocabulary([
   "provider_page_budget",
   "call_deadline",
@@ -981,7 +1012,7 @@ var CEAL_ACTIVITY_GAP_CODES = vocabulary([
   "provider_cursor_unavailable",
   "malformed_provider_page",
   "visibility_incomplete",
-  "unsupported_event_kind",
+  CEAL_ACTIVITY_UNSUPPORTED_EVENT_KIND_CODE,
   "direct_messages_excluded"
 ]);
 var CEAL_ACTIVITY_EVENT_KINDS = vocabulary([
@@ -1033,6 +1064,7 @@ var RESOURCE_ROW_KEY_RULES = Object.freeze({
   next: { required: true, timestamp: false },
   kind: { required: true, timestamp: false },
   matched_kinds: { required: false, timestamp: false },
+  title_match: { required: false, timestamp: false },
   title: { required: true, timestamp: false },
   container_label: { required: true, timestamp: false },
   container_ref: { required: false, timestamp: false },
@@ -1046,6 +1078,8 @@ var RESOURCE_ROW_KEY_RULES = Object.freeze({
   modified_at: { required: false, timestamp: true },
   modified_at_local: { required: false, timestamp: true },
   viewed_by_me_at: { required: false, timestamp: true },
+  own_ceal_write: { required: false, timestamp: false },
+  owned_by_me: { required: false, timestamp: false },
   visibility: { required: false, timestamp: false },
   start: { required: false, timestamp: false },
   end: { required: false, timestamp: false },
@@ -1079,6 +1113,15 @@ function cealExcludedTargetCoverageJsonSchema() {
   };
 }
 
+// packages/ceal-client-protocol/src/gateway-write-identity.ts
+var CEAL_GATEWAY_WRITE_IDENTITY_ROLES = Object.freeze(["replay_identity", "lookup_handle", "collision_evidence"]);
+var CEAL_GATEWAY_WRITE_REQUEST_REF_PATTERN = /^gateway-write-request:[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/u;
+var CEAL_GATEWAY_WRITE_IDENTITY_FIELDS = Object.freeze({
+  replay_identity: "idempotency_claim_sha256",
+  lookup_handle: "write_request_sha256",
+  collision_evidence: "normalized_mutation_sha256"
+});
+
 // packages/ceal-client-protocol/src/write-safety-finding.ts
 var CEAL_WRITE_SAFETY_FINDING_STATUSES = vocabulary(["warning", "unchecked"]);
 var CEAL_WRITE_SAFETY_AUDIENCES = vocabulary(["workspace", "person", "members", "unknown"]);
@@ -1106,7 +1149,11 @@ var CEAL_REFRESH_FAILURE_CODES = vocabulary([
   "refresh_revoked",
   "authority_replaced",
   "refresh_recovery_unavailable",
-  "refresh_recovery_expired"
+  "refresh_recovery_expired",
+  // The serving gate answers this while the Gateway is still starting and the
+  // refresh was never attempted; the same attempt stays retryable. It is never
+  // stored by the session owner, only answered at the serving edge.
+  "gateway_starting"
 ]);
 
 // packages/ceal-client-protocol/src/request-validation-primitives.ts
@@ -1139,7 +1186,7 @@ var CANCELLATION_STATES = vocabulary(["requested", "cancelled"]);
 var CEAL_REQUEST_KEYS = Object.freeze(["schema_version", "ceal_request_ref", "created_at", "authority", "prompt_ref", "host_session_ref", "host_turn_ref", "host_source_ref"]);
 var CEAL_REQUEST_JSON_SCHEMA = {
   type: "object",
-  maxProperties: 10,
+  maxProperties: 11,
   additionalProperties: false,
   properties: {
     schema_version: { type: "string", const: CEAL_REQUEST_SCHEMA_VERSION, maxLength: 32 },
@@ -1163,7 +1210,8 @@ var CEAL_REQUEST_JSON_SCHEMA = {
     host_turn_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
     host_input_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
     host_source_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
-    requester_timezone: { type: "string", minLength: 1, maxLength: 128, description: "IANA timezone observed for the requester on this Request." }
+    requester_timezone: { type: "string", minLength: 1, maxLength: 128, description: "IANA timezone observed for the requester on this Request." },
+    device_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source, description: "Device that submitted this Request through its client session; absent for Host turns and older records." }
   },
   required: CEAL_REQUEST_KEYS
 };
@@ -1222,6 +1270,7 @@ var REQUEST_EXECUTION_PREPARE_REFUSAL_PROPERTIES = {
   retryable: { type: "boolean" },
   source: { type: "string", enum: ["provider", "gateway"] },
   retry_after_ms: { type: "integer", minimum: 0, maximum: CEAL_RETRY_AFTER_MAX_MS },
+  write_request_ref: { type: "string", pattern: CEAL_GATEWAY_WRITE_REQUEST_REF_PATTERN.source, maxLength: 128 },
   excluded_targets: cealExcludedTargetCoverageJsonSchema(),
   repaired_input: {},
   unrepaired_pointers: { type: "array", maxItems: 128, items: { type: "string", minLength: 1, maxLength: 256 } },
@@ -1280,6 +1329,7 @@ function isCealHostInputKind(value) {
   return typeof value === "string" && CEAL_HOST_INPUT_KINDS.some((kind) => kind === value);
 }
 var CEAL_HOST_OBSERVATION_REF_PREFIX = "host-observation:";
+var HOST_TOKEN_OBSERVATION_BREAKDOWN_KEYS = vocabulary(["cached_input", "cache_write_input", "reasoning_output"]);
 function validateCealHostObservationDraft(value) {
   const record6 = operationRecord(value, "Ceal Host observation draft is invalid.");
   requirePrefixedRef(record6.observation_ref, CEAL_HOST_OBSERVATION_REF_PREFIX, "Ceal Host observation reference is invalid.");
@@ -1433,6 +1483,94 @@ var CEAL_HOST_MINT_REQUEST_CONTEXT_REFUSAL_REASONS = vocabulary([
   "host_input_mismatch",
   "host_prompt_mismatch"
 ]);
+var CEAL_HOST_AUTHENTICATION_CAUSES = vocabulary([
+  "invalid_arguments",
+  "options_invalid",
+  "session_unavailable",
+  "context_unavailable",
+  "context_replaced",
+  "no_binding",
+  "context_stale",
+  "context_expired",
+  "host_source_refused",
+  "host_credential_refused",
+  "gateway_unavailable",
+  "gateway_rate_limited",
+  "gateway_refused",
+  "gateway_response_invalid",
+  "producer_frame_invalid",
+  "relay_permission_denied",
+  "relay_unavailable",
+  "transient_retryable",
+  "mint_failed",
+  "relay_failed",
+  "host_refusal_invalid"
+]);
+var CEAL_HOST_AUTHENTICATION_POLICY = Object.freeze({
+  invalid_arguments: Object.freeze({ classification: "host_arguments_invalid", next_action: "answer_with_gap" }),
+  options_invalid: Object.freeze({ classification: "host_configuration_invalid", next_action: "answer_with_gap" }),
+  session_unavailable: Object.freeze({ classification: "host_session_unavailable", next_action: "answer_with_gap" }),
+  context_unavailable: Object.freeze({ classification: "host_context_unavailable", next_action: "refresh_host_invocation_context", remedy: "the Host has no invocation context from the current transcript turn; send a new message to start a fresh Host turn, then retry this command on that turn (run `ceal-host install` only if the Host hook registration is missing or drifted)" }),
+  context_replaced: Object.freeze({ classification: "host_invocation_context_stale", next_action: "refresh_host_invocation_context" }),
+  no_binding: Object.freeze({ classification: "host_binding_unavailable", next_action: "refresh_host_invocation_context" }),
+  context_stale: Object.freeze({ classification: "host_invocation_context_stale", next_action: "refresh_host_invocation_context" }),
+  context_expired: Object.freeze({ classification: "host_invocation_context_expired", next_action: "refresh_host_invocation_context" }),
+  host_source_refused: Object.freeze({ classification: "host_source_refused", next_action: "answer_with_gap" }),
+  host_credential_refused: Object.freeze({ classification: "host_registration_credential_refused", next_action: "ask_admin" }),
+  gateway_unavailable: Object.freeze({ classification: "host_mint_gateway_unavailable", next_action: "ask_admin" }),
+  gateway_rate_limited: Object.freeze({ classification: "host_mint_gateway_rate_limited", next_action: "answer_with_gap" }),
+  gateway_refused: Object.freeze({ classification: "host_mint_gateway_refused", next_action: "answer_with_gap" }),
+  gateway_response_invalid: Object.freeze({ classification: "host_mint_gateway_response_invalid", next_action: "answer_with_gap" }),
+  producer_frame_invalid: Object.freeze({ classification: "host_producer_frame_invalid", next_action: "ask_admin", remedy: "ask an administrator to inspect and repair the producer frame, then start a fresh Host turn" }),
+  relay_permission_denied: Object.freeze({ classification: "host_relay_permission_denied", next_action: "rerun_outside_agent_sandbox", remedy: "an agent sandbox denied the Host Relay socket; run `ceal` as the only command, with no pipe, redirect, or `&&`, so the Host allow rule runs it outside the sandbox" }),
+  relay_unavailable: Object.freeze({ classification: "host_relay_unavailable", next_action: "answer_with_gap" }),
+  transient_retryable: Object.freeze({ classification: "host_mint_transient_retryable", next_action: "retry" }),
+  mint_failed: Object.freeze({ classification: "host_mint_failed", next_action: "answer_with_gap" }),
+  relay_failed: Object.freeze({ classification: "host_relay_failed", next_action: "answer_with_gap" }),
+  host_refusal_invalid: Object.freeze({ classification: "host_refusal_invalid", next_action: "answer_with_gap" })
+});
+function projectCealHostAuthenticationCause(diagnostic) {
+  return projectRelayCodeCause(diagnostic) ?? projectGatewayCodeCause(diagnostic) ?? projectGatewayStatusCause(diagnostic) ?? "mint_failed";
+}
+function projectRelayCodeCause(diagnostic) {
+  switch (diagnostic.relayCode) {
+    case "credential":
+      return "host_credential_refused";
+    case "configuration":
+      return "options_invalid";
+    case "payload_rejected":
+      return "producer_frame_invalid";
+    case "invalid_response":
+      return "gateway_response_invalid";
+    case "gateway_refused":
+      return projectGatewayRefusedCause(diagnostic);
+    case "gateway_unavailable":
+      return diagnostic.exhausted === true ? void 0 : "gateway_unavailable";
+    case void 0:
+    case "":
+      return void 0;
+    default:
+      return "mint_failed";
+  }
+}
+function projectGatewayRefusedCause(diagnostic) {
+  if (diagnostic.gatewayStatus === 401 || diagnostic.gatewayStatus === 403) return "host_credential_refused";
+  const stale = projectGatewayCodeCause(diagnostic);
+  if (stale !== void 0) return stale;
+  if (diagnostic.exhausted === true && (diagnostic.gatewayStatus === 408 || diagnostic.gatewayStatus === 429)) return "gateway_rate_limited";
+  return "gateway_refused";
+}
+function projectGatewayCodeCause(diagnostic) {
+  if (diagnostic.gatewayCode === "request_context_refused" && diagnostic.gatewayReason !== void 0 && isVocabularyWord(CEAL_HOST_MINT_REQUEST_CONTEXT_REFUSAL_REASONS, diagnostic.gatewayReason)) return "context_stale";
+  if (diagnostic.gatewayCode === "context_expired") return "context_expired";
+  if (diagnostic.gatewayCode === "host_source_refused") return "host_source_refused";
+  return void 0;
+}
+function projectGatewayStatusCause(diagnostic) {
+  if (diagnostic.gatewayStatus === 401 || diagnostic.gatewayStatus === 403) return "host_credential_refused";
+  if (diagnostic.exhausted === true && (diagnostic.gatewayStatus === 408 || diagnostic.gatewayStatus === 429)) return "gateway_rate_limited";
+  return void 0;
+}
 function decodeCealHostInvocationAuthenticationResult(value, now = /* @__PURE__ */ new Date()) {
   if (!isCealJsonRecord(value) || !exactKeys(value, ["schema_version", "context_token", "expires_at"]) || value.schema_version !== CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA || typeof value.context_token !== "string" || !CEAL_HOST_CONTEXT_TOKEN_PATTERN.test(value.context_token) || typeof value.expires_at !== "string" || !validFutureTimestamp(value.expires_at, now)) {
     throw new TypeError("The Host invocation authentication result is invalid.");
@@ -1448,11 +1586,38 @@ function exactKeys(value, expected) {
   return keys.length === expected.length && expected.every((key) => Object.hasOwn(value, key));
 }
 
+// packages/ceal-client-protocol/src/host-service-diagnostic.ts
+var CEAL_HOST_SERVICE_DIAGNOSTIC_SCHEMA = "ceal.host_service_diagnostic.v1";
+var CEAL_HOST_SERVICE_DIAGNOSTIC_PRODUCERS = vocabulary(["claude", "codex"]);
+var CEAL_HOST_SERVICE_DIAGNOSTIC_EVENTS = vocabulary([
+  "hook_invoked",
+  "registration_written",
+  "hook_failed",
+  "watcher_turn_observed",
+  "current_prompt_registered",
+  "current_prompt_registration_failed",
+  "current_prompt_capacity_exhausted",
+  "activation_recorded",
+  "activation_failed",
+  "watcher_scan_failed",
+  "activation_wait_skipped",
+  "activation_wait_engaged",
+  "activation_wait_completed",
+  "activation_wait_exhausted"
+]);
+var CEAL_HOST_SERVICE_DIAGNOSTIC_FAILURE_KINDS = vocabulary([
+  "malformed_line",
+  "other",
+  "payload_rejected",
+  "read_error",
+  "size_budget",
+  "symlink"
+]);
+
 // packages/ceal-client-protocol/src/client-result-materialization.ts
 var CEAL_UNREAD_REASONS = vocabulary(["blocked", "unavailable", "too_large", "unsupported", "download_failed", "permission_denied"]);
-var CEAL_MODEL_VISIBLE_COMMAND_OUTPUT_MAX_BYTES = 32 * 1024;
-var REQUIRED_FIELDS2 = Object.freeze(["schema_version", "operation_id", "read_argv"]);
-var FIELDS = /* @__PURE__ */ new Set([...REQUIRED_FIELDS2, "local_result_root", "continue_argv", "model_disclosure"]);
+var REQUIRED_FIELDS2 = Object.freeze(["schema_version", "operation_id", "path", "sha256"]);
+var FIELDS = /* @__PURE__ */ new Set([...REQUIRED_FIELDS2, "items_path", "row_count", "result_complete", "coverage", "local_result_root", "model_disclosure", "continue_argv", "how_to_read"]);
 
 // packages/ceal-client-protocol/src/gateway-cache-origin-validation.ts
 var CEAL_MAX_CACHE_ORIGIN_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -1482,14 +1647,6 @@ var CEAL_GATEWAY_ANNOUNCEMENT_POLICY_NON_CLAIMS = vocabulary([
   "target_specific_scope_not_declared"
 ]);
 
-// packages/ceal-client-protocol/src/gateway-write-identity.ts
-var CEAL_GATEWAY_WRITE_IDENTITY_ROLES = Object.freeze(["replay_identity", "lookup_handle", "collision_evidence"]);
-var CEAL_GATEWAY_WRITE_IDENTITY_FIELDS = Object.freeze({
-  replay_identity: "idempotency_claim_sha256",
-  lookup_handle: "write_request_sha256",
-  collision_evidence: "normalized_mutation_sha256"
-});
-
 // packages/ceal-client-protocol/src/gateway-scoped-identity-projection-validation.ts
 var PROJECTION_REVISION_KEYS = Object.freeze(["graph_revision", "subject_key_revision", "projection_revision"]);
 
@@ -1502,6 +1659,18 @@ var CEAL_SUPPORTED_GATEWAY_PROTOCOL_RANGE = Object.freeze({
 // packages/ceal-client-protocol/src/admin-projection-vocabulary.ts
 var ADMIN_PROJECTION_STATES = vocabulary(["ready", "empty", "partial", "unknown"]);
 var ADMIN_VIEW_KINDS = vocabulary(["request_detail", "resource_access_timeline", "weekly_usage"]);
+var ADMIN_RECORD_PROJECTION_KINDS = vocabulary([
+  "request_list",
+  "usage_series",
+  "connector_health",
+  "person_connections",
+  "client_sessions",
+  "knowledge_base",
+  "change_history",
+  "approval_queue",
+  "access_group_list",
+  "capability_catalogue"
+]);
 var ADMIN_GAP_KINDS = vocabulary(["unknown", "unavailable", "partial"]);
 var ADMIN_UNAVAILABLE_REASONS = vocabulary([
   "not_recorded",
@@ -1525,7 +1694,11 @@ var ADMIN_SOURCE_OWNERS = vocabulary([
   "person",
   "resource",
   "prompt",
-  "usage"
+  "usage",
+  "connector",
+  "session",
+  "knowledge",
+  "policy"
 ]);
 var ADMIN_COMPLETENESS_STATES = vocabulary(["complete", "partial", "unknown"]);
 var ADMIN_OPERATION_OUTCOMES = vocabulary(["completed", "failed", "denied", "cancelled", "unknown"]);
@@ -1580,6 +1753,17 @@ function errorCode(error) {
 import { copyFile, open, stat, truncate } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 var HOST_SERVICE_LOG_ENVIRONMENT = "CEAL_HOST_SERVICE_LOG";
+function writeHostServiceDiagnostic(producer_id, event, failure_kind, cause, sink) {
+  const line = `${JSON.stringify({ schema_version: CEAL_HOST_SERVICE_DIAGNOSTIC_SCHEMA, producer_id, event, ...event === "watcher_scan_failed" && failure_kind !== void 0 ? { failure_kind } : {}, ...event === "watcher_scan_failed" && cause !== void 0 ? { cause } : {} })}
+`;
+  try {
+    (sink ?? defaultHostServiceDiagnosticSink)(line);
+  } catch {
+  }
+}
+function defaultHostServiceDiagnosticSink(line) {
+  process.stderr.write(line);
+}
 var HOST_SERVICE_LOG_MAX_BYTES = 1024 * 1024;
 var HOST_SERVICE_LOG_CHECK_INTERVAL_MS = 6e4;
 function hostServiceLogPreviousPath(path) {
@@ -1760,6 +1944,15 @@ var FRAME_KINDS = new Set(HOST_PRODUCER_FRAME_KINDS);
 function isHostProducerFrameKind(value) {
   return typeof value === "string" && FRAME_KINDS.has(value);
 }
+var HOST_PRODUCER_FRAME_ERROR_CODES = [
+  "invalid_frame_encoding",
+  "invalid_frame_length",
+  "frame_truncated",
+  "unsupported_frame_schema",
+  "invalid_frame_shape",
+  "invalid_producer_identity",
+  "frame_too_large"
+];
 var HostProducerFrameError = class extends Error {
   code;
   constructor(code, message = code) {
@@ -1800,6 +1993,30 @@ function decodeHostProducerFrame(input) {
 function hostProducerFrameHash(frame) {
   return createHash3("sha256").update(JSON.stringify(frame), "utf8").digest("hex");
 }
+function extractHostBindingSelector(frame) {
+  if (frame.frame_kind !== "user_input") return null;
+  if (!PRODUCERS.has(frame.producer_id) || !safeRef(frame.producer_installation_ref)) return null;
+  const payload = frame.payload;
+  if (!safeRef(payload.local_session_ref) || !safeRef(payload.local_turn_ref)) return null;
+  const aliases = payload.local_turn_aliases;
+  if (aliases === void 0) {
+    return Object.freeze({
+      producer_id: frame.producer_id,
+      producer_installation_ref: frame.producer_installation_ref,
+      local_session_ref: payload.local_session_ref,
+      local_turn_ref: payload.local_turn_ref,
+      local_turn_aliases: Object.freeze([])
+    });
+  }
+  if (!Array.isArray(aliases) || aliases.length > 16 || !aliases.every(safeRef) || new Set(aliases).size !== aliases.length) return null;
+  return Object.freeze({
+    producer_id: frame.producer_id,
+    producer_installation_ref: frame.producer_installation_ref,
+    local_session_ref: payload.local_session_ref,
+    local_turn_ref: payload.local_turn_ref,
+    local_turn_aliases: Object.freeze([...aliases])
+  });
+}
 function hostProducerIdentityRefs(hostSourceRef, frame, localSessionRef, localTurnRef, localInputRef) {
   if (!opaqueHostSourceRef(hostSourceRef)) throw new TypeError("Gateway host source reference is invalid.");
   const host_session_ref = localSessionRef === void 0 ? void 0 : `ceal-host-session:${cealRequestSha256({ host_source_ref: hostSourceRef, producer_id: frame.producer_id, producer_installation_ref: frame.producer_installation_ref, local_session_ref: localSessionRef })}`;
@@ -1823,6 +2040,31 @@ function hostProducerSubmissionRef(hostSourceRef, frame) {
 function opaqueHostSourceRef(value) {
   return typeof value === "string" && SAFE_REF2.test(value) && !value.startsWith("ceal-host-source:");
 }
+function isHostSafeRef(value) {
+  return safeRef(value);
+}
+var BOUNDED_REFUSAL_WORD = /^[a-z][a-z0-9_]{0,63}$/u;
+function isBoundedRefusalWord(value) {
+  return typeof value === "string" && BOUNDED_REFUSAL_WORD.test(value);
+}
+function hasExactKeys2(value, required, optional = []) {
+  return required.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+}
+function isUndefinedOr(value, guard) {
+  return value === void 0 || guard(value);
+}
+var HOST_RELAY_GATEWAY_ERROR_CODES = [
+  "configuration",
+  "credential",
+  "gateway_unavailable",
+  "gateway_refused",
+  "invalid_response",
+  "payload_rejected"
+];
+function isRelayGatewayErrorCode(value) {
+  return isVocabularyWord(HOST_RELAY_GATEWAY_ERROR_CODES, value);
+}
+var RELAY_DELIVERY_DIAGNOSTIC_KEYS = ["relayCode", "gatewayStatus", "gatewayCode", "gatewayReason", "exhausted"];
 function requiredIdentity(value) {
   if (value === void 0) throw new TypeError("Canonical Host identity is incomplete.");
   return value;
@@ -2251,6 +2493,8 @@ var RELAY_QUARANTINE_MAX_RECORDS = 512;
 var RELAY_QUARANTINE_MAX_BYTES = 16 * 1024 * 1024;
 var MAX_CAPTURE_BYTES = 262148;
 var PRODUCERS2 = ["codex", "claude", "unknown"];
+var RELAY_QUARANTINE_FRAME_REASONS = ["frame_identity_conflict", "sequence_gap", "gateway_refused"];
+var RELAY_QUARANTINE_REASONS = [...RELAY_QUARANTINE_FRAME_REASONS, ...HOST_PRODUCER_FRAME_ERROR_CODES];
 var RelayQuarantineStore = class {
   root;
   maxRecords;
@@ -2263,8 +2507,8 @@ var RelayQuarantineStore = class {
     if (!Number.isSafeInteger(this.maxRecords) || this.maxRecords < 1 || this.maxRecords > RELAY_QUARANTINE_MAX_RECORDS) throw new TypeError(`Relay quarantine record cap is invalid: ${refusalFact("max_records", this.maxRecords, `between 1 and ${RELAY_QUARANTINE_MAX_RECORDS}`)}.`);
     if (!Number.isSafeInteger(this.maxBytes) || this.maxBytes < 1 || this.maxBytes > RELAY_QUARANTINE_MAX_BYTES) throw new TypeError(`Relay quarantine byte cap is invalid: ${refusalFact("max_bytes", this.maxBytes, `between 1 and ${RELAY_QUARANTINE_MAX_BYTES}`)}.`);
   }
-  async retainFrame(frame, reason, capturedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-    await this.retain(encodeHostProducerFrame(frame), frame.producer_id, reason, capturedAt);
+  async retainFrame(frame, reason, attribution, capturedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+    await this.retain(encodeHostProducerFrame(frame), frame.producer_id, reason, capturedAt, attribution);
   }
   async retainMalformed(rawFrame, reason, capturedAt = (/* @__PURE__ */ new Date()).toISOString()) {
     await this.retain(rawFrame, inferProducer(rawFrame), reason, capturedAt);
@@ -2276,11 +2520,26 @@ var RelayQuarantineStore = class {
     const records = state.producers[producerId].slice(-Math.min(limit, this.maxRecords)).map((record6) => structuredClone(record6));
     return { producer_id: producerId, records, total_bytes: records.reduce((total, record6) => total + record6.charged_bytes, 0) };
   }
+  /**
+   * The newest quarantined record whose exact-turn attribution matches the
+   * query, or null when evicted, unattributed, or for another turn. The
+   * file-backed state survives drain, restart, and overwrite.
+   */
+  async findNewestAttributedMatch(query) {
+    await this.tail;
+    const state = await this.readState();
+    const bucket = query.producer_id === "codex" || query.producer_id === "claude" ? state.producers[query.producer_id] : [];
+    for (let index = bucket.length - 1; index >= 0; index -= 1) {
+      const record6 = bucket[index];
+      if (record6 !== void 0 && attributedRecordMatchesQuery(record6, query)) return structuredClone(record6);
+    }
+    return null;
+  }
   async snapshot() {
     await this.tail;
     return this.readState();
   }
-  async retain(rawFrame, producerId, reason, capturedAt) {
+  async retain(rawFrame, producerId, reason, capturedAt, attribution) {
     const run = this.tail.then(async () => {
       if (!PRODUCERS2.includes(producerId) || !Number.isFinite(Date.parse(capturedAt))) throw new TypeError("Relay quarantine record identity is invalid.");
       const raw = Buffer.from(rawFrame).subarray(0, MAX_CAPTURE_BYTES);
@@ -2292,7 +2551,8 @@ var RelayQuarantineStore = class {
         captured_at: capturedAt,
         frame_sha256: createHash4("sha256").update(raw).digest("hex"),
         charged_bytes: raw.byteLength,
-        raw_frame_base64: raw.toString("base64")
+        raw_frame_base64: raw.toString("base64"),
+        ...attribution === void 0 ? {} : { attribution: structuredClone(attribution) }
       };
       const records = state.producers[producerId];
       records.push(record6);
@@ -2329,8 +2589,47 @@ function decodeState2(value) {
   return state;
 }
 function validRecord(value) {
-  if (!record3(value) || typeof value.quarantine_ref !== "string" || !quarantineProducer(value.producer_id) || typeof value.reason !== "string" || !Number.isFinite(Date.parse(String(value.captured_at))) || typeof value.frame_sha256 !== "string" || typeof value.charged_bytes !== "number" || !Number.isSafeInteger(value.charged_bytes) || value.charged_bytes < 0 || typeof value.raw_frame_base64 !== "string") return false;
-  return true;
+  if (!record3(value) || !validRecordIdentity(value)) return false;
+  return value.attribution === void 0 || validAttribution(value.attribution);
+}
+function validRecordIdentity(value) {
+  return typeof value.quarantine_ref === "string" && quarantineProducer(value.producer_id) && validReason(value.reason) && Number.isFinite(Date.parse(String(value.captured_at))) && typeof value.frame_sha256 === "string" && typeof value.raw_frame_base64 === "string" && validChargedBytes(value.charged_bytes);
+}
+function validReason(value) {
+  return typeof value === "string" && RELAY_QUARANTINE_REASONS.includes(value);
+}
+function validChargedBytes(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+var ATTRIBUTION_REQUIRED_KEYS = ["producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref", "local_turn_aliases", "sequence", "frame_sha256"];
+var ATTRIBUTION_OPTIONAL_KEYS = ["diagnostic"];
+function validAttribution(value) {
+  if (!record3(value) || !hasExactKeys2(value, ATTRIBUTION_REQUIRED_KEYS, ATTRIBUTION_OPTIONAL_KEYS)) return false;
+  return validAttributionIdentity(value) && validAttributionAliases(value.local_turn_aliases) && validAttributionEnvelope(value) && (value.diagnostic === void 0 || validAttributionDiagnostic(value.diagnostic));
+}
+function validAttributionIdentity(value) {
+  return (value.producer_id === "codex" || value.producer_id === "claude") && isHostSafeRef(value.producer_installation_ref) && isHostSafeRef(value.local_session_ref) && isHostSafeRef(value.local_turn_ref);
+}
+function validAttributionAliases(value) {
+  return Array.isArray(value) && value.length <= 16 && value.every(isHostSafeRef);
+}
+function validAttributionEnvelope(value) {
+  return typeof value.sequence === "number" && Number.isSafeInteger(value.sequence) && value.sequence > 0 && typeof value.frame_sha256 === "string";
+}
+function validAttributionDiagnostic(value) {
+  if (!record3(value) || !hasExactKeys2(value, [], RELAY_DELIVERY_DIAGNOSTIC_KEYS)) return false;
+  return isUndefinedOr(value.relayCode, isRelayGatewayErrorCode) && isUndefinedOr(value.gatewayStatus, isSafeInteger) && isUndefinedOr(value.gatewayCode, isBoundedRefusalWord) && isUndefinedOr(value.gatewayReason, isBoundedRefusalWord) && isUndefinedOr(value.exhausted, isBoolean);
+}
+function isSafeInteger(value) {
+  return Number.isSafeInteger(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function attributedRecordMatchesQuery(recordValue, query) {
+  const attribution = recordValue.attribution;
+  if (attribution === void 0) return false;
+  return attribution.producer_id === query.producer_id && attribution.producer_installation_ref === query.producer_installation_ref && attribution.local_session_ref === query.local_session_ref && (attribution.local_turn_ref === query.local_turn_ref || attribution.local_turn_aliases.includes(query.local_turn_ref));
 }
 function quarantineProducer(value) {
   return value === "codex" || value === "claude" || value === "unknown";
@@ -2418,11 +2717,11 @@ var RelayAdmissionStore = class {
     const hash = hostProducerFrameHash(frame);
     const replay = replayCode(existing, hash, frame.sequence, installation2);
     if (replay !== null) {
-      if (replay === "frame_identity_conflict") await this.quarantine.retainFrame(frame, replay);
+      if (replay === "frame_identity_conflict") await this.quarantine.retainFrame(frame, replay, attributionForFrame(frame, hash, frame.sequence));
       return result(replay, installation2);
     }
     if (frame.sequence !== installation2.admitted_through_sequence + 1) {
-      await this.quarantine.retainFrame(frame, "sequence_gap");
+      await this.quarantine.retainFrame(frame, "sequence_gap", attributionForFrame(frame, hash, frame.sequence));
       return result("sequence_gap", installation2);
     }
     const chargedBytes = 4 + Buffer.byteLength(JSON.stringify(frame), "utf8");
@@ -2468,8 +2767,9 @@ var RelayAdmissionStore = class {
     const installation2 = state.installations[installationKey(head.frame)];
     if (!installation2) throw new TypeError("Host Relay delivery installation is unavailable.");
     if (outcome.status === "refused" || exhausted) {
-      await this.quarantine.retainFrame(head.frame, "gateway_refused");
-      installation2.last_refusal = { sequence: head.sequence, submission_ref: input.submission_ref, ...refusalCause(outcome, head), refused_at_ms: options.now_ms };
+      const diagnostic = exhaustedDiagnostic(outcome, exhausted);
+      await this.quarantine.retainFrame(head.frame, "gateway_refused", attributionForFrame(head.frame, head.hash, head.sequence, diagnostic));
+      installation2.last_refusal = { sequence: head.sequence, submission_ref: input.submission_ref, ...refusalCause(outcome, head), ...diagnostic === void 0 ? {} : { diagnostic }, refused_at_ms: options.now_ms };
       refused.push(input.submission_ref);
     } else {
       await options.after_gateway_accept_before_delivery_fsync?.({ fault_point: "after_gateway_accept_before_delivery_fsync", delivery: structuredClone(input) });
@@ -2513,17 +2813,22 @@ function installationKey(frame) {
   return `${frame.producer_id}\0${frame.producer_installation_ref}`;
 }
 function pendingFrameMatchesBindingQuery(entry2, query) {
-  if (entry2.frame.frame_kind !== "user_input") return false;
-  const payload = entry2.frame.payload;
-  if (typeof payload.local_session_ref !== "string" || typeof payload.local_turn_ref !== "string") return false;
-  const aliases = Array.isArray(payload.local_turn_aliases) ? payload.local_turn_aliases.filter((value) => typeof value === "string") : [];
-  return relayRequestBindingMatchesQuery(query, {
-    producer_id: entry2.frame.producer_id,
-    producer_installation_ref: entry2.frame.producer_installation_ref,
-    local_session_ref: payload.local_session_ref,
-    local_turn_ref: payload.local_turn_ref,
-    local_turn_aliases: aliases
-  });
+  const selector = extractHostBindingSelector(entry2.frame);
+  if (selector === null) return false;
+  return relayRequestBindingMatchesQuery(query, selector);
+}
+function attributionForFrame(frame, hash, sequence, diagnostic) {
+  const selector = extractHostBindingSelector(frame);
+  if (selector === null) return void 0;
+  if (frame.producer_id !== selector.producer_id || frame.producer_installation_ref !== selector.producer_installation_ref || frame.sequence !== sequence) return void 0;
+  if (hostProducerFrameHash(frame) !== hash) return void 0;
+  return { ...selector, sequence, frame_sha256: hash, ...diagnostic === void 0 ? {} : { diagnostic } };
+}
+function exhaustedDiagnostic(outcome, exhausted) {
+  if (outcome.status !== "retryable" && outcome.status !== "refused") return void 0;
+  if (outcome.diagnostic !== void 0) return exhausted ? { ...outcome.diagnostic, exhausted: true } : outcome.diagnostic;
+  if (exhausted) return { exhausted: true };
+  return void 0;
 }
 function replayCode(existing, hash, sequence, installation2) {
   if (existing !== void 0) return existing.hash === hash ? "already_admitted" : "frame_identity_conflict";
@@ -2575,7 +2880,17 @@ function installation(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && "epoch" in value && "admitted_through_sequence" in value && "delivered_through_sequence" in value && [value.epoch, value.admitted_through_sequence, value.delivered_through_sequence].every(Number.isSafeInteger) && (!("last_refusal" in value) || refusalRecord(value.last_refusal));
 }
 function refusalRecord(value) {
-  return object(value) && Number.isSafeInteger(value.sequence) && typeof value.submission_ref === "string" && typeof value.code === "string" && typeof value.message === "string" && Number.isSafeInteger(value.refused_at_ms);
+  return object(value) && Number.isSafeInteger(value.sequence) && typeof value.submission_ref === "string" && typeof value.code === "string" && typeof value.message === "string" && Number.isSafeInteger(value.refused_at_ms) && (value.diagnostic === void 0 || validDiagnostic(value.diagnostic));
+}
+function validDiagnostic(value) {
+  if (!object(value) || !hasExactKeys2(value, [], RELAY_DELIVERY_DIAGNOSTIC_KEYS)) return false;
+  return isUndefinedOr(value.relayCode, isRelayGatewayErrorCode) && isUndefinedOr(value.gatewayStatus, isSafeInteger2) && isUndefinedOr(value.gatewayCode, isBoundedRefusalWord) && isUndefinedOr(value.gatewayReason, isBoundedRefusalWord) && isUndefinedOr(value.exhausted, isBoolean2);
+}
+function isSafeInteger2(value) {
+  return Number.isSafeInteger(value);
+}
+function isBoolean2(value) {
+  return typeof value === "boolean";
 }
 function entry(value) {
   return object(value) && producer2(value.producer_id) && typeof value.producer_installation_ref === "string" && Number.isSafeInteger(value.sequence) && typeof value.hash === "string" && Number.isSafeInteger(value.charged_bytes) && object(value.frame) && Number.isSafeInteger(value.retry_attempts) && Number.isSafeInteger(value.retry_at_ms);
@@ -2783,10 +3098,22 @@ function submissionRefusal(error) {
   const status = isRecord(error) && typeof error.status === "number" ? error.status : void 0;
   const code = errorCode7(error) ?? "gateway_unavailable";
   const definitive = code === "payload_rejected" || status !== void 0 && status >= 400 && status < 500 && !RETRYABLE_HTTP_STATUSES.has(status);
-  return { code, message: errorMessage(error), definitive };
+  return { code, message: errorMessage(error), definitive, diagnostic: typedDiagnostic(error, status) };
+}
+function typedDiagnostic(error, status) {
+  if (!isRecord(error)) return status === void 0 ? {} : { gatewayStatus: status };
+  const gatewayCode = isBoundedRefusalWord(error.error_code) ? error.error_code : void 0;
+  const gatewayReason = isBoundedRefusalWord(error.refusal_reason) ? error.refusal_reason : void 0;
+  return {
+    ...typeof error.code === "string" ? { relayCode: error.code } : {},
+    ...status === void 0 ? {} : { gatewayStatus: status },
+    ...gatewayCode === void 0 ? {} : { gatewayCode },
+    ...gatewayReason === void 0 ? {} : { gatewayReason }
+  };
 }
 function deliveryRefusal(refusal) {
-  return refusal.definitive ? { status: "refused", code: refusal.code, message: refusal.message } : { status: "retryable", reason: `${refusal.code}: ${refusal.message}` };
+  const diagnostic = refusal.diagnostic === void 0 ? {} : { diagnostic: refusal.diagnostic };
+  return refusal.definitive ? { status: "refused", code: refusal.code, message: refusal.message, ...diagnostic } : { status: "retryable", reason: `${refusal.code}: ${refusal.message}`, ...diagnostic };
 }
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -3009,6 +3336,10 @@ async function gatewayRefusal(response2) {
     return {};
   }
 }
+function submitRefusalCode(body) {
+  if (!isCealJsonRecord(body) || typeof body.error_code !== "string" || !GATEWAY_REFUSAL_CODE_PATTERN.test(body.error_code)) return void 0;
+  return body.error_code;
+}
 function refusalMessage(status, body) {
   const record6 = isCealJsonRecord(body) ? body : {};
   const code = typeof record6.error_code === "string" ? record6.error_code : "unknown";
@@ -3036,7 +3367,7 @@ function createHostRelayGatewayHttpPort(options) {
         invalidEventTime: () => new HostRelayGatewayError("payload_rejected", "Host Relay submission has no event time."),
         unavailable: () => new HostRelayGatewayError("gateway_unavailable", "Gateway Host ingress is unavailable."),
         invalidResponse: () => new HostRelayGatewayError("invalid_response", "Gateway Host ingress response is not JSON."),
-        refused: (status, body) => new HostRelayGatewayError("gateway_refused", refusalMessage(status, body), status),
+        refused: (status, body) => new HostRelayGatewayError("gateway_refused", refusalMessage(status, body), status, submitRefusalCode(body)),
         acknowledgement
       });
     },
@@ -3186,10 +3517,20 @@ import { dirname as dirname3, join as join6 } from "node:path";
 import { createHash as createHash5 } from "node:crypto";
 var HOST_CURRENT_PROMPT_MAX_BYTES = 256 * 1024;
 var MAX_CURRENT_PROMPTS = 1024;
+var MAX_CONSUMED_PROMPTS = 1024;
+var HostCurrentPromptCapacityError = class extends Error {
+  report_diagnostic;
+  constructor(reportDiagnostic) {
+    super("current_prompt_unavailable");
+    this.name = "HostCurrentPromptCapacityError";
+    this.report_diagnostic = reportDiagnostic;
+  }
+};
 var HostCurrentPromptCustody = class {
   #records = /* @__PURE__ */ new Map();
   #consumed = /* @__PURE__ */ new Map();
   #now;
+  #capacityDiagnosticReported = false;
   constructor(now = Date.now) {
     this.#now = now;
   }
@@ -3201,10 +3542,14 @@ var HostCurrentPromptCustody = class {
     this.#purge();
     const key = promptKey(identity);
     if (this.#consumed.has(key)) return;
-    if (!this.#records.has(key) && this.#records.size + this.#consumed.size >= MAX_CURRENT_PROMPTS) throw new TypeError("current_prompt_unavailable");
+    if (!this.#records.has(key) && this.#records.size >= MAX_CURRENT_PROMPTS) {
+      const reportDiagnostic = !this.#capacityDiagnosticReported;
+      this.#capacityDiagnosticReported = true;
+      throw new HostCurrentPromptCapacityError(reportDiagnostic);
+    }
     this.#records.set(key, { prompt, expires_at_ms: expiry });
   }
-  /** Transfer this turn's prompt into at most one authenticated invocation. */
+  /** Transfer this turn's prompt once while its bounded recent replay guard retains the identity. */
   take(identity) {
     this.#purge();
     const key = promptKey(identity);
@@ -3212,14 +3557,38 @@ var HostCurrentPromptCustody = class {
     if (prompt !== void 0) {
       const expiresAt = this.#records.get(key)?.expires_at_ms;
       this.#records.delete(key);
-      if (expiresAt !== void 0) this.#consumed.set(key, expiresAt);
+      if (expiresAt !== void 0) this.#rememberConsumed(key, expiresAt);
+      this.#resetCapacityDiagnosticIfAvailable();
     }
     return prompt;
   }
+  /** Release a prompt after its turn ends while retaining the same bounded replay guard. */
+  release(identity) {
+    this.#purge();
+    const key = promptKey(identity);
+    const record6 = this.#records.get(key);
+    if (record6 === void 0) return false;
+    this.#records.delete(key);
+    this.#rememberConsumed(key, record6.expires_at_ms);
+    this.#resetCapacityDiagnosticIfAvailable();
+    return true;
+  }
+  #rememberConsumed(key, expiresAt) {
+    this.#consumed.set(key, expiresAt);
+    while (this.#consumed.size > MAX_CONSUMED_PROMPTS) {
+      const oldest = this.#consumed.keys().next().value;
+      if (oldest === void 0) return;
+      this.#consumed.delete(oldest);
+    }
+  }
   #purge() {
     const now = this.#now();
     for (const [key, value] of this.#records) if (value.expires_at_ms <= now) this.#records.delete(key);
     for (const [key, expiresAt] of this.#consumed) if (expiresAt <= now) this.#consumed.delete(key);
+    this.#resetCapacityDiagnosticIfAvailable();
+  }
+  #resetCapacityDiagnosticIfAvailable() {
+    if (this.#records.size < MAX_CURRENT_PROMPTS) this.#capacityDiagnosticReported = false;
   }
 };
 function promptKey(value) {
@@ -3248,6 +3617,7 @@ var HOST_RELAY_BINDING_RESULT_SCHEMA = "ceal.host_relay_binding_result.v1";
 var HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA = "ceal.host_relay_invocation_context_query.v1";
 var HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA = "ceal.host_relay_invocation_context_result.v1";
 var HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA = "ceal.host_relay_current_prompt_register.v1";
+var HOST_RELAY_CURRENT_PROMPT_RELEASE_SCHEMA = "ceal.host_relay_current_prompt_release.v1";
 var HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA = "ceal.host_relay_current_prompt_result.v1";
 var HOST_RELAY_IPC_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
 var HOST_RELAY_INVOCATION_MINT_REFUSAL_REASONS = vocabulary([
@@ -3258,6 +3628,8 @@ var HOST_RELAY_INVOCATION_MINT_REFUSAL_REASONS = vocabulary([
   "gateway_unavailable",
   "gateway_refused",
   "gateway_response_invalid",
+  "gateway_rate_limited",
+  "producer_frame_invalid",
   "deadline",
   "cancelled",
   "mint_failed",
@@ -3271,6 +3643,17 @@ var HOST_RELAY_INVOCATION_MINT_REFUSAL_REASONS = vocabulary([
   "host_input_mismatch",
   "host_prompt_mismatch"
 ]);
+var HOST_RELAY_DIRECT_WIRE_MINT_REASONS = vocabulary([
+  "context_stale",
+  "context_expired",
+  "host_source_refused",
+  "host_credential_refused",
+  "gateway_unavailable",
+  "gateway_rate_limited",
+  "gateway_refused",
+  "gateway_response_invalid",
+  "producer_frame_invalid"
+]);
 var HostRelayInvocationMintRefusal = class extends Error {
   reason;
   constructor(reason) {
@@ -3358,7 +3741,7 @@ function serveSocket(socket, options, currentPrompts, quarantine, active, socket
   socket.once("error", () => closeConnection(socket, state, active, sockets));
   socket.once("close", () => closeConnection(socket, state, active, sockets));
   socket.once("end", () => {
-    if (state.buffer.length > 0 && currentPromptWire(state.buffer)) {
+    if (state.buffer.length > 0 && isCurrentPromptWire(state.buffer)) {
       writeCurrentPromptResponse(socket, "current_prompt_unavailable");
       socket.end();
     } else if (state.buffer.length > 0) void quarantine.retainMalformed(state.buffer, "frame_truncated").finally(() => {
@@ -3374,7 +3757,7 @@ async function drainFrames(socket, state, options, currentPrompts, quarantine, a
 }
 async function processBufferedRequest(socket, state, options, currentPrompts, quarantine, active) {
   const length = state.buffer.readUInt32BE(0);
-  const promptWire = currentPromptWire(state.buffer);
+  const promptWire = isCurrentPromptWire(state.buffer);
   const maximum = promptWire ? HOST_CURRENT_PROMPT_MAX_BYTES + 4096 : HOST_PRODUCER_MAX_JSON_BYTES;
   if (length === 0 || length > maximum) {
     await refuseInvalidBufferedRequest(socket, state.buffer, length, promptWire, quarantine);
@@ -3392,13 +3775,8 @@ async function processBufferedRequest(socket, state, options, currentPrompts, qu
     await refuseMalformedRequest(socket, encoded, promptWire, error, quarantine);
     return true;
   }
-  if (request2.schema_version === HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA) {
-    try {
-      currentPrompts.register(request2, request2.current_prompt, request2.context_expires_at);
-      writeCurrentPromptResponse(socket, "registered");
-    } catch {
-      writeCurrentPromptResponse(socket, "current_prompt_unavailable");
-    }
+  if (request2.schema_version === HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA || request2.schema_version === HOST_RELAY_CURRENT_PROMPT_RELEASE_SCHEMA) {
+    answerCurrentPromptRequest(socket, request2, currentPrompts, options.diagnostic_sink);
     return true;
   }
   const answered = await processHostQuery(socket, request2, options, currentPrompts, state.abort.signal);
@@ -3410,6 +3788,22 @@ async function processBufferedRequest(socket, state, options, currentPrompts, qu
   await processProducerRequest(socket, state, request2, encoded, options.admission, quarantine, active);
   return true;
 }
+function answerCurrentPromptRequest(socket, request2, currentPrompts, sink) {
+  if (request2.schema_version === HOST_RELAY_CURRENT_PROMPT_RELEASE_SCHEMA) {
+    currentPrompts.release(request2);
+    writeCurrentPromptResponse(socket, "released");
+    return;
+  }
+  try {
+    currentPrompts.register(request2, request2.current_prompt, request2.context_expires_at);
+    writeCurrentPromptResponse(socket, "registered");
+  } catch (error) {
+    if (error instanceof HostCurrentPromptCapacityError) {
+      if (error.report_diagnostic) writeHostServiceDiagnostic(request2.producer_id, "current_prompt_capacity_exhausted", void 0, void 0, sink);
+      writeCurrentPromptResponse(socket, "capacity_exhausted");
+    } else writeCurrentPromptResponse(socket, "current_prompt_unavailable");
+  }
+}
 async function refuseInvalidBufferedRequest(socket, rawBuffer, length, promptWire, quarantine) {
   if (promptWire) {
     writeCurrentPromptResponse(socket, "current_prompt_unavailable");
@@ -3500,30 +3894,62 @@ async function resolveInvocationContext(request2, admission, bindings, currentPr
   const query = bindingQueryFromRequest(request2);
   const expectedSequences = pendingAdmissionSequences(await admission.snapshot(), query);
   const binding = await waitForRequestBinding(query, admission, bindings, signal);
-  if (binding.status !== "ready") return unboundInvocationContextRefusal(await admission.snapshot(), query, expectedSequences) ?? { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "no_binding" };
+  if (binding.status !== "ready") return await unboundInvocationContextRefusal(admission, await admission.snapshot(), query, expectedSequences) ?? { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "no_binding" };
   const currentPrompt = currentPrompts.take({ producer_id: request2.producer_id, producer_installation_ref: request2.producer_installation_ref, local_session_ref: request2.local_session_ref, local_turn_ref: request2.local_turn_ref, prompt_ref: binding.binding.prompt_ref });
   let result2;
   try {
-    result2 = await mint({ client_nonce: request2.client_nonce, context_expires_at: binding.binding.context_expires_at ?? binding.binding.bound_at, request_work_context: relayRequestWorkContextFromBinding(binding.binding), ...currentPrompt === void 0 ? {} : { current_prompt: currentPrompt } }, signal);
+    result2 = await mint({ client_nonce: request2.client_nonce, context_expires_at: binding.binding.context_expires_at ?? binding.binding.bound_at, request_work_context: relayRequestWorkContextFromBinding(binding.binding), ...currentPrompt === void 0 ? {} : { current_prompt: currentPrompt }, ...request2.visible_output_max_bytes === void 0 ? {} : { visible_output_max_bytes: request2.visible_output_max_bytes } }, signal);
   } catch (error) {
     return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "refused", reason: error instanceof HostRelayInvocationMintRefusal ? error.reason : "mint_failed" };
   }
   return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "ready", result: result2 };
 }
-function unboundInvocationContextRefusal(snapshot, query, expectedSequences) {
-  if (expectedSequences.length === 0) return null;
-  const refusal = snapshot.installations[`${query.producer_id}\0${query.producer_installation_ref}`]?.last_refusal;
-  if (refusal === void 0 || !expectedSequences.includes(refusal.sequence) || refusal.code !== "gateway_refused") return null;
-  return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "refused", reason: "gateway_refused" };
+async function unboundInvocationContextRefusal(admission, snapshot, query, expectedSequences) {
+  if (expectedSequences.length > 0) {
+    const refusal = snapshot.installations[`${query.producer_id}\0${query.producer_installation_ref}`]?.last_refusal;
+    if (refusal !== void 0 && expectedSequences.includes(refusal.sequence)) {
+      const reason2 = mintReasonForDeliveryRefusal(refusal.code, refusal.diagnostic);
+      if (reason2 !== void 0) return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "refused", reason: reason2 };
+    }
+  }
+  const selector = Object.freeze({
+    producer_id: query.producer_id,
+    producer_installation_ref: query.producer_installation_ref,
+    local_session_ref: query.local_session_ref,
+    local_turn_ref: query.local_turn_ref,
+    local_turn_aliases: Object.freeze([])
+  });
+  const match = await admission.quarantine.findNewestAttributedMatch(selector);
+  if (match === null) return null;
+  const reason = mintReasonForQuarantinedMatch(match);
+  if (reason === void 0) return null;
+  return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "refused", reason };
+}
+function mintReasonForDeliveryRefusal(code, diagnostic) {
+  if (code !== "gateway_refused") return void 0;
+  if (diagnostic === void 0) return "gateway_refused";
+  return mintReasonForWireCause(projectCealHostAuthenticationCause(diagnostic));
+}
+function mintReasonForQuarantinedMatch(match) {
+  if (match === null) return void 0;
+  if (match.reason !== "gateway_refused") return "producer_frame_invalid";
+  const diagnostic = match.attribution?.diagnostic;
+  if (diagnostic === void 0) return void 0;
+  return mintReasonForWireCause(projectCealHostAuthenticationCause(diagnostic));
+}
+function mintReasonForWireCause(cause) {
+  if (isDirectWireCause(cause)) return cause;
+  if (cause === "relay_failed" || cause === "relay_unavailable" || cause === "options_invalid") return "relay_failed";
+  return "mint_failed";
+}
+function isDirectWireCause(cause) {
+  return isVocabularyWord(HOST_RELAY_DIRECT_WIRE_MINT_REASONS, cause);
 }
 function pendingAdmissionSequences(snapshot, query) {
   const sequences = [];
   for (const entry2 of snapshot.entries) {
-    if (entry2.frame.frame_kind !== "user_input") continue;
-    const payload = entry2.frame.payload;
-    if (typeof payload.local_session_ref !== "string" || typeof payload.local_turn_ref !== "string") continue;
-    const aliases = Array.isArray(payload.local_turn_aliases) ? payload.local_turn_aliases.filter((value) => typeof value === "string") : [];
-    if (!relayRequestBindingMatchesQuery(query, { producer_id: entry2.frame.producer_id, producer_installation_ref: entry2.frame.producer_installation_ref, local_session_ref: payload.local_session_ref, local_turn_ref: payload.local_turn_ref, local_turn_aliases: aliases })) continue;
+    const selector = extractHostBindingSelector(entry2.frame);
+    if (selector === null || !relayRequestBindingMatchesQuery(query, selector)) continue;
     sequences.push(entry2.sequence);
   }
   return sequences;
@@ -3625,6 +4051,10 @@ function decodeLocalRequest(value) {
     if (!validCurrentPromptRegisterRequest(value)) throw new HostProducerFrameError("invalid_frame_shape");
     return value;
   }
+  if (value.schema_version === HOST_RELAY_CURRENT_PROMPT_RELEASE_SCHEMA) {
+    if (!validCurrentPromptReleaseRequest(value)) throw new HostProducerFrameError("invalid_frame_shape");
+    return value;
+  }
   if (value.schema_version === HOST_RELAY_BINDING_QUERY_SCHEMA) {
     if (!validBindingQueryRequest(value)) throw new HostProducerFrameError("invalid_frame_shape");
     return value;
@@ -3638,6 +4068,9 @@ function decodeLocalRequest(value) {
 function validCurrentPromptRegisterRequest(value) {
   return validQueryIdentity(value, HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA) && exactKeys4(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref", "prompt_ref", "current_prompt", "context_expires_at"]) && safeRef3(value.prompt_ref) && typeof value.current_prompt === "string" && Buffer.byteLength(value.current_prompt, "utf8") > 0 && Buffer.byteLength(value.current_prompt, "utf8") <= HOST_CURRENT_PROMPT_MAX_BYTES && validTimestamp2(value.context_expires_at);
 }
+function validCurrentPromptReleaseRequest(value) {
+  return validQueryIdentity(value, HOST_RELAY_CURRENT_PROMPT_RELEASE_SCHEMA) && exactKeys4(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref", "prompt_ref"]) && safeRef3(value.prompt_ref);
+}
 function validBindingQueryRequest(value) {
   return validQueryIdentity(value, HOST_RELAY_BINDING_QUERY_SCHEMA) && exactKeys4(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref"]);
 }
@@ -3645,11 +4078,14 @@ function bindingQueryFromRequest(value) {
   return { producer_id: value.producer_id, producer_installation_ref: value.producer_installation_ref, local_session_ref: value.local_session_ref, local_turn_ref: value.local_turn_ref };
 }
 function validInvocationContextQueryRequest(value) {
-  return validQueryIdentity(value, HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) && exactKeys4(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref", "client_nonce"]) && typeof value.client_nonce === "string" && CEAL_HOST_CLIENT_NONCE_PATTERN.test(value.client_nonce);
+  return validQueryIdentity(value, HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) && exactKeys4(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref", "client_nonce"], ["visible_output_max_bytes"]) && typeof value.client_nonce === "string" && CEAL_HOST_CLIENT_NONCE_PATTERN.test(value.client_nonce) && (value.visible_output_max_bytes === void 0 || validVisibleOutputBudget(value.visible_output_max_bytes));
 }
 function validQueryIdentity(value, schema) {
   return record4(value) && value.schema_version === schema && (value.producer_id === "codex" || value.producer_id === "claude") && safeRef3(value.producer_installation_ref) && safeRef3(value.local_session_ref) && safeRef3(value.local_turn_ref);
 }
+function validVisibleOutputBudget(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= CEAL_CANONICAL_HTTP_MAX_RESPONSE_BYTES;
+}
 function decodeLengthPrefixedJson(input, maximum) {
   if (input.length < HOST_RELAY_IPC_LENGTH_BYTES) return null;
   const length = input.readUInt32BE(0);
@@ -3669,11 +4105,18 @@ function encodeLengthPrefixed(value) {
   body.copy(output, HOST_RELAY_IPC_LENGTH_BYTES);
   return output;
 }
-function currentPromptWire(value) {
+function isCurrentPromptWire(value) {
+  return currentPromptRegisterWire(value) || currentPromptReleaseWire(value);
+}
+function currentPromptRegisterWire(value) {
   return value.subarray(HOST_RELAY_IPC_LENGTH_BYTES, Math.min(value.length, HOST_RELAY_IPC_LENGTH_BYTES + 128)).includes(Buffer.from(`"schema_version":"${HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA}"`, "utf8"));
 }
-function exactKeys4(value, keys) {
-  return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+function currentPromptReleaseWire(value) {
+  return value.subarray(HOST_RELAY_IPC_LENGTH_BYTES, Math.min(value.length, HOST_RELAY_IPC_LENGTH_BYTES + 128)).includes(Buffer.from(`"schema_version":"${HOST_RELAY_CURRENT_PROMPT_RELEASE_SCHEMA}"`, "utf8"));
+}
+function exactKeys4(value, required, optional = []) {
+  const keys = Object.keys(value);
+  return required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => required.includes(key) || optional.includes(key));
 }
 function safeRef3(value) {
   return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);