npm - @corca-org/ceal-host-linux-arm64 - Versions diffs - 1.0.19 → 1.0.21 - Mend

@corca-org/ceal-host-linux-arm64 1.0.19 → 1.0.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/bin/ceal-host +0 -0
package/libexec/ceal-host/claude-hook.mjs +1327 -1211
package/libexec/ceal-host/claude-invocation-authentication.mjs +1986 -1272
package/libexec/ceal-host/claude-producer.mjs +1376 -1313
package/libexec/ceal-host/codex-hook.mjs +1215 -1392
package/libexec/ceal-host/codex-invocation-authentication.mjs +1924 -1364
package/libexec/ceal-host/codex-producer.mjs +1222 -1286
package/libexec/ceal-host/control.mjs +2818 -2076
package/libexec/ceal-host/relay.mjs +1733 -1811
package/package.json +1 -1
package/share/ceal-host/bundle-manifest.json +12 -12
package/share/ceal-host/bundle-manifest.sigstore.json +1 -1

package/libexec/ceal-host/claude-invocation-authentication.mjs CHANGED Viewed

@@ -29,16 +29,34 @@ function isPlainRecord(value) {
   return prototype === Object.prototype || prototype === null;
 }
+// packages/ceal-client-protocol/src/client-wire-contract.ts
+import { createHash } from "node:crypto";
 // packages/ceal-client-protocol/client-wire-contract.json
 var client_wire_contract_default = {
   schema_version: "ceal.client_wire_contract.v1",
+  doctor: {
+    schema_version: "ceal.doctor.v1"
+  },
+  client_commands: {
+    doctor: ["doctor"],
+    version: ["version"],
+    access_group_list: ["access-group", "list"]
+  },
+  client_environment: {
+    environment_prefix: "CEAL",
+    context_override_suffixes: ["GATEWAY_ORIGIN", "GATEWAY_TRANSPORT_ORIGIN", "ACCESS_TOKEN", "CONTEXT_STORE_PATH"]
+  },
   canonical_json: {
     ordering: "utf16_code_unit_ascending"
   },
   artifact_descriptor: {
-    operation_contract_bundle_schema_version: "ceal.operation_contract_bundle.v1",
-    schema_version: "ceal.verified_artifact_descriptor.v1",
-    binding_schema_version: "ceal.verified_artifact_binding.v1",
+    operation_contract_bundle_schema_name: "ceal.operation_contract_bundle",
+    operation_contract_bundle_fields: ["schema_version", "catalog_revision", "operations", "failure_guidance"],
+    schema_name: "ceal.verified_artifact_descriptor",
+    fields: ["schema_version", "kind", "media_type", "byte_count", "sha256", "binding"],
+    binding_schema_name: "ceal.verified_artifact_binding",
+    binding_fields: ["schema_version", "kind", "catalog_revision"],
     kind: "verified_artifact",
     binding_kind: "catalog",
     media_type: "application/json",
@@ -54,14 +72,16 @@ var client_wire_contract_default = {
       length: 72,
       pattern: "^catalog:[a-f0-9]{64}$"
     },
-    envelope_max_bytes: 389
+    envelope_max_bytes: 407
   },
   command_request: {
-    schema_version: "ceal.command_request.v1",
+    schema_name: "ceal.command_request",
+    fields: ["schema_version", "argv", "operation", "client_nonce", "context_token"],
     absolute_transport_max_bytes: 65536
   },
   command_resolution: {
-    schema_version: "ceal.gateway_command_resolution.v1",
+    schema_name: "ceal.gateway_command_resolution",
+    fields: ["schema_version", "kind", "ok", "execution_started", "program", "route", "authority", "routes", "operations", "required_action_sequence", "semantic_options", "result_delivery", "operation", "invocation", "entrypoints", "common_concepts", "withheld", "catalog_revision", "operation_id", "input", "transport", "output", "unresolved_inputs", "unresolved_refusal", "attempted_route", "did_you_mean", "error"],
     authority: {
       anonymous: {
         state: "anonymous",
@@ -101,7 +121,8 @@ var client_wire_contract_default = {
     }
   },
   command_response: {
-    schema_version: "ceal.command_response.v1",
+    schema_name: "ceal.command_response",
+    fields: ["schema_version", "exit_code", "document", "operation_id", "visible_output_max_bytes", "local_delivery", "verified_artifact"],
     descriptor_field: "verified_artifact",
     required_fields: [
       "schema_version",
@@ -125,29 +146,41 @@ var client_wire_contract_default = {
       "required_action_sequence",
       "withheld"
     ],
-    prompt_field: "prompt",
-    prompt_schema_version: "ceal.prompt.v1",
-    focused_prompt_document_fields: [
-      "catalog_revision",
-      "prompt"
-    ],
-    focused_prompt_continuation_document_fields: [
-      "catalog_revision",
-      "remaining_work",
-      "prompt"
-    ],
     discovery_command: "discovery",
-    discovery_manifest_schema_version: "ceal.discovery_manifest.v1",
+    discovery_manifest_schema_name: "ceal.discovery_manifest",
+    discovery_manifest_fields: ["schema_version", "skill", "authority_scope", "connector_kinds", "personal_connector_kinds", "guide_markdown", "renderer_version", "digest"],
     discovery_manifest_document_fields: [
       "discovery_manifest"
     ],
     exit_code_max: 125,
     bare_document_max_bytes: 65536,
-    complete_max_bytes: 66019
+    complete_max_bytes: 66046
+  },
+  host_invocation_authentication: {
+    request_schema_name: "ceal.host_invocation_authentication_request",
+    request_fields: [
+      "schema_version",
+      "client_nonce"
+    ],
+    result_schema_name: "ceal.host_invocation_authentication_result",
+    result_fields: [
+      "schema_version",
+      "context_token",
+      "expires_at"
+    ],
+    client_nonce: {
+      character_class_source: "A-Za-z0-9_-",
+      encoded_characters: 43
+    }
+  },
+  gateway_host_invocation_context_request: {
+    schema_name: "ceal.gateway_host_invocation_context_request",
+    fields: ["schema_version", "client_nonce", "context_expires_at", "request_work_context", "current_prompt", "visible_output_max_bytes"]
   },
   resource_stream: {
     path: "/api/ceal/v2/resources",
-    request_schema_version: "ceal.resource_stream_request.v1",
+    request_schema_name: "ceal.resource_stream_request",
+    request_fields: ["schema_version", "resource_ref", "client_nonce", "context_token"],
     ref_pattern: "^resource:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
     media_type_pattern: "^[a-z0-9][a-z0-9!#$&^_.+-]{0,63}/[a-z0-9][a-z0-9!#$&^_.+-]{0,63}$",
     filename_max_bytes: 512,
@@ -164,92 +197,6 @@ var client_wire_contract_default = {
   }
 };
-// packages/ceal-client-protocol/src/client-wire-contract.ts
-var CEAL_CLIENT_WIRE_CONTRACT = Object.freeze(client_wire_contract_default);
-var commandResolution = CEAL_CLIENT_WIRE_CONTRACT.command_resolution;
-var commandResolutionAuthority = commandResolution.authority;
-var commandResolutionSemanticOptions = commandResolution.semantic_options;
-var CEAL_GATEWAY_COMMAND_RESOLUTION_SCHEMA_VERSION = commandResolution.schema_version;
-var CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES = CEAL_CLIENT_WIRE_CONTRACT.encoded_json_document.max_bytes;
-var artifact = CEAL_CLIENT_WIRE_CONTRACT.artifact_descriptor;
-var request = CEAL_CLIENT_WIRE_CONTRACT.command_request;
-var response = CEAL_CLIENT_WIRE_CONTRACT.command_response;
-var CEAL_OPERATION_CONTRACT_BUNDLE_SCHEMA_VERSION = artifact.operation_contract_bundle_schema_version;
-var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_SCHEMA_VERSION = artifact.schema_version;
-var CEAL_VERIFIED_ARTIFACT_BINDING_SCHEMA_VERSION = artifact.binding_schema_version;
-var CEAL_VERIFIED_ARTIFACT_KIND = artifact.kind;
-var CEAL_VERIFIED_ARTIFACT_BINDING_KIND = artifact.binding_kind;
-var CEAL_VERIFIED_ARTIFACT_MEDIA_TYPE = artifact.media_type;
-var CEAL_VERIFIED_ARTIFACT_DIGEST_LENGTH = artifact.digest.length;
-var CEAL_VERIFIED_ARTIFACT_DIGEST_PATTERN = artifact.digest.pattern;
-var CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_LENGTH = artifact.catalog_revision.length;
-var CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_PATTERN = artifact.catalog_revision.pattern;
-var CEAL_VERIFIED_ARTIFACT_MAX_BYTES = CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES;
-var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_MAX_BYTES = artifact.envelope_max_bytes;
-var CEAL_COMMAND_REQUEST_SCHEMA_VERSION = request.schema_version;
-var CEAL_COMMAND_REQUEST_MAX_BYTES = request.absolute_transport_max_bytes;
-var CEAL_COMMAND_RESPONSE_BARE_DOCUMENT_MAX_BYTES = response.bare_document_max_bytes;
-var CEAL_COMMAND_RESPONSE_PROMPT_FIELD = response.prompt_field;
-var CEAL_COMMAND_RESPONSE_PROMPT_SCHEMA_VERSION = response.prompt_schema_version;
-var CEAL_COMMAND_RESPONSE_BARE_DOCUMENT_OPTIONAL_FIELDS = Object.freeze([...response.bare_document_optional_fields]);
-var CEAL_COMMAND_RESPONSE_PROMPT_DOCUMENT_FIELDS = Object.freeze([...response.bare_document_fields, response.prompt_field]);
-var CEAL_COMMAND_RESPONSE_FOCUSED_PROMPT_DOCUMENT_FIELDS = Object.freeze([...response.focused_prompt_document_fields]);
-var CEAL_COMMAND_RESPONSE_FOCUSED_PROMPT_CONTINUATION_DOCUMENT_FIELDS = Object.freeze([...response.focused_prompt_continuation_document_fields]);
-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) {
-  return Object.freeze(words);
-}
-function isVocabularyWord(words, value) {
-  return words.some((word) => word === value);
-}
-// packages/ceal-client-protocol/src/gateway-response-types.ts
-var CEAL_OPERATION_READINESS_VALUES = vocabulary(["ready", "degraded", "unavailable", "unknown"]);
-var CEAL_TARGET_REQUIREMENTS = vocabulary(["required", "optional", "none"]);
-var CEAL_AUDIT_OUTCOMES = vocabulary(["succeeded", "denied", "failed"]);
-var CEAL_GATEWAY_PROVIDER_STEP_OUTCOMES = vocabulary(["completed", "rejected", "throttled", "failed"]);
-var CEAL_GATEWAY_READ_REUSE_DISPOSITIONS = vocabulary(["response_cache_hit", "corpus_hit", "corpus_hit_after_revalidation", "corpus_partial_provider_supplement", "provider_direct", "provider_continuation", "reuse_unavailable"]);
-var CEAL_GATEWAY_READ_REUSE_UNAVAILABLE_REASONS = vocabulary(["not_reported", "storage_unavailable", "coverage_incomplete", "freshness_refresh_required", "not_reusable", "bypassed"]);
-var CEAL_GATEWAY_DERIVED_STORE_FAILURE_CLASSES = vocabulary(["storage_unavailable", "decode_mismatch", "write_conflict", "quota", "store_error"]);
-var CEAL_POLICY_DECISIONS = vocabulary(["allowed", "denied", "not_evaluated"]);
-var CEAL_CONNECTOR_ROUTE_PHASES = vocabulary(["scope_observation", "target_selection", "route_resolution"]);
-var CEAL_CONNECTOR_ROUTE_CAUSES = vocabulary(["provider_throttled", "provider_unavailable", "binding_invalid", "scope_limit_exceeded"]);
-var CEAL_WRITE_SOURCE_KINDS = vocabulary(["authenticated_registered_client", "provider_authenticated_event"]);
-var CEAL_REFRESH_DELIVERIES = vocabulary(["initial", "recovery", "replay", "terminal_failure", "recovery_unavailable"]);
-var CEAL_CLIENT_OPERATIONS = vocabulary(["handshake", "discover", "call", "readback"]);
-var CEAL_WRITE_IDEMPOTENCY_POSTURES = vocabulary(["required", "optional", "not_required"]);
-var CEAL_WRITE_PROVIDER_READBACK_POSTURES = vocabulary(["required", "best_effort", "not_available"]);
-var CEAL_WRITE_ATTRIBUTIONS = vocabulary(["subject", "requester_event", "connector_integration"]);
-var CEAL_WRITE_RECEIPT_PROVIDER_STATES = vocabulary(["outcome_unknown", "verified", "not_dispatched"]);
-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",
-  "continuation_write_pending",
-  "provider_pacing_pending",
-  "corpus_replay_pending",
-  "corpus_append_pending",
-  "corpus_fence_pending",
-  "corpus_content_pending",
-  "corpus_transaction_pending"
-]);
-var CEAL_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["connector_kind", "phase", "schema_version"]);
-var CEAL_CLASSIFIED_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["cause", ...CEAL_CONNECTOR_ROUTE_FAILURE_KEYS]);
-var CEAL_UNCLASSIFIED_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["connector_kind", "error_class", "phase", "schema_version"]);
-var CEAL_GATEWAY_ORGANIZATION_ROUTE_FACT_CALL_KEYS = Object.freeze([
-  "connector_ref",
-  "connector_revision",
-  "policy_decision_revision"
-]);
 // 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";
@@ -316,7 +263,10 @@ var CALLER_RECOVERABLE_NEXT_ACTION_VALUES = [
   "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"
+  "materialize_local_argument",
+  // A peer's derived schema identifier changed with its field set; install or
+  // upgrade the CLI and Host Relay to the Gateway's release before retrying.
+  "upgrade_ceal_client"
 ];
 var CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS = Object.freeze(CALLER_RECOVERABLE_NEXT_ACTION_VALUES);
 var NON_REMEDY_NEXT_ACTION_VALUES = [
@@ -429,47 +379,56 @@ var CEAL_OPERATION_WITHHELD_NEXT_ACTIONS = Object.freeze({
   personal_authorization_required: "connect_personal_account"
 });
-// packages/ceal-client-protocol/src/operation-withheld-cause.ts
-var CEAL_OPERATION_WITHHELD_CAUSES = vocabulary(["provider_permission", "access_level", "personal_authorization_required"]);
+// packages/ceal-client-protocol/src/vocabulary.ts
+function vocabulary(words) {
+  return Object.freeze(words);
+}
+function isVocabularyWord(words, value) {
+  return words.some((word) => word === value);
+}
-// packages/ceal-client-protocol/src/operation-contract-types.ts
-var CEAL_JSON_SCHEMA_2020_12 = "https://json-schema.org/draft/2020-12/schema";
-var CEAL_OPERATION_ERROR_SCHEMA_VERSION = "ceal.operation_error.v1";
-var CEAL_ARTIFACT_STAGE_TERMINALS = vocabulary(["chunk_accepted", "artifact_ready", "idempotency_replayed"]);
-var CEAL_RETRY_AFTER_MAX_MS = 60 * 60 * 1e3;
-var CEAL_JSON_SCHEMA_TYPES = vocabulary(["object", "array", "string", "integer", "number", "boolean", "null"]);
-var OBSERVATION_POSTURES = vocabulary(["direct_readback", "approved_no_readback", "operator_mediated", "excluded"]);
-var EFFECT_DOMAINS = vocabulary(["none", "gateway_state", "provider", "external_world"]);
-var SAFETY_CLASSES = vocabulary(["routine", "sensitive", "high_impact"]);
-var IDEMPOTENCY_CLASSES = vocabulary(["idempotent", "conditionally_idempotent", "non_idempotent"]);
-var REVERSIBILITY_CLASSES = vocabulary(["none", "reversible", "compensatable", "irreversible"]);
-var COMPENSATION_OWNERS = vocabulary(["none", "connector", "operator"]);
-var CANCELLATION_BOUNDARIES = vocabulary(["before_admission", "before_handoff", "after_handoff_reconcile"]);
-var HANDOFF_CLASSES = vocabulary(["not_applicable", "submission", "effect"]);
-var AUTHORITATIVE_READBACK_CLASSES = vocabulary(["required", "unavailable"]);
-var PROVIDER_READBACK_CLASSES = vocabulary(["required", "not_available", "not_applicable"]);
-var RECONCILIATION_CLASSES = vocabulary(["none", "automatic", "operator"]);
-var NO_READBACK_APPROVAL_CLASSES = vocabulary(["not_applicable", "explicit", "operator"]);
-var REPLAY_PREREQUISITES = vocabulary(["never", "fresh_admission", "reconciled_non_application", "operator_approval"]);
-var UNKNOWN_OUTCOMES = vocabulary(["reconcile", "operator_action", "excluded"]);
-var RECOVERY_OWNERS = vocabulary(["gateway", "connector", "operator"]);
-var CEAL_OPERATION_ADMISSION_STATES = vocabulary(["proposed", "refused", "admitted"]);
-var CEAL_OPERATION_EXECUTION_STATES = vocabulary(["not_started", "started", "completed"]);
-var CEAL_OPERATION_PROVIDER_HANDOFF_STATES = vocabulary(["not_offered", "offered", "accepted", "rejected", "unknown"]);
-var CEAL_OPERATION_EFFECT_STATES = vocabulary(["none", "applied", "failed", "unknown", "compensated"]);
-var CEAL_OPERATION_OBSERVATION_STATES = vocabulary(["not_started", "not_required", "pending", "observed", "unavailable"]);
-var CEAL_OPERATION_RECOVERY_KINDS = vocabulary(["none", "reconcile", "compensate", "operator_action"]);
-var CEAL_OPERATION_RECOVERY_STATUSES = vocabulary(["not_started", "active", "completed"]);
-var CEAL_OPERATION_PROVIDER_READBACK_AVAILABILITY = vocabulary(["not_started", "not_applicable", "not_available", "pending", "available"]);
-var CEAL_OPERATION_OFFERED_HANDOFF_STATES = vocabulary(["accepted", "rejected", "unknown"]);
-var CEAL_OPERATION_RECEIPT_AUTHORITY_KEYS = Object.freeze(["instance_ref", "access_group_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]);
-var CEAL_OPERATION_APPROVAL_DISPOSITIONS = vocabulary([
-  "approval_not_required_by_policy",
-  "interactive_pending",
-  "interactive_granted",
-  "interactive_denied",
-  "interactive_expired",
-  "interactive_unavailable"
+// packages/ceal-client-protocol/src/gateway-response-types.ts
+var CEAL_OPERATION_READINESS_VALUES = vocabulary(["ready", "degraded", "unavailable", "unknown"]);
+var CEAL_TARGET_REQUIREMENTS = vocabulary(["required", "optional", "none"]);
+var CEAL_AUDIT_OUTCOMES = vocabulary(["succeeded", "denied", "failed"]);
+var CEAL_GATEWAY_PROVIDER_STEP_OUTCOMES = vocabulary(["completed", "rejected", "throttled", "failed"]);
+var CEAL_GATEWAY_READ_REUSE_DISPOSITIONS = vocabulary(["response_cache_hit", "corpus_hit", "corpus_hit_after_revalidation", "corpus_partial_provider_supplement", "provider_direct", "provider_continuation", "reuse_unavailable"]);
+var CEAL_GATEWAY_READ_REUSE_UNAVAILABLE_REASONS = vocabulary(["not_reported", "storage_unavailable", "coverage_incomplete", "freshness_refresh_required", "not_reusable", "bypassed"]);
+var CEAL_GATEWAY_DERIVED_STORE_FAILURE_CLASSES = vocabulary(["storage_unavailable", "decode_mismatch", "write_conflict", "quota", "store_error"]);
+var CEAL_POLICY_DECISIONS = vocabulary(["allowed", "denied", "not_evaluated"]);
+var CEAL_CONNECTOR_ROUTE_PHASES = vocabulary(["scope_observation", "target_selection", "route_resolution"]);
+var CEAL_CONNECTOR_ROUTE_CAUSES = vocabulary(["provider_throttled", "provider_unavailable", "binding_invalid", "scope_limit_exceeded"]);
+var CEAL_WRITE_SOURCE_KINDS = vocabulary(["authenticated_registered_client", "provider_authenticated_event"]);
+var CEAL_REFRESH_DELIVERIES = vocabulary(["initial", "recovery", "replay", "terminal_failure", "recovery_unavailable"]);
+var CEAL_CLIENT_OPERATIONS = vocabulary(["handshake", "discover", "call", "readback"]);
+var CEAL_WRITE_IDEMPOTENCY_POSTURES = vocabulary(["required", "optional", "not_required"]);
+var CEAL_WRITE_PROVIDER_READBACK_POSTURES = vocabulary(["required", "best_effort", "not_available"]);
+var CEAL_WRITE_ATTRIBUTIONS = vocabulary(["subject", "requester_event", "connector_integration"]);
+var CEAL_WRITE_RECEIPT_PROVIDER_STATES = vocabulary(["outcome_unknown", "verified", "not_dispatched"]);
+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_CALL_RESULT_SCHEMA_VERSION = "ceal.gateway_call_result.v1";
+var CEAL_GATEWAY_CONTINUATION_CURSOR_PHASES = vocabulary(["scan", "delivery", "terminal"]);
+var CEAL_GATEWAY_ACTIVE_CALL_PHASES = vocabulary([
+  "audited_call_pending",
+  "continuation_read_pending",
+  "continuation_write_pending",
+  "provider_pacing_pending",
+  "corpus_replay_pending",
+  "corpus_append_pending",
+  "corpus_fence_pending",
+  "corpus_content_pending",
+  "corpus_transaction_pending"
+]);
+var CEAL_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["connector_kind", "phase", "schema_version"]);
+var CEAL_CLASSIFIED_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["cause", ...CEAL_CONNECTOR_ROUTE_FAILURE_KEYS]);
+var CEAL_UNCLASSIFIED_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["connector_kind", "error_class", "phase", "schema_version"]);
+var CEAL_GATEWAY_AUDIT_CALL_DETAIL_SCHEMA_VERSION = "ceal.gateway_audit_call_detail.v1";
+var CEAL_GATEWAY_ORGANIZATION_ROUTE_FACT_CALL_KEYS = Object.freeze([
+  "connector_ref",
+  "connector_revision",
+  "policy_decision_revision"
 ]);
 // packages/ceal-client-protocol/src/gateway-validation-primitives.ts
@@ -609,6 +568,11 @@ function isCealJsonRecord(value) {
 }
 var CEAL_VALIDATION_STATUSES = vocabulary(["not_applicable", "valid", "invalid"]);
 var CEAL_PARSE_STATUSES = vocabulary(["not_applicable", "parsed", "parse_failed"]);
+function hasExactKeys(value, expected) {
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  return actual.length === wanted.length && actual.every((key, index) => key === wanted[index]);
+}
 function invalidByContext(options) {
   if (options.forbidAuthorityKeys) invalidRequest();
   invalidResponse();
@@ -683,51 +647,6 @@ function cut(text) {
   return text.length <= REFUSAL_VALUE_MAX_CHARS ? text : `${text.slice(0, REFUSAL_VALUE_MAX_CHARS)}...(+${text.length - REFUSAL_VALUE_MAX_CHARS} chars)`;
 }
-// packages/ceal-client-protocol/src/operation-access-class.ts
-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_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", "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
-var SAFE_JSON_MIN_BYTES_PER_NODE = 4;
-function safeJsonNodeBudgetForBytes(maxBytes) {
-  if (!Number.isSafeInteger(maxBytes) || maxBytes < SAFE_JSON_MIN_BYTES_PER_NODE) {
-    throw new RangeError(`safe-JSON byte cap is invalid: ${refusalFact("maxBytes", maxBytes, `at least ${SAFE_JSON_MIN_BYTES_PER_NODE} bytes`)}`);
-  }
-  return Math.floor(maxBytes / SAFE_JSON_MIN_BYTES_PER_NODE);
-}
-// packages/ceal-client-protocol/src/protocol-bounds.ts
-var CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES = 64 * 1024;
-var CEAL_PROTOCOL_RESPONSE_VALUE_MAX_NODES = safeJsonNodeBudgetForBytes(CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES);
-var OPERATION_SCHEMA_LITERAL_MAX_BYTES = CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES / 4;
-var CEAL_OPERATION_JSON_SCHEMA_BUDGET = Object.freeze({
-  max_depth: 8,
-  max_properties: 96,
-  max_string_length: OPERATION_SCHEMA_LITERAL_MAX_BYTES / 4,
-  max_alternatives: 8,
-  max_enum_values: 64,
-  max_literal_bytes: OPERATION_SCHEMA_LITERAL_MAX_BYTES,
-  /** @basis our_policy -- bounds explanatory schema prose carried in one catalog. */
-  max_description_characters: 1024,
-  /** @basis our_policy -- bounds regular-expression compilation input from one schema. */
-  max_pattern_characters: 256,
-  /** @basis our_policy -- bounds traversal work inside one already byte-bounded schema literal. */
-  max_literal_nodes: 512
-});
 // packages/ceal-client-protocol/src/operation-validation-primitives.ts
 var ISO_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,9}))?([Zz]|([+-])(\d{2}):(\d{2}))$/u;
 var CEAL_CALENDAR_DATE_PATTERN_SOURCE = "^\\d{4}-\\d{2}-\\d{2}$";
@@ -795,38 +714,366 @@ function requireIsoTimestamp(value, message) {
   if (!isCealIsoTimestamp(value)) throw new TypeError(message);
 }
-// packages/ceal-client-protocol/src/operation-json-schema.ts
-var JSON_DESCRIPTION_CONTROL_CHARACTER = new RegExp("\\p{Cc}", "u");
-// packages/ceal-client-protocol/src/operation-contract-validation.ts
-var CEAL_OPERATION_AUTHORITY_POLICY_KEYS = Object.freeze(["access_group", "instance_binding", "target", "admission_recheck"]);
-var MAX_OPERATION_INPUT_RESOLVER_BINDINGS = 96;
-var CEAL_OPERATION_DESCRIPTOR_REQUIRED_ENVELOPE_KEYS = Object.freeze(["schema_version", "id", "input_contract", "result_contract", "policy"]);
-var CEAL_OPERATION_DESCRIPTOR_OPTIONAL_ENVELOPE_KEYS = Object.freeze(["input_resolution", "summary"]);
-// packages/ceal-client-protocol/src/operation-catalog.ts
-var CEAL_OPERATION_CATALOG_SCHEMA_VERSION = "ceal.catalog.v3";
-var CLIENT_AUDIENCES = Object.freeze(["ceal", "cealctl", "agent"]);
-var CLIENT_AUDIENCE_SET = new Set(CLIENT_AUDIENCES);
+// packages/ceal-client-protocol/src/failure-guidance-table.ts
+var CEAL_FAILURE_REDACTION_CLASSES = vocabulary(["model_safe", "withheld"]);
+var CEAL_GATEWAY_STARTING_FAILURE_CODE = "gateway_starting";
+var CEAL_OWNER_BOOTSTRAP_ABSENT_FAILURE_CODE = "bootstrap_absent";
+var CEAL_OWNER_BOOTSTRAP_UNAVAILABLE_FAILURE_CODE = "bootstrap_unavailable";
+var LOCAL_COMMAND_INVALID = "The local command or argument is invalid.";
+var LOCAL_TRANSPORT_INCOMPLETE = "The local Ceal transport could not complete; report this as a gap.";
+var GATEWAY_TRANSPORT_UNAVAILABLE = "The Gateway transport is unavailable; ask an administrator to restore Gateway availability.";
+var HOST_AUTHENTICATION_UNAVAILABLE = "The Host could not authenticate this invocation; report this as a gap.";
+var SESSION_CONTEXT_UNAVAILABLE = "The local Gateway session context is unavailable.";
+function guidance(message, next_action, http_status, retryable = false, redaction_class = "model_safe") {
+  return Object.freeze({ message, next_action, http_status, retryable, redaction_class });
+}
+var CEAL_FAILURE_GUIDANCE_TABLE = Object.freeze({
+  invalid_command: guidance(LOCAL_COMMAND_INVALID, "correct_argument", 400),
+  invalid_argument: guidance(LOCAL_COMMAND_INVALID, "correct_argument", 400),
+  command_not_found: guidance(LOCAL_COMMAND_INVALID, "correct_argument", 404),
+  unknown_operation: guidance("The requested Operation is absent from the current verified catalog; report this as a gap unless a catalog suggestion names a replacement.", "answer_with_gap", 404),
+  local_route_unavailable: guidance("The requested local route is unavailable or its descriptor is invalid; report this as a gap.", "answer_with_gap", 404),
+  local_route_ambiguous: guidance("The requested local route is ambiguous; no local executable was selected. Report this as a gap.", "answer_with_gap", 400),
+  local_execution_unavailable: guidance("The selected local route executable is unavailable; report this as a gap.", "answer_with_gap", 500),
+  local_pickup_failed: guidance("The Host Request pickup failed; the Gateway command was not sent. Report this as a gap.", "answer_with_gap", 502),
+  invocation_authentication_unavailable: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 401),
+  local_execution_cancellation_unknown: guidance("The selected local route cancellation outcome is unknown; a retry can repeat an effect the cancelled route already completed. Report this as a gap and do not retry.", "answer_with_gap", 409),
+  gateway_origin_required: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  access_token_required: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  context_pair_required: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  context_not_selected: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  context_store_invalid: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  context_store_conflict: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  refresh_invalid: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  refresh_expired: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  refresh_replayed: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  refresh_revoked: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  refresh_recovery_unavailable: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  refresh_custody_invalid: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  session_store_unwritable: guidance("The Ceal client could not write its local session store; the operating system refused the write (EACCES, EPERM, or EROFS). rerun_outside_agent_sandbox reruns it with escalated execution.", "rerun_outside_agent_sandbox", 500),
+  local_output_exists: guidance("The selected local output path already exists; nothing was written to it.", "choose_new_output_path", 400),
+  local_output_outside_result_root: guidance("The selected local output path lies outside this run's result root; only a path inside the result root named here is writable.", "choose_new_output_path", 400),
+  local_output_unwritable: guidance("The Ceal client could not write the result file at its local path; the operating system refused the write. When that step followed the Gateway call, the call may already have completed a write effect that a rerun repeats. rerun_outside_agent_sandbox reruns it with escalated execution.", "rerun_outside_agent_sandbox", 500),
+  local_output_unavailable: guidance("The Gateway result could not be materialized at the selected local path; report this as a gap.", "answer_with_gap", 500),
+  local_materialization_required: guidance("The Gateway result could not be materialized at the selected local path; report this as a gap.", "answer_with_gap", 500),
+  contract_artifact_cache_invalid: guidance("The verified contract artifact could not be stored in the private local cache; report this as a gap.", "answer_with_gap", 500),
+  response_encoding_failed: guidance("The local response could not be encoded; report this as a gap.", "answer_with_gap", 500),
+  request_timeout: guidance(GATEWAY_TRANSPORT_UNAVAILABLE, "ask_admin", 504),
+  request_failed: guidance(GATEWAY_TRANSPORT_UNAVAILABLE, "ask_admin", 502),
+  gateway_unavailable: guidance(GATEWAY_TRANSPORT_UNAVAILABLE, "ask_admin", 503, true),
+  contract_mismatch: guidance("Install or upgrade the Ceal CLI and Host Relay to the same release as the Gateway, then retry.", "upgrade_ceal_client", 409),
+  // `gateway_starting` is the one retryable envelope the serving gate answers on every route while starting
+  // (`cli/internal/client/gateway_startup_wait.go` re-drives it); the sentence is the client default that renders
+  // when the wait ends still unserved, moved from the `localFailureText` default branch.
+  [CEAL_GATEWAY_STARTING_FAILURE_CODE]: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 503, true),
+  gateway_internal_error: guidance("The Gateway failed without exposing internal state; report this as a gap.", "answer_with_gap", 500),
+  // The serving gate emits this code with no message; the sentence is the owner-normalized form of the
+  // `gateway_internal_error` guidance (decided with the operator 2026-10-13).
+  internal_error: guidance("The Gateway failed without exposing internal state.", "answer_with_gap", 500),
+  // Owned by the Gateway canonical adapter (`gateway/core/src/gateway-canonical-operation-http-adapter.ts`):
+  // the client variant of this sentence in `localFailureText` was retired when the client started reading this table.
+  request_body_too_large: guidance("The Gateway request body exceeds its bounded limit.", "reduce_request_size", 413),
+  // Restored verbatim from the retired `localFailureText` `unknown_outcome`
+  // case: the outcome is unknown, so a read may be retried while a write
+  // must receipt-check first. Collapsing both to "do not repeat the call"
+  // forbids the safe read retry the sentence exists to allow.
+  unknown_outcome: guidance("The transport outcome is unknown: a read may be retried; for a write, check write_receipt.get before repeating.", "answer_with_gap", 500),
+  // Restored verbatim from the retired `localFailureText`
+  // `refresh_unknown_outcome` case: a refresh that ends unknown leaves the
+  // session context unavailable, so the caller repairs or adopts the
+  // session instead of reporting a transport gap.
+  refresh_unknown_outcome: guidance(SESSION_CONTEXT_UNAVAILABLE, "repair_or_adopt_session", 401),
+  request_cancelled: guidance("The caller cancelled the request before it completed.", "retry", 400, true),
+  expired: guidance("The activation transaction or its administrator approval request expired before completion; repeat the original activation arguments to start a new transaction.", "repeat_original_arguments", 410, true),
+  denied: guidance("An administrator denied this device's activation request; ask an administrator whether to reconsider it.", "ask_admin", 403),
+  device_approval_pending_limit: guidance("Device approval requests are already waiting for an administrator decision; ask an administrator to decide a pending request before adding another device.", "ask_admin", 429),
+  session_already_adopted: guidance("The requested enrollment was not started because this machine already has a live session with the Gateway. Report this as a gap if that local session needs replacement.", "answer_with_gap", 409),
+  pending_adoption_limit: guidance("This device's pending activation file is full; another activation is refused while an administrator decision is pending. Report this as a gap.", "answer_with_gap", 429),
+  recovery_required: guidance("The Gateway could not safely complete the activation transaction automatically; ask an administrator to recover this transaction.", "ask_admin", 500),
+  unsupported_feature: guidance("This Ceal client does not support the Gateway's required activation protocol; ask an administrator to update the client.", "ask_admin", 501),
+  // Activation commit codes rendered through the `localFailureText` default before phase 2b; `retryable` is moved from the
+  // emitting sites in `cli/internal/client/gateway_installation_activation.go` and `activation.go:483`.
+  activation_state_commit_failed: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 500, true),
+  activation_response_invalid: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 502, true),
+  activation_rejected: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 502),
+  activation_failed: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 500),
+  activation_binding: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 400),
+  activation_crypto: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 500),
+  activation_state_invalid: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 500),
+  // Long-tail local codes rendered through the `localFailureText` default before phase 2b; sentences moved from that branch.
+  invalid_response: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 500),
+  invalid_configuration: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 500),
+  activation_state_unavailable: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 500),
+  activation_code_invalid: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 400),
+  activation_code_file_invalid: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 400),
+  activation_code_unavailable: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 404),
+  bootstrap_file_invalid: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 400),
+  bootstrap_not_active: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 409),
+  bootstrap_unauthorized: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 401),
+  // The Gateway owner-bootstrap store file was never created, so the Gateway
+  // holds no owner bootstrap to exchange (`gateway/src/host/owner-bootstrap-http-composition.ts`
+  // `absent`, stored at `gateway/src/shared/installation/owner-bootstrap-store.ts:162`);
+  // the sentence is the owner-normalized form of that store error. Non-retryable:
+  // repeating the exchange cannot create the store; only an administrator
+  // placing a bootstrap (fresh gateway setup) changes the outcome.
+  [CEAL_OWNER_BOOTSTRAP_ABSENT_FAILURE_CODE]: guidance("The Gateway holds no owner bootstrap to exchange; report this as a gap.", "answer_with_gap", 503),
+  // The Gateway owner-bootstrap store file exists but cannot be read, so the
+  // exchange cannot proceed (`gateway/src/host/owner-bootstrap-http-composition.ts`
+  // `unavailable`, stored at `gateway/src/shared/installation/owner-bootstrap-store.ts:163`);
+  // the sentence is the owner-normalized form of that store error. Retryable:
+  // unlike `absent`, a later exchange may succeed once the store is readable.
+  [CEAL_OWNER_BOOTSTRAP_UNAVAILABLE_FAILURE_CODE]: guidance("The Gateway owner bootstrap store is unavailable; retry the exchange.", "retry", 503, true),
+  context_selection_ambiguous: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 400),
+  session_authority_unverified: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 401),
+  session_authority_mismatch: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 409),
+  local_credential_lost: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 401),
+  local_capability_invalid: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 500),
+  host_unavailable: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 503),
+  host_activation_failed: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 500),
+  doctor_unavailable: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 503),
+  admin_sign_in_invalid: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 502),
+  // `invalid_request` renders through the client default today (local encode/path faults); Gateway-answered
+  // envelopes carry the Gateway message verbatim and never read this sentence.
+  invalid_request: guidance(LOCAL_TRANSPORT_INCOMPLETE, "answer_with_gap", 400),
+  // Gateway canonical-route codes, sentences moved from their minting adapters; statuses moved from the
+  // `valid*Failure` decoder maps in `cli/internal/client/gateway_api.go` and `transport.go`.
+  invalid_json: guidance("The Gateway request body must be valid JSON.", "answer_with_gap", 400),
+  // Per-route variants name their route; the table holds the one stable guidance and the route's `allow`
+  // header stays the measured fact (decided with the operator 2026-10-13).
+  method_not_allowed: guidance("The HTTP method is not allowed for this Gateway route.", "answer_with_gap", 405),
+  request_target_too_large: guidance("The Gateway request target exceeds its bounded limit.", "reduce_request_size", 414),
+  route_not_found: guidance("The Gateway route is not present.", "answer_with_gap", 404),
+  artifact_unavailable: guidance("The Gateway artifact is unavailable.", "answer_with_gap", 503),
+  discovery_unavailable: guidance("The Gateway discovery manifest is unavailable.", "answer_with_gap", 503),
+  serialization_failed: guidance("The Gateway response could not be serialized.", "answer_with_gap", 500),
+  request_header_too_large: guidance("A consumed Gateway request header exceeds its bounded limit.", "answer_with_gap", 431),
+  request_work_context_missing: guidance("The Gateway command requires a Request work context.", "answer_with_gap", 400),
+  request_work_context_invalid: guidance("The Gateway Request work context encoding is invalid.", "answer_with_gap", 400),
+  request_work_context_refused: guidance("The Host-only discovery manifest takes no Request work context.", "answer_with_gap", 400),
+  // Moved from `gateway/src/operations/http-composition.ts` (`unauthorized`) and `command-runtime.ts:827`
+  // (`artifact_stale`); both travel with Gateway messages verbatim online, so these sentences are the
+  // owner fallback guidance. `unauthorized` re-authenticates through the session, hence its action.
+  unauthorized: guidance("Unauthorized.", "repair_or_adopt_session", 401),
+  artifact_stale: guidance("The requested contract artifact is not the current catalog artifact.", "answer_with_gap", 409),
+  // Host mint classifications. The CLI emits `invocation_authentication_unavailable` with the classification
+  // in its detail fact; rows without their own sentence share that code's moved sentence, while `next_action`
+  // is moved from `canonicalHostAuthenticationNextActions` (generated from `CEAL_HOST_AUTHENTICATION_POLICY`)
+  // and `retryable` from `hostAuthenticationFailureForCause` (`failure.nextAction == "retry"`). The three rows
+  // with their own sentences carry the retired policy remedies as Gateway-owned guidance. Statuses are the
+  // Gateway-owned mapping decided with the operator 2026-10-13. This covers every wire cause the maps at
+  // `host/invocation-authentication-command.ts:217-242` emit, through their policy classifications.
+  host_arguments_invalid: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 400),
+  host_configuration_invalid: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 500),
+  host_session_unavailable: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 401),
+  // Moved from the retired `CEAL_HOST_AUTHENTICATION_POLICY` remedy: the
+  // missing exact-turn fact names the fresh Host turn, not a reinstall.
+  host_context_unavailable: guidance("The Host has not activated an invocation context for this session yet. Wait for the Host turn hook to register the session, then retry this command.", "retry", 401, true),
+  host_invocation_context_stale: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "retry", 401, true),
+  host_invocation_context_expired: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "retry", 401, true),
+  host_source_refused: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 403),
+  host_registration_credential_refused: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "ask_admin", 403),
+  host_mint_gateway_unavailable: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "ask_admin", 503),
+  host_mint_gateway_rate_limited: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 429),
+  host_mint_gateway_refused: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 502),
+  host_mint_gateway_response_invalid: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 502),
+  // Moved from the retired `CEAL_HOST_AUTHENTICATION_POLICY` remedy: the
+  // producer-frame fault names the administrator repair step.
+  host_producer_frame_invalid: guidance("Ask an administrator to inspect and repair the producer frame, then start a fresh Host turn.", "ask_admin", 400),
+  // Moved from the retired `CEAL_HOST_AUTHENTICATION_POLICY` remedy: the
+  // sandboxed Relay socket names the run-alone retry.
+  host_relay_permission_denied: guidance("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.", "rerun_outside_agent_sandbox", 403),
+  host_relay_unavailable: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 503),
+  host_mint_transient_retryable: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "retry", 503, true),
+  host_mint_failed: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 500),
+  host_relay_failed: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 502),
+  host_refusal_invalid: guidance(HOST_AUTHENTICATION_UNAVAILABLE, "answer_with_gap", 500)
+});
+function cealFailureGuidanceForCode(code2) {
+  const entry = CEAL_FAILURE_GUIDANCE_TABLE[code2];
+  if (entry === void 0) throw new TypeError(`Failure guidance code is not guided: ${code2}.`);
+  return entry;
+}
+var FAILURE_GUIDANCE_ENTRY_KEYS = Object.freeze(["message", "next_action", "http_status", "retryable", "redaction_class"]);
-// packages/ceal-client-protocol/src/schema-literals.ts
-var CEAL_SCHEMA_LITERALS = [
-  "ceal.activation_transport.v1",
-  CEAL_OPERATION_ACCESS_SCHEMA_VERSION,
-  CEAL_OPERATION_CATALOG_SCHEMA_VERSION,
-  "ceal.client_refresh_request.v1",
-  "ceal.client_refresh_result.v1",
-  "ceal.client_revoke_request.v1",
-  "ceal.client_revoke_result.v1",
-  CEAL_COMMAND_REQUEST_SCHEMA_VERSION,
-  "ceal.device_enrollment_challenge.v1",
-  "ceal.device_enrollment_challenge_request.v1",
-  "ceal.device_enrollment_hpke_aad.v1",
-  "ceal.device_enrollment_hpke_info.v1",
-  "ceal.device_enrollment_poll.v1",
-  "ceal.device_enrollment_poll_result.v1",
-  "ceal.device_enrollment_proof.v1",
-  "ceal.device_enrollment_start.v1",
+// packages/ceal-client-protocol/src/client-wire-contract.ts
+var CEAL_CLIENT_WIRE_CONTRACT = Object.freeze(client_wire_contract_default);
+var CEAL_CLIENT_DOCTOR_SCHEMA_VERSION = CEAL_CLIENT_WIRE_CONTRACT.doctor.schema_version;
+var clientCommands = CEAL_CLIENT_WIRE_CONTRACT.client_commands;
+var CEAL_CLIENT_DOCTOR_COMMAND = Object.freeze([...clientCommands.doctor]);
+var CEAL_CLIENT_VERSION_COMMAND = Object.freeze([...clientCommands.version]);
+var CEAL_CLIENT_ACCESS_GROUP_LIST_COMMAND = Object.freeze([...clientCommands.access_group_list]);
+function deriveCealClientWireSchemaVersion(schema) {
+  if (!/^ceal\.[a-z][a-z0-9_]*$/u.test(schema.schema_name) || !schema.fields.includes("schema_version") || new Set(schema.fields).size !== schema.fields.length || schema.fields.some((field) => typeof field !== "string" || !/^[a-z][a-z0-9_]*$/u.test(field))) {
+    throw new TypeError("Client wire schema name or field set is invalid.");
+  }
+  const fields = schema.fields.filter((field) => field !== "schema_version").sort();
+  const hash8 = createHash("sha256").update(cealCanonicalJson(fields), "utf8").digest("hex").slice(0, 8);
+  return `${schema.schema_name}.v1.${hash8}`;
+}
+var CealClientWireContractMismatchError = class extends Error {
+  code = "contract_mismatch";
+  next_action = cealFailureGuidanceForCode("contract_mismatch").next_action;
+  constructor(expected, actual) {
+    super(`The peer wire contract ${actual} does not match this client contract ${expected}.`);
+    this.name = "CealClientWireContractMismatchError";
+  }
+};
+function requireCealClientWireSchemaVersion(value, expected) {
+  if (typeof value === "string" && value !== expected) throw new CealClientWireContractMismatchError(expected, value);
+}
+var commandResolution = CEAL_CLIENT_WIRE_CONTRACT.command_resolution;
+var commandResolutionAuthority = commandResolution.authority;
+var commandResolutionSemanticOptions = commandResolution.semantic_options;
+var CEAL_GATEWAY_COMMAND_RESOLUTION_SCHEMA_VERSION = deriveCealClientWireSchemaVersion(commandResolution);
+var CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES = CEAL_CLIENT_WIRE_CONTRACT.encoded_json_document.max_bytes;
+var artifact = CEAL_CLIENT_WIRE_CONTRACT.artifact_descriptor;
+var request = CEAL_CLIENT_WIRE_CONTRACT.command_request;
+var response = CEAL_CLIENT_WIRE_CONTRACT.command_response;
+var CEAL_OPERATION_CONTRACT_BUNDLE_SCHEMA_VERSION = deriveCealClientWireSchemaVersion({ schema_name: artifact.operation_contract_bundle_schema_name, fields: artifact.operation_contract_bundle_fields });
+var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_SCHEMA_VERSION = deriveCealClientWireSchemaVersion(artifact);
+var CEAL_VERIFIED_ARTIFACT_BINDING_SCHEMA_VERSION = deriveCealClientWireSchemaVersion({ schema_name: artifact.binding_schema_name, fields: artifact.binding_fields });
+var CEAL_VERIFIED_ARTIFACT_KIND = artifact.kind;
+var CEAL_VERIFIED_ARTIFACT_BINDING_KIND = artifact.binding_kind;
+var CEAL_VERIFIED_ARTIFACT_MEDIA_TYPE = artifact.media_type;
+var CEAL_VERIFIED_ARTIFACT_DIGEST_LENGTH = artifact.digest.length;
+var CEAL_VERIFIED_ARTIFACT_DIGEST_PATTERN = artifact.digest.pattern;
+var CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_LENGTH = artifact.catalog_revision.length;
+var CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_PATTERN = artifact.catalog_revision.pattern;
+var CEAL_VERIFIED_ARTIFACT_MAX_BYTES = CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES;
+var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_MAX_BYTES = artifact.envelope_max_bytes;
+var CEAL_COMMAND_REQUEST_SCHEMA_VERSION = deriveCealClientWireSchemaVersion(request);
+var CEAL_COMMAND_REQUEST_MAX_BYTES = request.absolute_transport_max_bytes;
+var CEAL_COMMAND_RESPONSE_BARE_DOCUMENT_MAX_BYTES = response.bare_document_max_bytes;
+var CEAL_COMMAND_RESPONSE_BARE_DOCUMENT_OPTIONAL_FIELDS = Object.freeze([...response.bare_document_optional_fields]);
+var CEAL_COMMAND_RESPONSE_DISCOVERY_COMMAND = response.discovery_command;
+var CEAL_COMMAND_RESPONSE_DISCOVERY_MANIFEST_SCHEMA_VERSION = deriveCealClientWireSchemaVersion({ schema_name: response.discovery_manifest_schema_name, fields: response.discovery_manifest_fields });
+var CEAL_COMMAND_RESPONSE_SCHEMA_VERSION = deriveCealClientWireSchemaVersion(response);
+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;
+var CEAL_RESOURCE_STREAM_REQUEST_SCHEMA_VERSION = deriveCealClientWireSchemaVersion({ schema_name: CEAL_CLIENT_WIRE_CONTRACT.resource_stream.request_schema_name, fields: CEAL_CLIENT_WIRE_CONTRACT.resource_stream.request_fields });
+var CEAL_RESOURCE_STREAM_REQUEST_FIELDS = Object.freeze([...CEAL_CLIENT_WIRE_CONTRACT.resource_stream.request_fields]);
+// packages/ceal-client-protocol/src/operation-withheld-cause.ts
+var CEAL_OPERATION_WITHHELD_CAUSES = vocabulary(["provider_permission", "access_level", "personal_authorization_required"]);
+// packages/ceal-client-protocol/src/operation-contract-types.ts
+var CEAL_JSON_SCHEMA_2020_12 = "https://json-schema.org/draft/2020-12/schema";
+var CEAL_OPERATION_DESCRIPTOR_SCHEMA_VERSION = "ceal.operation_descriptor.v1";
+var CEAL_OPERATION_ERROR_SCHEMA_VERSION = "ceal.operation_error.v1";
+var CEAL_ARTIFACT_STAGE_TERMINALS = vocabulary(["chunk_accepted", "artifact_ready", "idempotency_replayed"]);
+var CEAL_RETRY_AFTER_MAX_MS = 60 * 60 * 1e3;
+var CEAL_JSON_SCHEMA_TYPES = vocabulary(["object", "array", "string", "integer", "number", "boolean", "null"]);
+var OBSERVATION_POSTURES = vocabulary(["direct_readback", "approved_no_readback", "operator_mediated", "excluded"]);
+var EFFECT_DOMAINS = vocabulary(["none", "gateway_state", "provider", "external_world"]);
+var SAFETY_CLASSES = vocabulary(["routine", "sensitive", "high_impact"]);
+var IDEMPOTENCY_CLASSES = vocabulary(["idempotent", "conditionally_idempotent", "non_idempotent"]);
+var REVERSIBILITY_CLASSES = vocabulary(["none", "reversible", "compensatable", "irreversible"]);
+var COMPENSATION_OWNERS = vocabulary(["none", "connector", "operator"]);
+var CANCELLATION_BOUNDARIES = vocabulary(["before_admission", "before_handoff", "after_handoff_reconcile"]);
+var HANDOFF_CLASSES = vocabulary(["not_applicable", "submission", "effect"]);
+var AUTHORITATIVE_READBACK_CLASSES = vocabulary(["required", "unavailable"]);
+var PROVIDER_READBACK_CLASSES = vocabulary(["required", "not_available", "not_applicable"]);
+var RECONCILIATION_CLASSES = vocabulary(["none", "automatic", "operator"]);
+var NO_READBACK_APPROVAL_CLASSES = vocabulary(["not_applicable", "explicit", "operator"]);
+var REPLAY_PREREQUISITES = vocabulary(["never", "fresh_admission", "reconciled_non_application", "operator_approval"]);
+var UNKNOWN_OUTCOMES = vocabulary(["reconcile", "operator_action", "excluded"]);
+var RECOVERY_OWNERS = vocabulary(["gateway", "connector", "operator"]);
+var CEAL_OPERATION_ADMISSION_STATES = vocabulary(["proposed", "refused", "admitted"]);
+var CEAL_OPERATION_EXECUTION_STATES = vocabulary(["not_started", "started", "completed"]);
+var CEAL_OPERATION_PROVIDER_HANDOFF_STATES = vocabulary(["not_offered", "offered", "accepted", "rejected", "unknown"]);
+var CEAL_OPERATION_EFFECT_STATES = vocabulary(["none", "applied", "failed", "unknown", "compensated"]);
+var CEAL_OPERATION_OBSERVATION_STATES = vocabulary(["not_started", "not_required", "pending", "observed", "unavailable"]);
+var CEAL_OPERATION_RECOVERY_KINDS = vocabulary(["none", "reconcile", "compensate", "operator_action"]);
+var CEAL_OPERATION_RECOVERY_STATUSES = vocabulary(["not_started", "active", "completed"]);
+var CEAL_OPERATION_PROVIDER_READBACK_AVAILABILITY = vocabulary(["not_started", "not_applicable", "not_available", "pending", "available"]);
+var CEAL_OPERATION_OFFERED_HANDOFF_STATES = vocabulary(["accepted", "rejected", "unknown"]);
+var CEAL_OPERATION_RECEIPT_AUTHORITY_KEYS = Object.freeze(["instance_ref", "access_group_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]);
+var CEAL_OPERATION_APPROVAL_DISPOSITIONS = vocabulary([
+  "approval_not_required_by_policy",
+  "interactive_pending",
+  "interactive_granted",
+  "interactive_denied",
+  "interactive_expired",
+  "interactive_unavailable"
+]);
+// packages/ceal-client-protocol/src/operation-access-class.ts
+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_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", "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
+var SAFE_JSON_MIN_BYTES_PER_NODE = 4;
+function safeJsonNodeBudgetForBytes(maxBytes) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < SAFE_JSON_MIN_BYTES_PER_NODE) {
+    throw new RangeError(`safe-JSON byte cap is invalid: ${refusalFact("maxBytes", maxBytes, `at least ${SAFE_JSON_MIN_BYTES_PER_NODE} bytes`)}`);
+  }
+  return Math.floor(maxBytes / SAFE_JSON_MIN_BYTES_PER_NODE);
+}
+// packages/ceal-client-protocol/src/protocol-bounds.ts
+var CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES = 64 * 1024;
+var CEAL_PROTOCOL_RESPONSE_VALUE_MAX_NODES = safeJsonNodeBudgetForBytes(CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES);
+var OPERATION_SCHEMA_LITERAL_MAX_BYTES = CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES / 4;
+var CEAL_OPERATION_JSON_SCHEMA_BUDGET = Object.freeze({
+  max_depth: 8,
+  max_properties: 96,
+  max_string_length: OPERATION_SCHEMA_LITERAL_MAX_BYTES / 4,
+  max_alternatives: 8,
+  max_enum_values: 64,
+  max_literal_bytes: OPERATION_SCHEMA_LITERAL_MAX_BYTES,
+  /** @basis our_policy -- bounds explanatory schema prose carried in one catalog. */
+  max_description_characters: 1024,
+  /** @basis our_policy -- bounds regular-expression compilation input from one schema. */
+  max_pattern_characters: 256,
+  /** @basis our_policy -- bounds traversal work inside one already byte-bounded schema literal. */
+  max_literal_nodes: 512
+});
+// packages/ceal-client-protocol/src/operation-json-schema.ts
+var JSON_DESCRIPTION_CONTROL_CHARACTER = new RegExp("\\p{Cc}", "u");
+// packages/ceal-client-protocol/src/operation-contract-validation.ts
+var CEAL_OPERATION_AUTHORITY_POLICY_KEYS = Object.freeze(["access_group", "instance_binding", "target", "admission_recheck"]);
+var MAX_OPERATION_INPUT_RESOLVER_BINDINGS = 96;
+var CEAL_OPERATION_DESCRIPTOR_REQUIRED_ENVELOPE_KEYS = Object.freeze(["schema_version", "id", "input_contract", "result_contract", "policy"]);
+var CEAL_OPERATION_DESCRIPTOR_OPTIONAL_ENVELOPE_KEYS = Object.freeze(["input_resolution", "summary"]);
+// packages/ceal-client-protocol/src/operation-catalog.ts
+var CEAL_OPERATION_CATALOG_SCHEMA_VERSION = "ceal.catalog.v3";
+var CLIENT_AUDIENCES = Object.freeze(["ceal", "cealctl", "agent"]);
+var CLIENT_AUDIENCE_SET = new Set(CLIENT_AUDIENCES);
+// packages/ceal-client-protocol/src/schema-literals.ts
+var CEAL_SCHEMA_LITERALS = [
+  "ceal.activation_transport.v1",
+  CEAL_OPERATION_ACCESS_SCHEMA_VERSION,
+  CEAL_OPERATION_CATALOG_SCHEMA_VERSION,
+  "ceal.client_refresh_request.v1",
+  "ceal.client_refresh_result.v1",
+  "ceal.client_revoke_request.v1",
+  "ceal.client_revoke_result.v1",
+  CEAL_COMMAND_REQUEST_SCHEMA_VERSION,
+  "ceal.device_enrollment_challenge.v1",
+  "ceal.device_enrollment_challenge_request.v1",
+  "ceal.device_enrollment_hpke_aad.v1",
+  "ceal.device_enrollment_hpke_info.v1",
+  "ceal.device_enrollment_poll.v1",
+  "ceal.device_enrollment_poll_result.v1",
+  "ceal.device_enrollment_proof.v1",
+  "ceal.device_enrollment_start.v1",
   "ceal.device_enrollment_start_result.v1",
   "ceal.effect_approval.v1",
   "ceal.effect_approval_confirmation.v1",
@@ -836,12 +1083,12 @@ var CEAL_SCHEMA_LITERALS = [
   "ceal.enrollment_result.v1",
   "ceal.first_activation_causal_join.v1",
   "ceal.gateway_announcement_policy.v1",
-  "ceal.gateway_audit_call_detail.v1",
+  CEAL_GATEWAY_AUDIT_CALL_DETAIL_SCHEMA_VERSION,
   "ceal.gateway_audit_event.v1",
   "ceal.gateway_audit_readback.v1",
   "ceal.gateway_authorization_snapshot.v1",
   "ceal.gateway_cache_origin.v1",
-  "ceal.gateway_call_result.v1",
+  CEAL_GATEWAY_CALL_RESULT_SCHEMA_VERSION,
   CEAL_GATEWAY_COMMAND_RESOLUTION_SCHEMA_VERSION,
   "ceal.gateway_connector_route_failure.v1",
   "ceal.gateway_discovery.v1",
@@ -866,7 +1113,7 @@ var CEAL_SCHEMA_LITERALS = [
   "ceal.host_observation.v1",
   "ceal.host_registration_request.v1",
   "ceal.host_registration_result.v1",
-  "ceal.operation_descriptor.v1",
+  CEAL_OPERATION_DESCRIPTOR_SCHEMA_VERSION,
   "ceal.operation_error.v1",
   "ceal.operation_failure.v1",
   "ceal.operation_failure.compact.v1",
@@ -974,11 +1221,22 @@ var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_JSON_SCHEMA = Object.freeze({
 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"]);
+// packages/ceal-client-protocol/src/client-environment-generated.ts
+var CEAL_CLIENT_CONTEXT_OVERRIDE_ENVIRONMENTS = Object.freeze(["CEAL_GATEWAY_ORIGIN", "CEAL_GATEWAY_TRANSPORT_ORIGIN", "CEAL_ACCESS_TOKEN", "CEAL_CONTEXT_STORE_PATH"]);
+// packages/ceal-client-protocol/src/client-process-contract.ts
+var CEAL_CLIENT_VERSION_SCHEMA_SUFFIX = ".version.v1";
+var CEAL_CLIENT_VERSION_SCHEMA_VERSION = `ceal${CEAL_CLIENT_VERSION_SCHEMA_SUFFIX}`;
 // packages/ceal-client-protocol/src/bare-document.ts
 var REQUIRED_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_fields;
 var OPTIONAL_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_optional_fields;
+// packages/ceal-client-protocol/src/actor-kind.ts
+var CEAL_ACTOR_KINDS = vocabulary(["human", "bot", "app", "unknown"]);
 // 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"]);
@@ -991,6 +1249,8 @@ var CEAL_ACTIVITY_TIMESTAMP_BASES = vocabulary([
   "resource_created",
   "review_submitted",
   "comment_created",
+  "reaction_created",
+  "ceal_write_completed",
   "event_start",
   "all_day_start",
   "file_created",
@@ -1025,6 +1285,10 @@ var CEAL_ACTIVITY_EVENT_KINDS = vocabulary([
   "github.review.submitted",
   "github.issue_comment.created",
   "github.review_comment.created",
+  "github.reaction.created",
+  "github.reaction.deleted",
+  "github.pull_request.review_requested",
+  "github.pull_request.review_request_removed",
   "calendar.organized",
   "calendar.accepted_invite",
   "calendar.recorded",
@@ -1046,6 +1310,10 @@ var CEAL_ACTIVITY_EVENT_TIMESTAMP_BASIS_MAP = Object.freeze({
   "github.pull_request.opened": "resource_created",
   "github.issue.edited": "resource_modified",
   "github.pull_request.edited": "resource_modified",
+  "github.reaction.created": "reaction_created",
+  "github.reaction.deleted": "ceal_write_completed",
+  "github.pull_request.review_requested": "ceal_write_completed",
+  "github.pull_request.review_request_removed": "ceal_write_completed",
   "calendar.organized": "resource_created",
   "drive.file.created": "file_created",
   "drive.file.modified": "file_modified_by_me",
@@ -1062,12 +1330,14 @@ 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 },
   source_url: { required: false, timestamp: false },
   source: { required: true, timestamp: false },
   owner: { required: false, timestamp: false },
+  actor_kind: { required: false, timestamp: false },
   counterparts: { required: false, timestamp: false },
   attachments: { required: false, timestamp: false },
   created_at: { required: false, timestamp: true },
@@ -1075,9 +1345,18 @@ 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 },
+  modified_by_me_at: { required: false, timestamp: true },
   own_ceal_write: { required: false, timestamp: false },
   owned_by_me: { required: false, timestamp: false },
+  mime_type: { required: false, timestamp: false },
+  size_bytes: { required: false, timestamp: false },
+  version: { required: false, timestamp: false },
+  trashed: { required: false, timestamp: false },
   visibility: { required: false, timestamp: false },
+  archived: { required: false, timestamp: false },
+  tag: { required: false, timestamp: false },
+  labels: { required: false, timestamp: false },
+  labels_incomplete: { required: false, timestamp: false },
   start: { required: false, timestamp: false },
   end: { required: false, timestamp: false },
   status: { required: false, timestamp: false },
@@ -1150,18 +1429,29 @@ var CEAL_REFRESH_FAILURE_CODES = vocabulary([
   // 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"
+  CEAL_GATEWAY_STARTING_FAILURE_CODE
+]);
+var CEAL_CLIENT_REVOKE_FAILURE_CODES = vocabulary([
+  "refresh_invalid",
+  "refresh_expired",
+  "refresh_replayed",
+  "refresh_revoked"
 ]);
+var CEAL_PERSONAL_CLIENT_ACCESS_TOKEN_PREFIX = "ceal_personal_";
+var CEAL_PERSONAL_CLIENT_REFRESH_TOKEN_PREFIX = "ceal_refresh_";
+var PERSONAL_CLIENT_TOKEN_SUFFIX_PATTERN = "[A-Za-z0-9_-]{43}";
+var CEAL_PERSONAL_CLIENT_ACCESS_TOKEN = new RegExp(`^${CEAL_PERSONAL_CLIENT_ACCESS_TOKEN_PREFIX}${PERSONAL_CLIENT_TOKEN_SUFFIX_PATTERN}$`, "u");
+var CEAL_PERSONAL_CLIENT_REFRESH_TOKEN = new RegExp(`^${CEAL_PERSONAL_CLIENT_REFRESH_TOKEN_PREFIX}${PERSONAL_CLIENT_TOKEN_SUFFIX_PATTERN}$`, "u");
 // packages/ceal-client-protocol/src/request-validation-primitives.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 var DIGEST = /^[a-f0-9]{64}$/u;
 var CEAL_SHA256_DIGEST_PATTERN = DIGEST.source;
 function isCealDigest(value) {
   return typeof value === "string" && DIGEST.test(value);
 }
 function cealRequestSha256(value) {
-  return createHash("sha256").update(cealCanonicalJson(value), "utf8").digest("hex");
+  return createHash2("sha256").update(cealCanonicalJson(value), "utf8").digest("hex");
 }
 function operationRecord(value, message) {
   requireOperationRecord(value, message);
@@ -1177,40 +1467,71 @@ function requirePrefixedRef(value, prefix, message) {
 // packages/ceal-client-protocol/src/request-authority.ts
 var CEAL_REQUEST_SCHEMA_VERSION = "ceal.request.v1";
 var CEAL_REQUEST_ARTIFACT_OWNERS = vocabulary(["gateway", "host", "connector"]);
-var CEAL_REQUEST_HOST_BINDING_KEYS = vocabulary(["prompt_ref", "host_session_ref", "host_turn_ref", "host_source_ref"]);
+var CEAL_HOST_INVOCATION_IDENTITY_KEYS = vocabulary(["host_session_ref", "host_turn_ref", "host_source_ref"]);
 var CEAL_REQUEST_ARTIFACT_RETENTION_CLASSES = vocabulary(["request", "source", "result"]);
 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_KEYS = Object.freeze(["schema_version", "ceal_request_ref", "created_at", "authority"]);
+var CEAL_REQUEST_COMMON_PROPERTIES = Object.freeze({
+  schema_version: { type: "string", const: CEAL_REQUEST_SCHEMA_VERSION, maxLength: 32 },
+  ceal_request_ref: { type: "string", minLength: 1, maxLength: 128, pattern: "^ceal-request:[A-Za-z0-9][A-Za-z0-9._:-]{0,114}$" },
+  created_at: { type: "string", minLength: 1, maxLength: 64 },
+  authority: {
+    type: "object",
+    maxProperties: 5,
+    additionalProperties: false,
+    properties: {
+      instance_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+      access_group_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+      principal_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+      execution_subject_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+      authority_revision_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source }
+    },
+    required: ["instance_ref", "access_group_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]
+  }
+});
+var CEAL_REQUEST_HOST_PROPERTIES = Object.freeze({
+  prompt_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+  host_session_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+  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 }
+});
+var CEAL_REQUEST_CALLER_PROPERTIES = Object.freeze({
+  caller_call_group_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source, description: "Gateway-minted call-group identity for a non-Host caller." },
+  caller_call_input_sha256: { type: "string", minLength: 64, maxLength: 64, pattern: "^[a-f0-9]{64}$", description: "Commitment to the exact input for active non-Host identity-reuse checks; a migrated legacy call group commits to its legacy group key because the original input may no longer exist." }
+});
+var CEAL_REQUEST_OPTIONAL_PROPERTIES = Object.freeze({
+  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, including Host turns when the authenticated Host registration carries the device; absent for older records." }
+});
+var CEAL_REQUEST_HOST_REQUIRED_KEYS = Object.freeze([...CEAL_REQUEST_KEYS, ...CEAL_HOST_INVOCATION_IDENTITY_KEYS, "prompt_ref"]);
+var CEAL_REQUEST_CALLER_REQUIRED_KEYS = Object.freeze([...CEAL_REQUEST_KEYS, "caller_call_group_ref", "caller_call_input_sha256"]);
 var CEAL_REQUEST_JSON_SCHEMA = {
   type: "object",
-  maxProperties: 11,
+  description: "A Request has exactly one creation identity: the complete Host tuple and prompt reference, or a caller call-group identity. Caller Requests retain no prompt reference or prompt body.",
+  maxProperties: 13,
   additionalProperties: false,
   properties: {
-    schema_version: { type: "string", const: CEAL_REQUEST_SCHEMA_VERSION, maxLength: 32 },
-    ceal_request_ref: { type: "string", minLength: 1, maxLength: 128, pattern: "^ceal-request:[A-Za-z0-9][A-Za-z0-9._:-]{0,114}$" },
-    created_at: { type: "string", minLength: 1, maxLength: 64 },
-    authority: {
+    ...CEAL_REQUEST_COMMON_PROPERTIES,
+    ...CEAL_REQUEST_HOST_PROPERTIES,
+    ...CEAL_REQUEST_CALLER_PROPERTIES,
+    ...CEAL_REQUEST_OPTIONAL_PROPERTIES
+  },
+  required: CEAL_REQUEST_KEYS,
+  anyOf: [
+    {
       type: "object",
-      maxProperties: 5,
-      additionalProperties: false,
-      properties: {
-        instance_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
-        access_group_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
-        principal_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
-        execution_subject_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
-        authority_revision_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source }
-      },
-      required: ["instance_ref", "access_group_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]
+      required: CEAL_REQUEST_HOST_REQUIRED_KEYS,
+      properties: { ...CEAL_REQUEST_COMMON_PROPERTIES, ...CEAL_REQUEST_HOST_PROPERTIES, ...CEAL_REQUEST_OPTIONAL_PROPERTIES },
+      additionalProperties: false
     },
-    prompt_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
-    host_session_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
-    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." },
-    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
+    {
+      type: "object",
+      required: CEAL_REQUEST_CALLER_REQUIRED_KEYS,
+      properties: { ...CEAL_REQUEST_COMMON_PROPERTIES, ...CEAL_REQUEST_CALLER_PROPERTIES, ...CEAL_REQUEST_OPTIONAL_PROPERTIES },
+      additionalProperties: false
+    }
+  ]
 };
 // packages/ceal-client-protocol/src/request-operands.ts
@@ -1321,10 +1642,6 @@ var CEAL_REQUEST_RUN_BATCH_JSON_SCHEMA = {
 };
 // packages/ceal-client-protocol/src/host-observation.ts
-var CEAL_HOST_INPUT_KINDS = vocabulary(["human", "host_automatic"]);
-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_OBSERVATION_PRODUCER = /^[a-z][a-z0-9]{0,31}$/u;
 var HOST_OBSERVATION_DIGEST = /^[a-f0-9]{8,64}$/u;
@@ -1377,7 +1694,7 @@ function validateCealHostObservationDraft(value) {
   assertHostObservationValue(record5.value, record5.observation_kind);
 }
 var CEAL_REQUEST_MAX_OBSERVATION_VALUE_BYTES = 64 * 1024;
-var CEAL_HOST_OBSERVATION_KINDS = vocabulary(["prompt", "session", "turn", "model", "token", "cost", "timing"]);
+var CEAL_HOST_OBSERVATION_KINDS = vocabulary(["prompt", "session", "turn", "model", "token", "timing"]);
 function isCealHostPromptObservationValue(value) {
   return isOperationRecord(value) && Object.keys(value).length === 1 && isCealDigest(value.body_sha256);
 }
@@ -1500,17 +1817,128 @@ var CEAL_REQUEST_GRAPH_NODE_PREPARE_READINESS_JSON_SCHEMA = {
 };
 // packages/ceal-client-protocol/src/host-invocation-authentication.ts
-var CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA = "ceal.host_invocation_authentication_request.v1";
-var CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA = "ceal.host_invocation_authentication_result.v1";
-var CEAL_HOST_NONCE_ENCODED_CHARACTERS = 43;
-var CEAL_HOST_CLIENT_NONCE_PATTERN = new RegExp(`^[A-Za-z0-9_-]{${CEAL_HOST_NONCE_ENCODED_CHARACTERS}}$`, "u");
-var CEAL_HOST_CONTEXT_TOKEN_PATTERN = new RegExp(`^ceal_context_[A-Za-z0-9_-]{${CEAL_HOST_NONCE_ENCODED_CHARACTERS}}$`, "u");
-var CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_MAX_BYTES = new TextEncoder().encode(`${JSON.stringify({
-  schema_version: CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA,
-  context_token: `ceal_context_${"A".repeat(CEAL_HOST_NONCE_ENCODED_CHARACTERS)}`,
-  expires_at: (/* @__PURE__ */ new Date("+010000-01-01T00:00:00.000Z")).toISOString()
-})}
+var hostInvocationAuthenticationContract = CEAL_CLIENT_WIRE_CONTRACT.host_invocation_authentication;
+var CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA = deriveCealClientWireSchemaVersion({ schema_name: hostInvocationAuthenticationContract.request_schema_name, fields: hostInvocationAuthenticationContract.request_fields });
+var CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_FIELDS = Object.freeze([...hostInvocationAuthenticationContract.request_fields]);
+var CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA = deriveCealClientWireSchemaVersion({ schema_name: hostInvocationAuthenticationContract.result_schema_name, fields: hostInvocationAuthenticationContract.result_fields });
+var CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_FIELDS = Object.freeze([...hostInvocationAuthenticationContract.result_fields]);
+var CEAL_HOST_AUTHENTICATION_BUDGET_ENVIRONMENT = "CEAL_HOST_AUTHENTICATION_BUDGET_MS";
+var CEAL_HOST_AUTHENTICATION_BUDGET_PATTERN_SOURCE = "^(?:0|[1-9][0-9]{0,8})$";
+var CEAL_HOST_AUTHENTICATION_BUDGET_PATTERN = new RegExp(CEAL_HOST_AUTHENTICATION_BUDGET_PATTERN_SOURCE, "u");
+var CEAL_HOST_INVOCATION_CONTEXT_REQUEST_SCHEMA = "ceal.gateway_host_invocation_context_request.v2";
+var CEAL_HOST_INVOCATION_CONTEXT_REQUEST_MAX_BYTES = 16 * 1024;
+var CEAL_HOST_INVOCATION_HUMAN_MESSAGE_WINDOW_MAX_BYTES = 2 * 1024;
+var CEAL_HOST_INVOCATION_HUMAN_MESSAGE_WINDOW_MAX_MESSAGES = 32;
+var HOST_CONTEXT_EXPIRY_MAX_CHARS = 64;
+var CEAL_HOST_INVOCATION_CONTEXT_VISIBLE_OUTPUT_MAX_BYTES = CEAL_CANONICAL_HTTP_MAX_RESPONSE_BYTES;
+var CEAL_HOST_CONTEXT_TOKEN_PREFIX = "ceal_context_";
+function boundCealHostInvocationHumanMessageWindow(newestFirst, sourceTruncated = false) {
+  const messages = [];
+  let truncated = sourceTruncated || newestFirst.length > CEAL_HOST_INVOCATION_HUMAN_MESSAGE_WINDOW_MAX_MESSAGES;
+  for (const candidate of newestFirst.slice(0, CEAL_HOST_INVOCATION_HUMAN_MESSAGE_WINDOW_MAX_MESSAGES)) {
+    const next = [...messages, candidate];
+    if (new TextEncoder().encode(JSON.stringify(next)).byteLength > CEAL_HOST_INVOCATION_HUMAN_MESSAGE_WINDOW_MAX_BYTES) {
+      truncated = true;
+      break;
+    }
+    messages.push(Object.freeze({ host_turn_ref: candidate.host_turn_ref, host_input_ref: candidate.host_input_ref, text: candidate.text }));
+  }
+  return Object.freeze({ messages: Object.freeze(messages), truncated });
+}
+function decodeCealHostInvocationContextRequest(value) {
+  if (!isCealJsonRecord(value)) throw invalidInvocationContextRequest();
+  requireCealClientWireSchemaVersion(value.schema_version, CEAL_HOST_INVOCATION_CONTEXT_REQUEST_SCHEMA);
+  if (!hasInvocationContextRequestKeys(value)) throw invalidInvocationContextRequest();
+  const clientNonce = requireClientNonce(value.client_nonce);
+  const expiresAt = requireContextExpiration(value.context_expires_at);
+  const hostBinding = requireHostBinding(value.host_binding);
+  const messageWindow = requireHumanMessageWindow(value.human_message_window);
+  const lastRequestRef = optionalSafeReference(value.last_seen_request_ref);
+  const visibleOutputMaxBytes = optionalVisibleOutputBudget(value.visible_output_max_bytes);
+  return Object.freeze({
+    schema_version: CEAL_HOST_INVOCATION_CONTEXT_REQUEST_SCHEMA,
+    client_nonce: clientNonce,
+    context_expires_at: expiresAt,
+    host_binding: Object.freeze({ ...hostBinding }),
+    human_message_window: messageWindow,
+    ...lastRequestRef === void 0 ? {} : { last_seen_request_ref: lastRequestRef },
+    ...visibleOutputMaxBytes === void 0 ? {} : { visible_output_max_bytes: visibleOutputMaxBytes }
+  });
+}
+function hasInvocationContextRequestKeys(value) {
+  const required = ["schema_version", "client_nonce", "context_expires_at", "host_binding", "human_message_window"];
+  const optional = ["last_seen_request_ref", "visible_output_max_bytes"];
+  const optionalKeys = Object.keys(value).filter((key) => optional.includes(key));
+  return hasExactKeys(value, [...required, ...optionalKeys]) && required.every((key) => Object.hasOwn(value, key)) && value.schema_version === CEAL_HOST_INVOCATION_CONTEXT_REQUEST_SCHEMA;
+}
+function requireClientNonce(value) {
+  if (typeof value !== "string" || !CEAL_HOST_CLIENT_NONCE_PATTERN.test(value)) throw invalidInvocationContextRequest();
+  return value;
+}
+function requireContextExpiration(value) {
+  if (typeof value !== "string" || value.length > HOST_CONTEXT_EXPIRY_MAX_CHARS || !Number.isFinite(Date.parse(value))) throw invalidInvocationContextRequest();
+  return value;
+}
+function requireHostBinding(value) {
+  if (!isCealJsonRecord(value) || !exactOptionalKeys(value, ["host_source_ref", "host_session_ref", "host_turn_ref"], []) || !safeReference(value.host_source_ref) || !safeReference(value.host_session_ref) || !safeReference(value.host_turn_ref)) throw invalidInvocationContextRequest();
+  return { host_source_ref: value.host_source_ref, host_session_ref: value.host_session_ref, host_turn_ref: value.host_turn_ref };
+}
+function requireHumanMessageWindow(value) {
+  if (!isCealJsonRecord(value) || !exactOptionalKeys(value, ["messages", "truncated"], []) || !Array.isArray(value.messages) || value.messages.length > CEAL_HOST_INVOCATION_HUMAN_MESSAGE_WINDOW_MAX_MESSAGES || typeof value.truncated !== "boolean") throw invalidInvocationContextRequest();
+  const messages = value.messages.map(decodeHumanMessage);
+  const bytes = new TextEncoder().encode(JSON.stringify(messages)).byteLength;
+  if (bytes > CEAL_HOST_INVOCATION_HUMAN_MESSAGE_WINDOW_MAX_BYTES) throw invalidInvocationContextRequest();
+  return Object.freeze({ messages: Object.freeze(messages), truncated: value.truncated });
+}
+function decodeHumanMessage(candidate) {
+  if (!isCealJsonRecord(candidate) || !exactOptionalKeys(candidate, ["host_turn_ref", "host_input_ref", "text"], []) || !safeReference(candidate.host_turn_ref) || !safeReference(candidate.host_input_ref) || typeof candidate.text !== "string") throw invalidInvocationContextRequest();
+  return Object.freeze({ host_turn_ref: candidate.host_turn_ref, host_input_ref: candidate.host_input_ref, text: candidate.text });
+}
+function optionalSafeReference(value) {
+  if (value === void 0) return void 0;
+  if (!safeReference(value)) throw invalidInvocationContextRequest();
+  return value;
+}
+function safeReference(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+}
+function exactOptionalKeys(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 optionalVisibleOutputBudget(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > CEAL_HOST_INVOCATION_CONTEXT_VISIBLE_OUTPUT_MAX_BYTES) throw invalidInvocationContextRequest();
+  return value;
+}
+function invalidInvocationContextRequest() {
+  return new TypeError("The Host invocation context request is invalid.");
+}
+function deriveCealHostInvocationNonceContract(contract = CEAL_CLIENT_WIRE_CONTRACT) {
+  const clientNonce = contract.host_invocation_authentication.client_nonce;
+  return {
+    encoded_characters: clientNonce.encoded_characters,
+    client_nonce_pattern_source: `^[${clientNonce.character_class_source}]{${clientNonce.encoded_characters}}$`,
+    context_token_pattern_source: `^${CEAL_HOST_CONTEXT_TOKEN_PREFIX}[${clientNonce.character_class_source}]{${clientNonce.encoded_characters}}$`
+  };
+}
+var hostNonceContract = deriveCealHostInvocationNonceContract();
+var CEAL_HOST_NONCE_ENCODED_CHARACTERS = hostNonceContract.encoded_characters;
+var CEAL_HOST_CLIENT_NONCE_PATTERN = new RegExp(hostNonceContract.client_nonce_pattern_source, "u");
+var CEAL_HOST_CONTEXT_TOKEN_PATTERN = new RegExp(hostNonceContract.context_token_pattern_source, "u");
+var CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_MAX_BYTES = deriveCealHostInvocationAuthenticationResultMaxBytes();
+function deriveCealHostInvocationAuthenticationResultMaxBytes(contract = CEAL_CLIENT_WIRE_CONTRACT) {
+  const hostAuthentication = contract.host_invocation_authentication;
+  const values = {
+    schema_version: deriveCealClientWireSchemaVersion({ schema_name: hostAuthentication.result_schema_name, fields: hostAuthentication.result_fields }),
+    context_token: `${CEAL_HOST_CONTEXT_TOKEN_PREFIX}${"A".repeat(hostAuthentication.client_nonce.encoded_characters)}`,
+    expires_at: (/* @__PURE__ */ new Date("+010000-01-01T00:00:00.000Z")).toISOString()
+  };
+  const fields = hostAuthentication.result_fields;
+  if (fields.some((field) => !Object.hasOwn(values, field))) throw new TypeError("Host invocation result fields have no bounded sample value.");
+  return new TextEncoder().encode(`${JSON.stringify(Object.fromEntries(fields.map((field) => [field, values[field]])))}
 `).byteLength;
+}
 var CEAL_HOST_MINT_REQUEST_CONTEXT_REFUSAL_REASONS = vocabulary([
   "request_authority_unavailable",
   "request_missing",
@@ -1534,6 +1962,7 @@ var CEAL_HOST_AUTHENTICATION_CAUSES = vocabulary([
   "host_credential_refused",
   "gateway_unavailable",
   "gateway_rate_limited",
+  "contract_mismatch",
   "gateway_refused",
   "gateway_response_invalid",
   "producer_frame_invalid",
@@ -1548,19 +1977,23 @@ 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; run `ceal-host install` to repair the Host hook registration, then retry this command on a fresh Host turn" }),
-  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" }),
+  context_unavailable: Object.freeze({ classification: "host_context_unavailable", next_action: "retry" }),
+  context_replaced: Object.freeze({ classification: "host_invocation_context_stale", next_action: "retry" }),
+  // `no_binding` now means the producer has no real current Host session. The
+  // Host Relay never uses it for an uncreated Gateway Request; there is no
+  // useful retry until the consumer is running inside a Host session.
+  no_binding: Object.freeze({ classification: "host_session_unavailable", next_action: "answer_with_gap" }),
+  context_stale: Object.freeze({ classification: "host_invocation_context_stale", next_action: "retry" }),
+  context_expired: Object.freeze({ classification: "host_invocation_context_expired", next_action: "retry" }),
   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" }),
+  contract_mismatch: Object.freeze({ classification: "contract_mismatch", next_action: "upgrade_ceal_client" }),
   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" }),
+  producer_frame_invalid: Object.freeze({ classification: "host_producer_frame_invalid", next_action: "ask_admin" }),
+  relay_permission_denied: Object.freeze({ classification: "host_relay_permission_denied", next_action: "rerun_outside_agent_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" }),
@@ -1570,21 +2003,33 @@ var CEAL_HOST_AUTHENTICATION_POLICY = Object.freeze({
 function isCealHostAuthenticationCause(value) {
   return isVocabularyWord(CEAL_HOST_AUTHENTICATION_CAUSES, value);
 }
+function cealHostAuthenticationCauseForExchangeFailure(failure2) {
+  if (failure2 === "permission_denied") return "relay_permission_denied";
+  if (failure2 === "timed_out") return "transient_retryable";
+  return "relay_unavailable";
+}
 function decodeCealHostInvocationAuthenticationRequest(value) {
-  if (!isCealJsonRecord(value) || !exactKeys(value, ["schema_version", "client_nonce"]) || value.schema_version !== CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA || typeof value.client_nonce !== "string" || !CEAL_HOST_CLIENT_NONCE_PATTERN.test(value.client_nonce)) {
+  if (!isCealJsonRecord(value)) throw new TypeError("The Host invocation authentication request is invalid.");
+  requireCealClientWireSchemaVersion(value.schema_version, CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA);
+  if (!exactKeys(value, CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_FIELDS) || typeof value.client_nonce !== "string" || !CEAL_HOST_CLIENT_NONCE_PATTERN.test(value.client_nonce)) {
     throw new TypeError("The Host invocation authentication request is invalid.");
   }
   return Object.freeze({ schema_version: CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA, client_nonce: value.client_nonce });
 }
 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)) {
+  return decodeHostInvocationAuthenticationResult(value, CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_FIELDS, now);
+}
+function decodeHostInvocationAuthenticationResult(value, fields, now) {
+  if (!isCealJsonRecord(value)) throw new TypeError("The Host invocation authentication result is invalid.");
+  requireCealClientWireSchemaVersion(value.schema_version, CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA);
+  if (!exactKeys(value, fields) || 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.");
   }
   return Object.freeze({ schema_version: CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA, context_token: value.context_token, expires_at: value.expires_at });
 }
 function validFutureTimestamp(value, now) {
-  const timestamp4 = Date.parse(value);
-  return Number.isFinite(timestamp4) && new Date(timestamp4).toISOString() === value && timestamp4 > now.getTime();
+  const timestamp3 = Date.parse(value);
+  return Number.isFinite(timestamp3) && new Date(timestamp3).toISOString() === value && timestamp3 > now.getTime();
 }
 function exactKeys(value, expected) {
   const keys = Object.keys(value);
@@ -1598,9 +2043,6 @@ var CEAL_HOST_SERVICE_DIAGNOSTIC_EVENTS = vocabulary([
   "hook_invoked",
   "registration_written",
   "hook_failed",
-  "watcher_turn_observed",
-  "current_prompt_registered",
-  "current_prompt_registration_failed",
   "activation_recorded",
   "activation_failed",
   "watcher_scan_failed",
@@ -1623,6 +2065,9 @@ var CEAL_UNREAD_REASONS = vocabulary(["blocked", "unavailable", "too_large", "un
 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/discovery-manifest.ts
+var DISCOVERY_MANIFEST_KEYS = CEAL_CLIENT_WIRE_CONTRACT.command_response.discovery_manifest_fields;
 // packages/ceal-client-protocol/src/gateway-cache-origin-validation.ts
 var CEAL_MAX_CACHE_ORIGIN_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -1681,6 +2126,7 @@ var ADMIN_UNAVAILABLE_REASONS = vocabulary([
   "legacy",
   "invalid_observation",
   "redacted",
+  "organization_setting_disabled",
   "owner_unavailable",
   "unit_unknown",
   "retention_gap",
@@ -1710,15 +2156,13 @@ var ADMIN_APPROVAL_DISPOSITIONS = CEAL_OPERATION_APPROVAL_DISPOSITIONS;
 var ADMIN_APPROVAL_POSTURES = vocabulary([...ADMIN_APPROVAL_DISPOSITIONS, "not_applicable"]);
 var ADMIN_LINEAGE_NODE_KINDS = vocabulary(["source_read", "synthesis_preview", "approval", "effect", "readback"]);
-// packages/ceal-client-protocol/src/actor-kind.ts
-var CEAL_ACTOR_KINDS = vocabulary(["human", "bot", "app", "unknown"]);
 // packages/ceal-client-protocol/src/device-enrollment.ts
 var CEAL_DEVICE_ENROLLMENT_POLL_FAILURE_CODES = Object.freeze(["unsupported_feature", "recovery_required", "expired", "denied"]);
 var POLL_RESULT_KEYS = Object.freeze(["retry_after_ms", "schema_version", "status"]);
 // packages/ceal-client-protocol/src/personal-client-session.ts
 var REFRESH_FAILURE_CODES = new Set(CEAL_REFRESH_FAILURE_CODES);
+var REVOKE_FAILURE_CODES = new Set(CEAL_CLIENT_REVOKE_FAILURE_CODES);
 // packages/ceal-client-protocol/src/index.ts
 var MAX_REQUEST_BYTES = 32 * 1024;
@@ -1813,16 +2257,9 @@ function hostClientProbeRefusal(probe, subject) {
 import { performance } from "node:perf_hooks";
 // host/relay/src/producer-frame.ts
-var HOST_PRODUCER_FRAME_SCHEMA = "ceal.host_producer_frame.v1";
-var HOST_PRODUCER_MAX_JSON_BYTES = 262144;
 var HOST_PRODUCER_FRAME_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
-var SAFE_REF2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-var PRODUCERS = /* @__PURE__ */ new Set(["codex", "claude"]);
-var HOST_PRODUCER_FRAME_KINDS = ["session_started", "turn_started", "user_input", "turn_terminal", "producer_status"];
+var HOST_PRODUCER_FRAME_KINDS = ["session_started", "turn_started", "turn_terminal", "producer_status"];
 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",
@@ -1832,515 +2269,217 @@ var HOST_PRODUCER_FRAME_ERROR_CODES = [
   "invalid_producer_identity",
   "frame_too_large"
 ];
-var HostProducerFrameError = class extends Error {
-  code;
-  constructor(code2, message = code2) {
+// host/relay/src/host-producer-core.ts
+import { createHash as createHash3 } from "node:crypto";
+// host/secure-file.ts
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { dirname, win32 } from "node:path";
+import { fileURLToPath } from "node:url";
+var SecureFileCustodyError = class extends Error {
+  name = "SecureFileCustodyError";
+  reason;
+  constructor(reason, message) {
     super(message);
-    this.code = code2;
+    this.reason = reason;
+  }
+  get code() {
+    if (this.reason === "reparse_point") return "ELOOP";
+    if (this.reason === "not_found") return "ENOENT";
+    if (this.reason === "too_large") return "secure_file_too_large";
+    if (this.reason === "already_exists") return "EEXIST";
+    return this.reason === "not_private" ? "secure_file_not_private" : "secure_file_unavailable";
   }
 };
-function encodeHostProducerFrame(frame) {
-  validateFrame(frame);
-  const json = Buffer.from(JSON.stringify(frame), "utf8");
-  if (json.byteLength > HOST_PRODUCER_MAX_JSON_BYTES) throw new HostProducerFrameError("frame_too_large", `frame_too_large: ${refusalFact("frame_bytes", json.byteLength, `at most ${HOST_PRODUCER_MAX_JSON_BYTES}`)}`);
-  const result = Buffer.allocUnsafe(json.byteLength + HOST_PRODUCER_FRAME_LENGTH_BYTES);
-  result.writeUInt32BE(json.byteLength, 0);
-  json.copy(result, HOST_PRODUCER_FRAME_LENGTH_BYTES);
-  return result;
-}
-function decodeHostProducerFrame(input) {
-  if (input.byteLength < HOST_PRODUCER_FRAME_LENGTH_BYTES) throw new HostProducerFrameError("frame_truncated", `frame_truncated: ${refusalFact("frame_bytes", input.byteLength, `at least ${HOST_PRODUCER_FRAME_LENGTH_BYTES}`)}`);
-  const length = input.readUInt32BE(0);
-  if (length > HOST_PRODUCER_MAX_JSON_BYTES) throw new HostProducerFrameError("frame_too_large", `frame_too_large: ${refusalFact("declared_bytes", length, `at most ${HOST_PRODUCER_MAX_JSON_BYTES}`)}`);
-  if (length === 0) throw new HostProducerFrameError("invalid_frame_length");
-  if (input.byteLength !== length + HOST_PRODUCER_FRAME_LENGTH_BYTES) throw new HostProducerFrameError(input.byteLength < length + HOST_PRODUCER_FRAME_LENGTH_BYTES ? "frame_truncated" : "invalid_frame_length");
-  const bytes = input.subarray(HOST_PRODUCER_FRAME_LENGTH_BYTES);
-  const text = new TextDecoder("utf-8", { fatal: true });
-  let value;
+var WINDOWS_SECUREFS_REFUSAL_SCHEMA = "ceal.host_securefs_refusal.v1";
+var WINDOWS_SECUREFS_MAX_RANDOM_FILE_BYTES = 4096;
+var WINDOWS_SECUREFS_TIMEOUT_MS = 1e4;
+var WINDOWS_SECUREFS_DIAGNOSTIC_BYTES = 4096;
+function secureOpenFlags(flags, platform) {
+  if (platform === "win32") return flags;
+  const nofollow = constants.O_NOFOLLOW;
+  if (typeof nofollow === "number" && nofollow !== 0) return flags | nofollow;
+  throw new Error("Secure file reads require O_NOFOLLOW on this platform.");
+}
+async function openNoFollow(path, flags = constants.O_RDONLY, mode, platform = process.platform, _custody = {}) {
+  if (platform !== "win32") return await open(path, secureOpenFlags(flags, platform), mode);
+  return await openWindowsIdentityScreened(path, flags, mode);
+}
+async function openWindowsIdentityScreened(path, flags, mode) {
+  const handle = await open(path, flags, mode);
   try {
-    value = JSON.parse(text.decode(bytes));
+    const first = await handle.stat();
+    if (!first.isFile()) throw new SecureFileCustodyError("not_private", "The Windows Host file is not a regular file.");
+    await assertWindowsLinkFree(path, first);
+    await assertWindowsIdentityStable(handle, first, path);
+    return handle;
   } catch (error) {
-    if (error instanceof TypeError) throw new HostProducerFrameError("invalid_frame_encoding");
-    throw new HostProducerFrameError("frame_truncated");
+    await handle.close();
+    throw error;
   }
-  validateFrame(value);
-  return value;
 }
-function isHostSafeRef(value) {
-  return safeRef(value);
+async function assertWindowsLinkFree(path, first) {
+  const entry = await lstat(path);
+  if (entry.isSymbolicLink() || entry.dev !== first.dev || entry.ino !== first.ino) {
+    throw new SecureFileCustodyError("reparse_point", "The Windows Host file path resolves through a reparse point.");
+  }
+}
+async function assertWindowsIdentityStable(handle, first, path) {
+  const second = await handle.stat();
+  if (second.dev !== first.dev || second.ino !== first.ino || second.size !== first.size || second.mtimeMs !== first.mtimeMs) {
+    throw new SecureFileCustodyError("unavailable", "The Windows Host file changed while its identity was checked.");
+  }
+  const entry = await lstat(path);
+  if (entry.isSymbolicLink()) throw new SecureFileCustodyError("reparse_point", "The Windows Host file path resolves through a reparse point.");
+  if (entry.dev !== second.dev || entry.ino !== second.ino) throw new SecureFileCustodyError("unavailable", "The Windows Host file path no longer names the opened file.");
+}
+async function readPrivateFileWithSecurefs(path, maxBytes, custody = {}) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new TypeError("The securefs read bound must be a positive safe integer.");
+  const result = await runWindowsSecurefs(["internal", "securefs", "read-private-file", path, String(maxBytes)], maxBytes, custody);
+  if (result.exit_code === 0 && result.stderr.length === 0 && result.stdout.length <= maxBytes) return result.stdout;
+  if (result.stdout.length !== 0) throw new SecureFileCustodyError("unavailable", "The Windows Host securefs command returned bytes with a refusal.");
+  if (result.exit_code === 0) throw new SecureFileCustodyError("unavailable", "The Windows Host securefs command exceeded its output contract.");
+  throw securefsRefusal(result.stderr);
+}
+async function createRandomPrivateFileWithSecurefs(path, byteLength2, custody = {}) {
+  if (!Number.isSafeInteger(byteLength2) || byteLength2 < 1 || byteLength2 > WINDOWS_SECUREFS_MAX_RANDOM_FILE_BYTES) throw new TypeError(`The securefs random-file size must be between 1 and ${WINDOWS_SECUREFS_MAX_RANDOM_FILE_BYTES} bytes.`);
+  const result = await runWindowsSecurefs(["internal", "securefs", "create-random-private-file", path, String(byteLength2)], 0, custody);
+  if (result.exit_code === 0 && result.stdout.length === 0 && result.stderr.length === 0) return;
+  if (result.stdout.length !== 0) throw new SecureFileCustodyError("unavailable", "The Windows Host securefs command returned unexpected creation bytes.");
+  if (result.exit_code === 0) throw new SecureFileCustodyError("unavailable", "The Windows Host securefs command returned an invalid creation result.");
+  throw securefsRefusal(result.stderr);
+}
+async function runWindowsSecurefs(args, maxBytes, custody) {
+  if (custody.run_securefs_command !== void 0) return await custody.run_securefs_command(args);
+  const executable = custody.securefs_executable ?? resolveInstalledHostExecutable();
+  const processArgs = [...custody.securefs_args_prefix ?? [], ...args];
+  return await new Promise((resolve, reject) => {
+    execFile(executable, processArgs, { encoding: "buffer", timeout: WINDOWS_SECUREFS_TIMEOUT_MS, maxBuffer: maxBytes + WINDOWS_SECUREFS_DIAGNOSTIC_BYTES }, (error, stdout, stderr) => {
+      const exitCode = error === null ? 0 : typeof error.code === "number" ? error.code : null;
+      if (exitCode === null) {
+        reject(new SecureFileCustodyError("unavailable", "The installed Windows Host securefs command could not run."));
+        return;
+      }
+      resolve({ exit_code: exitCode, stdout: Buffer.from(stdout), stderr: Buffer.from(stderr) });
+    });
+  });
 }
-function validateFrame(value) {
-  if (!record(value)) throw new HostProducerFrameError("invalid_frame_shape");
-  if (value.schema_version !== HOST_PRODUCER_FRAME_SCHEMA) throw new HostProducerFrameError("unsupported_frame_schema", `unsupported_frame_schema: ${refusalFact("schema_version", value.schema_version, HOST_PRODUCER_FRAME_SCHEMA)}`);
-  if (!exactKeys2(value, ["schema_version", "producer_id", "producer_installation_ref", "producer_epoch", "sequence", "frame_kind", "occurred_at", "payload"])) throw new HostProducerFrameError("invalid_frame_shape");
-  if (!PRODUCERS.has(String(value.producer_id)) || !safeRef(value.producer_installation_ref)) throw new HostProducerFrameError("invalid_producer_identity");
-  if (!positive(value.producer_epoch) || !positive(value.sequence) || !hostProducerFrameKind(value.frame_kind) || !timestamp(value.occurred_at) || !record(value.payload)) throw new HostProducerFrameError("invalid_frame_shape");
-  validatePayload(value.frame_kind, value.payload);
+function securefsRefusal(stderr) {
+  let value;
+  try {
+    value = JSON.parse(stderr.toString("utf8"));
+  } catch {
+    return new SecureFileCustodyError("unavailable", "The Windows Host securefs command returned an unreadable refusal.");
+  }
+  if (!isRecord(value) || value.schema_version !== WINDOWS_SECUREFS_REFUSAL_SCHEMA || typeof value.code !== "string") return new SecureFileCustodyError("unavailable", "The Windows Host securefs command returned an unreadable refusal.");
+  if (value.code === "reparse_point") return new SecureFileCustodyError("reparse_point", "The Windows Host securefs file is a reparse point.");
+  if (value.code === "not_found") return new SecureFileCustodyError("not_found", "The Windows Host securefs file was not found.");
+  if (value.code === "too_large") return new SecureFileCustodyError("too_large", "The Windows Host securefs file exceeds its read bound.");
+  if (value.code === "already_exists") return new SecureFileCustodyError("already_exists", "The Windows Host securefs target already exists.");
+  if (value.code === "not_private") return new SecureFileCustodyError("not_private", "The Windows Host securefs file is not private to the current user.");
+  return new SecureFileCustodyError("unavailable", "The Windows Host securefs command refused the file read.");
 }
-function validatePayload(kind, value) {
-  const valid = kind === "session_started" ? validSession(value) : kind === "turn_started" ? validTurn(value) : kind === "user_input" ? validInput(value) : kind === "turn_terminal" ? validTerminal(value) : validStatus(value);
-  if (!valid) throw new HostProducerFrameError("invalid_frame_shape");
+function resolveInstalledHostExecutable() {
+  const privateRuntimeRoot = dirname(fileURLToPath(import.meta.url));
+  return win32.join(privateRuntimeRoot, "..", "..", "bin", "ceal-host.exe");
 }
-function validSession(value) {
-  return exactOptional(value, ["local_session_ref", "working_directory_ref"], ["model", "host_version", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.working_directory_ref) && optionalText(value.model, 256) && optionalText(value.host_version, 256) && validObservations(value.observations);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function validTurn(value) {
-  return exactOptional(value, ["local_session_ref", "local_turn_ref"], ["model", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && optionalText(value.model, 256) && validObservations(value.observations);
+function isOwnedBy(uid, expectedUid) {
+  return Number.isSafeInteger(uid) && Number.isSafeInteger(expectedUid) && uid === expectedUid;
 }
-function validInput(value) {
-  return exactOptional(value, ["local_session_ref", "local_turn_ref", "local_input_ref", "input_kind", "origin_input", "observations"], ["local_turn_aliases", "context_expires_at"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && safeRef(value.local_input_ref) && validInputObservations(value.observations) && isCealHostInputKind(value.input_kind) && typeof value.origin_input === "boolean" && validInputOptionals(value);
+function isSelfOwned(uid, platform = process.platform, _handle) {
+  if (platform === "win32" || typeof process.geteuid !== "function") return false;
+  return isOwnedBy(uid, process.geteuid());
 }
-function validInputObservations(value) {
-  return validObservations(value) && Array.isArray(value) && value.filter((item) => record(item) && item.observation_kind === "prompt").length === 1;
+function isPrivateFileMode(mode, platform = process.platform, _handle) {
+  if (platform === "win32") return false;
+  return (mode & 63) === 0;
 }
-function validInputOptionals(value) {
-  return optionalRefs(value.local_turn_aliases) && (value.context_expires_at === void 0 || timestamp(value.context_expires_at));
+// host/relay/src/host-producer-core.ts
+var HOST_TRANSCRIPT_CURSOR_REASONS = vocabulary(["transcript_replaced", "transcript_truncated", "transcript_rewritten", "transcript_malformed"]);
+function isHostTranscriptCursorReason(value) {
+  return typeof value === "string" && HOST_TRANSCRIPT_CURSOR_REASONS.some((reason) => reason === value);
 }
-function validTerminal(value) {
-  return exactOptional(value, ["local_session_ref", "local_turn_ref", "terminal_state"], ["abort_reason", "duration_ms", "time_to_first_token_ms", "usage", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && validTerminalDisposition(value.terminal_state, value.abort_reason) && optionalNonNegative(value.duration_ms) && optionalNonNegative(value.time_to_first_token_ms) && (value.usage === void 0 || jsonValue(value.usage)) && validObservations(value.observations);
+var TRANSCRIPT_MISSING_REASON = "transcript_missing";
+var TRANSCRIPT_SCAN_READ_ERROR_ERRNOS = ["EBADF", "EACCES", "EIO", "EMFILE", "ENFILE", "ENOENT", "ENOTDIR", "EPERM"];
+var HOST_INVOCATION_TRANSCRIPT_TAIL_MAX_BYTES = 1024 * 1024;
+async function readBoundedHostTranscriptTail(path, maximumBytes = HOST_INVOCATION_TRANSCRIPT_TAIL_MAX_BYTES) {
+  if (!Number.isSafeInteger(maximumBytes) || maximumBytes < 1 || maximumBytes > HOST_INVOCATION_TRANSCRIPT_TAIL_MAX_BYTES) throw new TypeError("Host transcript window byte bound is invalid.");
+  const handle = await openNoFollow(path);
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile() || !isSelfOwned(stats.uid)) throw new TypeError("Host transcript source is not an owner-owned regular file.");
+    const truncated = stats.size > maximumBytes;
+    const start = Math.max(0, stats.size - maximumBytes);
+    const bytes = await readTranscriptBytes(handle, start, stats.size - start);
+    return { bytes: truncated ? dropPartialLeadingTranscriptRecord(bytes) : bytes, truncated };
+  } finally {
+    await handle.close();
+  }
 }
-function validTerminalDisposition(state, reason) {
-  return (state === "completed" || state === "aborted") && (reason === void 0 || state === "aborted" && safeRef(reason));
+async function readTranscriptBytes(handle, start, length) {
+  const output = Buffer.alloc(Math.max(0, length));
+  let offset = 0;
+  while (offset < output.length) {
+    const { bytesRead } = await handle.read(output, offset, output.length - offset, start + offset);
+    if (bytesRead === 0) break;
+    offset += bytesRead;
+  }
+  return output.subarray(0, offset);
 }
-function validStatus(value) {
-  return exactOptional(value, ["status", "reason_code"], ["detail"]) && ["ready", "degraded", "stopping"].includes(String(value.status)) && safeRef(value.reason_code) && optionalText(value.detail, 4096);
+function dropPartialLeadingTranscriptRecord(bytes) {
+  if (bytes.length === 0) return bytes;
+  const newline = bytes.indexOf(10);
+  return newline < 0 ? Buffer.alloc(0) : bytes.subarray(newline + 1);
 }
-function optionalText(value, maxLength) {
-  return value === void 0 || typeof value === "string" && value.length > 0 && value.length <= maxLength;
+async function readRegisteredHostInvocationHumanMessageWindow(listRegistrations, identity, decodeLine) {
+  try {
+    const registration = (await listRegistrations()).find((candidate) => candidate.host_source_ref === identity.host_source_ref && candidate.host_session_ref === identity.host_session_ref && Date.parse(candidate.expires_at) > Date.now());
+    if (registration === void 0) throw new TypeError("context_unavailable");
+    return await readHostInvocationHumanMessageWindow(registration.transcript_path, (line) => decodeLine(line, registration));
+  } catch {
+    throw new TypeError("context_unavailable");
+  }
+}
+async function readHostInvocationHumanMessageWindow(path, decodeLine) {
+  const tail = await readBoundedHostTranscriptTail(path);
+  const lines = new TextDecoder("utf-8", { fatal: true }).decode(tail.bytes).split("\n");
+  const incompleteTail = lines.at(-1) !== "";
+  if (incompleteTail) lines.pop();
+  let truncated = tail.truncated || incompleteTail;
+  const newestFirst = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of lines.reverse()) {
+    if (line.length === 0) continue;
+    const message = decodeLine(line);
+    if (message === "malformed") {
+      truncated = true;
+      continue;
+    }
+    if (message === null || seen.has(message.host_input_ref)) continue;
+    seen.add(message.host_input_ref);
+    newestFirst.push(message);
+  }
+  return boundCealHostInvocationHumanMessageWindow(newestFirst, truncated);
 }
-function optionalNonNegative(value) {
-  return value === void 0 || typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-function optionalRefs(value) {
-  return value === void 0 || Array.isArray(value) && value.length <= 16 && value.every(safeRef);
-}
-function validObservations(value) {
-  if (value === void 0) return true;
-  if (!Array.isArray(value) || value.length > 32) return false;
-  return value.every((item) => {
-    try {
-      validateCealHostObservationDraft(item);
-      return true;
-    } catch {
-      return false;
-    }
-  });
-}
-function jsonValue(value, depth = 0) {
-  if (depth > 16) return false;
-  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
-  if (typeof value === "number") return Number.isFinite(value);
-  if (Array.isArray(value)) return value.length <= 256 && value.every((item) => jsonValue(item, depth + 1));
-  return record(value) && Object.keys(value).length <= 256 && Object.entries(value).every(([key, item]) => key.length > 0 && key.length <= 128 && jsonValue(item, depth + 1));
-}
-function record(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function safeRef(value) {
-  return typeof value === "string" && SAFE_REF2.test(value);
-}
-function positive(value) {
-  return Number.isSafeInteger(value) && Number(value) > 0;
-}
-function timestamp(value) {
-  return typeof value === "string" && Number.isFinite(Date.parse(value));
-}
-function hostProducerFrameKind(value) {
-  return isHostProducerFrameKind(value);
-}
-function exactKeys2(value, keys) {
-  return JSON.stringify(Object.keys(value).sort()) === JSON.stringify([...keys].sort());
-}
-function exactOptional(value, required, optional) {
-  const keys = Object.keys(value);
-  return required.every((key) => keys.includes(key)) && keys.every((key) => required.includes(key) || optional.includes(key));
-}
-// host/relay/src/host-producer-core.ts
-import { createHash as createHash2 } from "node:crypto";
-import { O_NOFOLLOW, O_RDONLY as O_RDONLY2 } from "node:constants";
-import { mkdir as mkdir2, open as open2, readFile, rename as rename2, writeFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
-// host/relay/src/relay-ipc.ts
-import { createConnection, createServer } from "node:net";
-// host/relay/src/durable-atomic-replacement.ts
-import { O_RDONLY } from "node:constants";
-import { lstat, mkdir, open, rename, unlink } from "node:fs/promises";
-import { dirname } from "node:path";
-var DEFAULT_PORT = {
-  platform: process.platform,
-  mkdir: (path, options) => mkdir(path, options),
-  lstat: (path) => lstat(path),
-  open_file: (path) => open(path, "wx", 384),
-  rename,
-  unlink,
-  open_directory: (path) => open(path, O_RDONLY),
-  unique_ref: () => `${process.pid}.${crypto.randomUUID()}`
-};
-async function durableAtomicReplace(target, data, port = DEFAULT_PORT) {
-  const parent = dirname(target);
-  await port.mkdir(parent, { recursive: true, mode: 448 });
-  const parentStats = await port.lstat(parent);
-  if (!parentStats.isDirectory() || parentStats.isSymbolicLink() || !ownerPrivate(parentStats, port.platform)) throw new TypeError(`Host Relay durable-state directory is unsafe: ${refusalFacts([{ name: "parent_stats", value: parentStats, expected: "an owner-private directory" }, { name: "platform", value: port.platform }])}.`);
-  const temporary = `${target}.${port.unique_ref()}.new`;
-  let staged;
-  const failures = [];
-  try {
-    staged = await port.open_file(temporary);
-    await staged.writeFile(data, typeof data === "string" ? { encoding: "utf8" } : void 0);
-    await staged.sync();
-    const closing = staged;
-    staged = void 0;
-    await closing.close();
-    await port.rename(temporary, target);
-    await syncParentDirectory(parent, port);
-  } catch (error) {
-    failures.push(error);
-  }
-  await closeStaged(staged, failures);
-  await removeTemporary(temporary, port, failures);
-  throwFailures(failures);
-}
-async function syncParentDirectory(path, port) {
-  if (port.platform === "win32") return;
-  const handle = await port.open_directory(path);
-  let failure2;
-  try {
-    await handle.sync();
-  } catch (error) {
-    if (!directorySyncUnsupported(error)) failure2 = error;
-  }
-  try {
-    await handle.close();
-  } catch (error) {
-    if (failure2 === void 0) failure2 = error;
-    else failure2 = new AggregateError([failure2, error], "Host Relay directory sync and close failed.");
-  }
-  if (failure2 !== void 0) throw failure2;
-}
-function ownerPrivate(stats, platform) {
-  if (platform === "win32") return true;
-  const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
-  return stats.uid === uid && (stats.mode & 63) === 0;
-}
-async function closeStaged(staged, failures) {
-  if (staged !== void 0) try {
-    await staged.close();
-  } catch (error) {
-    failures.push(error);
-  }
-}
-async function removeTemporary(path, port, failures) {
-  try {
-    await port.unlink(path);
-  } catch (error) {
-    if (errorCode2(error) !== "ENOENT") failures.push(error);
-  }
-}
-function throwFailures(failures) {
-  if (failures.length === 1) throw failures[0];
-  if (failures.length > 1) throw new AggregateError(failures, "Host Relay durable replacement and cleanup failed.");
-}
-function directorySyncUnsupported(error) {
-  return ["EINVAL", "ENOSYS", "ENOTSUP"].includes(errorCode2(error) ?? "");
-}
-function errorCode2(error) {
-  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : null;
-}
-// host/relay/src/relay-request-binding-store.ts
-var MAX_STATE_BYTES = 8 * 1024 * 1024;
-// host/relay/src/current-prompt-custody.ts
-var HOST_CURRENT_PROMPT_MAX_BYTES = 256 * 1024;
-// host/relay/src/relay-ipc.ts
-var HOST_RELAY_REQUEST_BINDING_KEYS = Object.freeze([
-  "schema_version",
-  "producer_id",
-  "producer_installation_ref",
-  "local_session_ref",
-  "local_turn_ref",
-  "local_turn_aliases",
-  "prompt_ref",
-  "request_ref",
-  "bound_at",
-  "host_source_ref",
-  "host_session_ref",
-  "host_turn_ref",
-  "host_input_ref"
-]);
-var HOST_RELAY_IPC_RESPONSE_SCHEMA = "ceal.host_relay_admission.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_RESULT_SCHEMA = "ceal.host_relay_current_prompt_result.v1";
-var HOST_RELAY_IPC_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
-var HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES = 4096;
-var HOST_RELAY_QUERY_RESPONSE_MAX_BYTES = 8192;
-var HOST_RELAY_INVOCATION_MINT_REFUSAL_REASONS = vocabulary([
-  "context_stale",
-  "context_expired",
-  "host_source_refused",
-  "host_credential_refused",
-  "gateway_unavailable",
-  "gateway_refused",
-  "gateway_response_invalid",
-  "gateway_rate_limited",
-  "producer_frame_invalid",
-  "deadline",
-  "cancelled",
-  "mint_failed",
-  "relay_failed",
-  "request_authority_unavailable",
-  "request_missing",
-  "authority_mismatch",
-  "host_source_mismatch",
-  "host_session_mismatch",
-  "host_turn_mismatch",
-  "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 HOST_RELAY_INVOCATION_MINT_OUTCOMES = vocabulary(["completed", "caller_cancelled", "deadline", "failed", "no_binding"]);
-var HOST_RELAY_EXCHANGE_FAILURES = vocabulary([
-  "permission_denied",
-  "socket_missing",
-  "connection_refused",
-  "closed_early",
-  "response_invalid",
-  "timed_out",
-  "cancelled",
-  "unavailable"
-]);
-var HostRelayIpcError = class extends Error {
-  code;
-  /** Set only when the client-side socket exchange itself failed. */
-  failure;
-  constructor(code2, message = code2, failure2) {
-    super(message);
-    this.code = code2;
-    this.failure = failure2;
-  }
-};
-function hostRelayExchangeFailure(error) {
-  return error instanceof HostRelayIpcError ? error.failure : void 0;
-}
-function socketErrorFailure(error) {
-  switch (errorCode3(error)) {
-    case "EACCES":
-    case "EPERM":
-      return "permission_denied";
-    case "ENOENT":
-      return "socket_missing";
-    case "ECONNREFUSED":
-      return "connection_refused";
-    default:
-      return "unavailable";
-  }
-}
-var HostRelayInvocationContextPort = class {
-  endpoint;
-  constructor(endpoint) {
-    this.endpoint = endpoint;
-  }
-  mintInvocationContext(input, signal) {
-    return queryHostRelayInvocationContext(this.endpoint, input, signal);
-  }
-};
-var HostRelayIpcAdmissionPort = class {
-  endpoint;
-  timeout_ms;
-  constructor(endpoint, timeoutMs = 5e3) {
-    this.endpoint = endpoint;
-    this.timeout_ms = timeoutMs;
-  }
-  async admit(frame) {
-    const response2 = await submitHostProducerFrame(this.endpoint, frame, this.timeout_ms);
-    if (!relayAdmissionCode(response2.code)) throw new HostRelayIpcError(response2.code);
-    return { code: response2.code, admitted_through_sequence: response2.admitted_through_sequence, delivered_through_sequence: response2.delivered_through_sequence };
-  }
-};
-var HostRelayCurrentPromptPort = class {
-  endpoint;
-  timeout_ms;
-  constructor(endpoint, timeoutMs = 5e3) {
-    this.endpoint = endpoint;
-    this.timeout_ms = timeoutMs;
-  }
-  async register(input) {
-    const request2 = { schema_version: HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA, ...input };
-    const response2 = await exchange(this.endpoint, encodeLengthPrefixed(request2), this.timeout_ms, decodeCurrentPromptResponseBuffer);
-    if (response2.status !== "registered") throw new HostRelayIpcError("relay_unavailable", response2.status);
-  }
-};
-function submitHostProducerFrame(endpoint, frame, timeoutMs = 5e3) {
-  return exchange(endpoint, encodeHostProducerFrame(frame), timeoutMs, decodeResponseBuffer);
-}
-function queryHostRelayInvocationContext(endpoint, query, signal) {
-  return exchange(endpoint, encodeInvocationContextQuery(query), void 0, decodeInvocationContextResponseBuffer, signal);
-}
-function exchange(endpoint, encoded, timeoutMs, decode, signal) {
-  return new Promise((resolve, reject) => {
-    const socket = createConnection(endpoint);
-    let buffer = Buffer.alloc(0);
-    let settled = false;
-    const aborted = () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC was cancelled.", "cancelled"));
-    const finish = (error, response2) => {
-      if (settled) return;
-      settled = true;
-      signal?.removeEventListener("abort", aborted);
-      socket.destroy();
-      if (error !== null) reject(error);
-      else if (response2 !== void 0) resolve(response2);
-    };
-    if (timeoutMs !== void 0) socket.setTimeout(timeoutMs, () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC timed out.", "timed_out")));
-    if (signal?.aborted === true) {
-      aborted();
-      return;
-    }
-    signal?.addEventListener("abort", aborted, { once: true });
-    socket.once("error", (error) => {
-      const failure2 = socketErrorFailure(error);
-      finish(new HostRelayIpcError("relay_unavailable", `Host Relay IPC is unavailable: ${failure2}.`, failure2));
-    });
-    socket.once("connect", () => socket.write(encoded));
-    socket.on("data", (chunk) => {
-      try {
-        buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
-        const decoded = decode(buffer);
-        if (decoded !== null) finish(null, decoded);
-      } catch (error) {
-        finish(new HostRelayIpcError("relay_unavailable", error instanceof Error ? error.message : "Host Relay IPC response is invalid.", "response_invalid"));
-      }
-    });
-    socket.once("end", () => {
-      if (!settled) finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC closed without a response.", "closed_early"));
-    });
-  });
-}
-function decodeHostRelayIpcResponse(input) {
-  if (input.length < HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response is truncated: ${refusalFact("response_bytes", input.byteLength, `at least ${HOST_RELAY_IPC_LENGTH_BYTES}`)}.`);
-  const length = input.readUInt32BE(0);
-  if (length === 0 || length > HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES || input.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response length is invalid: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `between 1 and ${HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES}` }, { name: "received_bytes", value: input.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
-  let value;
-  try {
-    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(HOST_RELAY_IPC_LENGTH_BYTES)));
-  } catch {
-    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC response is invalid.");
-  }
-  if (!validResponse(value)) throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC response shape is invalid.");
-  return value;
-}
-function relayAdmissionCode(value) {
-  return value === "admitted" || value === "already_admitted" || value === "producer_epoch_stale" || value === "sequence_gap" || value === "frame_identity_conflict" || value === "producer_queue_full" || value === "relay_queue_full" || value === "producer_already_connected" || value === "invalid_producer_identity";
-}
-function validResponse(value) {
-  return record2(value) && value.schema_version === HOST_RELAY_IPC_RESPONSE_SCHEMA && hostRelayIpcCode(value.code) && nonnegative(value.admitted_through_sequence) && nonnegative(value.delivered_through_sequence) && Object.keys(value).length === 4;
-}
-function hostRelayIpcCode(value) {
-  return typeof value === "string" && ["admitted", "already_admitted", "producer_epoch_stale", "sequence_gap", "frame_identity_conflict", "producer_queue_full", "relay_queue_full", "invalid_frame_encoding", "invalid_frame_length", "frame_truncated", "unsupported_frame_schema", "invalid_frame_shape", "invalid_producer_identity", "frame_too_large", "producer_already_connected", "relay_unavailable"].includes(value);
-}
-function nonnegative(value) {
-  return Number.isSafeInteger(value) && Number(value) >= 0;
-}
-function record2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function decodeResponseBuffer(buffer) {
-  if (buffer.length < HOST_RELAY_IPC_LENGTH_BYTES) return null;
-  const length = buffer.readUInt32BE(0);
-  if (length === 0 || length > HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response length is invalid: ${refusalFact("declared_bytes", length, `between 1 and ${HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES}`)}.`);
-  if (buffer.length < length + HOST_RELAY_IPC_LENGTH_BYTES) return null;
-  if (buffer.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC returned trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `the received message length minus ${HOST_RELAY_IPC_LENGTH_BYTES}` }, { name: "received_bytes", value: buffer.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
-  return decodeHostRelayIpcResponse(buffer);
-}
-function decodeInvocationContextResponseBuffer(buffer) {
-  const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_QUERY_RESPONSE_MAX_BYTES);
-  if (value === null) return null;
-  if (!validInvocationContextResponse(value)) throw new HostRelayIpcError("relay_unavailable", "Host Relay invocation context response is invalid.");
-  return value;
-}
-function decodeCurrentPromptResponseBuffer(buffer) {
-  const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES);
-  if (value === null) return null;
-  if (!record2(value) || !exactKeys3(value, ["schema_version", "status"]) || value.schema_version !== HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA || value.status !== "registered" && value.status !== "current_prompt_unavailable") throw new HostRelayIpcError("relay_unavailable");
-  return { schema_version: HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA, status: value.status };
-}
-function encodeInvocationContextQuery(query) {
-  const value = { schema_version: HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA, ...query };
-  if (!validInvocationContextQueryRequest(value)) throw new HostRelayIpcError("invalid_frame_shape");
-  return encodeLengthPrefixed(value);
-}
-function validInvocationContextQueryRequest(value) {
-  return validQueryIdentity(value, HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) && exactKeys3(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 record2(value) && value.schema_version === schema && (value.producer_id === "codex" || value.producer_id === "claude") && safeRef2(value.producer_installation_ref) && safeRef2(value.local_session_ref) && safeRef2(value.local_turn_ref);
-}
-function validVisibleOutputBudget(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= CEAL_CANONICAL_HTTP_MAX_RESPONSE_BYTES;
-}
-function validInvocationContextResponse(value) {
-  if (!record2(value) || value.schema_version !== HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA) return false;
-  if (value.status === "no_binding") return Object.keys(value).length === 2;
-  if (value.status === "refused") return Object.keys(value).length === 3 && isVocabularyWord(HOST_RELAY_INVOCATION_MINT_REFUSAL_REASONS, value.reason);
-  if (value.status !== "ready" || Object.keys(value).length !== 3) return false;
-  try {
-    decodeCealHostInvocationAuthenticationResult(value.result);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function decodeLengthPrefixedJson(input, maximum) {
-  if (input.length < HOST_RELAY_IPC_LENGTH_BYTES) return null;
-  const length = input.readUInt32BE(0);
-  if (length === 0 || length > maximum) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message length is invalid: ${refusalFact("declared_bytes", length, `between 1 and ${maximum}`)}.`);
-  if (input.length < length + HOST_RELAY_IPC_LENGTH_BYTES) return null;
-  if (input.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message has trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `the received message length minus ${HOST_RELAY_IPC_LENGTH_BYTES}` }, { name: "received_bytes", value: input.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
-  try {
-    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(HOST_RELAY_IPC_LENGTH_BYTES)));
-  } catch {
-    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC message is invalid.");
-  }
-}
-function encodeLengthPrefixed(value) {
-  const body = Buffer.from(JSON.stringify(value), "utf8");
-  const output = Buffer.allocUnsafe(body.length + HOST_RELAY_IPC_LENGTH_BYTES);
-  output.writeUInt32BE(body.length, 0);
-  body.copy(output, HOST_RELAY_IPC_LENGTH_BYTES);
-  return output;
-}
-function exactKeys3(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 safeRef2(value) {
-  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
-}
-function errorCode3(error) {
-  return record2(error) && typeof error.code === "string" ? error.code : null;
+function transcriptScanFailureKind(error, adapterFailureKind) {
+  if (transcriptErrorCode(error) === "ELOOP") return "symlink";
+  const adapter = adapterFailureKind(error);
+  if (adapter !== void 0) return adapter;
+  const code2 = transcriptErrorCode(error);
+  if (code2 === "EFBIG") return "size_budget";
+  if (code2 !== null && TRANSCRIPT_SCAN_READ_ERROR_ERRNOS.includes(code2)) return "read_error";
+  return "other";
 }
-// host/relay/src/host-producer-core.ts
-var HOST_TRANSCRIPT_CURSOR_REASONS = vocabulary(["transcript_replaced", "transcript_truncated", "transcript_rewritten", "transcript_malformed"]);
-function isHostTranscriptCursorReason(value) {
-  return typeof value === "string" && HOST_TRANSCRIPT_CURSOR_REASONS.some((reason) => reason === value);
+function transcriptErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
 }
-var TRANSCRIPT_MISSING_REASON = "transcript_missing";
 var HOST_TRANSCRIPT_READ_CHUNK_BYTES = 256 * 1024;
 async function readTranscriptCompleteChunk(handle, offset, size) {
   const available = Math.max(0, size - offset);
@@ -2385,10 +2524,10 @@ async function transcriptCursorBoundsReason(handle, cursor, size) {
   return null;
 }
 function transcriptSha256(value) {
-  return createHash2("sha256").update(value).digest("hex");
+  return createHash3("sha256").update(value).digest("hex");
 }
 function transcriptObjectSha256(value) {
-  return createHash2("sha256").update(JSON.stringify(value), "utf8").digest("hex");
+  return createHash3("sha256").update(JSON.stringify(value), "utf8").digest("hex");
 }
 function isTranscriptRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -2457,11 +2596,10 @@ var HostTranscriptWatcher = class {
   async openTranscript(registration, scan, handlers) {
     let handle;
     try {
-      handle = await open2(this.transcriptPathOf(registration), O_RDONLY2 | O_NOFOLLOW);
+      handle = await openNoFollow(this.transcriptPathOf(registration));
       return await scan(handle);
     } catch (error) {
       if (handle === void 0 && isMissingTranscriptError(error)) return handlers.missing();
-      if (hostRelayExchangeFailure(error) !== void 0) throw error;
       return handlers.failed(handle, error);
     } finally {
       await handle?.close();
@@ -2507,29 +2645,12 @@ var HostTranscriptWatcher = class {
     return transcriptCursorBoundsReason(handle, cursor, size);
   }
 };
-var HOST_PRODUCER_STATE_IDENTITY = {
-  codex: { file_name: "codex-producer-state.json", schema: "ceal.codex_producer_state.v1" },
-  claude: { file_name: "claude-producer-state.json", schema: "ceal.claude_producer_state.v1" }
-};
 var HostProducerDrainCore = class {
   host;
-  relay;
-  statePath;
-  stateSchema;
-  installationRef;
-  epoch;
   now;
   tail = Promise.resolve();
   constructor(host, runtime) {
-    if (!isHostSafeRef(runtime.producer_installation_ref)) throw host.fail("configuration", `${host.producer_label} producer installation identity is invalid.`);
-    const epoch = runtime.producer_epoch ?? 1;
-    if (!Number.isSafeInteger(epoch) || epoch <= 0) throw host.fail("configuration", `${host.producer_label} producer epoch is invalid.`);
     this.host = host;
-    this.relay = runtime.relay;
-    this.statePath = join2(host.outbox_directory, HOST_PRODUCER_STATE_IDENTITY[host.producer_id].file_name);
-    this.stateSchema = HOST_PRODUCER_STATE_IDENTITY[host.producer_id].schema;
-    this.installationRef = runtime.producer_installation_ref;
-    this.epoch = epoch;
     this.now = runtime.now ?? (() => /* @__PURE__ */ new Date());
   }
   drainOutbox() {
@@ -2539,156 +2660,681 @@ var HostProducerDrainCore = class {
   }
   async drainLocked() {
     const read = await this.host.listEnvelopes();
-    let admitted = 0;
+    let removed = 0;
     let expired = 0;
-    let retained = 0;
     for (const envelope of read.entries) {
-      const reserved = await this.hasReservation(this.host.submissionRefOf(envelope));
-      if (!reserved && Date.parse(this.host.expiresAtOf(envelope)) <= this.now().getTime()) {
-        await this.host.removeEnvelope(envelope);
-        expired += 1;
-        continue;
+      if (Date.parse(this.host.expiresAtOf(envelope)) <= this.now().getTime()) expired += 1;
+      else removed += 1;
+      await this.host.removeEnvelope(envelope);
+    }
+    return { removed, expired, malformed: read.malformed };
+  }
+};
+// host/relay/src/durable-atomic-replacement.ts
+import { lstat as lstat2, mkdir, open as open2, rename, unlink } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+// host/windows-rename-retry.ts
+import { setTimeout as setTimeout2 } from "node:timers/promises";
+var RETRY_WINDOW_MS = 1e4;
+var RETRY_START_DELAY_MS = 100;
+var RETRY_MAX_DELAY_MS = 2e3;
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["EBUSY", "EPERM", "EACCES"]);
+var WindowsRenameRetryError = class extends Error {
+  code = "rename_unavailable";
+  constructor(target, attempts, options = {}) {
+    super(`Windows did not permit renaming into place within the bounded retry window: ${target} (after ${attempts} attempts). Wait for the process holding the path to release it, then rerun the same install or update command.`, options);
+    this.name = "WindowsRenameRetryError";
+  }
+};
+function resolveRetrySchedule(tuning) {
+  return {
+    windowMs: tuning.windowMs ?? RETRY_WINDOW_MS,
+    startDelayMs: tuning.startDelayMs ?? RETRY_START_DELAY_MS,
+    maxDelayMs: tuning.maxDelayMs ?? RETRY_MAX_DELAY_MS,
+    sleep: tuning.sleep ?? ((ms) => setTimeout2(ms)),
+    now: tuning.now ?? (() => Date.now())
+  };
+}
+async function renameWithWindowsRetry(operation, tuning) {
+  const schedule = resolveRetrySchedule(tuning);
+  const deadline = schedule.now() + schedule.windowMs;
+  let delayMs = schedule.startDelayMs;
+  let attempts = 0;
+  for (; ; ) {
+    attempts += 1;
+    try {
+      await operation();
+      return;
+    } catch (error) {
+      if (tuning.platform !== "win32" || !isRetryableRenameError(error)) throw error;
+      await sleepWithinWindow(schedule, deadline, delayMs, () => new WindowsRenameRetryError(tuning.target, attempts, { cause: error }));
+      delayMs = Math.min(delayMs * 2, schedule.maxDelayMs);
+    }
+  }
+}
+async function sleepWithinWindow(schedule, deadline, delayMs, exhausted) {
+  if (schedule.now() >= deadline) throw exhausted();
+  await schedule.sleep(Math.min(delayMs, deadline - schedule.now()));
+  if (schedule.now() >= deadline) throw exhausted();
+}
+function isRetryableRenameError(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && RETRYABLE_CODES.has(error.code);
+}
+// host/relay/src/durable-atomic-replacement.ts
+var DEFAULT_PORT = {
+  platform: process.platform,
+  mkdir: (path, options) => mkdir(path, options),
+  lstat: (path) => lstat2(path),
+  open_file: (path) => open2(path, "wx", 384),
+  rename,
+  unlink,
+  open_directory: (path) => open2(path),
+  unique_ref: () => `${process.pid}.${crypto.randomUUID()}`
+};
+async function durableAtomicReplace(target, data, port = DEFAULT_PORT) {
+  const parent = dirname2(target);
+  await port.mkdir(parent, { recursive: true, mode: 448 });
+  const parentStats = await port.lstat(parent);
+  const expectedUid = typeof process.geteuid === "function" ? process.geteuid() : parentStats.uid;
+  const ownerPrivate = port.platform === "win32" || isOwnedBy(parentStats.uid, expectedUid) && isPrivateFileMode(parentStats.mode, port.platform);
+  if (!parentStats.isDirectory() || parentStats.isSymbolicLink() || !ownerPrivate) throw new TypeError(`Host Relay durable-state directory is unsafe: ${refusalFacts([{ name: "parent_stats", value: parentStats, expected: "an owner-private directory" }, { name: "platform", value: port.platform }])}.`);
+  const temporary = `${target}.${port.unique_ref()}.new`;
+  let staged;
+  const failures = [];
+  try {
+    staged = await port.open_file(temporary);
+    await staged.writeFile(data, typeof data === "string" ? { encoding: "utf8" } : void 0);
+    await staged.sync();
+    const closing = staged;
+    staged = void 0;
+    await closing.close();
+    await renameWithWindowsRetry(() => port.rename(temporary, target), { ...port.rename_retry, platform: port.platform, target });
+    await syncParentDirectory(parent, port);
+  } catch (error) {
+    failures.push(error);
+  }
+  await closeStaged(staged, failures);
+  await removeTemporary(temporary, port, failures);
+  throwFailures(failures);
+}
+async function syncParentDirectory(path, port) {
+  if (port.platform === "win32") return;
+  const handle = await port.open_directory(path);
+  let failure2;
+  try {
+    await handle.sync();
+  } catch (error) {
+    if (!directorySyncUnsupported(error)) failure2 = error;
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    if (failure2 === void 0) failure2 = error;
+    else failure2 = new AggregateError([failure2, error], "Host Relay directory sync and close failed.");
+  }
+  if (failure2 !== void 0) throw failure2;
+}
+async function closeStaged(staged, failures) {
+  if (staged !== void 0) try {
+    await staged.close();
+  } catch (error) {
+    failures.push(error);
+  }
+}
+async function removeTemporary(path, port, failures) {
+  try {
+    await port.unlink(path);
+  } catch (error) {
+    if (errorCode2(error) !== "ENOENT") failures.push(error);
+  }
+}
+function throwFailures(failures) {
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1) throw new AggregateError(failures, "Host Relay durable replacement and cleanup failed.");
+}
+function directorySyncUnsupported(error) {
+  return ["EINVAL", "ENOSYS", "ENOTSUP"].includes(errorCode2(error) ?? "");
+}
+function errorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : null;
+}
+// host/relay/src/relay-quarantine-store.ts
+var RELAY_QUARANTINE_MAX_BYTES = 16 * 1024 * 1024;
+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];
+// host/relay/src/relay-admission-store.ts
+var DEFAULT_LIMITS = { global_count: 8192, global_bytes: 64 * 1024 * 1024, producer_count: 4096, producer_bytes: 32 * 1024 * 1024 };
+var RETRY_SECONDS = [1, 2, 4, 8, 16, 32, 60];
+var MAX_RETRYABLE_ATTEMPTS = RETRY_SECONDS.length + 10;
+// host/relay/src/relay-ipc.ts
+import { createConnection, createServer } from "node:net";
+// host/relay/src/relay-pipe-handshake.ts
+import { createHmac, randomBytes } from "node:crypto";
+import { constants as constants2 } from "node:fs";
+import { link, unlink as unlink2 } from "node:fs/promises";
+import { dirname as dirname3, join as join2 } from "node:path";
+var RELAY_PIPE_HANDSHAKE_TIMEOUT_MS = 5e3;
+var RELAY_PIPE_KEY_BYTES = 32;
+var RELAY_PIPE_KEY_FILENAME = "relay-pipe.key";
+var RELAY_PIPE_NONCE_BYTES = 32;
+var RELAY_PIPE_NONCE_PATTERN = /^[A-Za-z0-9_-]{43}$/u;
+var RELAY_PIPE_HELLO_SCHEMA = "ceal.host_relay_pipe_hello.v1";
+var RELAY_PIPE_CHALLENGE_SCHEMA = "ceal.host_relay_pipe_challenge.v1";
+var RELAY_PIPE_RESPONSE_SCHEMA = "ceal.host_relay_pipe_response.v1";
+var RELAY_PIPE_FRAME_BYTES = Uint32Array.BYTES_PER_ELEMENT;
+var RELAY_PIPE_FRAME_MAX_BYTES = 1024;
+var RelayPipeHandshakeError = class extends Error {
+  name = "RelayPipeHandshakeError";
+  code;
+  constructor(code2, message) {
+    super(message);
+    this.code = code2;
+  }
+};
+function relayPipeStateRootForOutboxDir(outboxDir) {
+  return join2(dirname3(dirname3(dirname3(outboxDir))), "relay");
+}
+function relayPipeKeyPath(relayStateRoot) {
+  return join2(relayStateRoot, RELAY_PIPE_KEY_FILENAME);
+}
+async function loadRelayPipeKey(relayStateRoot, platform = process.platform, custody = {}) {
+  const path = relayPipeKeyPath(relayStateRoot);
+  if (platform === "win32") return await loadWindowsRelayPipeKey(path, custody);
+  const existing = await readRelayPipeKey(path, platform, custody);
+  if (existing !== null) return existing;
+  return await createPosixRelayPipeKey(path, platform, custody);
+}
+async function loadWindowsRelayPipeKey(path, custody) {
+  const existing = await readRelayPipeKey(path, "win32", custody);
+  if (existing !== null) return existing;
+  try {
+    await createRandomPrivateFileWithSecurefs(path, RELAY_PIPE_KEY_BYTES, custody);
+  } catch (error) {
+    if (errorCode3(error) === "EEXIST") return await readWinnerPipeKey(path, "win32", custody);
+    throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key is unavailable at ${path}; delete it and restart the Host Relay.`);
+  }
+  return await readWinnerPipeKey(path, "win32", custody);
+}
+async function createPosixRelayPipeKey(path, platform, custody) {
+  const key = randomBytes(RELAY_PIPE_KEY_BYTES);
+  const staging = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+  let handle;
+  try {
+    handle = await openNoFollow(staging, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL, 384);
+  } catch (error) {
+    if (errorCode3(error) !== "EEXIST") throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key is unavailable at ${path}.`);
+    return await readWinnerPipeKey(path, platform, custody);
+  }
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile() || !isSelfOwned(stats.uid) || !isPrivateFileMode(stats.mode)) throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key at ${path} is not a private regular file owned by the current user.`);
+    await handle.writeFile(key);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    await link(staging, path);
+  } catch (error) {
+    if (errorCode3(error) !== "EEXIST") throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key is unavailable at ${path}.`);
+    return await readWinnerPipeKey(path, platform, custody);
+  } finally {
+    await unlink2(staging).catch(() => void 0);
+  }
+  return Buffer.from(key);
+}
+async function readWinnerPipeKey(path, platform, custody) {
+  const winner = await readRelayPipeKey(path, platform, custody);
+  if (winner === null) throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key is unavailable at ${path}.`);
+  return winner;
+}
+async function readRelayPipeKey(path, platform, custody) {
+  if (platform === "win32") return await readWindowsRelayPipeKey(path, custody);
+  return await readPosixRelayPipeKey(path);
+}
+async function readWindowsRelayPipeKey(path, custody) {
+  let key;
+  try {
+    key = await readPrivateFileWithSecurefs(path, RELAY_PIPE_KEY_BYTES, custody);
+  } catch (error) {
+    if (errorCode3(error) === "ENOENT" || errorCode3(error) === "ELOOP") return null;
+    throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key is unavailable at ${path}; delete it and restart the Host Relay.`);
+  }
+  if (key.byteLength !== RELAY_PIPE_KEY_BYTES) throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key at ${path} has ${key.byteLength} bytes; want ${RELAY_PIPE_KEY_BYTES}. Delete the file and restart the Host Relay.`);
+  return Buffer.from(key);
+}
+async function readPosixRelayPipeKey(path) {
+  let handle;
+  try {
+    handle = await openNoFollow(path);
+  } catch (error) {
+    if (errorCode3(error) === "ENOENT" || errorCode3(error) === "ELOOP") return null;
+    throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key is unavailable at ${path}.`);
+  }
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile()) throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key at ${path} is not a regular file; delete it and restart the Host Relay.`);
+    if (!isSelfOwned(stats.uid) || !isPrivateFileMode(stats.mode)) throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key at ${path} is not a private file owned by the current user; delete it and restart the Host Relay.`);
+    if (stats.size !== RELAY_PIPE_KEY_BYTES) throw new RelayPipeHandshakeError("pipe_key_unavailable", `Host Relay pipe key at ${path} has ${stats.size} bytes; want ${RELAY_PIPE_KEY_BYTES}. Delete the file and restart the Host Relay.`);
+    return await handle.readFile();
+  } finally {
+    await handle.close();
+  }
+}
+function createPipeClientNonce() {
+  return randomBytes(RELAY_PIPE_NONCE_BYTES).toString("base64url");
+}
+function pipeProof(key, role, firstNonce, secondNonce) {
+  return createHmac("sha256", key).update(`${role}\0${firstNonce}\0${secondNonce}`, "utf8").digest("hex");
+}
+function createPipeServerProof(key, clientNonce, serverNonce) {
+  return pipeProof(key, "server", clientNonce, serverNonce);
+}
+function createPipeClientProof(key, serverNonce, clientNonce) {
+  return pipeProof(key, "client", serverNonce, clientNonce);
+}
+function encodePipeFrame(value) {
+  const body = Buffer.from(JSON.stringify(value), "utf8");
+  const output = Buffer.allocUnsafe(body.length + RELAY_PIPE_FRAME_BYTES);
+  output.writeUInt32BE(body.length, 0);
+  body.copy(output, RELAY_PIPE_FRAME_BYTES);
+  return output;
+}
+function decodePipeFrame(buffer) {
+  if (buffer.length < RELAY_PIPE_FRAME_BYTES) return null;
+  const length = buffer.readUInt32BE(0);
+  if (length === 0 || length > RELAY_PIPE_FRAME_MAX_BYTES) throw new RelayPipeHandshakeError("pipe_handshake_invalid", `Host Relay pipe handshake frame declares ${length} bytes; want between 1 and ${RELAY_PIPE_FRAME_MAX_BYTES}.`);
+  if (buffer.length < length + RELAY_PIPE_FRAME_BYTES) return null;
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(RELAY_PIPE_FRAME_BYTES, length + RELAY_PIPE_FRAME_BYTES)));
+  } catch {
+    throw new RelayPipeHandshakeError("pipe_handshake_invalid", "Host Relay pipe handshake frame is not JSON.");
+  }
+  return { value, rest: buffer.subarray(length + RELAY_PIPE_FRAME_BYTES) };
+}
+function validNonce(value) {
+  return typeof value === "string" && RELAY_PIPE_NONCE_PATTERN.test(value);
+}
+function writePipeFrame(socket, frame) {
+  if (socket.write(frame)) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    socket.once("drain", resolve);
+    socket.once("error", reject);
+    socket.once("close", () => reject(new RelayPipeHandshakeError("pipe_handshake_invalid", "Host Relay pipe handshake connection closed.")));
+  });
+}
+function readPipeFrames() {
+  let buffer = Buffer.alloc(0);
+  let pending = null;
+  const feed = (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    if (pending === null) return;
+    let frame;
+    try {
+      frame = decodePipeFrame(buffer);
+    } catch (error) {
+      const waiting2 = pending;
+      pending = null;
+      waiting2.reject(error instanceof Error ? error : new RelayPipeHandshakeError("pipe_handshake_invalid", "Host Relay pipe handshake frame is invalid."));
+      return;
+    }
+    if (frame === null) return;
+    buffer = frame.rest;
+    const waiting = pending;
+    pending = null;
+    waiting.resolve({ value: frame.value, rest: Buffer.alloc(0) });
+  };
+  const waiter = {
+    wait: () => new Promise((resolve, reject) => {
+      let frame;
+      try {
+        frame = decodePipeFrame(buffer);
+      } catch (error) {
+        reject(error instanceof Error ? error : new RelayPipeHandshakeError("pipe_handshake_invalid", "Host Relay pipe handshake frame is invalid."));
+        return;
+      }
+      if (frame !== null) {
+        buffer = frame.rest;
+        resolve({ value: frame.value, rest: Buffer.alloc(0) });
+        return;
+      }
+      pending = { resolve, reject };
+    }),
+    cancel: (error) => {
+      if (pending !== null) {
+        const waiting = pending;
+        pending = null;
+        waiting.reject(error);
       }
-      const frames = await this.reserve(envelope);
-      let complete = true;
-      for (const frame of frames) {
-        const outcome = await this.relay.admit(frame);
-        if (outcome.code !== "admitted" && outcome.code !== "already_admitted") {
-          complete = false;
-          break;
+    }
+  };
+  return { waiter, feed, remainder: () => buffer };
+}
+function attachHandshakeReader(socket, waiter, feed) {
+  const onData = (chunk) => feed(Buffer.from(chunk));
+  const onError = (error) => waiter.cancel(error);
+  const onClose = () => waiter.cancel(new RelayPipeHandshakeError("pipe_handshake_invalid", "Host Relay pipe handshake connection closed."));
+  socket.on("data", onData);
+  socket.once("error", onError);
+  socket.once("close", onClose);
+  return () => {
+    socket.removeListener("data", onData);
+    socket.removeListener("error", onError);
+    socket.removeListener("close", onClose);
+  };
+}
+function handshakeTimeout(timeoutMs) {
+  let timer;
+  const done = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new RelayPipeHandshakeError("pipe_handshake_timeout", `Host Relay pipe handshake stalled past ${timeoutMs} ms; dropping the connection.`)), timeoutMs);
+    timer.unref?.();
+  });
+  return { done, clear: () => clearTimeout(timer) };
+}
+async function conductPipeClientHandshake(socket, key, timeoutMs = RELAY_PIPE_HANDSHAKE_TIMEOUT_MS) {
+  const bound = handshakeTimeout(timeoutMs);
+  const { waiter, feed } = readPipeFrames();
+  const detach = attachHandshakeReader(socket, waiter, feed);
+  try {
+    const clientNonce = createPipeClientNonce();
+    await Promise.race([writePipeFrame(socket, encodePipeFrame({ schema_version: RELAY_PIPE_HELLO_SCHEMA, client_nonce: clientNonce })), bound.done]);
+    const challenge = await Promise.race([waiter.wait(), bound.done]);
+    if (!isRecord2(challenge.value) || challenge.value.schema_version !== RELAY_PIPE_CHALLENGE_SCHEMA || !validNonce(challenge.value.server_nonce) || typeof challenge.value.server_proof !== "string") {
+      throw new RelayPipeHandshakeError("pipe_server_unproven", "Host Relay pipe server proof is invalid; aborting before sending any request.");
+    }
+    const serverNonce = challenge.value.server_nonce;
+    const expected = createPipeServerProof(key, clientNonce, serverNonce);
+    if (!timingSafeEqualHex(expected, challenge.value.server_proof)) {
+      throw new RelayPipeHandshakeError("pipe_server_unproven", "Host Relay pipe server proof failed; aborting before sending any request.");
+    }
+    const clientProof = createPipeClientProof(key, serverNonce, clientNonce);
+    await Promise.race([writePipeFrame(socket, encodePipeFrame({ schema_version: RELAY_PIPE_RESPONSE_SCHEMA, client_proof: clientProof })), bound.done]);
+  } finally {
+    bound.clear();
+    detach();
+  }
+}
+function timingSafeEqualHex(left, right) {
+  if (left.length !== right.length) return false;
+  let diff = 0;
+  for (let index = 0; index < left.length; index += 1) diff |= left.charCodeAt(index) ^ right.charCodeAt(index);
+  return diff === 0;
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function errorCode3(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : null;
+}
+// host/relay/src/relay-ipc.ts
+var HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA = "ceal.host_relay_invocation_context_query.v2";
+var HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA = "ceal.host_relay_invocation_context_result.v2";
+var HOST_RELAY_IPC_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
+var HOST_RELAY_QUERY_RESPONSE_MAX_BYTES = 8192;
+var HOST_RELAY_EXCHANGE_FAILURES = vocabulary([
+  "permission_denied",
+  "socket_missing",
+  "connection_refused",
+  "closed_early",
+  "response_invalid",
+  "timed_out",
+  "cancelled",
+  "unavailable"
+]);
+var HostRelayIpcError = class extends Error {
+  code;
+  /** Set only when the client-side socket exchange itself failed. */
+  failure;
+  constructor(code2, message = code2, failure2) {
+    super(message);
+    this.code = code2;
+    this.failure = failure2;
+  }
+};
+function hostRelayExchangeFailure(error) {
+  return error instanceof HostRelayIpcError ? error.failure : void 0;
+}
+function socketErrorFailure(error) {
+  switch (errorCode4(error)) {
+    case "EACCES":
+    case "EPERM":
+      return "permission_denied";
+    case "ENOENT":
+      return "socket_missing";
+    case "ECONNREFUSED":
+      return "connection_refused";
+    default:
+      return "unavailable";
+  }
+}
+var HostRelayInvocationContextPort = class {
+  endpoint;
+  pipe_key;
+  timeout_ms;
+  constructor(endpoint, pipeKey, timeoutMs = 5e3) {
+    this.endpoint = endpoint;
+    this.pipe_key = pipeKey;
+    this.timeout_ms = timeoutMs;
+  }
+  mintInvocationContext(input, signal) {
+    return queryHostRelayInvocationContext(this.endpoint, input, this.timeout_ms, signal, this.pipe_key);
+  }
+};
+function queryHostRelayInvocationContext(endpoint, query, timeoutMs, signal, pipeKey) {
+  return exchange(endpoint, encodeInvocationContextQuery(query), timeoutMs, decodeInvocationContextResponseBuffer, signal, pipeKey);
+}
+function exchange(endpoint, encoded, timeoutMs, decode, signal, pipeKey) {
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(endpoint);
+    let buffer = Buffer.alloc(0);
+    let settled = false;
+    const aborted = () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC was cancelled.", "cancelled"));
+    const finish = (error, response2) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", aborted);
+      socket.destroy();
+      if (error !== null) reject(error);
+      else if (response2 !== void 0) resolve(response2);
+    };
+    if (timeoutMs !== void 0) socket.setTimeout(timeoutMs, () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC timed out.", "timed_out")));
+    if (signal?.aborted === true) {
+      aborted();
+      return;
+    }
+    signal?.addEventListener("abort", aborted, { once: true });
+    socket.once("error", (error) => {
+      const failure2 = socketErrorFailure(error);
+      finish(new HostRelayIpcError("relay_unavailable", `Host Relay IPC is unavailable: ${failure2}.`, failure2));
+    });
+    socket.once("connect", () => {
+      void beginExchange();
+    });
+    async function beginExchange() {
+      try {
+        if (process.platform === "win32") {
+          if (pipeKey === void 0) throw new HostRelayIpcError("relay_unavailable", "Host Relay pipe key is unavailable; refusing to send any request.");
+          await conductPipeClientHandshake(socket, pipeKey, RELAY_PIPE_HANDSHAKE_TIMEOUT_MS);
         }
+      } catch (error) {
+        finish(error instanceof HostRelayIpcError ? error : new HostRelayIpcError("relay_unavailable", error instanceof Error ? error.message : "Host Relay pipe handshake failed.", "closed_early"));
+        return;
       }
-      if (!complete) {
-        retained += 1;
-        break;
-      }
-      await this.host.removeEnvelope(envelope);
-      await this.release(this.host.submissionRefOf(envelope));
-      admitted += 1;
-    }
-    return { admitted, retained: retained + Math.max(0, read.entries.length - admitted - expired - retained), expired, malformed: read.malformed };
-  }
-  async hasReservation(submissionRef2) {
-    return (await this.readState()).pending[submissionRef2] !== void 0;
-  }
-  async reserve(envelope) {
-    const state = await this.readState();
-    const submissionRef2 = this.host.submissionRefOf(envelope);
-    const existing = state.pending[submissionRef2];
-    if (existing !== void 0) return existing;
-    const drafts = await this.host.mapEnvelope(envelope);
-    const frames = drafts.map((draft, offset) => ({
-      schema_version: "ceal.host_producer_frame.v1",
-      producer_id: this.host.producer_id,
-      producer_installation_ref: this.installationRef,
-      producer_epoch: this.epoch,
-      sequence: state.next_sequence + offset,
-      frame_kind: draft.frame_kind,
-      occurred_at: this.host.createdAtOf(envelope),
-      payload: draft.payload
-    }));
-    await this.writeState({ ...state, next_sequence: state.next_sequence + frames.length, pending: { ...state.pending, [submissionRef2]: frames } });
-    return frames;
-  }
-  async release(submissionRef2) {
-    const state = await this.readState();
-    if (state.pending[submissionRef2] === void 0) return;
-    const pending = { ...state.pending };
-    delete pending[submissionRef2];
-    await this.writeState({ ...state, pending });
-  }
-  async readState() {
-    try {
-      const value = JSON.parse(await readFile(this.statePath, "utf8"));
-      return this.decodeState(value);
-    } catch (error) {
-      if (errorCode4(error) !== "ENOENT") throw error;
-      return { schema_version: this.stateSchema, producer_installation_ref: this.installationRef, producer_epoch: this.epoch, next_sequence: 1, pending: {} };
+      if (settled) return;
+      socket.once("error", (error) => {
+        const failure2 = socketErrorFailure(error);
+        finish(new HostRelayIpcError("relay_unavailable", `Host Relay IPC is unavailable: ${failure2}.`, failure2));
+      });
+      socket.on("data", (chunk) => {
+        try {
+          buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+          const decoded = decode(buffer);
+          if (decoded !== null) finish(null, decoded);
+        } catch (error) {
+          finish(new HostRelayIpcError("relay_unavailable", error instanceof Error ? error.message : "Host Relay IPC response is invalid.", "response_invalid"));
+        }
+      });
+      socket.once("end", () => {
+        if (!settled) finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC closed without a response.", "closed_early"));
+      });
+      socket.write(encoded);
     }
+  });
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function decodeInvocationContextResponseBuffer(buffer) {
+  const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_QUERY_RESPONSE_MAX_BYTES);
+  if (value === null) return null;
+  if (!validInvocationContextResponse(value)) throw new HostRelayIpcError("relay_unavailable", "Host Relay invocation context response is invalid.");
+  return value;
+}
+function encodeInvocationContextQuery(query) {
+  const value = { schema_version: HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA, ...query };
+  if (!validInvocationContextQueryRequest(value)) throw new HostRelayIpcError("invalid_frame_shape");
+  return encodeLengthPrefixed(value);
+}
+function validInvocationContextQueryRequest(value) {
+  if (!validQueryEnvelope(value)) return false;
+  try {
+    decodeCealHostInvocationContextRequest({
+      schema_version: CEAL_HOST_INVOCATION_CONTEXT_REQUEST_SCHEMA,
+      client_nonce: value.client_nonce,
+      context_expires_at: value.context_expires_at,
+      host_binding: value.host_binding,
+      human_message_window: value.human_message_window,
+      ...value.visible_output_max_bytes === void 0 ? {} : { visible_output_max_bytes: value.visible_output_max_bytes }
+    });
+    return true;
+  } catch {
+    return false;
   }
-  async writeState(state) {
-    await mkdir2(this.host.outbox_directory, { recursive: true, mode: 448 });
-    const temporary = `${this.statePath}.${process.pid}.new`;
-    await writeFile(temporary, JSON.stringify(state), { mode: 384 });
-    await rename2(temporary, this.statePath);
-  }
-  decodeState(value) {
-    const label = this.host.producer_label;
-    const fail = (code2, message) => this.host.fail(code2, message);
-    if (!isDrainStateHeader(value, this.stateSchema, this.installationRef)) {
-      throw fail("storage", `${label} producer state header is malformed or belongs to another installation (${refusalFacts([
-        { name: "schema_version", value: isTranscriptRecord(value) ? value.schema_version : void 0, expected: this.stateSchema },
-        { name: "producer_installation_ref", value: isTranscriptRecord(value) ? value.producer_installation_ref : void 0, expected: this.installationRef }
-      ])}).`);
-    }
-    if (Number(value.producer_epoch) > this.epoch) throw fail("storage", `${label} producer state epoch is ahead of this installation (${refusalFact("producer_epoch", value.producer_epoch, `at most ${this.epoch}`)}).`);
-    const pending = {};
-    const storedEpoch = Number(value.producer_epoch);
-    for (const [submissionRef2, frames] of Object.entries(value.pending)) {
-      if (!isHostSafeRef(submissionRef2) || !Array.isArray(frames) || frames.length === 0) throw fail("storage", `${label} producer pending reservation is malformed.`);
-      pending[submissionRef2] = frames.map((frame) => this.decodeStoredFrame(frame, storedEpoch));
-    }
-    return { schema_version: this.stateSchema, producer_installation_ref: this.installationRef, producer_epoch: this.epoch, next_sequence: Number(value.next_sequence), pending };
-  }
-  decodeStoredFrame(value, storedEpoch) {
-    const label = this.host.producer_label;
-    const json = Buffer.from(JSON.stringify(value), "utf8");
-    const encoded = Buffer.allocUnsafe(json.length + 4);
-    encoded.writeUInt32BE(json.length, 0);
-    json.copy(encoded, 4);
-    const frame = decodeHostProducerFrame(encoded);
-    if (frame.producer_id !== this.host.producer_id || frame.producer_installation_ref !== this.installationRef || frame.producer_epoch > storedEpoch) throw this.host.fail("storage", `${label} producer pending frame identity is malformed (${refusalFacts([
-      { name: "producer_id", value: frame.producer_id, expected: this.host.producer_id },
-      { name: "producer_installation_ref", value: frame.producer_installation_ref, expected: this.installationRef },
-      { name: "producer_epoch", value: frame.producer_epoch, expected: `at most ${storedEpoch}` }
-    ])}).`);
-    return frame;
+}
+function validQueryEnvelope(value) {
+  if (!validQueryIdentity(value, HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) || !exactKeys2(value, ["schema_version", "producer_id", "producer_installation_ref", "client_nonce", "context_expires_at", "host_binding", "human_message_window"], ["visible_output_max_bytes"])) return false;
+  return typeof value.client_nonce === "string" && CEAL_HOST_CLIENT_NONCE_PATTERN.test(value.client_nonce) && typeof value.context_expires_at === "string" && (value.visible_output_max_bytes === void 0 || validVisibleOutputBudget(value.visible_output_max_bytes));
+}
+function validQueryIdentity(value, schema) {
+  return record(value) && value.schema_version === schema && (value.producer_id === "codex" || value.producer_id === "claude") && safeRef(value.producer_installation_ref);
+}
+function validVisibleOutputBudget(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= CEAL_CANONICAL_HTTP_MAX_RESPONSE_BYTES;
+}
+function validInvocationContextResponse(value) {
+  if (!record(value) || value.schema_version !== HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA) return false;
+  return value.status === "refused" ? validInvocationContextRefusal(value) : validReadyInvocationContext(value);
+}
+function validInvocationContextRefusal(value) {
+  return exactKeys2(value, ["schema_version", "status", "reason"]) && isCealHostAuthenticationCause(value.reason) && value.reason !== "no_binding";
+}
+function validReadyInvocationContext(value) {
+  if (value.status !== "ready" || !exactKeys2(value, ["schema_version", "status", "request_ref", "result"]) || !safeRef(value.request_ref) || !value.request_ref.startsWith("ceal-request:") || !record(value.result)) return false;
+  const result = value.result;
+  return exactKeys2(result, ["schema_version", "context_token", "expires_at"]) && result.schema_version === CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA && typeof result.context_token === "string" && CEAL_HOST_CONTEXT_TOKEN_PATTERN.test(result.context_token) && typeof result.expires_at === "string" && Number.isFinite(Date.parse(result.expires_at));
+}
+function decodeLengthPrefixedJson(input, maximum) {
+  if (input.length < HOST_RELAY_IPC_LENGTH_BYTES) return null;
+  const length = input.readUInt32BE(0);
+  if (length === 0 || length > maximum) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message length is invalid: ${refusalFact("declared_bytes", length, `between 1 and ${maximum}`)}.`);
+  if (input.length < length + HOST_RELAY_IPC_LENGTH_BYTES) return null;
+  if (input.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message has trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `the received message length minus ${HOST_RELAY_IPC_LENGTH_BYTES}` }, { name: "received_bytes", value: input.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(HOST_RELAY_IPC_LENGTH_BYTES)));
+  } catch {
+    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC message is invalid.");
   }
-};
-function isDrainStateHeader(value, schema, installationRef) {
-  return isTranscriptRecord(value) && value.schema_version === schema && value.producer_installation_ref === installationRef && Number.isSafeInteger(value.producer_epoch) && Number(value.producer_epoch) > 0 && Number.isSafeInteger(value.next_sequence) && Number(value.next_sequence) > 0 && isTranscriptRecord(value.pending);
+}
+function encodeLengthPrefixed(value) {
+  const body = Buffer.from(JSON.stringify(value), "utf8");
+  const output = Buffer.allocUnsafe(body.length + HOST_RELAY_IPC_LENGTH_BYTES);
+  output.writeUInt32BE(body.length, 0);
+  body.copy(output, HOST_RELAY_IPC_LENGTH_BYTES);
+  return output;
+}
+function exactKeys2(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 safeRef(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
 }
 function errorCode4(error) {
-  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : null;
+  return record(error) && typeof error.code === "string" ? error.code : null;
 }
-// host/relay/src/relay-quarantine-store.ts
-var RELAY_QUARANTINE_MAX_BYTES = 16 * 1024 * 1024;
-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];
-// host/relay/src/relay-admission-store.ts
-var DEFAULT_LIMITS = { global_count: 8192, global_bytes: 64 * 1024 * 1024, producer_count: 4096, producer_bytes: 32 * 1024 * 1024 };
-var RETRY_SECONDS = [1, 2, 4, 8, 16, 32, 60];
-var MAX_RETRYABLE_ATTEMPTS = RETRY_SECONDS.length + 10;
 // host/service-log.ts
-function writeHostServiceDiagnostic(producer_id, event, failure_kind) {
+import { copyFile, mkdir as mkdir2, stat, truncate, appendFile } from "node:fs/promises";
+import { dirname as dirname4, isAbsolute, posix, win32 as win322 } 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 {
-    process.stderr.write(`${JSON.stringify({ schema_version: CEAL_HOST_SERVICE_DIAGNOSTIC_SCHEMA, producer_id, event, ...event === "watcher_scan_failed" && failure_kind !== void 0 ? { failure_kind } : {} })}
-`);
+    (sink ?? defaultHostServiceDiagnosticSink)(line);
   } catch {
   }
 }
+function defaultHostServiceDiagnosticSink(line) {
+  writeHostServiceLogLine(line);
+  process.stderr.write(line);
+}
 var HOST_SERVICE_LOG_MAX_BYTES = 1024 * 1024;
+function writeHostServiceLogLine(line, environment = process.env) {
+  if (process.platform !== "win32") return;
+  const path = environment[HOST_SERVICE_LOG_ENVIRONMENT];
+  if (path === void 0 || !win322.isAbsolute(path) || win322.normalize(path) !== path) return;
+  void appendHostServiceLogLine(path, line).catch(() => void 0);
+}
+async function appendHostServiceLogLine(path, line) {
+  if (!isAbsolute(path)) return;
+  await ensureHostServiceLogDirectory(path);
+  await appendFile(path, line);
+}
 var HOST_SERVICE_LOG_TAIL_BYTES = 64 * 1024;
+var hostServiceLogDirectories = /* @__PURE__ */ new Map();
+function ensureHostServiceLogDirectory(path) {
+  const directory = dirname4(path);
+  const existing = hostServiceLogDirectories.get(directory);
+  if (existing !== void 0) return existing;
+  const pending = mkdir2(directory, { recursive: true, mode: 448 }).then(() => void 0).catch((error) => {
+    hostServiceLogDirectories.delete(directory);
+    throw error;
+  });
+  hostServiceLogDirectories.set(directory, pending);
+  return pending;
+}
+// host/local-capability-descriptor.ts
+var HOST_LOCAL_CAPABILITY_AUTHENTICATION_SUFFIX = Object.freeze(["authenticate", "--client-nonce"]);
 // host/invocation-authentication-command.ts
-var HOST_INVOCATION_AUTHENTICATION_COMMAND_PREFIX = ["authenticate", "--client-nonce"];
-var HOST_AUTHENTICATION_BUDGET_ENVIRONMENT = "CEAL_HOST_AUTHENTICATION_BUDGET_MS";
 var HOST_CONTEXT_ACTIVATION_WAIT_MAX_MS = 2e4;
 var CLAUDE_CONTEXT_ACTIVATION_WAIT_MAX_MS = HOST_CONTEXT_ACTIVATION_WAIT_MAX_MS;
 var HOST_AUTHENTICATION_COMPLETION_RESERVE_MS = 5e3;
 var INVOCATION_CONTEXT_POLL_INTERVAL_MS = 250;
 var REFUSAL_REASON_PATTERN = /^[a-z][a-z0-9_]{0,63}$/u;
 function installedHostInvocationAuthenticationCommandOptions(config, contextBudgetMs, maxContextWaitMs) {
-  const port = new HostRelayInvocationContextPort(config.relay_endpoint);
+  let pipeKey;
+  const loadPipeKey = () => {
+    if (pipeKey === void 0) pipeKey = process.platform === "win32" ? loadRelayPipeKey(relayPipeStateRootForOutboxDir(config.outbox_dir)) : Promise.resolve(void 0);
+    return pipeKey;
+  };
   return {
     host_source_ref: config.host_source_ref,
     outbox_dir: config.outbox_dir,
     producer_installation_ref: config.producer_installation_ref,
     context_activation_wait_ms: boundedContextActivationWait(contextBudgetMs, config.ipc_timeout_ms, maxContextWaitMs),
-    mint_invocation_context: (input) => port.mintInvocationContext({ ...input, producer_id: input.producer_id })
+    mint_invocation_context: async (input) => new HostRelayInvocationContextPort(config.relay_endpoint, await loadPipeKey(), config.ipc_timeout_ms).mintInvocationContext(input)
   };
 }
 async function runHostInvocationAuthenticationCommand(descriptor, args, options) {
@@ -2709,26 +3355,31 @@ function authenticationRefusalReason(error) {
   return isCealHostAuthenticationCause(message) ? message : "host_refusal_invalid";
 }
 async function authenticateHostInvocation(descriptor, input, options) {
-  if (input.length !== HOST_INVOCATION_AUTHENTICATION_COMMAND_PREFIX.length + 1 || input[0] !== HOST_INVOCATION_AUTHENTICATION_COMMAND_PREFIX[0] || input[1] !== HOST_INVOCATION_AUTHENTICATION_COMMAND_PREFIX[1]) throw new TypeError("invalid_arguments");
+  if (input.length !== HOST_LOCAL_CAPABILITY_AUTHENTICATION_SUFFIX.length + 1 || input[0] !== HOST_LOCAL_CAPABILITY_AUTHENTICATION_SUFFIX[0] || input[1] !== HOST_LOCAL_CAPABILITY_AUTHENTICATION_SUFFIX[1]) throw new TypeError("invalid_arguments");
   const request2 = decodeCealHostInvocationAuthenticationRequest({ schema_version: CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA, client_nonce: input[2] });
   const config = validateOptions(options);
   const now = config.now ?? (() => /* @__PURE__ */ new Date());
   const { store, current } = await currentInvocation(descriptor, config, now);
   if (config.mint_invocation_context === void 0) throw new TypeError("relay_failed");
-  const query = {
-    producer_id: descriptor.producer_id,
-    producer_installation_ref: config.producer_installation_ref,
-    local_session_ref: current.identity.host_session_ref,
-    local_turn_ref: current.identity.host_turn_ref,
-    client_nonce: request2.client_nonce,
-    ...await visibleOutputBudget(descriptor)
-  };
+  const query = await invocationMintQuery(descriptor, store, current, request2.client_nonce, config);
   const response2 = await mintedResult(config.mint_invocation_context, query);
   const completedAt = now();
   const rechecked = await store.readInvocationContext(current.identity.host_source_ref, current.identity.host_session_ref, completedAt);
   if (rechecked === null || !sameTurn(current, rechecked)) throw new TypeError("context_replaced");
   return decodeCealHostInvocationAuthenticationResult(response2.result, completedAt);
 }
+async function invocationMintQuery(descriptor, store, current, clientNonce, options) {
+  const readWindow = options.read_human_message_window?.(current.identity) ?? descriptor.read_human_message_window?.({ store, identity: current.identity }) ?? Promise.resolve({ messages: [], truncated: false });
+  return {
+    producer_id: descriptor.producer_id,
+    producer_installation_ref: options.producer_installation_ref,
+    client_nonce: clientNonce,
+    context_expires_at: current.expires_at,
+    host_binding: { ...current.identity },
+    human_message_window: await readWindow,
+    ...await visibleOutputBudget(descriptor)
+  };
+}
 async function visibleOutputBudget(descriptor) {
   const bytes = await descriptor.resolve_visible_output_max_bytes?.();
   return bytes === void 0 ? {} : { visible_output_max_bytes: bytes };
@@ -2738,30 +3389,15 @@ async function mintedResult(mint, query) {
   try {
     response2 = await mint(query);
   } catch (error) {
-    throw new TypeError(exchangeFailureCause(hostRelayExchangeFailure(error) ?? "unavailable"));
+    throw new TypeError(cealHostAuthenticationCauseForExchangeFailure(hostRelayExchangeFailure(error) ?? "unavailable"));
   }
-  if (response2.status === "refused") throw new TypeError(mintRefusalCause(response2.reason));
-  if (response2.status !== "ready") throw new TypeError("no_binding");
+  if (response2.status !== "ready") throw new TypeError(isCealHostAuthenticationCause(response2.reason) && response2.reason !== "no_binding" ? response2.reason : "host_refusal_invalid");
   return response2;
 }
-function mintRefusalCause(reason) {
-  if (isDirectMintRefusalCause(reason)) return reason;
-  if (reason === "deadline" || reason === "cancelled") return "transient_retryable";
-  if (reason === "mint_failed" || reason === "relay_failed") return reason;
-  return isVocabularyWord(CEAL_HOST_MINT_REQUEST_CONTEXT_REFUSAL_REASONS, reason) ? "context_stale" : "host_refusal_invalid";
-}
-function isDirectMintRefusalCause(reason) {
-  return isVocabularyWord(HOST_RELAY_DIRECT_WIRE_MINT_REASONS, reason);
-}
-function exchangeFailureCause(failure2) {
-  if (failure2 === "permission_denied") return "relay_permission_denied";
-  if (failure2 === "timed_out") return "transient_retryable";
-  return "relay_unavailable";
-}
 async function currentInvocation(descriptor, config, now) {
   const store = descriptor.create_store(config.outbox_dir);
   const identity = resolveIdentity(descriptor, config);
-  if (identity.status !== "ready") throw new TypeError(identity.status);
+  if (identity.status === "session_unavailable") throw new TypeError("no_binding");
   const waitBudgetMs = config.context_activation_wait_ms ?? 0;
   const monotonicNow = config.monotonic_now ?? (() => performance.now());
   const deadline = monotonicNow() + waitBudgetMs;
@@ -2769,36 +3405,36 @@ async function currentInvocation(descriptor, config, now) {
   let waitEngaged = false;
   while (true) {
     if (!firstCheck && monotonicNow() >= deadline) {
-      recordActivationWaitExhaustion(descriptor.producer_id, waitEngaged, waitBudgetMs);
+      recordActivationWaitExhaustion(descriptor.producer_id, waitEngaged, waitBudgetMs, config.diagnostic_sink);
       throw new TypeError("context_unavailable");
     }
     firstCheck = false;
     const observedAt = now();
     const current = await readLiveSessionContext(store, identity.identity.host_source_ref, identity.identity.host_session_ref, observedAt);
     if (current !== null) {
-      recordActivationWaitCompletion(descriptor.producer_id, waitEngaged);
+      recordActivationWaitCompletion(descriptor.producer_id, waitEngaged, config.diagnostic_sink);
       return { store, current };
     }
     const remainingMs = deadline - monotonicNow();
     if (remainingMs <= 0) {
-      recordActivationWaitExhaustion(descriptor.producer_id, waitEngaged, waitBudgetMs);
+      recordActivationWaitExhaustion(descriptor.producer_id, waitEngaged, waitBudgetMs, config.diagnostic_sink);
       throw new TypeError("context_unavailable");
     }
-    recordActivationWaitEngagement(descriptor.producer_id, waitEngaged);
+    recordActivationWaitEngagement(descriptor.producer_id, waitEngaged, config.diagnostic_sink);
     waitEngaged = true;
     const intervalMs = Math.min(INVOCATION_CONTEXT_POLL_INTERVAL_MS, remainingMs);
     await (config.wait ?? waitForContextActivation)(intervalMs);
   }
 }
-function recordActivationWaitExhaustion(producer, engaged, budgetMs) {
-  if (engaged || budgetMs > 0) writeHostServiceDiagnostic(producer, "activation_wait_exhausted");
-  else writeHostServiceDiagnostic(producer, "activation_wait_skipped");
+function recordActivationWaitExhaustion(producer, engaged, budgetMs, sink) {
+  if (engaged || budgetMs > 0) writeHostServiceDiagnostic(producer, "activation_wait_exhausted", void 0, void 0, sink);
+  else writeHostServiceDiagnostic(producer, "activation_wait_skipped", void 0, void 0, sink);
 }
-function recordActivationWaitCompletion(producer, engaged) {
-  if (engaged) writeHostServiceDiagnostic(producer, "activation_wait_completed");
+function recordActivationWaitCompletion(producer, engaged, sink) {
+  if (engaged) writeHostServiceDiagnostic(producer, "activation_wait_completed", void 0, void 0, sink);
 }
-function recordActivationWaitEngagement(producer, engaged) {
-  if (!engaged) writeHostServiceDiagnostic(producer, "activation_wait_engaged");
+function recordActivationWaitEngagement(producer, engaged, sink) {
+  if (!engaged) writeHostServiceDiagnostic(producer, "activation_wait_engaged", void 0, void 0, sink);
 }
 async function readLiveSessionContext(store, hostSourceRef, hostSessionRef, now) {
   const current = await store.readInvocationContext(hostSourceRef, hostSessionRef, now);
@@ -2825,9 +3461,9 @@ async function resolveOptions(descriptor, args, options) {
   };
 }
 function authenticationBudgetMsFromEnvironment() {
-  const value = process.env[HOST_AUTHENTICATION_BUDGET_ENVIRONMENT];
+  const value = process.env[CEAL_HOST_AUTHENTICATION_BUDGET_ENVIRONMENT];
   if (value === void 0) return 0;
-  if (!/^(?:0|[1-9][0-9]{0,8})$/u.test(value)) throw new TypeError("invalid_arguments");
+  if (!CEAL_HOST_AUTHENTICATION_BUDGET_PATTERN.test(value)) throw new TypeError("invalid_arguments");
   return Number(value);
 }
 function boundedContextActivationWait(contextBudgetMs, relayTimeoutMs, maxContextWaitMs) {
@@ -2864,16 +3500,16 @@ function writeResult(value, sink) {
 }
 // host/producer-service.ts
-import { posix as posix3, win32 as win323 } from "node:path";
+import { posix as posix4, win32 as win325 } from "node:path";
 // host/runtime-source-paths.ts
-import { createHash as createHash3 } from "node:crypto";
-import { posix as posix2, win32 as win322 } from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+import { posix as posix3, win32 as win324 } from "node:path";
 // host/absolute-path.ts
-import { posix, win32 } from "node:path";
+import { posix as posix2, win32 as win323 } from "node:path";
 function isAbsoluteNormalizedNonRootPath(value, flavor = process.platform, allowRoot = false) {
-  const pathApi = flavor === "win32" || flavor === "windows" ? win32 : posix;
+  const pathApi = flavor === "win32" || flavor === "windows" ? win323 : posix2;
   return typeof value === "string" && value.length <= 4096 && !value.includes("\0") && pathApi.isAbsolute(value) && pathApi.normalize(value) === value && (allowRoot || pathApi.parse(value).root !== value);
 }
@@ -2885,28 +3521,23 @@ function hostSourceUuid(sourceRef) {
 function hostRuntimeSourcePaths(stateRoot, sourceRef, platform = process.platform) {
   const sourceId = hostSourceUuid(sourceRef);
   if (!isAbsoluteNormalizedNonRootPath(stateRoot, platform) || sourceId === null) throw new TypeError("Host runtime source identity is invalid.");
-  const path = platform === "win32" ? win322 : posix2;
+  const path = platform === "win32" ? win324 : posix3;
   const sourcesRoot = path.join(stateRoot, "sources");
   const sourceRoot = path.join(sourcesRoot, sourceId);
   const runtimeRoot = path.join(stateRoot, "run");
-  const endpoint = platform === "win32" ? `\\\\.\\pipe\\ceal-host-${createHash3("sha256").update(`${stateRoot}\0${sourceRef}`).digest("hex").slice(0, 24)}` : path.join(runtimeRoot, `${sourceId}.sock`);
-  assertHostRuntimeIpcLength(endpoint, platform);
+  const endpoint = platform === "win32" ? `\\\\.\\pipe\\ceal-host-${createHash4("sha256").update(`${stateRoot}\0${sourceRef}`).digest("hex").slice(0, 24)}` : path.join(runtimeRoot, `${sourceId}.sock`);
   return { sourceId, sourcesRoot, sourceRoot, relayRoot: path.join(sourceRoot, "relay"), codexOutbox: path.join(sourceRoot, "producers", "codex", "outbox"), claudeOutbox: path.join(sourceRoot, "producers", "claude", "outbox"), endpoint, runtimeRoot };
 }
-function assertHostRuntimeIpcLength(endpoint, platform) {
-  if (platform === "win32") return;
-  const maximum = platform === "linux" ? 107 : 103;
-  if (Buffer.byteLength(endpoint, "utf8") > maximum) throw Object.assign(new TypeError(`ipc_endpoint_too_long: Host IPC path exceeds ${maximum} bytes; use a shorter Host state root.`), { code: "ipc_endpoint_too_long" });
-}
 function assertHostProducerSourcePaths(stateRoot, config, producer, platform = process.platform) {
   const paths = hostRuntimeSourcePaths(stateRoot, config.host_source_ref, platform);
-  if (config.outbox_dir !== (producer === "codex" ? paths.codexOutbox : paths.claudeOutbox) || config.relay_endpoint !== paths.endpoint) throw new TypeError("Host producer outbox and IPC must belong to its configured source.");
+  if (config.outbox_dir !== (producer === "codex" ? paths.codexOutbox : paths.claudeOutbox) || platform !== "win32" && config.relay_endpoint !== paths.endpoint) throw new TypeError("Host producer outbox and IPC must belong to its configured source.");
+  return paths.endpoint;
 }
 // host/producer-service.ts
-import { constants } from "node:fs";
-import { lstat as lstat2, open as open3 } from "node:fs/promises";
-var SAFE_REF3 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+import { constants as constants3 } from "node:fs";
+import { lstat as lstat3 } from "node:fs/promises";
+var SAFE_REF2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 var HOST_PRODUCER_CONFIG_FLAG = "--ceal-host-config";
 var HostProducerServiceError = class extends Error {
   code;
@@ -2917,18 +3548,19 @@ var HostProducerServiceError = class extends Error {
   }
 };
 var HOST_PRODUCER_CONFIG_KEYS = ["schema_version", "host_source_ref", "producer_installation_ref", "producer_epoch", "outbox_dir", "relay_endpoint"];
+var HOST_PRODUCER_CONFIG_ENDPOINT_KEY = "relay_endpoint";
 var HOST_PRODUCER_TIMING_DEFAULTS = Object.freeze({ reconcile_interval_ms: 250, retry_backoff_ms: 1e3, ipc_timeout_ms: 5e3 });
 function hostProducerExtraPath(extras, key) {
   const value = extras[key];
-  if (value === void 0) throw hostProducerError("invalid_config");
+  if (value === void 0) throw hostProducerError("invalid_config", refusalFact(key, "missing", "an absolute path"));
   return value;
 }
 function parseHostProducerConfigFlag(args, platform = process.platform) {
   return parseProducerHostConfigFlag(args, HOST_PRODUCER_CONFIG_FLAG, platform, hostProducerError);
 }
-async function readHostProducerConfig(descriptor, configPath, platform = process.platform) {
-  const config = decodeHostProducerConfigText(descriptor, await readProducerConfigText(configPath, platform, hostProducerError), platform);
-  const path = platform === "win32" ? win323 : posix3;
+async function readHostProducerConfig(descriptor, configPath, platform = process.platform, custody = {}) {
+  const config = decodeHostProducerConfigText(descriptor, await readProducerConfigText(configPath, platform, hostProducerError, custody), platform);
+  const path = platform === "win32" ? win325 : posix4;
   const root = path.resolve(config.outbox_dir, "../../../../..");
   try {
     assertHostProducerSourcePaths(root, config, descriptor.producer_id, platform);
@@ -2954,15 +3586,31 @@ function parseProducerHostConfigFlag(args, flag, platform, error) {
   assertProducerAbsolutePath(value, platform, "config", error);
   return value;
 }
-async function readProducerConfigText(configPath, platform, error) {
-  assertProducerAbsolutePath(configPath, platform, "config", error);
+async function readProducerConfigText(configPath, platform, error, custody) {
+  assertProducerAbsolutePath(configPath, process.platform, "config", error);
+  if (platform === "win32") {
+    let bytes;
+    try {
+      bytes = await readPrivateFileWithSecurefs(configPath, CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES, custody);
+    } catch (cause) {
+      if (cause instanceof SecureFileCustodyError && cause.reason === "not_private") throw error("config_not_private");
+      if (cause instanceof SecureFileCustodyError && cause.reason === "too_large") throw error("invalid_config", refusalFact("config_bytes", "over_limit", `at most ${CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES}`));
+      if (cause instanceof SecureFileCustodyError && cause.reason === "reparse_point") throw error("invalid_config");
+      throw error("config_unavailable");
+    }
+    if (bytes.byteLength === 0) throw error("invalid_config", refusalFact("config_bytes", 0, `between 1 and ${CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES}`));
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    } catch {
+      throw error("invalid_config");
+    }
+  }
   const pathStat = await configPathStat(configPath, error);
   validateConfigFile(pathStat, platform, error);
-  const noFollow = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
-  const handle = await openConfigFile(configPath, constants.O_RDONLY | noFollow, error);
+  const handle = await openConfigFile(configPath, platform, error, custody);
   try {
     const opened = await handle.stat();
-    validateConfigFile(opened, platform, error);
+    validateConfigFile(opened, platform, error, handle);
     validateOpenedFile(opened, pathStat, platform, error);
     return await readBoundedConfig(handle, opened.size, error);
   } finally {
@@ -2970,8 +3618,9 @@ async function readProducerConfigText(configPath, platform, error) {
   }
 }
 function decodeProducerConfigCore(text, options) {
+  const ownership = producerConfigKeyOwnership(options.keys, options.platform);
   const value = parseCanonicalJson(text, options.error);
-  if (!isRecord(value) || !hasConfigKeys(value, options.keys) || value.schema_version !== options.schema) throw options.error("invalid_config");
+  if (!isRecord3(value) || !hasConfigKeys(value, ownership.required, ownership.tolerated) || value.schema_version !== options.schema) throw options.error("invalid_config", refusalFacts(producerShapeFacts(value, { schema: options.schema, keys: ownership.required, tolerated: ownership.tolerated })));
   const hostSourceRef = typeof value.host_source_ref === "string" ? value.host_source_ref : "";
   const installationRef = typeof value.producer_installation_ref === "string" ? value.producer_installation_ref : "";
   const producerEpoch = validateIdentity(hostSourceRef, installationRef, value.producer_epoch, options.error);
@@ -2989,14 +3638,21 @@ function decodeProducerConfigCore(text, options) {
     producer_installation_ref: installationRef,
     producer_epoch: producerEpoch,
     outbox_dir: value.outbox_dir,
-    relay_endpoint: value.relay_endpoint,
+    relay_endpoint: producerConfigEndpoint(value),
     reconcile_interval_ms: intervals[0],
     retry_backoff_ms: intervals[1],
     ipc_timeout_ms: intervals[2]
   };
 }
+function producerConfigKeyOwnership(keys, platform) {
+  if (platform !== "win32") return { required: keys, tolerated: [] };
+  return { required: keys.filter((key) => key !== HOST_PRODUCER_CONFIG_ENDPOINT_KEY), tolerated: [HOST_PRODUCER_CONFIG_ENDPOINT_KEY] };
+}
+function producerConfigEndpoint(value) {
+  return typeof value.relay_endpoint === "string" ? value.relay_endpoint : "";
+}
 function assertProducerRelayEndpoint(value, platform, error) {
-  if (platform === "win32" && typeof value === "string" && /^\\\\\.\\pipe\\[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value)) return;
+  if (platform === "win32") return;
   assertProducerAbsolutePath(value, platform, "runtime", error);
 }
 function assertProducerAbsolutePath(value, platform, kind, error) {
@@ -3004,26 +3660,27 @@ function assertProducerAbsolutePath(value, platform, kind, error) {
 }
 async function configPathStat(configPath, error) {
   try {
-    return await lstat2(configPath);
+    return await lstat3(configPath);
   } catch {
     throw error("config_unavailable");
   }
 }
-function validateConfigFile(value, platform, error) {
+function validateConfigFile(value, platform, error, handle) {
   if (!value.isFile() || value.isSymbolicLink()) throw error("invalid_config", refusalFacts([{ name: "config_is_file", value: value.isFile(), expected: "true" }, { name: "config_is_symlink", value: value.isSymbolicLink(), expected: "false" }]));
   if (value.size <= 0 || value.size > CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES) throw error("invalid_config", refusalFact("config_bytes", value.size, `between 1 and ${CEAL_ENCODED_JSON_DOCUMENT_MAX_BYTES}`));
-  if (platform !== "win32" && (value.uid !== process.getuid?.() || (value.mode & 63) !== 0)) throw error("config_not_private", refusalFacts([{ name: "platform", value: platform, expected: "win32 or owner-private" }, { name: "config_uid", value: value.uid, expected: "the current user" }, { name: "config_mode", value: value.mode, expected: "owner-private" }]));
+  if (!isSelfOwned(value.uid, platform, handle) || !isPrivateFileMode(value.mode, platform, handle)) throw error("config_not_private", refusalFacts([{ name: "platform", value: platform, expected: "a platform with verifiable owner and private-mode facts" }, { name: "config_uid", value: value.uid, expected: "the current user" }, { name: "config_mode", value: value.mode, expected: "private to its owner" }]));
 }
-async function openConfigFile(configPath, flags, error) {
+async function openConfigFile(configPath, platform, error, custody) {
   try {
-    return await open3(configPath, flags);
-  } catch {
+    return await openNoFollow(configPath, constants3.O_RDONLY, void 0, platform, custody);
+  } catch (error_) {
+    if (error_ instanceof SecureFileCustodyError) throw error(error_.reason === "not_private" ? "config_not_private" : "invalid_config");
     throw error("config_unavailable");
   }
 }
 function validateOpenedFile(opened, pathStat, platform, error) {
   if (!opened.isFile()) throw error("config_unavailable", refusalFacts([{ name: "opened_is_file", value: opened.isFile(), expected: "true" }, { name: "opened_mode", value: opened.mode.toString(8), expected: "a regular file mode" }]));
-  if (platform !== "win32" && (opened.dev !== pathStat.dev || opened.ino !== pathStat.ino)) throw error("config_unavailable", refusalFacts([{ name: "platform", value: platform, expected: "win32, or the same file the path named" }, { name: "opened_device", value: opened.dev, expected: String(pathStat.dev) }, { name: "opened_inode", value: opened.ino, expected: String(pathStat.ino) }]));
+  if (opened.dev !== pathStat.dev || opened.ino !== pathStat.ino) throw error("config_unavailable", refusalFacts([{ name: "platform", value: platform, expected: "the same file the path named" }, { name: "opened_device", value: opened.dev, expected: String(pathStat.dev) }, { name: "opened_inode", value: opened.ino, expected: String(pathStat.ino) }]));
 }
 async function readBoundedConfig(handle, expectedBytes, error) {
   const buffer = Buffer.allocUnsafe(expectedBytes + 1);
@@ -3055,29 +3712,54 @@ function firstDifferenceIndex(left, right) {
   for (let index = 0; index < shared; index += 1) if (left[index] !== right[index]) return index;
   return shared;
 }
+function producerShapeFacts(value, options) {
+  if (!isRecord3(value)) return [{ name: "config", value: "wrong_type", expected: "a record" }];
+  const tolerated = options.tolerated ?? [];
+  const allowed = [...options.keys, ...tolerated, ...Object.keys(HOST_PRODUCER_TIMING_DEFAULTS)];
+  const facts = [
+    ...Object.keys(value).filter((key) => !allowed.includes(key)).map((key) => ({ name: key, value: "unknown", expected: `one of ${[...options.keys, ...tolerated].join(", ")}` })),
+    ...options.keys.filter((key) => !Object.hasOwn(value, key)).map((key) => ({ name: key, value: "missing", expected: "present" }))
+  ];
+  if (Object.hasOwn(value, "schema_version") && value.schema_version !== options.schema) facts.push({ name: "schema_version", value: "wrong_type", expected: options.schema });
+  return facts;
+}
 function validateIdentity(sourceRef, installationRef, epoch, error) {
-  if (!SAFE_REF3.test(sourceRef) || !SAFE_REF3.test(installationRef) || !positive2(epoch, 2147483647)) throw error("invalid_config");
+  if (!SAFE_REF2.test(sourceRef) || !SAFE_REF2.test(installationRef) || !positive(epoch, 2147483647)) throw error("invalid_config", refusalFacts(producerIdentityFacts(sourceRef, installationRef, epoch)));
   return epoch;
 }
+function producerIdentityFacts(sourceRef, installationRef, epoch) {
+  const facts = [];
+  if (!SAFE_REF2.test(sourceRef)) facts.push({ name: "host_source_ref", value: "wrong_type", expected: "a safe reference" });
+  if (!SAFE_REF2.test(installationRef)) facts.push({ name: "producer_installation_ref", value: "wrong_type", expected: "a safe reference" });
+  if (!positive(epoch, 2147483647)) facts.push({ name: "producer_epoch", value: "wrong_type", expected: "a positive integer" });
+  return facts;
+}
 function validateIntervals(reconcile, retry, timeout, error) {
-  if (!boundedMilliseconds(reconcile) || !boundedMilliseconds(retry) || !boundedMilliseconds(timeout)) throw error("invalid_config");
+  if (!boundedMilliseconds(reconcile) || !boundedMilliseconds(retry) || !boundedMilliseconds(timeout)) throw error("invalid_config", refusalFacts(producerIntervalFacts(reconcile, retry, timeout)));
   return [reconcile, retry, timeout];
 }
-function hasConfigKeys(value, required) {
-  return required.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => required.includes(key) || Object.hasOwn(HOST_PRODUCER_TIMING_DEFAULTS, key));
+function producerIntervalFacts(reconcile, retry, timeout) {
+  const facts = [];
+  if (!boundedMilliseconds(reconcile)) facts.push({ name: "reconcile_interval_ms", value: "wrong_type", expected: "25..60000 milliseconds" });
+  if (!boundedMilliseconds(retry)) facts.push({ name: "retry_backoff_ms", value: "wrong_type", expected: "25..60000 milliseconds" });
+  if (!boundedMilliseconds(timeout)) facts.push({ name: "ipc_timeout_ms", value: "wrong_type", expected: "25..60000 milliseconds" });
+  return facts;
 }
-function isRecord(value) {
+function hasConfigKeys(value, required, tolerated = []) {
+  return required.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => required.includes(key) || tolerated.includes(key) || Object.hasOwn(HOST_PRODUCER_TIMING_DEFAULTS, key));
+}
+function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function positive2(value, maximum) {
+function positive(value, maximum) {
   return Number.isSafeInteger(value) && Number(value) > 0 && Number(value) <= maximum;
 }
 function boundedMilliseconds(value) {
-  return positive2(value, 6e4) && Number(value) >= 25;
+  return positive(value, 6e4) && Number(value) >= 25;
 }
 // host/claude/src/claude-decoder.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 // host/claude/src/claude-types.ts
 var CLAUDE_SESSION_ID_ENVIRONMENT = "CLAUDE_CODE_SESSION_ID";
@@ -3108,6 +3790,76 @@ var ClaudeHostError = class extends Error {
 // host/claude/src/claude-decoder.ts
 var MAX_HOOK_BYTES = 256 * 1024;
+function decodeClaudeQueuedPromptRow(row, sessionId) {
+  if (!record2(row)) return null;
+  if (row.type === "user") return decodeArrayTextPrompt(row, sessionId);
+  if (row.type === "attachment") return decodeQueuedCommandPrompt(row, sessionId);
+  if (row.type === "queue-operation") return decodeQueueEnqueuePrompt(row, sessionId);
+  return null;
+}
+function decodeClaudeHumanMessageRow(row, sessionId) {
+  if (!isClaudeNativeHumanMessageRow(row)) return decodeClaudeQueuedPromptRow(row, sessionId);
+  return decodeClaudeNativeHumanMessage(row, sessionId);
+}
+function isClaudeNativeHumanMessageRow(row) {
+  return record2(row) && row.type === "user" && record2(row.message) && typeof row.message.content === "string";
+}
+function decodeClaudeNativeHumanMessage(row, sessionId) {
+  if (!sessionMatches(row, sessionId)) return null;
+  if (row.isMeta === true && (!record2(row.origin) || typeof row.origin.kind !== "string")) return null;
+  const identity = queuedRowIdentity(row);
+  if (identity === null) throw new ClaudeHostError("payload_rejected", "Claude transcript human message identity is malformed.");
+  const message = row.message;
+  if (!record2(message) || typeof message.content !== "string") return null;
+  return { turnId: identity.uuid, timestamp: identity.timestamp, content: message.content };
+}
+function decodeArrayTextPrompt(row, sessionId) {
+  if (!record2(row.message) || !Array.isArray(row.message.content)) return null;
+  if (!sessionMatches(row, sessionId)) return null;
+  if (row.isMeta === true && (!record2(row.origin) || typeof row.origin.kind !== "string")) return null;
+  const texts = arrayTextBlocks(row.message.content);
+  if (texts === null) return null;
+  const identity = queuedRowIdentity(row);
+  if (identity === null) return null;
+  return { turnId: identity.uuid, timestamp: identity.timestamp, content: texts.join("") };
+}
+function arrayTextBlocks(content) {
+  const texts = [];
+  for (const block of content) {
+    if (!record2(block) || block.type !== "text" || typeof block.text !== "string") return null;
+    texts.push(block.text);
+  }
+  return texts.length === 0 ? null : texts;
+}
+function decodeQueuedCommandPrompt(row, sessionId) {
+  if (!record2(row.attachment) || row.attachment.type !== "queued_command" || row.attachment.commandMode !== "prompt") return null;
+  if (typeof row.attachment.prompt !== "string" || row.attachment.prompt.length === 0) return null;
+  if (!sessionMatches(row, sessionId)) return null;
+  const identity = queuedRowIdentity(row);
+  if (identity === null) return null;
+  return { turnId: identity.uuid, timestamp: identity.timestamp, content: row.attachment.prompt };
+}
+function decodeQueueEnqueuePrompt(row, sessionId) {
+  if (row.operation !== "enqueue" || typeof row.content !== "string" || row.content.length === 0) return null;
+  if (!sessionMatches(row, sessionId)) return null;
+  if (typeof row.timestamp !== "string" || !Number.isFinite(Date.parse(row.timestamp))) return null;
+  return { turnId: queueEnqueueTurnId(sessionId, row.timestamp, row.content), timestamp: row.timestamp, content: row.content };
+}
+function sessionMatches(row, sessionId) {
+  const hasSessionId = Object.hasOwn(row, "sessionId");
+  const hasSnakeSessionId = Object.hasOwn(row, "session_id");
+  return (hasSessionId || hasSnakeSessionId) && (!hasSessionId || row.sessionId === sessionId) && (!hasSnakeSessionId || row.session_id === sessionId);
+}
+function queuedRowIdentity(row) {
+  if (typeof row.uuid !== "string" || row.uuid.length === 0 || row.uuid.length > 256) return null;
+  if (typeof row.timestamp !== "string" || !Number.isFinite(Date.parse(row.timestamp))) return null;
+  return { uuid: row.uuid, timestamp: row.timestamp };
+}
+function queueEnqueueTurnId(sessionId, timestamp3, content) {
+  return `queue-enqueue:${createHash5("sha256").update(`${sessionId}
+${timestamp3}
+${content}`, "utf8").digest("hex").slice(0, 32)}`;
+}
 function claudeLocalSessionRef(sessionId) {
   return `claude-session:${digest(sessionId)}`;
 }
@@ -3117,25 +3869,25 @@ function claudeLocalTurnRef(sessionId, turnId) {
 function claudeLocalInputRef(sessionId, turnId) {
   return `claude-input:${cealRequestSha256({ session_id: sessionId, prompt_id: turnId })}`;
 }
-function claudeWorkspaceRef(cwd) {
-  return `workspace:${digest(cwd)}`;
-}
 function digest(value) {
-  return createHash4("sha256").update(value, "utf8").digest("hex");
+  return createHash5("sha256").update(value, "utf8").digest("hex");
+}
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 // host/claude/src/claude-outbox.ts
-import { mkdir as mkdir3, readdir, readFile as readFile2, unlink as unlink2 } from "node:fs/promises";
-import { isAbsolute, join as join3 } from "node:path";
+import { mkdir as mkdir3, readdir, readFile, unlink as unlink3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join3 } from "node:path";
 // host/invocation-context.ts
-var HOST_INVOCATION_IDENTITY_KEYS = ["host_session_ref", "host_turn_ref", "host_source_ref"];
+var HOST_INVOCATION_TURN_SELECTION_SCHEMA = "ceal.host_invocation_turn_selection.v1";
 var HOST_INVOCATION_CONTEXT_REQUIRED_KEYS = ["schema_version", "identity", "prompt_ref", "expires_at"];
 function invocationContextKey(identity) {
   return cealRequestSha256({ host_source_ref: identity.host_source_ref, host_session_ref: identity.host_session_ref });
 }
 function hasHostInvocationIdentityKeys(value) {
-  return exactKeys4(value, HOST_INVOCATION_IDENTITY_KEYS);
+  return exactKeys3(value, CEAL_HOST_INVOCATION_IDENTITY_KEYS);
 }
 function hasHostInvocationContextKeys(value, optional = []) {
   return requiredKeys(value, HOST_INVOCATION_CONTEXT_REQUIRED_KEYS, optional);
@@ -3161,12 +3913,9 @@ function invocationContextFromTurn(identity, promptRef, expiresAt, descriptor) {
   return Object.freeze(context);
 }
 function isHostInvocationTurnSelection(value) {
-  return isRecord2(value) && Object.keys(value).length === 5 && value.schema_version === "ceal.host_invocation_turn_selection.v1" && ["host_source_ref", "host_session_ref", "prompt_ref", "turn_generation_ref"].every((key) => safeRef3(value[key]));
-}
-function invocationTurnSelectionMatches(context, selection) {
-  return selection === null || context !== null && selection.host_source_ref === context.identity.host_source_ref && selection.host_session_ref === context.identity.host_session_ref && selection.prompt_ref === context.prompt_ref && selection.turn_generation_ref === context.turn_generation_ref;
+  return isRecord4(value) && Object.keys(value).length === 5 && value.schema_version === HOST_INVOCATION_TURN_SELECTION_SCHEMA && ["host_source_ref", "host_session_ref", "prompt_ref", "turn_generation_ref"].every((key) => safeRef2(value[key]));
 }
-function exactKeys4(value, keys) {
+function exactKeys3(value, keys) {
   const actual = Object.keys(value);
   return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key)) && actual.every((key) => keys.includes(key));
 }
@@ -3175,10 +3924,10 @@ function requiredKeys(value, required, optional) {
   const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
   return actual.length >= required.length && actual.length <= allowed.size && required.every((key) => Object.hasOwn(value, key)) && actual.every((key) => allowed.has(key));
 }
-function isRecord2(value) {
+function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function safeRef3(value) {
+function safeRef2(value) {
   return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
 }
@@ -3193,34 +3942,30 @@ function validateClaudeHostInvocationContext(value) {
   validateContextTimes(value);
 }
 function contextShape(value) {
-  return record3(value) && value.schema_version === CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION && hasHostInvocationContextKeys(value, ["request_ref", "bound_at", "working_directory", "turn_generation_ref"]);
+  return record3(value) && value.schema_version === CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION && hasHostInvocationContextKeys(value, ["working_directory", "turn_generation_ref"]);
 }
 function validateIdentity2(value) {
   if (!validIdentity(value)) throw new ClaudeHostError("storage", "Claude Host invocation identity is malformed.");
 }
 function validateContextReferences(value) {
-  if (!safeRef4(value.prompt_ref) || !optionalSafeRef(value.request_ref) || !optionalSafeRef(value.turn_generation_ref)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
+  if (!safeRef3(value.prompt_ref) || !optionalSafeRef(value.turn_generation_ref)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
 }
 function validateContextTimes(value) {
-  if (!timestamp2(value.expires_at) || !optionalTimestamp(value.bound_at) || !optionalDirectory(value.working_directory)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
-  if (typeof value.bound_at === "string" && Date.parse(value.bound_at) > Date.parse(String(value.expires_at))) throw new ClaudeHostError("storage", `Claude Host invocation context has invalid binding time (${refusalFact("bound_at", value.bound_at, `at or before ${String(value.expires_at)}`)}).`);
+  if (!timestamp(value.expires_at) || !optionalDirectory(value.working_directory)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
 }
 function validIdentity(value) {
-  return record3(value) && hasHostInvocationIdentityKeys(value) && [value.host_session_ref, value.host_turn_ref, value.host_source_ref].every(safeRef4);
+  return record3(value) && hasHostInvocationIdentityKeys(value) && [value.host_session_ref, value.host_turn_ref, value.host_source_ref].every(safeRef3);
 }
 function optionalSafeRef(value) {
-  return value === void 0 || safeRef4(value);
-}
-function optionalTimestamp(value) {
-  return value === void 0 || timestamp2(value);
+  return value === void 0 || safeRef3(value);
 }
 function optionalDirectory(value) {
   return value === void 0 || typeof value === "string" && value.startsWith("/") && !value.includes("\0") && value.length <= 4096;
 }
-function safeRef4(value) {
+function safeRef3(value) {
   return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
 }
-function timestamp2(value) {
+function timestamp(value) {
   return typeof value === "string" && value.length <= 64 && Number.isFinite(Date.parse(value));
 }
 function record3(value) {
@@ -3228,7 +3973,7 @@ function record3(value) {
 }
 // host/claude/src/claude-outbox.ts
-var SAFE_REF4 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var SAFE_REF3 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 var CLAUDE_TRANSCRIPT_PATH_MAX_CHARACTERS = 4096;
 var CLAUDE_TRANSCRIPT_SUBAGENT_NAME_MAX_CHARACTERS = 256;
 var ClaudeOutboxStore = class {
@@ -3286,10 +4031,10 @@ var ClaudeOutboxStore = class {
    * a missing one. Every other caller keeps the fail-closed read above.
    */
   async readRawInvocationContext(hostSourceRef, hostSessionRef) {
-    if (!SAFE_REF4.test(hostSourceRef) || !SAFE_REF4.test(hostSessionRef)) throw new ClaudeHostError("invalid_input", "Claude Host context identity or clock is invalid.");
+    if (!SAFE_REF3.test(hostSourceRef) || !SAFE_REF3.test(hostSessionRef)) throw new ClaudeHostError("invalid_input", "Claude Host context identity or clock is invalid.");
     await this.prepare();
     const context = await readLatestSessionProjection(this.activeContextPath({ host_source_ref: hostSourceRef, host_session_ref: hostSessionRef }), hostSourceRef, hostSessionRef, readProjectionFile);
-    return invocationTurnSelectionMatches(context, await this.readInvocationTurnSelection(hostSourceRef, hostSessionRef)) ? context : null;
+    return context;
   }
   async listInvocationContexts(now = /* @__PURE__ */ new Date()) {
     await this.prepare();
@@ -3297,9 +4042,9 @@ var ClaudeOutboxStore = class {
     for (const name of await readdir(this.activeContexts)) {
       if (!name.endsWith(".json")) continue;
       try {
-        const value = JSON.parse(await readFile2(join3(this.activeContexts, name), "utf8"));
+        const value = JSON.parse(await readFile(join3(this.activeContexts, name), "utf8"));
         validateClaudeHostInvocationContext(value);
-        if (Date.parse(value.expires_at) > now.getTime() && invocationTurnSelectionMatches(value, await this.readInvocationTurnSelection(value.identity.host_source_ref, value.identity.host_session_ref))) contexts.push(value);
+        if (Date.parse(value.expires_at) > now.getTime()) contexts.push(value);
       } catch {
       }
     }
@@ -3317,7 +4062,7 @@ var ClaudeOutboxStore = class {
     for (const name of await readdir(this.envelopes)) {
       if (!name.endsWith(".json")) continue;
       try {
-        const value = JSON.parse(await readFile2(join3(this.envelopes, name), "utf8"));
+        const value = JSON.parse(await readFile(join3(this.envelopes, name), "utf8"));
         validateEnvelope(value);
         entries.push(value);
       } catch {
@@ -3330,7 +4075,7 @@ var ClaudeOutboxStore = class {
   async removeEnvelope(entry) {
     validateEnvelope(entry);
     try {
-      await unlink2(this.envelopePath(entry.submission_ref));
+      await unlink3(this.envelopePath(entry.submission_ref));
     } catch (error) {
       if (code(error) !== "ENOENT") throw error;
     }
@@ -3341,10 +4086,10 @@ var ClaudeOutboxStore = class {
     await durableAtomicReplace(join3(this.sessions, `${cealRequestSha256({ source: snapshot.host_source_ref, session: snapshot.host_session_ref })}.json`), JSON.stringify(snapshot));
   }
   async readSession(sourceRef, sessionRef) {
-    if (!SAFE_REF4.test(sourceRef) || !SAFE_REF4.test(sessionRef)) throw new ClaudeHostError("invalid_input", "Claude session identity is invalid.");
+    if (!SAFE_REF3.test(sourceRef) || !SAFE_REF3.test(sessionRef)) throw new ClaudeHostError("invalid_input", "Claude session identity is invalid.");
     await this.prepare();
     try {
-      const value = JSON.parse(await readFile2(join3(this.sessions, `${cealRequestSha256({ source: sourceRef, session: sessionRef })}.json`), "utf8"));
+      const value = JSON.parse(await readFile(join3(this.sessions, `${cealRequestSha256({ source: sourceRef, session: sessionRef })}.json`), "utf8"));
       validateSession(value);
       return value;
     } catch (error) {
@@ -3379,7 +4124,7 @@ var ClaudeOutboxStore = class {
     for (const name of await readdir(this.registrations)) {
       if (!name.endsWith(".json")) continue;
       try {
-        const value = JSON.parse(await readFile2(join3(this.registrations, name), "utf8"));
+        const value = JSON.parse(await readFile(join3(this.registrations, name), "utf8"));
         validateRegistration(value);
         registrations.push(value);
       } catch {
@@ -3388,10 +4133,10 @@ var ClaudeOutboxStore = class {
     return registrations.sort((left, right) => left.registered_at.localeCompare(right.registered_at));
   }
   async readInvocationTurnSelection(hostSourceRef, hostSessionRef) {
-    if (!SAFE_REF4.test(hostSourceRef) || !SAFE_REF4.test(hostSessionRef)) throw new ClaudeHostError("invalid_input", "Claude Host turn selection identity is invalid.");
+    if (!SAFE_REF3.test(hostSourceRef) || !SAFE_REF3.test(hostSessionRef)) throw new ClaudeHostError("invalid_input", "Claude Host turn selection identity is invalid.");
     await this.prepare();
     try {
-      const value = JSON.parse(await readFile2(this.turnSelectionPath(hostSourceRef, hostSessionRef), "utf8"));
+      const value = JSON.parse(await readFile(this.turnSelectionPath(hostSourceRef, hostSessionRef), "utf8"));
       if (!isHostInvocationTurnSelection(value) || value.host_source_ref !== hostSourceRef || value.host_session_ref !== hostSessionRef) throw new ClaudeHostError("storage", "Claude Host turn selection is malformed.");
       return value;
     } catch (error) {
@@ -3403,7 +4148,7 @@ var ClaudeOutboxStore = class {
     validateRegistration(registration);
     await this.prepare();
     try {
-      const value = JSON.parse(await readFile2(this.cursorPath(registration.host_source_ref, registration.host_session_ref), "utf8"));
+      const value = JSON.parse(await readFile(this.cursorPath(registration.host_source_ref, registration.host_session_ref), "utf8"));
       validateCursor(value);
       return value;
     } catch (error) {
@@ -3430,7 +4175,7 @@ var ClaudeOutboxStore = class {
   }
   async readRegistrationFile(path) {
     try {
-      const value = JSON.parse(await readFile2(path, "utf8"));
+      const value = JSON.parse(await readFile(path, "utf8"));
       validateRegistration(value);
       return value;
     } catch (error) {
@@ -3440,7 +4185,7 @@ var ClaudeOutboxStore = class {
   }
   async removeStateFile(path) {
     try {
-      await unlink2(path);
+      await unlink3(path);
     } catch (error) {
       if (code(error) !== "ENOENT") throw error;
     }
@@ -3450,11 +4195,11 @@ var ClaudeOutboxStore = class {
   }
 };
 function validateInvocationContextReadArguments(hostSourceRef, hostSessionRef, now) {
-  if (!SAFE_REF4.test(hostSourceRef) || !SAFE_REF4.test(hostSessionRef) || !(now instanceof Date) || !Number.isFinite(now.getTime())) throw new ClaudeHostError("invalid_input", "Claude Host context identity or clock is invalid.");
+  if (!SAFE_REF3.test(hostSourceRef) || !SAFE_REF3.test(hostSessionRef) || !(now instanceof Date) || !Number.isFinite(now.getTime())) throw new ClaudeHostError("invalid_input", "Claude Host context identity or clock is invalid.");
 }
 async function readProjectionFile(file) {
   try {
-    const context = JSON.parse(await readFile2(file, "utf8"));
+    const context = JSON.parse(await readFile(file, "utf8"));
     validateClaudeHostInvocationContext(context);
     return context;
   } catch (error) {
@@ -3463,10 +4208,10 @@ async function readProjectionFile(file) {
     throw new ClaudeHostError("storage", "Unable to read the Claude Host invocation context.");
   }
 }
-function safeRef5(value) {
-  return typeof value === "string" && SAFE_REF4.test(value);
+function safeRef4(value) {
+  return typeof value === "string" && SAFE_REF3.test(value);
 }
-function timestamp3(value) {
+function timestamp2(value) {
   return typeof value === "string" && Number.isFinite(Date.parse(value));
 }
 function record4(value) {
@@ -3477,26 +4222,24 @@ function code(error) {
 }
 function validateEnvelope(value) {
   if (!record4(value)) throw new ClaudeHostError("storage", "Claude outbox entry is malformed.");
-  if (!sameKeys(value, ["schema_version", "identity", "host_input_ref", "input_kind", "prompt_ref", "observations", "origin_input", "submission_ref", "created_at", "expires_at"], ["request_ref"])) {
+  if (!sameKeys(value, ["schema_version", "identity", "host_input_ref", "prompt_ref", "observations", "origin_input", "submission_ref", "created_at", "expires_at"])) {
     throw new ClaudeHostError("storage", `Claude outbox entry key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the outbox entry key set")}).`);
   }
   if (value.schema_version !== CLAUDE_OUTBOX_SCHEMA_VERSION) throw new ClaudeHostError("storage", `Claude outbox entry is malformed (${refusalFact("schema_version", value.schema_version, `expected ${CLAUDE_OUTBOX_SCHEMA_VERSION}`)}).`);
   validateEnvelopeIdentity(value);
   validateEnvelopeObservations(value.observations);
   if (typeof value.origin_input !== "boolean") throw new ClaudeHostError("storage", "Claude outbox origin disposition is malformed.");
-  if (!timestamp3(value.created_at) || !timestamp3(value.expires_at)) throw new ClaudeHostError("storage", "Claude outbox timestamps are malformed.");
+  if (!timestamp2(value.created_at) || !timestamp2(value.expires_at)) throw new ClaudeHostError("storage", "Claude outbox timestamps are malformed.");
 }
 function validateEnvelopeIdentity(value) {
   validateIdentity3(value.identity);
-  if (!safeRef5(value.host_input_ref)) throw new ClaudeHostError("storage", "Claude outbox input reference is malformed.");
-  if (!isCealHostInputKind(value.input_kind)) throw new ClaudeHostError("storage", "Claude outbox input provenance is malformed.");
-  if (!safeRef5(value.prompt_ref) || !safeRef5(value.submission_ref)) throw new ClaudeHostError("storage", "Claude outbox references are malformed.");
-  if (value.request_ref !== void 0 && !safeRef5(value.request_ref)) throw new ClaudeHostError("storage", "Claude outbox Request reference is malformed.");
+  if (!safeRef4(value.host_input_ref)) throw new ClaudeHostError("storage", "Claude outbox input reference is malformed.");
+  if (!safeRef4(value.prompt_ref) || !safeRef4(value.submission_ref)) throw new ClaudeHostError("storage", "Claude outbox references are malformed.");
 }
 function validateEnvelopeObservations(value) {
   if (!Array.isArray(value)) throw new ClaudeHostError("storage", "Claude outbox observations are malformed.");
   try {
-    for (const observation2 of value) validateCealHostObservationDraft(observation2);
+    for (const observation of value) validateCealHostObservationDraft(observation);
   } catch {
     throw new ClaudeHostError("storage", "Claude outbox observations are malformed.");
   }
@@ -3507,7 +4250,7 @@ function validateSession(value) {
     throw new ClaudeHostError("storage", `Claude session snapshot key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the session snapshot key set")}).`);
   }
   if (value.schema_version !== CLAUDE_SESSION_SCHEMA_VERSION) throw new ClaudeHostError("storage", `Claude session snapshot is malformed (${refusalFact("schema_version", value.schema_version, `expected ${CLAUDE_SESSION_SCHEMA_VERSION}`)}).`);
-  if (!safeRef5(value.host_session_ref) || !safeRef5(value.host_source_ref) || !timestamp3(value.observed_at) || !timestamp3(value.expires_at)) {
+  if (!safeRef4(value.host_session_ref) || !safeRef4(value.host_source_ref) || !timestamp2(value.observed_at) || !timestamp2(value.expires_at)) {
     throw new ClaudeHostError("storage", "Claude session snapshot fields are malformed.");
   }
 }
@@ -3517,14 +4260,14 @@ function validateRegistration(value) {
     throw new ClaudeHostError("storage", `Claude transcript registration key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the registration key set")}).`);
   }
   if (value.schema_version !== CLAUDE_TRANSCRIPT_REGISTRATION_SCHEMA_VERSION) throw new ClaudeHostError("storage", "Claude transcript registration is malformed.");
-  if (![value.host_source_ref, value.host_session_ref, value.claude_session_id].every((candidate) => typeof candidate === "string" && SAFE_REF4.test(candidate))) {
+  if (![value.host_source_ref, value.host_session_ref, value.claude_session_id].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) {
     throw new ClaudeHostError("storage", "Claude transcript registration references are malformed.");
   }
   validateRegistrationPaths(value.cwd, value.transcript_path);
-  if (!timestamp3(value.registered_at) || !timestamp3(value.expires_at)) throw new ClaudeHostError("storage", "Claude transcript registration timestamps are malformed.");
+  if (!timestamp2(value.registered_at) || !timestamp2(value.expires_at)) throw new ClaudeHostError("storage", "Claude transcript registration timestamps are malformed.");
 }
 function validateRegistrationPaths(cwd, transcriptPath) {
-  if (cwd !== void 0 && (typeof cwd !== "string" || !isAbsolute(cwd) || cwd.length > CLAUDE_TRANSCRIPT_PATH_MAX_CHARACTERS || cwd.includes("\0"))) {
+  if (cwd !== void 0 && (typeof cwd !== "string" || !isAbsolute2(cwd) || cwd.length > CLAUDE_TRANSCRIPT_PATH_MAX_CHARACTERS || cwd.includes("\0"))) {
     throw new ClaudeHostError("storage", "Claude transcript registration working directory is malformed.");
   }
   if (typeof transcriptPath !== "string" || transcriptPath.length === 0 || transcriptPath.length > CLAUDE_TRANSCRIPT_PATH_MAX_CHARACTERS) {
@@ -3537,7 +4280,7 @@ function validateCursor(value) {
     throw new ClaudeHostError("storage", "Claude transcript cursor key set is malformed.");
   }
   if (value.schema_version !== CLAUDE_TRANSCRIPT_CURSOR_SCHEMA_VERSION) throw new ClaudeHostError("storage", "Claude transcript cursor is malformed.");
-  if (![value.host_source_ref, value.host_session_ref].every((candidate) => typeof candidate === "string" && SAFE_REF4.test(candidate))) throw new ClaudeHostError("storage", "Claude transcript cursor references are malformed.");
+  if (![value.host_source_ref, value.host_session_ref].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) throw new ClaudeHostError("storage", "Claude transcript cursor references are malformed.");
   if (typeof value.transcript_path !== "string" || value.transcript_path.length === 0) throw new ClaudeHostError("storage", "Claude transcript cursor path is malformed.");
   validateCursorPosition(value);
   validateCursorTurn(value.open_turn, value.unattributed, value.session_observed);
@@ -3549,7 +4292,7 @@ function validateCursorPosition(value) {
   if (value.device !== void 0 && typeof value.device !== "string") throw new ClaudeHostError("storage", "Claude transcript cursor device is malformed.");
   if (value.inode !== void 0 && typeof value.inode !== "string") throw new ClaudeHostError("storage", "Claude transcript cursor inode is malformed.");
   if (value.device === void 0 && value.offset !== 0) throw new ClaudeHostError("storage", "Claude transcript cursor is unpinned past its start.");
-  if (value.status !== "active" && value.status !== "quarantined" || !timestamp3(value.updated_at)) throw new ClaudeHostError("storage", "Claude transcript cursor status is malformed.");
+  if (value.status !== "active" && value.status !== "quarantined" || !timestamp2(value.updated_at)) throw new ClaudeHostError("storage", "Claude transcript cursor status is malformed.");
 }
 function validateCursorTurn(openTurn, unattributed, sessionObserved) {
   if (openTurn !== void 0 && !validOpenTurn(openTurn)) throw new ClaudeHostError("storage", "Claude transcript turn cursor is malformed.");
@@ -3580,8 +4323,8 @@ function validCursorPosition(value) {
 }
 function validOpenTurn(value) {
   if (!record4(value) || !sameKeys(value, ["turn_key", "user_uuid", "prompt_ref", "host_input_ref", "started_at", "last_observed_at", "message_ids", "counts"], ["last_terminal_digest"])) return false;
-  if (![value.turn_key, value.user_uuid, value.prompt_ref, value.host_input_ref].every((candidate) => typeof candidate === "string" && SAFE_REF4.test(candidate))) return false;
-  if (!timestamp3(value.started_at) || !timestamp3(value.last_observed_at)) return false;
+  if (![value.turn_key, value.user_uuid, value.prompt_ref, value.host_input_ref].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) return false;
+  if (!timestamp2(value.started_at) || !timestamp2(value.last_observed_at)) return false;
   if (!validMessageIds(value.message_ids)) return false;
   if (!validTurnCounts(value.counts)) return false;
   return value.last_terminal_digest === void 0 || typeof value.last_terminal_digest === "string" && /^[a-f0-9]{64}$/u.test(value.last_terminal_digest);
@@ -3594,7 +4337,7 @@ function validMessageIds(value) {
 function validUnattributed(value) {
   if (!record4(value) || !sameKeys(value, ["input", "cached_input", "cache_write_input", "output", "message_ids", "last_observed_at"])) return false;
   if (!validMessageIds(value.message_ids) || value.message_ids.length === 0) return false;
-  if (!timestamp3(value.last_observed_at)) return false;
+  if (!timestamp2(value.last_observed_at)) return false;
   return validTurnCounts(value);
 }
 function validTurnCounts(value) {
@@ -3602,7 +4345,7 @@ function validTurnCounts(value) {
   return [value.input, value.cached_input, value.cache_write_input, value.output].every(nonNegativeInteger);
 }
 function validateIdentity3(value) {
-  if (!record4(value) || ![value.host_session_ref, value.host_turn_ref, value.host_source_ref].every((candidate) => typeof candidate === "string" && SAFE_REF4.test(candidate))) {
+  if (!record4(value) || ![value.host_session_ref, value.host_turn_ref, value.host_source_ref].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) {
     throw new ClaudeHostError("storage", "Claude Host identity is malformed.");
   }
 }
@@ -3615,125 +4358,32 @@ function sameKeys(value, required, optional = []) {
 // host/claude/src/claude-producer.ts
 var ClaudeProducer = class {
-  producer_id = "claude";
-  producer_label = "Claude";
-  outbox_directory;
   store;
   core;
   constructor(options) {
     this.store = new ClaudeOutboxStore(options.outbox_dir);
-    this.outbox_directory = this.store.directory;
     this.core = new HostProducerDrainCore(this, options);
   }
   drainOutbox() {
     return this.core.drainOutbox();
   }
-  fail(code2, message) {
-    return new ClaudeHostError(code2, message);
-  }
   listEnvelopes() {
     return this.store.listEnvelopes();
   }
   removeEnvelope(envelope) {
     return this.store.removeEnvelope(envelope);
   }
-  submissionRefOf(envelope) {
-    return envelope.submission_ref;
-  }
   expiresAtOf(envelope) {
     return envelope.expires_at;
   }
-  createdAtOf(envelope) {
-    return envelope.created_at;
-  }
-  async mapEnvelope(envelope) {
-    const prompt = observation(envelope, "prompt");
-    if (prompt !== void 0) return this.mapInput(envelope, prompt);
-    return [mapTerminal(envelope)];
-  }
-  async mapInput(envelope, prompt) {
-    const drafts = [];
-    const session = observation(envelope, "session");
-    if (session !== void 0) {
-      const registrations = await this.store.listTranscriptRegistrations();
-      const registration = registrations.find((item) => item.host_source_ref === envelope.identity.host_source_ref && item.host_session_ref === envelope.identity.host_session_ref);
-      const directoryIdentity = registration?.cwd ?? envelope.identity.host_session_ref;
-      drafts.push({
-        frame_kind: "session_started",
-        payload: compact({
-          local_session_ref: envelope.identity.host_session_ref,
-          working_directory_ref: claudeWorkspaceRef(directoryIdentity),
-          model: recordText(session.value, "model"),
-          observations: [session]
-        })
-      });
-    }
-    const turn = observation(envelope, "turn");
-    if (turn !== void 0) drafts.push({
-      frame_kind: "turn_started",
-      payload: compact({
-        local_session_ref: envelope.identity.host_session_ref,
-        local_turn_ref: localTurnRef(envelope),
-        observations: [turn]
-      })
-    });
-    if (!isCealHostPromptObservationValue(prompt.value)) throw new ClaudeHostError("storage", "Claude prompt observation is malformed.");
-    drafts.push({
-      frame_kind: "user_input",
-      payload: compact({
-        local_session_ref: envelope.identity.host_session_ref,
-        local_turn_ref: localTurnRef(envelope),
-        local_input_ref: envelope.host_input_ref,
-        input_kind: envelope.input_kind,
-        origin_input: envelope.origin_input,
-        observations: [prompt],
-        context_expires_at: envelope.expires_at
-      })
-    });
-    return drafts;
-  }
 };
-function mapTerminal(envelope) {
-  const usage = envelope.observations.filter((item) => ["token", "cost"].includes(item.observation_kind));
-  return {
-    frame_kind: "turn_terminal",
-    payload: compact({
-      local_session_ref: envelope.identity.host_session_ref,
-      local_turn_ref: localTurnRef(envelope),
-      terminal_state: "completed",
-      usage: usage.length === 0 ? void 0 : Object.fromEntries(usage.map((item) => [item.observation_kind, item.value])),
-      observations: envelope.observations
-    })
-  };
-}
-function observation(envelope, kind) {
-  return envelope.observations.find((item) => item.observation_kind === kind);
-}
-function localTurnRef(envelope) {
-  return envelope.identity.host_turn_ref;
-}
-function compact(value) {
-  return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== void 0));
-}
-function asRecord(value) {
-  return isRecord3(value) ? value : void 0;
-}
-function recordText(value, key) {
-  const record5 = asRecord(value);
-  return typeof record5?.[key] === "string" ? record5[key] : void 0;
-}
-function isRecord3(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 // host/claude/src/claude-transcript-watcher.ts
-import { O_NOFOLLOW as O_NOFOLLOW2, O_RDONLY as O_RDONLY3 } from "node:constants";
-import { open as open4, readdir as readdir2 } from "node:fs/promises";
+import { readdir as readdir2 } from "node:fs/promises";
 import { join as join4 } from "node:path";
 var TOKEN_OBSERVATION_SOURCE = "claude_transcript.message.usage";
 var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
   store;
-  registerCurrentPrompt;
   diagnostic;
   constructor(options) {
     super(options, {
@@ -3742,7 +4392,6 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       clock_failure: () => new ClaudeHostError("storage", "Claude watcher clock is invalid.")
     });
     this.store = new ClaudeOutboxStore(options.outbox_dir);
-    this.registerCurrentPrompt = options.register_current_prompt;
     this.diagnostic = options.diagnostic ?? (() => void 0);
   }
   transcriptPathOf(registration) {
@@ -3755,13 +4404,15 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
     const { size, device, inode } = await ownedClaudeTranscriptFile(handle);
     const cursor = await this.preflight(registration, handle, size, device, inode);
     if (cursor === null) return { records: 0, enqueued: 0, quarantined: true };
-    if (cursor.status === "quarantined") return { records: 0, enqueued: 0, quarantined: true };
+    if (cursor.status === "quarantined") {
+      return { records: 0, enqueued: 0, quarantined: true };
+    }
     const draft = mutableCursor(cursor);
     await this.scanOpenedTranscript(registration, handle, draft, size, device, inode);
     return { records: draft.consumed, enqueued: draft.enqueued, quarantined: false };
   }
   async scanFailed(handle, registration, error) {
-    this.diagnostic("watcher_scan_failed", claudeTranscriptScanFailureKind(error));
+    this.diagnostic("watcher_scan_failed", claudeTranscriptScanFailureKind(error), claudeTranscriptScanCause(handle, error));
     if (handle === void 0 && isSymlinkTranscript(error)) return await this.quarantineUnopened(registration, "transcript_malformed");
     if (error instanceof ClaudeHostError && error.code === "payload_rejected") return await this.quarantineDraft(await this.preservedCursor(registration));
     await this.quarantineFailure(registration, handle);
@@ -3814,42 +4465,59 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       if (isUserTurnLine(record5)) await this.openTurn(registration, draft, record5);
       else if (isAssistantUsageLine(record5)) this.accumulateUsage(draft, toUsage(record5.uuid, record5.timestamp, record5.message.usage));
       else if (isAssistantLine(record5) && record5.message.usage !== void 0) throw new ClaudeHostError("payload_rejected", "Claude transcript usage is malformed.");
+      else {
+        const queued = decodeClaudeQueuedPromptRow(record5, registration.claude_session_id);
+        if (queued !== null) await this.openQueuedTurn(registration, draft, queued);
+      }
     }
   }
   async openTurn(registration, draft, record5) {
-    this.diagnostic("watcher_turn_observed");
-    await this.closeTurn(registration, draft, record5.timestamp);
+    await this.openPromptTurn(registration, draft, { uuid: record5.uuid, timestamp: record5.timestamp, content: record5.message.content });
+  }
+  async openQueuedTurn(registration, draft, queued) {
+    await this.openPromptTurn(registration, draft, { uuid: queued.turnId, timestamp: queued.timestamp, content: queued.content });
+  }
+  async openPromptTurn(registration, draft, prompt) {
+    await this.closeTurn(registration, draft, prompt.timestamp);
     const sessionRef = registration.host_session_ref;
-    const turnRef = claudeLocalTurnRef(registration.claude_session_id, record5.uuid);
-    const inputRef = claudeLocalInputRef(registration.claude_session_id, record5.uuid);
-    const promptRef = hostProducerPromptRef(this.sha(record5.message.content));
+    const turnRef = claudeLocalTurnRef(registration.claude_session_id, prompt.uuid);
+    const inputRef = claudeLocalInputRef(registration.claude_session_id, prompt.uuid);
+    const promptRef = hostProducerPromptRef(this.sha(prompt.content));
     const identity = { host_source_ref: registration.host_source_ref, host_session_ref: sessionRef, host_turn_ref: turnRef };
     const observations = [
-      { observation_ref: observationRef("transcript_user_text", inputRef, record5.message.content), observation_kind: "prompt", observed_at: record5.timestamp, value: { body_sha256: this.sha(record5.message.content) } },
-      { observation_ref: observationRef("transcript_turn_started", turnRef, record5.uuid), observation_kind: "turn", observed_at: record5.timestamp, value: { status: "started", host_session_id_sha256: this.sha(registration.claude_session_id), host_turn_ref: turnRef } }
+      { observation_ref: observationRef(registration.host_source_ref, "transcript_user_text", inputRef, prompt.content), observation_kind: "prompt", observed_at: prompt.timestamp, value: { body_sha256: this.sha(prompt.content) } },
+      { observation_ref: observationRef(registration.host_source_ref, "transcript_turn_started", turnRef, prompt.uuid), observation_kind: "turn", observed_at: prompt.timestamp, value: { status: "started", host_session_id_sha256: this.sha(registration.claude_session_id), host_turn_ref: turnRef } }
     ];
     if (!draft.session_observed) {
       const session = await this.store.readSession(registration.host_source_ref, sessionRef);
-      if (session !== null) observations.push({ observation_ref: observationRef("transcript_session", sessionRef, session.value), observation_kind: "session", observed_at: record5.timestamp, value: session.value });
+      if (session !== null) observations.push({ observation_ref: observationRef(registration.host_source_ref, "transcript_session", sessionRef, session.value), observation_kind: "session", observed_at: prompt.timestamp, value: session.value });
       draft.session_observed = true;
     }
+    await this.persistOpenedTurnContext(draft, { uuid: prompt.uuid, timestamp: prompt.timestamp, message: { content: prompt.content } }, inputRef, turnRef, promptRef, identity, observations);
+  }
+  async persistOpenedTurnContext(draft, record5, inputRef, turnRef, promptRef, identity, observations) {
+    const expiresAt = this.expire(this.outboxRetentionMs);
     await this.store.putEnvelope({
       schema_version: "ceal.claude_observation_outbox.v1",
       identity,
       host_input_ref: inputRef,
-      input_kind: "human",
       prompt_ref: promptRef,
       observations,
       origin_input: true,
       submission_ref: submissionRef("input", turnRef, inputRef, promptRef),
       created_at: record5.timestamp,
-      expires_at: this.expire(this.outboxRetentionMs)
+      expires_at: expiresAt
     });
     draft.enqueued += 1;
-    await this.registerPrompt(sessionRef, turnRef, promptRef, record5.message.content);
+    await this.activateOpenedTurnContext(identity, promptRef, expiresAt);
+    this.setOpenedTurn(draft, record5, inputRef, turnRef, promptRef);
+  }
+  async activateOpenedTurnContext(identity, promptRef, expiresAt) {
     const selection = await this.store.readInvocationTurnSelection(identity.host_source_ref, identity.host_session_ref);
     const turnGenerationRef = selection?.prompt_ref === promptRef ? selection.turn_generation_ref : void 0;
-    await this.activateContext(identity, promptRef, turnGenerationRef);
+    await this.activateContext(identity, promptRef, turnGenerationRef, expiresAt);
+  }
+  setOpenedTurn(draft, record5, inputRef, turnRef, promptRef) {
     const folded = foldUnattributed(draft.unattributed);
     draft.open_turn = {
       turn_key: turnRef,
@@ -3868,9 +4536,10 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
     draft.open_turn = void 0;
     if (turn === void 0) return;
     const digest2 = terminalDigest(turn);
-    if (digest2 === turn.last_terminal_digest) return;
-    await this.putTerminalEnvelope(registration, turn, digest2, turn.message_ids.length === 0 ? at : void 0);
-    draft.enqueued += 1;
+    if (digest2 !== turn.last_terminal_digest) {
+      await this.putTerminalEnvelope(registration, turn, digest2, turn.message_ids.length === 0 ? at : void 0);
+      draft.enqueued += 1;
+    }
   }
   accumulateUsage(draft, usage) {
     const turn = draft.open_turn;
@@ -3904,6 +4573,8 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       if (isMissingTranscriptError(error) || isNotDirectory(error)) return 0;
       throw new ClaudeHostError("payload_rejected", "Claude subagent transcript directory is unavailable.");
     }
+    const listed = new Set(names);
+    for (const name of Object.keys(draft.subagents)) if (!listed.has(name)) delete draft.subagents[name];
     if (names.length > CLAUDE_TRANSCRIPT_MAX_SUBAGENT_FILES) {
       this.log(`Claude ignored subagent transcripts past its file bound: transcript_path=${JSON.stringify(registration.transcript_path)}, files=${names.length}.`);
       names = names.slice(0, CLAUDE_TRANSCRIPT_MAX_SUBAGENT_FILES);
@@ -3918,7 +4589,7 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
     const path = join4(directory, name);
     let handle;
     try {
-      handle = await open4(path, O_RDONLY3 | O_NOFOLLOW2);
+      handle = await openNoFollow(path);
       const { size, device, inode } = await ownedClaudeTranscriptFile(handle);
       const entry = draft.subagents[name] ?? { offset: 0, anchor_start: 0, anchor_sha256: this.sha(Buffer.alloc(0)) };
       const pinned = await this.preflightSubagent(entry, size, device, inode);
@@ -3985,12 +4656,10 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       schema_version: "ceal.claude_observation_outbox.v1",
       identity,
       host_input_ref: turn.host_input_ref,
-      input_kind: "host_automatic",
       prompt_ref: turn.prompt_ref,
       observations: [
-        { observation_ref: observationRef("transcript_terminal", turn.turn_key, digest2), observation_kind: "turn", observed_at: observedAt, value: { status: "stopped", host_session_id_sha256: this.sha(registration.claude_session_id), host_turn_ref: turn.turn_key } },
-        { observation_ref: observationRef("transcript_token", turn.turn_key, digest2), observation_kind: "token", observed_at: observedAt, value: tokenValue },
-        { observation_ref: observationRef("transcript_cost", turn.turn_key, digest2), observation_kind: "cost", observed_at: observedAt, value: hostObservationNotRecorded("provider_cost_not_observed") }
+        { observation_ref: observationRef(registration.host_source_ref, "transcript_terminal", turn.turn_key, digest2), observation_kind: "turn", observed_at: observedAt, value: { status: "stopped", host_session_id_sha256: this.sha(registration.claude_session_id), host_turn_ref: turn.turn_key } },
+        { observation_ref: observationRef(registration.host_source_ref, "transcript_token", turn.turn_key, digest2), observation_kind: "token", observed_at: observedAt, value: tokenValue }
       ],
       origin_input: false,
       submission_ref: submissionRef("terminal", turn.turn_key, digest2, turn.prompt_ref),
@@ -4018,27 +4687,9 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       updated_at: this.stamp()
     });
   }
-  async registerPrompt(sessionRef, turnRef, promptRef, prompt) {
-    if (this.producerInstallationRef === void 0 || this.registerCurrentPrompt === void 0) return;
-    try {
-      await this.registerCurrentPrompt({
-        producer_id: "claude",
-        producer_installation_ref: this.producerInstallationRef,
-        local_session_ref: sessionRef,
-        local_turn_ref: turnRef,
-        prompt_ref: promptRef,
-        current_prompt: prompt,
-        context_expires_at: this.expire(this.outboxRetentionMs)
-      });
-      this.diagnostic("current_prompt_registered");
-    } catch (error) {
-      this.diagnostic("current_prompt_registration_failed");
-      throw error;
-    }
-  }
-  async activateContext(identity, promptRef, turnGenerationRef) {
+  async activateContext(identity, promptRef, turnGenerationRef, expiresAt) {
     try {
-      await this.store.activateInvocationContext(identity, promptRef, this.expire(this.outboxRetentionMs), void 0, turnGenerationRef);
+      await this.store.activateInvocationContext(identity, promptRef, expiresAt, void 0, turnGenerationRef);
       this.diagnostic("activation_recorded");
     } catch (error) {
       this.diagnostic("activation_failed");
@@ -4162,18 +4813,6 @@ function isUserTurnLine(record5) {
   if (identity === null) throw new ClaudeHostError("payload_rejected", "Claude transcript user line is malformed.");
   return true;
 }
-function claudeTranscriptScanFailureKind(error) {
-  if (isSymlinkTranscript(error)) return "symlink";
-  if (error instanceof ClaudeHostError) {
-    if (error.diagnostic_kind !== void 0) return error.diagnostic_kind;
-    if (error.code === "payload_rejected") return "payload_rejected";
-    if (error.code === "storage") return "read_error";
-  }
-  const code2 = transcriptErrorCode(error);
-  if (code2 === "EFBIG") return "size_budget";
-  if (["EBADF", "EACCES", "EIO", "EMFILE", "ENFILE", "ENOENT", "ENOTDIR", "EPERM"].includes(code2 ?? "")) return "read_error";
-  return "other";
-}
 function isAssistantLine(record5) {
   return isTranscriptRecord(record5) && record5.type === "assistant" && isTranscriptRecord(record5.message);
 }
@@ -4188,42 +4827,50 @@ function subagentsDirectory(transcriptPath) {
   const stem = transcriptPath.endsWith(".jsonl") ? transcriptPath.slice(0, -".jsonl".length) : transcriptPath;
   return join4(stem, "subagents");
 }
-function observationRef(event, identity, value) {
-  return cealHostObservationRef("claude", transcriptObjectSha256({ event, identity, value }));
+function observationRef(hostSourceRef, event, identity, value) {
+  return cealHostObservationRef("claude", transcriptObjectSha256({ host_source_ref: hostSourceRef, event, identity, value }));
 }
 function submissionRef(kind, turn, digest2, prompt) {
   return `claude-submission:${transcriptObjectSha256({ kind, turn, digest: digest2, prompt })}`;
 }
 async function ownedClaudeTranscriptFile(handle) {
   const stats = await handle.stat();
-  const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
   if (!stats.isFile()) throw new ClaudeHostError("payload_rejected", "Claude transcript source is not a regular file.");
-  if (stats.uid !== uid) throw new ClaudeHostError("payload_rejected", "Claude transcript source is owned by another user.");
+  if (process.platform !== "win32" && !isSelfOwned(stats.uid, process.platform, handle)) throw new ClaudeHostError("payload_rejected", "Claude transcript source is owned by another user.");
   return { size: stats.size, device: String(stats.dev), inode: String(stats.ino) };
 }
 function isNotDirectory(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOTDIR";
 }
+function claudeTranscriptScanCause(handle, error) {
+  if (error instanceof ClaudeHostError) return error.diagnostic_kind ?? error.code;
+  const code2 = transcriptErrorCode(error);
+  if (code2 !== null) return `${handle === void 0 ? "open" : "scan"}:${code2}`;
+  return `${handle === void 0 ? "open" : "scan"}:unknown`;
+}
+function claudeTranscriptScanFailureKind(error) {
+  return transcriptScanFailureKind(error, (candidate) => {
+    if (!(candidate instanceof ClaudeHostError)) return void 0;
+    if (candidate.diagnostic_kind !== void 0) return candidate.diagnostic_kind;
+    if (candidate.code === "payload_rejected") return "payload_rejected";
+    if (candidate.code === "storage") return "read_error";
+    return void 0;
+  });
+}
 function isSymlinkTranscript(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ELOOP";
 }
-function transcriptErrorCode(error) {
-  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
-}
 // host/claude/src/claude-producer-runtime.ts
 async function drainClaudeProducerOnce(options) {
-  const promptPort = new HostRelayCurrentPromptPort(options.relay_endpoint, options.timeout_ms);
   const scan = await new ClaudeTranscriptWatcher({
     outbox_dir: options.outbox_dir,
-    producer_installation_ref: options.producer_installation_ref,
-    register_current_prompt: (input) => promptPort.register(input),
-    diagnostic: (event, failure_kind) => writeHostServiceDiagnostic("claude", event, failure_kind)
+    diagnostic: (event, failure_kind, cause) => writeHostServiceDiagnostic("claude", event, failure_kind, cause)
   }).scanOnce().catch((error) => {
-    writeHostServiceDiagnostic("claude", "watcher_scan_failed", claudeTranscriptScanFailureKind(error));
+    writeHostServiceDiagnostic("claude", "watcher_scan_failed", claudeTranscriptScanFailureKind(error), claudeTranscriptScanCause(void 0, error));
     throw error;
   });
-  const producer = new ClaudeProducer({ outbox_dir: options.outbox_dir, producer_installation_ref: options.producer_installation_ref, relay: new HostRelayIpcAdmissionPort(options.relay_endpoint, options.timeout_ms), ...options.producer_epoch === void 0 ? {} : { producer_epoch: options.producer_epoch }, ...options.now === void 0 ? {} : { now: options.now } });
+  const producer = new ClaudeProducer({ outbox_dir: options.outbox_dir, ...options.now === void 0 ? {} : { now: options.now } });
   return { scanned: scan.enqueued, ...await producer.drainOutbox() };
 }
@@ -4236,19 +4883,25 @@ var CLAUDE_PRODUCER_DESCRIPTOR = {
   extra_paths: [CLAUDE_TRANSCRIPTS_ROOT],
   config: (shared, extras) => ({ ...shared, claude_transcripts_root: hostProducerExtraPath(extras, CLAUDE_TRANSCRIPTS_ROOT) }),
   runtime_options: (config) => Object.freeze({
-    outbox_dir: config.outbox_dir,
-    producer_installation_ref: config.producer_installation_ref,
-    producer_epoch: config.producer_epoch,
-    relay_endpoint: config.relay_endpoint,
-    timeout_ms: config.ipc_timeout_ms
+    outbox_dir: config.outbox_dir
   }),
   drain: drainClaudeProducerOnce
 };
 // host/claude/src/claude-visible-output-budget.ts
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 import { homedir } from "node:os";
+import { join as join6 } from "node:path";
+// host/claude/src/claude-runtime-paths.ts
 import { join as join5 } from "node:path";
+var CLAUDE_CONFIG_DIRECTORY_ENVIRONMENT = "CLAUDE_CONFIG_DIR";
+var CLAUDE_HOME_DEFAULT_DIRECTORY = ".claude";
+function resolveClaudeConfigHome(environment, home) {
+  return environment[CLAUDE_CONFIG_DIRECTORY_ENVIRONMENT] || join5(home, CLAUDE_HOME_DEFAULT_DIRECTORY);
+}
+// host/claude/src/claude-visible-output-budget.ts
 var CLAUDE_DEFAULT_BASH_OUTPUT_MAX_CHARS = 3e4;
 var CLAUDE_MAX_INLINE_OUTPUT_MAX_CHARS = 128e3;
 async function resolveClaudeVisibleOutputMaxBytes(environment = process.env, workingDirectory = process.cwd()) {
@@ -4258,17 +4911,17 @@ async function resolveClaudeVisibleOutputMaxBytes(environment = process.env, wor
   return Math.min(bashReadback ?? CLAUDE_DEFAULT_BASH_OUTPUT_MAX_CHARS, CLAUDE_DEFAULT_BASH_OUTPUT_MAX_CHARS);
 }
 async function projectOrUserInlineLimit(environment, workingDirectory) {
-  const configHome = environment.CLAUDE_CONFIG_DIR ?? join5(homedir(), ".claude");
-  const userLimit = await settingsInlineLimit(join5(configHome, "settings.json"));
-  const projectLimit = await settingsInlineLimit(join5(workingDirectory, ".claude", "settings.json"));
-  const localLimit = await settingsInlineLimit(join5(workingDirectory, ".claude", "settings.local.json"));
+  const configHome = resolveClaudeConfigHome(environment, homedir());
+  const userLimit = await settingsInlineLimit(join6(configHome, "settings.json"));
+  const projectLimit = await settingsInlineLimit(join6(workingDirectory, ".claude", "settings.json"));
+  const localLimit = await settingsInlineLimit(join6(workingDirectory, ".claude", "settings.local.json"));
   const candidate = localLimit ?? projectLimit ?? userLimit;
   return candidate === void 0 ? void 0 : Math.min(candidate, CLAUDE_MAX_INLINE_OUTPUT_MAX_CHARS);
 }
 async function settingsInlineLimit(path) {
   try {
-    const parsed = JSON.parse(await readFile3(path, "utf8"));
-    if (!isRecord4(parsed)) return void 0;
+    const parsed = JSON.parse(await readFile2(path, "utf8"));
+    if (!isRecord5(parsed)) return void 0;
     return positiveInteger(parsed.bashOutputMaxChars);
   } catch {
     return void 0;
@@ -4279,7 +4932,7 @@ function positiveInteger(value) {
   const parsed = typeof normalized === "string" && normalized.length > 0 ? Number(normalized) : normalized;
   return typeof parsed === "number" && Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -4293,23 +4946,83 @@ var CLAUDE_INVOCATION_AUTHENTICATION_DESCRIPTOR = {
   config_flag: HOST_PRODUCER_CONFIG_FLAG,
   parse_config_flag: parseHostProducerConfigFlag,
   read_producer_config: (configPath) => readHostProducerConfig(CLAUDE_PRODUCER_DESCRIPTOR, configPath),
-  resolve_visible_output_max_bytes: () => resolveClaudeVisibleOutputMaxBytes()
+  resolve_visible_output_max_bytes: () => resolveClaudeVisibleOutputMaxBytes(),
+  read_human_message_window: readClaudeInvocationHumanMessageWindow
 };
 function runClaudeInvocationAuthenticationCommand(args, options) {
   return runHostInvocationAuthenticationCommand(CLAUDE_INVOCATION_AUTHENTICATION_DESCRIPTOR, args, options);
 }
+async function readClaudeInvocationHumanMessageWindow(input) {
+  return readRegisteredHostInvocationHumanMessageWindow(() => input.store.listTranscriptRegistrations(), input.identity, (line, registration) => {
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      return "malformed";
+    }
+    const message = decodeClaudeHumanMessageRow(row, registration.claude_session_id);
+    return message === null ? null : {
+      host_turn_ref: claudeLocalTurnRef(registration.claude_session_id, message.turnId),
+      host_input_ref: claudeLocalInputRef(registration.claude_session_id, message.turnId),
+      text: message.content
+    };
+  });
+}
 // host/client-doctor.ts
-import { createHash as createHash5 } from "node:crypto";
-import { execFile } from "node:child_process";
-import { access, open as open5, readFile as readFile4, realpath, stat } from "node:fs/promises";
-import { delimiter, isAbsolute as isAbsolute2, join as join6 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { execFile as execFile2 } from "node:child_process";
+import { access, open as open3, readFile as readFile3, realpath, stat as stat2 } from "node:fs/promises";
+import { delimiter, isAbsolute as isAbsolute3, join as join7 } from "node:path";
 import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
+// host/command-vector.ts
+import { win32 as win326 } from "node:path";
+var MAX_COMMAND_BYTES = 4096;
+function formatHostCommand(vector, platform) {
+  return formatWith(vector, platform === "windows" ? quoteWindowsArgument : quotePosixArgument);
+}
+function hostScriptLauncherInvocation(launcherPath, args, platform = process.platform, environment = process.env) {
+  if (/\.(?:cjs|js|mjs)$/iu.test(launcherPath)) return { executable: process.execPath, args: [launcherPath, ...args] };
+  if (platform === "win32" && /\.(?:bat|cmd)$/iu.test(launcherPath)) {
+    return {
+      executable: environment.ComSpec ?? "cmd.exe",
+      args: ["/d", "/s", "/c", `call ${formatHostCommand({ executable: launcherPath, args }, "windows")}`],
+      windowsVerbatimArguments: true
+    };
+  }
+  if (platform === "win32" && /\.ps1$/iu.test(launcherPath)) {
+    return {
+      executable: win326.join(environment.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+      args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-File", launcherPath, ...args]
+    };
+  }
+  return { executable: launcherPath, args };
+}
+function formatWith(vector, quote) {
+  const command = [vector.executable, ...vector.args].map(quote).join(" ");
+  const commandBytes = Buffer.byteLength(command, "utf8");
+  if (commandBytes > MAX_COMMAND_BYTES) throw new TypeError(`Host command vector is too large (${refusalFact("bytes", commandBytes, `at most ${MAX_COMMAND_BYTES} UTF-8 bytes`)}).`);
+  return command;
+}
+function quotePosixArgument(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function quoteWindowsArgument(value) {
+  if (value.includes("%") || value.includes("!")) throw new TypeError("Host command vector contains unsafe Windows expansion syntax.");
+  return quoteWindowsExecArgument(value);
+}
+function quoteWindowsExecArgument(value) {
+  const escaped = value.replace(/(\\*)"/gu, '$1$1\\"').replace(/(\\+)$/gu, "$1$1");
+  return `"${escaped}"`;
+}
+// host/client-doctor.ts
+var execFileAsync = promisify(execFile2);
 var GIT_OID = /^[a-f0-9]{40}$/u;
 var SHA2562 = /^[a-f0-9]{64}$/u;
-var SAFE_REF5 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
-var CEAL_ENVIRONMENT_OVERRIDES = ["CEAL_GATEWAY_ORIGIN", "CEAL_GATEWAY_TRANSPORT_ORIGIN", "CEAL_ACCESS_TOKEN", "CEAL_CONTEXT_STORE_PATH"];
+var SAFE_REF4 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
+var CEAL_ENVIRONMENT_OVERRIDES = CEAL_CLIENT_CONTEXT_OVERRIDE_ENVIRONMENTS;
 async function doctorClient(options = {}, component) {
   const environment = canonicalClientEnvironment(options.environment ?? process.env);
   const run = options.run ?? executeCealCommand;
@@ -4346,7 +5059,7 @@ async function inspectExecutable(options, environment, component) {
   return { ok: true, value: executable };
 }
 async function inspectVersion(options, executable, environment, run, component) {
-  const probe = hostClientProbe(await safeRun(run, executable.path, ["version"], environment), (result) => versionIdentity(commandDocument(result)));
+  const probe = hostClientProbe(await safeRun(run, executable.path, CEAL_CLIENT_VERSION_COMMAND, environment), (result) => versionIdentity(commandDocument(result)));
   if (probe.kind !== "value") return probeFailure(probe, "version", component, options);
   if (options.expected_source_commit !== void 0 && probe.value.source_commit !== options.expected_source_commit) return inspectedFailure("ceal_identity_mismatch", `The Ceal executable visible to the ${component} Host did not return the expected source identity (${refusalFact("source_commit", probe.value.source_commit, `expected ${options.expected_source_commit}`)}).`, `Install the exact candidate, restart ${component}, and verify \`ceal version\` from that Host.`);
   return { ok: true, value: probe.value };
@@ -4363,8 +5076,8 @@ function probeCode(code2) {
   return "ceal_output_unreadable";
 }
 async function inspectCanonicalContext(options, executable, environment, run, component) {
-  const probe = hostClientProbe(await safeRun(run, executable.path, ["access-group", "list"], environment), (result) => selectedContext(commandDocument(result)));
-  if (probe.kind === "unreachable") return probeFailure(probe, "access-group list", component, options);
+  const probe = hostClientProbe(await safeRun(run, executable.path, CEAL_CLIENT_ACCESS_GROUP_LIST_COMMAND, environment), (result) => selectedContext(commandDocument(result)));
+  if (probe.kind === "unreachable") return probeFailure(probe, CEAL_CLIENT_ACCESS_GROUP_LIST_COMMAND.join(" "), component, options);
   if (probe.kind !== "value" || options.expected_instance_ref !== void 0 && probe.value.instance_ref !== options.expected_instance_ref) return inspectedFailure("canonical_context_unavailable", `The ${component} Host cannot select the intended authenticated context from Ceal's canonical user configuration (${refusalFacts([{ name: "probe_kind", value: probe.kind, expected: "value" }, { name: "instance_ref", value: probe.kind === "value" ? probe.value.instance_ref : "unavailable", expected: options.expected_instance_ref ?? "a selected context" }])}).`, `Run \`ceal session adopt --email <email>\` without CEAL context overrides, then restart ${component}.`);
   return { ok: true, value: probe.value };
 }
@@ -4377,15 +5090,15 @@ function canonicalClientEnvironment(input) {
   return environment;
 }
 async function resolveCealExecutable(command, environment) {
-  const candidates = isAbsolute2(command) ? [command] : (environment.PATH ?? "").split(delimiter).filter((entry) => entry.length > 0).map((entry) => join6(entry, command));
+  const candidates = isAbsolute3(command) ? [command] : (environment.PATH ?? "").split(delimiter).filter((entry) => entry.length > 0).map((entry) => join7(entry, command));
   for (const candidate of candidates) {
     try {
       await access(candidate);
       const path = await realpath(candidate);
-      const metadata = await stat(path);
+      const metadata = await stat2(path);
       if (!metadata.isFile()) continue;
       if (await isLauncher(path)) return resolveLauncherBinary(path, environment);
-      return { path, sha256: createHash5("sha256").update(await readFile4(path)).digest("hex") };
+      return { path, sha256: createHash6("sha256").update(await readFile3(path)).digest("hex") };
     } catch {
     }
   }
@@ -4393,7 +5106,7 @@ async function resolveCealExecutable(command, environment) {
 }
 async function isLauncher(path) {
   if (/\.(?:bat|cjs|cmd|js|mjs|ps1)$/u.test(path)) return true;
-  const handle = await open5(path, "r");
+  const handle = await open3(path, "r");
   try {
     const buffer = Buffer.alloc(128);
     const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, 0);
@@ -4404,25 +5117,26 @@ async function isLauncher(path) {
   }
 }
 async function resolveLauncherBinary(launcherPath, environment) {
-  const result = await execFileAsync(launcherPath, ["doctor"], { env: environment, timeout: 15e3, encoding: "utf8", windowsHide: false });
+  const invocation = hostScriptLauncherInvocation(launcherPath, CEAL_CLIENT_DOCTOR_COMMAND, process.platform, environment);
+  const result = await execFileAsync(invocation.executable, [...invocation.args], { env: environment, timeout: 15e3, encoding: "utf8", windowsHide: false, ...invocation.windowsVerbatimArguments === void 0 ? {} : { windowsVerbatimArguments: invocation.windowsVerbatimArguments } });
   let parsed;
   try {
     parsed = JSON.parse(result.stdout);
   } catch {
     throw new Error("launcher doctor returned unreadable output");
   }
-  if (!isRecord5(parsed) || parsed.schema_version !== "ceal.doctor.v1" || parsed.ok !== true || typeof parsed.binary_path !== "string" || parsed.binary_path.length === 0) throw new Error("launcher doctor did not report a binary path");
+  if (!isRecord6(parsed) || parsed.schema_version !== CEAL_CLIENT_DOCTOR_SCHEMA_VERSION || parsed.ok !== true || typeof parsed.binary_path !== "string" || parsed.binary_path.length === 0) throw new Error("launcher doctor did not report a binary path");
   const binaryPath = await realpath(parsed.binary_path);
-  const metadata = await stat(binaryPath);
+  const metadata = await stat2(binaryPath);
   if (!metadata.isFile()) throw new Error("launcher doctor reported a non-file binary path");
-  return { path: binaryPath, sha256: createHash5("sha256").update(await readFile4(binaryPath)).digest("hex") };
+  return { path: binaryPath, sha256: createHash6("sha256").update(await readFile3(binaryPath)).digest("hex") };
 }
 async function executeCealCommand(executable, args, environment) {
   try {
     const result = await execFileAsync(executable, [...args], { env: environment, timeout: 15e3, encoding: "utf8" });
     return { exit_code: 0, stdout: result.stdout, stderr: result.stderr };
   } catch (error) {
-    if (isRecord5(error)) return { exit_code: typeof error.code === "number" ? error.code : 1, stdout: typeof error.stdout === "string" ? error.stdout : "", stderr: typeof error.stderr === "string" ? error.stderr : "" };
+    if (isRecord6(error)) return { exit_code: typeof error.code === "number" ? error.code : 1, stdout: typeof error.stdout === "string" ? error.stdout : "", stderr: typeof error.stderr === "string" ? error.stderr : "" };
     throw error;
   }
 }
@@ -4433,34 +5147,34 @@ function commandDocument(result) {
   if (result === null) return null;
   try {
     const value = JSON.parse(result.stdout);
-    return isRecord5(value) ? value : null;
+    return isRecord6(value) ? value : null;
   } catch {
     return null;
   }
 }
 function selectedContext(value) {
   if (value?.schema_version !== "ceal.access-group.v1" || value.ok !== true || !Array.isArray(value.contexts)) return null;
-  const selected = value.contexts.filter((item) => isRecord5(item) && item.selected === true);
+  const selected = value.contexts.filter((item) => isRecord6(item) && item.selected === true);
   if (selected.length !== 1) return null;
   return selectedContextRecord(selected[0]);
 }
 function selectedContextRecord(item) {
-  if (!isRecord5(item) || typeof item.name !== "string" || typeof item.instance_ref !== "string") return null;
-  if (!SAFE_REF5.test(item.instance_ref)) return null;
+  if (!isRecord6(item) || typeof item.name !== "string" || typeof item.instance_ref !== "string") return null;
+  if (!SAFE_REF4.test(item.instance_ref)) return null;
   return { name: item.name, instance_ref: item.instance_ref };
 }
 function versionIdentity(value) {
-  if (value?.schema_version !== "ceal.version.v1" || value.ok !== true || typeof value.version !== "string" || typeof value.source_commit !== "string" || typeof value.source_tree !== "string") return null;
+  if (value?.schema_version !== CEAL_CLIENT_VERSION_SCHEMA_VERSION || value.ok !== true || typeof value.version !== "string" || typeof value.source_commit !== "string" || typeof value.source_tree !== "string") return null;
   if (value.version.length === 0 || !GIT_OID.test(value.source_commit) || !GIT_OID.test(value.source_tree)) return null;
   return { version: value.version, source_commit: value.source_commit, source_tree: value.source_tree };
 }
 function validExpectations(options) {
-  return (options.expected_sha256 === void 0 || SHA2562.test(options.expected_sha256)) && (options.expected_source_commit === void 0 || GIT_OID.test(options.expected_source_commit)) && (options.expected_instance_ref === void 0 || SAFE_REF5.test(options.expected_instance_ref));
+  return (options.expected_sha256 === void 0 || SHA2562.test(options.expected_sha256)) && (options.expected_source_commit === void 0 || GIT_OID.test(options.expected_source_commit)) && (options.expected_instance_ref === void 0 || SAFE_REF4.test(options.expected_instance_ref));
 }
 function failure(code2, message, next_action) {
   return { ok: false, status: "failure", error: { code: code2, message, next_action } };
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }