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

package/libexec/ceal-host/codex-hook.mjs

@@ -3,8 +3,9 @@ import { createRequire as __cealCreateRequire } from "node:module";
 const require = __cealCreateRequire(import.meta.url);
 
 // host/codex/src/codex-adapter.ts
+import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { isAbsolute as isAbsolute3, join as join3, relative, resolve as resolve2 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join4, relative, resolve as resolve2 } from "node:path";
 
 // packages/ceal-client-protocol/src/canonical-json.ts
 function cealCanonicalJson(value) {
@@ -113,6 +114,9 @@ var client_wire_contract_default = {
       "document"
     ],
     optional_fields: [
+      "operation_id",
+      "visible_output_max_bytes",
+      "local_delivery",
       "verified_artifact"
     ],
     bare_document_fields: [
@@ -226,6 +230,7 @@ var CEAL_WRITE_RECEIPT_PROVIDER_STATES = vocabulary(["outcome_unknown", "verifie
 var CEAL_WRITE_RECEIPT_PROVIDER_READBACKS = vocabulary(["outcome_unknown", "verified", "not_applied"]);
 var CEAL_PROTOCOL_VERSION = "1.4.0";
 var CEAL_OPERATION_ACCESS_SCHEMA_VERSION = "ceal.operation_access.v1";
+var CEAL_GATEWAY_CONTINUATION_CURSOR_PHASES = vocabulary(["scan", "delivery", "terminal"]);
 var CEAL_GATEWAY_ACTIVE_CALL_PHASES = vocabulary([
   "audited_call_pending",
   "continuation_read_pending",
@@ -249,6 +254,7 @@ var CEAL_GATEWAY_ORGANIZATION_ROUTE_FACT_CALL_KEYS = Object.freeze([
 // packages/ceal-client-protocol/src/operation-next-actions.ts
 var CEAL_REPEAT_REQUEST_NEXT_ACTION = "repeat_request";
 var CEAL_INSPECT_RECEIPT_NEXT_ACTION = "inspect_receipt";
+var CEAL_ANSWER_WITH_GAP_NEXT_ACTION = "answer_with_gap";
 var CALLER_RECOVERABLE_NEXT_ACTION_VALUES = [
   "select_did_you_mean",
   "choose_new_output_path",
@@ -302,10 +308,20 @@ var CALLER_RECOVERABLE_NEXT_ACTION_VALUES = [
   "retry_after",
   // The ref names a container of rows (a Notion database or data source), which
   // has no body of its own; the caller searches its rows instead of reading it.
-  "search_container_rows"
+  "search_container_rows",
+  // A settled unknown write names the exact receipt Operation that can inspect
+  // its outcome without issuing another provider mutation.
+  "write_receipt.get",
+  // Command resolution carries the exact required Operation sequence beside
+  // this action, so the caller can execute each declared input in order.
+  "follow_required_action_sequence",
+  // The command needs caller-owned local materialization (for example an
+  // @path file) before the Gateway can receive the argument.
+  "materialize_local_argument"
 ];
 var CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS = Object.freeze(CALLER_RECOVERABLE_NEXT_ACTION_VALUES);
 var NON_REMEDY_NEXT_ACTION_VALUES = [
+  CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
   // Only an administrator can take the named step -- approving a place for an
   // Operation, granting a withheld capability -- so a non-administrator asks
   // one. The refusal names the administrator step; this word is the ask.
@@ -353,7 +369,58 @@ var NON_REMEDY_NEXT_ACTION_VALUES = [
   "select_exact_approval"
 ];
 var CEAL_NON_REMEDY_NEXT_ACTIONS = Object.freeze(NON_REMEDY_NEXT_ACTION_VALUES);
-var DECLARED = /* @__PURE__ */ new Set([...CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS, ...CEAL_NON_REMEDY_NEXT_ACTIONS]);
+var CEAL_DECLARED_NEXT_ACTIONS = Object.freeze([...CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS, ...CEAL_NON_REMEDY_NEXT_ACTIONS]);
+var DECLARED = new Set(CEAL_DECLARED_NEXT_ACTIONS);
+function defineCealNonModelNextActions(actions) {
+  return actions;
+}
+var NON_MODEL_NEXT_ACTION_VALUES = defineCealNonModelNextActions([
+  CEAL_INSPECT_RECEIPT_NEXT_ACTION,
+  "await_pending_approval",
+  "inspect_gateway",
+  "operator_action",
+  "none",
+  "check_gateway",
+  "inspect_context_store",
+  "inspect_local_cache",
+  "inspect_local_client",
+  "inspect_local_command",
+  "inspect_local_output",
+  "inspect_local_route",
+  "inspect_request",
+  "reconcile",
+  "reconcile_occurrence",
+  "retry_after_owner_recovery",
+  "select_exact_approval"
+]);
+var NON_MODEL_NEXT_ACTIONS = new Set(NON_MODEL_NEXT_ACTION_VALUES);
+function isCealModelActionableNonRemedyNextAction(action) {
+  return !NON_MODEL_NEXT_ACTIONS.has(action);
+}
+var CEAL_MODEL_ACTIONABLE_NEXT_ACTIONS = Object.freeze([
+  ...CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS,
+  ...CEAL_NON_REMEDY_NEXT_ACTIONS.filter(isCealModelActionableNonRemedyNextAction)
+]);
+var MODEL_ACTIONABLE = new Set(CEAL_MODEL_ACTIONABLE_NEXT_ACTIONS);
+var NON_MODEL_ACTION_TO_MODEL_ACTION = Object.freeze({
+  [CEAL_INSPECT_RECEIPT_NEXT_ACTION]: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  await_pending_approval: "ask_admin",
+  inspect_gateway: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  operator_action: "ask_admin",
+  none: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  check_gateway: "ask_admin",
+  inspect_context_store: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_cache: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_client: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_command: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_output: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_local_route: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  inspect_request: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  reconcile: CEAL_ANSWER_WITH_GAP_NEXT_ACTION,
+  reconcile_occurrence: "ask_admin",
+  retry_after_owner_recovery: "ask_admin",
+  select_exact_approval: "ask_admin"
+});
 var RETRY_PROMISE_NEXT_ACTIONS = ["retry", "retry_after"];
 var RETRY_PROMISE = new Set(RETRY_PROMISE_NEXT_ACTIONS);
 var RECOVERABLE = new Set(CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS);
@@ -623,21 +690,15 @@ var CEAL_OPERATION_ACCESS_CLASSES = vocabulary(["read", "write"]);
 // packages/ceal-client-protocol/src/domain-vocabulary.ts
 var CEAL_CONNECTOR_STATUSES = vocabulary(["active", "disabled", "disconnected"]);
 var CEAL_CONNECTOR_CUSTODIES = vocabulary(["organization", "personal"]);
-var CEAL_PROVIDER_BOUNDARY_KINDS = vocabulary([
-  "github_account",
-  "github_organization",
-  "google_workspace_domain",
-  "notion_workspace",
-  "slack_workspace"
-]);
-var CEAL_PROVIDER_BOUNDARY_EVIDENCE = vocabulary(["provider_readback", "operator_stated"]);
 var CEAL_ACCESS_LEVELS = vocabulary(["none", "read", "read_write"]);
 var CEAL_PERSONAL_ACCESS_CEILINGS = vocabulary(["disabled", "read", "read_write"]);
 var CEAL_TARGET_REF_PATTERN = "^[^\\p{Cc}]+$";
 var TARGET_REF = new RegExp(CEAL_TARGET_REF_PATTERN, "u");
 var CEAL_TARGET_VISIBILITIES = vocabulary(["public", "private"]);
-var CEAL_PRINCIPAL_KINDS = vocabulary(["human", "service", "runtime"]);
+var CEAL_PRINCIPAL_KINDS = vocabulary(["human", "runtime"]);
+var CEAL_PERSISTED_PRINCIPAL_KINDS = vocabulary(["human", "service", "runtime"]);
 var CEAL_ORGANIZATION_ROLES = vocabulary(["member", "admin"]);
+var CEAL_CALENDAR_PERIODS = vocabulary(["day", "week", "month"]);
 var LABEL_EXPECTATION = `public-safe display text of at most ${CEAL_PUBLIC_DISPLAY_NAME_MAX_BYTES} bytes`;
 
 // packages/ceal-client-protocol/src/safe-json-budget.ts
@@ -813,7 +874,7 @@ var CEAL_SCHEMA_LITERALS = [
   "ceal.operation_receipt.v1",
   "ceal.operation_result.v1",
   "ceal.operation_result.compact.v1",
-  "ceal.local_result_materialization.v1",
+  "ceal.local_result_file.v1",
   "ceal.local_result_root.v1",
   "ceal.owner_bootstrap_exchange_request.v1",
   "ceal.owner_bootstrap_exchange_result.v1",
@@ -907,41 +968,6 @@ var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_JSON_SCHEMA = Object.freeze({
   }
 });
 
-// packages/ceal-client-protocol/src/provider-operation-vocabulary.ts
-var CEAL_FILE_TYPE_FAMILIES = vocabulary(["all", "image", "pdf"]);
-var CEAL_GITHUB_ISSUE_STATES = vocabulary(["open", "closed", "all"]);
-var CEAL_NOTION_UPDATABLE_BLOCK_TYPES = vocabulary([
-  "paragraph",
-  "heading_1",
-  "heading_2",
-  "heading_3",
-  "bulleted_list_item",
-  "numbered_list_item",
-  "to_do",
-  "code"
-]);
-var CEAL_NOTION_NEUTRAL_TYPES = vocabulary([
-  "text",
-  "number",
-  "boolean",
-  "date",
-  "select",
-  "multi_select",
-  "people",
-  "url",
-  "email",
-  "phone",
-  "unsupported"
-]);
-var CEAL_NOTION_IDENTITY_GAP_REASONS = vocabulary([
-  "identity_unavailable",
-  "identity_stale",
-  "identity_ambiguous",
-  "identity_revoked",
-  "identity_unlinked"
-]);
-var CEAL_NOTION_STRING_VALUE_TYPES = vocabulary(["text", "select", "url", "email", "phone"]);
-
 // packages/ceal-client-protocol/src/opaque-reference.ts
 var CEAL_OPAQUE_HANDLE_KINDS = vocabulary(["target", "message", "thread", "artifact", "document", "block", "object"]);
 var CEAL_OPAQUE_REF_KINDS = vocabulary([...CEAL_OPAQUE_HANDLE_KINDS, "result", "operation-receipt", "reply-receipt", "field", "notion-data-source"]);
@@ -951,6 +977,7 @@ var REQUIRED_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_f
 var OPTIONAL_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_optional_fields;
 
 // packages/ceal-client-protocol/src/resource-row.ts
+var CEAL_RESOURCE_ROW_TITLE_MATCH_DISPOSITIONS = vocabulary(["exact", "not_exact", "unknown"]);
 var CEAL_RESOURCE_SEARCH_ORDERS = vocabulary(["relevance", "modified", "viewed", "created"]);
 var CEAL_RESOURCE_SEARCH_DIRECTIONS = vocabulary(["ascending", "descending"]);
 var CEAL_RESOURCE_SEARCH_FILTERS = vocabulary(["query", "modified_since", "since", "until", "authored_by_me", "authored_by", "include_replies", "kinds", "container_ref", "container_refs", "container_names", "addressed_to_me", "unread"]);
@@ -974,6 +1001,7 @@ var CEAL_ACTIVITY_TIMESTAMP_BASES = vocabulary([
   "resource_modified"
 ]);
 var CEAL_ACTIVITY_CONNECTOR_KINDS = vocabulary(["slack", "github", "google-calendar", "google-drive", "notion"]);
+var CEAL_ACTIVITY_UNSUPPORTED_EVENT_KIND_CODE = "unsupported_event_kind";
 var CEAL_ACTIVITY_GAP_CODES = vocabulary([
   "provider_page_budget",
   "call_deadline",
@@ -981,7 +1009,7 @@ var CEAL_ACTIVITY_GAP_CODES = vocabulary([
   "provider_cursor_unavailable",
   "malformed_provider_page",
   "visibility_incomplete",
-  "unsupported_event_kind",
+  CEAL_ACTIVITY_UNSUPPORTED_EVENT_KIND_CODE,
   "direct_messages_excluded"
 ]);
 var CEAL_ACTIVITY_EVENT_KINDS = vocabulary([
@@ -1033,6 +1061,7 @@ var RESOURCE_ROW_KEY_RULES = Object.freeze({
   next: { required: true, timestamp: false },
   kind: { required: true, timestamp: false },
   matched_kinds: { required: false, timestamp: false },
+  title_match: { required: false, timestamp: false },
   title: { required: true, timestamp: false },
   container_label: { required: true, timestamp: false },
   container_ref: { required: false, timestamp: false },
@@ -1046,6 +1075,8 @@ var RESOURCE_ROW_KEY_RULES = Object.freeze({
   modified_at: { required: false, timestamp: true },
   modified_at_local: { required: false, timestamp: true },
   viewed_by_me_at: { required: false, timestamp: true },
+  own_ceal_write: { required: false, timestamp: false },
+  owned_by_me: { required: false, timestamp: false },
   visibility: { required: false, timestamp: false },
   start: { required: false, timestamp: false },
   end: { required: false, timestamp: false },
@@ -1079,6 +1110,15 @@ function cealExcludedTargetCoverageJsonSchema() {
   };
 }
 
+// packages/ceal-client-protocol/src/gateway-write-identity.ts
+var CEAL_GATEWAY_WRITE_IDENTITY_ROLES = Object.freeze(["replay_identity", "lookup_handle", "collision_evidence"]);
+var CEAL_GATEWAY_WRITE_REQUEST_REF_PATTERN = /^gateway-write-request:[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/u;
+var CEAL_GATEWAY_WRITE_IDENTITY_FIELDS = Object.freeze({
+  replay_identity: "idempotency_claim_sha256",
+  lookup_handle: "write_request_sha256",
+  collision_evidence: "normalized_mutation_sha256"
+});
+
 // packages/ceal-client-protocol/src/write-safety-finding.ts
 var CEAL_WRITE_SAFETY_FINDING_STATUSES = vocabulary(["warning", "unchecked"]);
 var CEAL_WRITE_SAFETY_AUDIENCES = vocabulary(["workspace", "person", "members", "unknown"]);
@@ -1106,7 +1146,11 @@ var CEAL_REFRESH_FAILURE_CODES = vocabulary([
   "refresh_revoked",
   "authority_replaced",
   "refresh_recovery_unavailable",
-  "refresh_recovery_expired"
+  "refresh_recovery_expired",
+  // The serving gate answers this while the Gateway is still starting and the
+  // refresh was never attempted; the same attempt stays retryable. It is never
+  // stored by the session owner, only answered at the serving edge.
+  "gateway_starting"
 ]);
 
 // packages/ceal-client-protocol/src/request-validation-primitives.ts
@@ -1139,7 +1183,7 @@ var CANCELLATION_STATES = vocabulary(["requested", "cancelled"]);
 var CEAL_REQUEST_KEYS = Object.freeze(["schema_version", "ceal_request_ref", "created_at", "authority", "prompt_ref", "host_session_ref", "host_turn_ref", "host_source_ref"]);
 var CEAL_REQUEST_JSON_SCHEMA = {
   type: "object",
-  maxProperties: 10,
+  maxProperties: 11,
   additionalProperties: false,
   properties: {
     schema_version: { type: "string", const: CEAL_REQUEST_SCHEMA_VERSION, maxLength: 32 },
@@ -1163,7 +1207,8 @@ var CEAL_REQUEST_JSON_SCHEMA = {
     host_turn_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
     host_input_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
     host_source_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
-    requester_timezone: { type: "string", minLength: 1, maxLength: 128, description: "IANA timezone observed for the requester on this Request." }
+    requester_timezone: { type: "string", minLength: 1, maxLength: 128, description: "IANA timezone observed for the requester on this Request." },
+    device_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source, description: "Device that submitted this Request through its client session; absent for Host turns and older records." }
   },
   required: CEAL_REQUEST_KEYS
 };
@@ -1222,6 +1267,7 @@ var REQUEST_EXECUTION_PREPARE_REFUSAL_PROPERTIES = {
   retryable: { type: "boolean" },
   source: { type: "string", enum: ["provider", "gateway"] },
   retry_after_ms: { type: "integer", minimum: 0, maximum: CEAL_RETRY_AFTER_MAX_MS },
+  write_request_ref: { type: "string", pattern: CEAL_GATEWAY_WRITE_REQUEST_REF_PATTERN.source, maxLength: 128 },
   excluded_targets: cealExcludedTargetCoverageJsonSchema(),
   repaired_input: {},
   unrepaired_pointers: { type: "array", maxItems: 128, items: { type: "string", minLength: 1, maxLength: 256 } },
@@ -1286,6 +1332,43 @@ function cealHostObservationRef(producer, digest2) {
   if (!HOST_OBSERVATION_PRODUCER.test(producer) || !HOST_OBSERVATION_DIGEST.test(digest2)) invalid("Ceal Host observation reference parts are invalid.");
   return `${CEAL_HOST_OBSERVATION_REF_PREFIX}${producer}-${digest2}`;
 }
+var HOST_TOKEN_OBSERVATION_BREAKDOWN_KEYS = vocabulary(["cached_input", "cache_write_input", "reasoning_output"]);
+function createHostTokenObservationValue(counts, source) {
+  const core = validTokenCore(counts);
+  if (typeof source !== "string" || source.length === 0 || source.length > 256) invalid("Ceal Host token observation source is invalid.");
+  const value = { status: "available", unit: "tokens", input: core.input, output: core.output, total: core.total, source };
+  for (const breakdown of validTokenBreakdowns(counts)) value[breakdown.key] = breakdown.tokens;
+  assertHostObservationValue(value, "token");
+  return value;
+}
+function validTokenCore(counts) {
+  if (!isOperationRecord(counts) || !safeCount(counts.input) || !safeCount(counts.output) || !safeCount(counts.total)) invalid("Ceal Host token observation counts are invalid.");
+  if (counts.total !== counts.input + counts.output) invalid("Ceal Host token observation counts are invalid.");
+  return { input: counts.input, output: counts.output, total: counts.total };
+}
+function validTokenBreakdowns(counts) {
+  const breakdowns = [
+    { key: "cached_input", tokens: counts.cached_input },
+    { key: "cache_write_input", tokens: counts.cache_write_input },
+    { key: "reasoning_output", tokens: counts.reasoning_output }
+  ];
+  const stated = breakdowns.filter((breakdown) => breakdown.tokens !== void 0).map((breakdown) => ({ key: breakdown.key, tokens: Number(breakdown.tokens) }));
+  for (const breakdown of stated) {
+    if (!safeCount(breakdown.tokens)) invalid("Ceal Host token observation counts are invalid.");
+  }
+  const cached = counts.cached_input ?? 0;
+  const created = counts.cache_write_input ?? 0;
+  const reasoning = counts.reasoning_output ?? 0;
+  if (cached + created > counts.input || reasoning > counts.output) invalid("Ceal Host token observation counts are invalid.");
+  return stated;
+}
+function hostObservationNotRecorded(reason) {
+  if (typeof reason !== "string" || reason.length === 0 || reason.length > 256) invalid("Ceal Host observation gap reason is invalid.");
+  return { status: "not_recorded", reason };
+}
+function safeCount(value) {
+  return Number.isSafeInteger(value) && Number(value) >= 0;
+}
 function validateCealHostObservationDraft(value) {
   const record3 = operationRecord(value, "Ceal Host observation draft is invalid.");
   requirePrefixedRef(record3.observation_ref, CEAL_HOST_OBSERVATION_REF_PREFIX, "Ceal Host observation reference is invalid.");
@@ -1437,12 +1520,85 @@ var CEAL_HOST_MINT_REQUEST_CONTEXT_REFUSAL_REASONS = vocabulary([
   "host_input_mismatch",
   "host_prompt_mismatch"
 ]);
+var CEAL_HOST_AUTHENTICATION_CAUSES = vocabulary([
+  "invalid_arguments",
+  "options_invalid",
+  "session_unavailable",
+  "context_unavailable",
+  "context_replaced",
+  "no_binding",
+  "context_stale",
+  "context_expired",
+  "host_source_refused",
+  "host_credential_refused",
+  "gateway_unavailable",
+  "gateway_rate_limited",
+  "gateway_refused",
+  "gateway_response_invalid",
+  "producer_frame_invalid",
+  "relay_permission_denied",
+  "relay_unavailable",
+  "transient_retryable",
+  "mint_failed",
+  "relay_failed",
+  "host_refusal_invalid"
+]);
+var CEAL_HOST_AUTHENTICATION_POLICY = Object.freeze({
+  invalid_arguments: Object.freeze({ classification: "host_arguments_invalid", next_action: "answer_with_gap" }),
+  options_invalid: Object.freeze({ classification: "host_configuration_invalid", next_action: "answer_with_gap" }),
+  session_unavailable: Object.freeze({ classification: "host_session_unavailable", next_action: "answer_with_gap" }),
+  context_unavailable: Object.freeze({ classification: "host_context_unavailable", next_action: "refresh_host_invocation_context", remedy: "the Host has no invocation context from the current transcript turn; send a new message to start a fresh Host turn, then retry this command on that turn (run `ceal-host install` only if the Host hook registration is missing or drifted)" }),
+  context_replaced: Object.freeze({ classification: "host_invocation_context_stale", next_action: "refresh_host_invocation_context" }),
+  no_binding: Object.freeze({ classification: "host_binding_unavailable", next_action: "refresh_host_invocation_context" }),
+  context_stale: Object.freeze({ classification: "host_invocation_context_stale", next_action: "refresh_host_invocation_context" }),
+  context_expired: Object.freeze({ classification: "host_invocation_context_expired", next_action: "refresh_host_invocation_context" }),
+  host_source_refused: Object.freeze({ classification: "host_source_refused", next_action: "answer_with_gap" }),
+  host_credential_refused: Object.freeze({ classification: "host_registration_credential_refused", next_action: "ask_admin" }),
+  gateway_unavailable: Object.freeze({ classification: "host_mint_gateway_unavailable", next_action: "ask_admin" }),
+  gateway_rate_limited: Object.freeze({ classification: "host_mint_gateway_rate_limited", next_action: "answer_with_gap" }),
+  gateway_refused: Object.freeze({ classification: "host_mint_gateway_refused", next_action: "answer_with_gap" }),
+  gateway_response_invalid: Object.freeze({ classification: "host_mint_gateway_response_invalid", next_action: "answer_with_gap" }),
+  producer_frame_invalid: Object.freeze({ classification: "host_producer_frame_invalid", next_action: "ask_admin", remedy: "ask an administrator to inspect and repair the producer frame, then start a fresh Host turn" }),
+  relay_permission_denied: Object.freeze({ classification: "host_relay_permission_denied", next_action: "rerun_outside_agent_sandbox", remedy: "an agent sandbox denied the Host Relay socket; run `ceal` as the only command, with no pipe, redirect, or `&&`, so the Host allow rule runs it outside the sandbox" }),
+  relay_unavailable: Object.freeze({ classification: "host_relay_unavailable", next_action: "answer_with_gap" }),
+  transient_retryable: Object.freeze({ classification: "host_mint_transient_retryable", next_action: "retry" }),
+  mint_failed: Object.freeze({ classification: "host_mint_failed", next_action: "answer_with_gap" }),
+  relay_failed: Object.freeze({ classification: "host_relay_failed", next_action: "answer_with_gap" }),
+  host_refusal_invalid: Object.freeze({ classification: "host_refusal_invalid", next_action: "answer_with_gap" })
+});
+
+// packages/ceal-client-protocol/src/host-service-diagnostic.ts
+var CEAL_HOST_SERVICE_DIAGNOSTIC_SCHEMA = "ceal.host_service_diagnostic.v1";
+var CEAL_HOST_SERVICE_DIAGNOSTIC_PRODUCERS = vocabulary(["claude", "codex"]);
+var CEAL_HOST_SERVICE_DIAGNOSTIC_EVENTS = vocabulary([
+  "hook_invoked",
+  "registration_written",
+  "hook_failed",
+  "watcher_turn_observed",
+  "current_prompt_registered",
+  "current_prompt_registration_failed",
+  "current_prompt_capacity_exhausted",
+  "activation_recorded",
+  "activation_failed",
+  "watcher_scan_failed",
+  "activation_wait_skipped",
+  "activation_wait_engaged",
+  "activation_wait_completed",
+  "activation_wait_exhausted"
+]);
+var CEAL_HOST_SERVICE_DIAGNOSTIC_FAILURE_KINDS = vocabulary([
+  "malformed_line",
+  "other",
+  "payload_rejected",
+  "read_error",
+  "size_budget",
+  "symlink"
+]);
 
 // packages/ceal-client-protocol/src/client-result-materialization.ts
 var CEAL_UNREAD_REASONS = vocabulary(["blocked", "unavailable", "too_large", "unsupported", "download_failed", "permission_denied"]);
-var CEAL_MODEL_VISIBLE_COMMAND_OUTPUT_MAX_BYTES = 32 * 1024;
-var REQUIRED_FIELDS2 = Object.freeze(["schema_version", "operation_id", "read_argv"]);
-var FIELDS = /* @__PURE__ */ new Set([...REQUIRED_FIELDS2, "local_result_root", "continue_argv", "model_disclosure"]);
+var REQUIRED_FIELDS2 = Object.freeze(["schema_version", "operation_id", "path", "sha256"]);
+var FIELDS = /* @__PURE__ */ new Set([...REQUIRED_FIELDS2, "items_path", "row_count", "result_complete", "coverage", "local_result_root", "model_disclosure", "continue_argv", "how_to_read"]);
 
 // packages/ceal-client-protocol/src/gateway-cache-origin-validation.ts
 var CEAL_MAX_CACHE_ORIGIN_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -1472,14 +1628,6 @@ var CEAL_GATEWAY_ANNOUNCEMENT_POLICY_NON_CLAIMS = vocabulary([
   "target_specific_scope_not_declared"
 ]);
 
-// packages/ceal-client-protocol/src/gateway-write-identity.ts
-var CEAL_GATEWAY_WRITE_IDENTITY_ROLES = Object.freeze(["replay_identity", "lookup_handle", "collision_evidence"]);
-var CEAL_GATEWAY_WRITE_IDENTITY_FIELDS = Object.freeze({
-  replay_identity: "idempotency_claim_sha256",
-  lookup_handle: "write_request_sha256",
-  collision_evidence: "normalized_mutation_sha256"
-});
-
 // packages/ceal-client-protocol/src/gateway-scoped-identity-projection-validation.ts
 var PROJECTION_REVISION_KEYS = Object.freeze(["graph_revision", "subject_key_revision", "projection_revision"]);
 
@@ -1492,6 +1640,18 @@ var CEAL_SUPPORTED_GATEWAY_PROTOCOL_RANGE = Object.freeze({
 // packages/ceal-client-protocol/src/admin-projection-vocabulary.ts
 var ADMIN_PROJECTION_STATES = vocabulary(["ready", "empty", "partial", "unknown"]);
 var ADMIN_VIEW_KINDS = vocabulary(["request_detail", "resource_access_timeline", "weekly_usage"]);
+var ADMIN_RECORD_PROJECTION_KINDS = vocabulary([
+  "request_list",
+  "usage_series",
+  "connector_health",
+  "person_connections",
+  "client_sessions",
+  "knowledge_base",
+  "change_history",
+  "approval_queue",
+  "access_group_list",
+  "capability_catalogue"
+]);
 var ADMIN_GAP_KINDS = vocabulary(["unknown", "unavailable", "partial"]);
 var ADMIN_UNAVAILABLE_REASONS = vocabulary([
   "not_recorded",
@@ -1515,7 +1675,11 @@ var ADMIN_SOURCE_OWNERS = vocabulary([
   "person",
   "resource",
   "prompt",
-  "usage"
+  "usage",
+  "connector",
+  "session",
+  "knowledge",
+  "policy"
 ]);
 var ADMIN_COMPLETENESS_STATES = vocabulary(["complete", "partial", "unknown"]);
 var ADMIN_OPERATION_OUTCOMES = vocabulary(["completed", "failed", "denied", "cancelled", "unknown"]);
@@ -1552,11 +1716,7 @@ var CODEX_INVOCATION_CONTEXT_SCHEMA_VERSION = "ceal.codex_invocation_context.v1"
 var CODEX_TRANSCRIPT_REGISTRATION_SCHEMA_VERSION = "ceal.codex_transcript_registration.v1";
 var CODEX_TRANSCRIPT_CURSOR_SCHEMA_VERSION = "ceal.codex_transcript_cursor.v1";
 var CODEX_DEFAULT_RETENTION_MS = 24 * 60 * 60 * 1e3;
-var CODEX_HOOK_EVENTS = ["SessionStart"];
-var CODEX_TRANSCRIPT_CURSOR_REASONS = ["transcript_replaced", "transcript_truncated", "transcript_rewritten", "transcript_malformed"];
-function isCodexTranscriptCursorReason(value) {
-  return typeof value === "string" && CODEX_TRANSCRIPT_CURSOR_REASONS.some((reason) => reason === value);
-}
+var CODEX_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit"];
 var CodexHostAdapterError = class extends Error {
   name = "CodexHostAdapterError";
   code;
@@ -1571,12 +1731,12 @@ function isCodexHookEvent(value) {
 
 // host/codex/src/codex-decoder.ts
 var SAFE_REF2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-var MAX_PAYLOAD_BYTES = 64 * 1024;
+var MAX_PAYLOAD_BYTES = 512 * 1024;
 var MAX_TEXT = 256;
 function decodeCodexHookPayload(event, raw) {
-  if (event !== "SessionStart") reject(`Codex hook event is not installed by this adapter (${refusalFact("event", event, "SessionStart")})`);
   const input = parsePayload(raw);
-  return decodeSession(input, event);
+  if (event === "SessionStart") return decodeSession(input, event);
+  return decodeUserPromptSubmit(input, event);
 }
 function observationRef(event, identity, value) {
   return cealHostObservationRef("codex", shortDigest({ event, identity, value }));
@@ -1628,6 +1788,20 @@ function decodeSession(input, event) {
     transcript_path: requiredText(input.transcript_path, "transcript_path", 4096)
   };
 }
+function decodeUserPromptSubmit(input, event) {
+  exactKeys(input, ["cwd", "hook_event_name", "model", "permission_mode", "prompt", "session_id", "transcript_path", "turn_id"], []);
+  validateHookEventName(input, event);
+  const cwd = requiredText(input.cwd, "cwd", 4096);
+  if (!isAbsolute(cwd) || cwd.includes("\0")) reject("Codex cwd is invalid");
+  return {
+    event,
+    cwd: resolve(cwd),
+    session_id: requiredText(input.session_id, "session_id", MAX_TEXT),
+    transcript_path: requiredText(input.transcript_path, "transcript_path", 4096),
+    turn_id: requiredText(input.turn_id, "turn_id", MAX_TEXT),
+    prompt: requiredText(input.prompt, "prompt", MAX_PAYLOAD_BYTES)
+  };
+}
 function parsePayload(raw) {
   try {
     const text = typeof raw === "string" ? raw : JSON.stringify(raw);
@@ -1670,9 +1844,9 @@ function reject(message) {
 }
 
 // host/codex/src/codex-outbox.ts
-import { O_NOFOLLOW, O_RDONLY } from "node:constants";
-import { lstat, mkdir, open, readdir, rename, unlink } from "node:fs/promises";
-import { dirname, isAbsolute as isAbsolute2, join as join2 } from "node:path";
+import { O_NOFOLLOW as O_NOFOLLOW2, O_RDONLY as O_RDONLY3 } from "node:constants";
+import { lstat as lstat2, mkdir as mkdir3, open as open3, readdir, rename as rename3, unlink as unlink2 } from "node:fs/promises";
+import { dirname, 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"];
@@ -1686,17 +1860,32 @@ function hasHostInvocationIdentityKeys(value) {
 function hasHostInvocationContextKeys(value, optional = []) {
   return requiredKeys(value, HOST_INVOCATION_CONTEXT_REQUIRED_KEYS, optional);
 }
+async function readLatestSessionProjection(file, hostSourceRef, hostSessionRef, readProjection) {
+  const context = await readProjection(file);
+  if (context === null || context.identity.host_source_ref !== hostSourceRef || context.identity.host_session_ref !== hostSessionRef) return null;
+  return context;
+}
+function isLiveSessionProjection(context, now) {
+  return context !== null && Date.parse(context.expires_at) > now.getTime();
+}
 function invocationContextFromTurn(identity, promptRef, expiresAt, descriptor) {
   const context = {
     schema_version: descriptor.schema_version,
     identity,
     prompt_ref: promptRef,
     expires_at: expiresAt,
+    ...descriptor.turn_generation_ref === void 0 ? {} : { turn_generation_ref: descriptor.turn_generation_ref },
     ...descriptor.working_directory === void 0 ? {} : { working_directory: descriptor.working_directory }
   };
   descriptor.validate(context);
   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) => safeRef(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;
+}
 function exactKeys2(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));
@@ -1706,145 +1895,964 @@ 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) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function safeRef(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+}
 
-// host/codex/src/codex-invocation-context.ts
-function codexInvocationContextFromTurn(identity, promptRef, expiresAt) {
-  return invocationContextFromTurn(identity, promptRef, expiresAt, { schema_version: CODEX_INVOCATION_CONTEXT_SCHEMA_VERSION, validate: validateCodexHostInvocationContext });
+// 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_REF3 = /^[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 FRAME_KINDS = new Set(HOST_PRODUCER_FRAME_KINDS);
+function isHostProducerFrameKind(value) {
+  return typeof value === "string" && FRAME_KINDS.has(value);
 }
-function validateCodexHostInvocationContext(value) {
-  if (!isContextShape(value)) {
-    throw new CodexHostAdapterError("storage", "Codex Host invocation context is malformed.");
+var HOST_PRODUCER_FRAME_ERROR_CODES = [
+  "invalid_frame_encoding",
+  "invalid_frame_length",
+  "frame_truncated",
+  "unsupported_frame_schema",
+  "invalid_frame_shape",
+  "invalid_producer_identity",
+  "frame_too_large"
+];
+var HostProducerFrameError = class extends Error {
+  code;
+  constructor(code, message = code) {
+    super(message);
+    this.code = code;
   }
-  validateIdentity(value.identity);
-  validateContextReferences(value);
-  validateContextTimes(value);
-}
-function invocationContextFromBinding(binding) {
-  const context = {
-    schema_version: CODEX_INVOCATION_CONTEXT_SCHEMA_VERSION,
-    identity: binding.identity,
-    prompt_ref: binding.prompt_ref,
-    request_ref: binding.request_ref,
-    bound_at: binding.bound_at,
-    expires_at: binding.expires_at
-  };
-  validateCodexHostInvocationContext(context);
-  return Object.freeze(context);
+};
+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 validateIdentity(value) {
-  if (!isRecord2(value) || !hasHostInvocationIdentityKeys(value) || ![value.host_session_ref, value.host_turn_ref, value.host_source_ref].every(safeRef)) {
-    throw new CodexHostAdapterError("storage", "Codex Host invocation identity is malformed.");
+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;
+  try {
+    value = JSON.parse(text.decode(bytes));
+  } catch (error) {
+    if (error instanceof TypeError) throw new HostProducerFrameError("invalid_frame_encoding");
+    throw new HostProducerFrameError("frame_truncated");
   }
+  validateFrame(value);
+  return value;
 }
-function isContextShape(value) {
-  return isRecord2(value) && hasHostInvocationContextKeys(value, ["request_ref", "bound_at"]) && value.schema_version === CODEX_INVOCATION_CONTEXT_SCHEMA_VERSION;
+function isHostSafeRef(value) {
+  return safeRef2(value);
 }
-function validateContextReferences(value) {
-  if (!safeRef(value.prompt_ref) || !optionalSafeRef(value.request_ref)) throw new CodexHostAdapterError("storage", "Codex Host invocation context is malformed.");
+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 (!exactKeys3(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)) || !safeRef2(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 validateContextTimes(value) {
-  const expiresAt = value.expires_at;
-  const boundAt = value.bound_at;
-  if (!timestamp(expiresAt) || !optionalTimestamp(boundAt)) throw new CodexHostAdapterError("storage", "Codex Host invocation context is malformed.");
-  if (typeof boundAt === "string" && Date.parse(boundAt) > Date.parse(expiresAt)) throw new CodexHostAdapterError("storage", `Codex Host invocation context has invalid binding time (${refusalFact("bound_at", boundAt, `at or before ${expiresAt}`)}).`);
+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 optionalSafeRef(value) {
-  return value === void 0 || safeRef(value);
+function validSession(value) {
+  return exactOptional(value, ["local_session_ref", "working_directory_ref"], ["model", "host_version", "observations"]) && safeRef2(value.local_session_ref) && safeRef2(value.working_directory_ref) && optionalText(value.model, 256) && optionalText(value.host_version, 256) && validObservations(value.observations);
 }
-function optionalTimestamp(value) {
-  return value === void 0 || timestamp(value);
+function validTurn(value) {
+  return exactOptional(value, ["local_session_ref", "local_turn_ref"], ["model", "observations"]) && safeRef2(value.local_session_ref) && safeRef2(value.local_turn_ref) && optionalText(value.model, 256) && validObservations(value.observations);
 }
-function safeRef(value) {
-  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+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"]) && safeRef2(value.local_session_ref) && safeRef2(value.local_turn_ref) && safeRef2(value.local_input_ref) && validInputObservations(value.observations) && isCealHostInputKind(value.input_kind) && typeof value.origin_input === "boolean" && validInputOptionals(value);
 }
-function timestamp(value) {
-  return typeof value === "string" && value.length <= 64 && Number.isFinite(Date.parse(value));
+function validInputObservations(value) {
+  return validObservations(value) && Array.isArray(value) && value.filter((item) => record(item) && item.observation_kind === "prompt").length === 1;
 }
-function isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function validInputOptionals(value) {
+  return optionalRefs(value.local_turn_aliases) && (value.context_expires_at === void 0 || timestamp(value.context_expires_at));
 }
-
-// host/codex/src/codex-outbox.ts
-var SAFE_REF3 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-var CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS = 4096;
-var CodexOutboxStore = class {
-  directory;
-  entriesDirectory;
-  bindingsDirectory;
-  sessionsDirectory;
-  activeContextsDirectory;
-  registrationsDirectory;
-  cursorsDirectory;
-  constructor(directory) {
-    if (typeof directory !== "string" || directory.length === 0) throw new CodexHostAdapterError("configuration", "Codex outbox directory is required.");
-    this.directory = directory;
-    this.entriesDirectory = join2(directory, "entries");
-    this.bindingsDirectory = join2(directory, "bindings");
-    this.sessionsDirectory = join2(directory, "sessions");
-    this.activeContextsDirectory = join2(directory, "active-contexts");
-    this.registrationsDirectory = join2(directory, "transcript-registrations");
-    this.cursorsDirectory = join2(directory, "transcript-cursors");
-  }
-  async prepare() {
-    for (const path of [this.directory, this.entriesDirectory, this.bindingsDirectory, this.sessionsDirectory, this.activeContextsDirectory, this.registrationsDirectory, this.cursorsDirectory]) {
-      await ensurePrivateOwnerDirectory(path);
-    }
-  }
-  async put(entry) {
-    validateEnvelope(entry);
-    await this.prepare();
-    await writeAtomicJson(this.entryPath(entry.submission_ref), entry);
-  }
-  async list() {
-    await this.prepare();
-    const entries = [];
-    let malformed = 0;
-    for (const name of await readdir(this.entriesDirectory)) {
-      if (!name.endsWith(".json")) continue;
-      try {
-        const value = JSON.parse(await readPrivateFile(join2(this.entriesDirectory, name)));
-        validateEnvelope(value);
-        entries.push(value);
-      } catch {
-        malformed += 1;
-      }
-    }
-    entries.sort((left, right) => left.created_at.localeCompare(right.created_at));
-    return { entries, malformed };
-  }
-  async remove(entry) {
-    validateEnvelope(entry);
+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"]) && safeRef2(value.local_session_ref) && safeRef2(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);
+}
+function validTerminalDisposition(state, reason) {
+  return (state === "completed" || state === "aborted") && (reason === void 0 || state === "aborted" && safeRef2(reason));
+}
+function validStatus(value) {
+  return exactOptional(value, ["status", "reason_code"], ["detail"]) && ["ready", "degraded", "stopping"].includes(String(value.status)) && safeRef2(value.reason_code) && optionalText(value.detail, 4096);
+}
+function optionalText(value, maxLength) {
+  return value === void 0 || typeof value === "string" && value.length > 0 && value.length <= maxLength;
+}
+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(safeRef2);
+}
+function validObservations(value) {
+  if (value === void 0) return true;
+  if (!Array.isArray(value) || value.length > 32) return false;
+  return value.every((item) => {
     try {
-      await unlink(this.entryPath(entry.submission_ref));
-    } catch (error) {
-      if (!isNotFound(error)) throw storageError("Unable to remove the Codex outbox entry.");
+      validateCealHostObservationDraft(item);
+      return true;
+    } catch {
+      return false;
     }
-  }
-  async writeBinding(binding) {
-    validateBinding(binding);
-    await this.prepare();
-    await writeAtomicJson(this.bindingPath(binding.identity), binding);
-  }
-  /**
-   * Select the exact Host turn that model-reachable commands may use. A new
-   * prompt replaces this projection, so it cannot inherit the prior turn's
-   * Request by session alone.
-   */
-  async activateInvocationContext(identity, promptRef, expiresAt) {
-    const context = codexInvocationContextFromTurn(identity, promptRef, expiresAt);
-    await this.prepare();
-    const path = this.activeContextPath(identity);
-    try {
+  });
+}
+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 safeRef2(value) {
+  return typeof value === "string" && SAFE_REF3.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 exactKeys3(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 createHash3 } 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";
+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()}`
+};
+
+// 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/service-log.ts
+function writeHostServiceDiagnostic(producer_id, event, failure_kind, cause, sink) {
+  const line = `${JSON.stringify({ schema_version: CEAL_HOST_SERVICE_DIAGNOSTIC_SCHEMA, producer_id, event, ...event === "watcher_scan_failed" && failure_kind !== void 0 ? { failure_kind } : {}, ...event === "watcher_scan_failed" && cause !== void 0 ? { cause } : {} })}
+`;
+  try {
+    (sink ?? defaultHostServiceDiagnosticSink)(line);
+  } catch {
+  }
+}
+function defaultHostServiceDiagnosticSink(line) {
+  process.stderr.write(line);
+}
+var HOST_SERVICE_LOG_MAX_BYTES = 1024 * 1024;
+var HOST_SERVICE_LOG_TAIL_BYTES = 64 * 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_CURRENT_PROMPT_REGISTER_SCHEMA = "ceal.host_relay_current_prompt_register.v1";
+var HOST_RELAY_CURRENT_PROMPT_RELEASE_SCHEMA = "ceal.host_relay_current_prompt_release.v1";
+var HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA = "ceal.host_relay_current_prompt_result.v1";
+var HOST_RELAY_IPC_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
+var HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES = 4096;
+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(code, message = code, failure) {
+    super(message);
+    this.code = code;
+    this.failure = failure;
+  }
+};
+var HostRelayCurrentPromptCapacityRefusal = class extends Error {
+  constructor() {
+    super("current_prompt_capacity_exhausted");
+    this.name = "HostRelayCurrentPromptCapacityRefusal";
+  }
+};
+function hostRelayExchangeFailure(error) {
+  return error instanceof HostRelayIpcError ? error.failure : void 0;
+}
+function socketErrorFailure(error) {
+  switch (errorCode(error)) {
+    case "EACCES":
+    case "EPERM":
+      return "permission_denied";
+    case "ENOENT":
+      return "socket_missing";
+    case "ECONNREFUSED":
+      return "connection_refused";
+    default:
+      return "unavailable";
+  }
+}
+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 === "capacity_exhausted") throw new HostRelayCurrentPromptCapacityRefusal();
+    if (response2.status !== "registered") throw new HostRelayIpcError("relay_unavailable", response2.status);
+  }
+  async release(identity) {
+    const request2 = { schema_version: HOST_RELAY_CURRENT_PROMPT_RELEASE_SCHEMA, ...identity };
+    const response2 = await exchange(this.endpoint, encodeLengthPrefixed(request2), this.timeout_ms, decodeCurrentPromptResponseBuffer);
+    if (response2.status !== "released") throw new HostRelayIpcError("relay_unavailable", response2.status, "response_invalid");
+  }
+};
+function submitHostProducerFrame(endpoint, frame, timeoutMs = 5e3) {
+  return exchange(endpoint, encodeHostProducerFrame(frame), timeoutMs, decodeResponseBuffer);
+}
+function exchange(endpoint, encoded, timeoutMs, decode, signal) {
+  return new Promise((resolve3, reject3) => {
+    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) reject3(error);
+      else if (response2 !== void 0) resolve3(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 failure = socketErrorFailure(error);
+      finish(new HostRelayIpcError("relay_unavailable", `Host Relay IPC is unavailable: ${failure}.`, failure));
+    });
+    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 decodeCurrentPromptResponseBuffer(buffer) {
+  const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES);
+  if (value === null) return null;
+  if (!record2(value) || !exactKeys4(value, ["schema_version", "status"]) || value.schema_version !== HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA || value.status !== "registered" && value.status !== "capacity_exhausted" && value.status !== "current_prompt_unavailable" && value.status !== "released") throw new HostRelayIpcError("relay_unavailable", "Host Relay current-prompt response is invalid.", "response_invalid");
+  return { schema_version: HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA, status: value.status };
+}
+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 exactKeys4(value, required, optional = []) {
+  const keys = Object.keys(value);
+  return required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => required.includes(key) || optional.includes(key));
+}
+function errorCode(error) {
+  return record2(error) && typeof error.code === "string" ? error.code : null;
+}
+
+// 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);
+}
+var TRANSCRIPT_MISSING_REASON = "transcript_missing";
+var TRANSCRIPT_SCAN_READ_ERROR_ERRNOS = ["EBADF", "EACCES", "EIO", "EMFILE", "ENFILE", "ENOENT", "ENOTDIR", "EPERM"];
+function transcriptScanFailureKind(error, adapterFailureKind) {
+  if (transcriptErrorCode(error) === "ELOOP") return "symlink";
+  const adapter = adapterFailureKind(error);
+  if (adapter !== void 0) return adapter;
+  const code = transcriptErrorCode(error);
+  if (code === "EFBIG") return "size_budget";
+  if (code !== null && TRANSCRIPT_SCAN_READ_ERROR_ERRNOS.includes(code)) return "read_error";
+  return "other";
+}
+async function registerHostCurrentPromptDiagnosed(register, diagnostic) {
+  try {
+    await register();
+    diagnostic("current_prompt_registered");
+    return true;
+  } catch (error) {
+    if (!(error instanceof HostRelayCurrentPromptCapacityRefusal)) diagnostic("current_prompt_registration_failed");
+    throw error;
+  }
+}
+function transcriptErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
+}
+var HOST_TRANSCRIPT_READ_CHUNK_BYTES = 256 * 1024;
+async function readTranscriptCompleteChunk(handle, offset, size) {
+  const available = Math.max(0, size - offset);
+  if (available === 0) return "empty";
+  const chunks = [];
+  let position = offset;
+  let total = 0;
+  let lastNewline = -1;
+  while (position < size) {
+    const buffer = Buffer.alloc(Math.min(HOST_TRANSCRIPT_READ_CHUNK_BYTES, size - position));
+    const read = await handle.read(buffer, 0, buffer.length, position);
+    if (read.bytesRead === 0) break;
+    const chunk = buffer.subarray(0, read.bytesRead);
+    chunks.push(chunk);
+    const newline = chunk.lastIndexOf(10);
+    if (newline >= 0) lastNewline = total + newline;
+    total += chunk.length;
+    position += chunk.length;
+    if (lastNewline >= 0) break;
+  }
+  if (lastNewline < 0) return "partial";
+  return Buffer.concat(chunks, total).subarray(0, lastNewline + 1);
+}
+async function readTranscriptAnchor(handle, offset, anchorBytes) {
+  const start = Math.max(0, offset - anchorBytes);
+  const anchor = Buffer.alloc(offset - start);
+  if (anchor.length > 0) await handle.read(anchor, 0, anchor.length, start);
+  return { start, sha256: transcriptSha256(anchor) };
+}
+async function transcriptAnchorMatches(handle, cursor) {
+  const buffer = Buffer.alloc(cursor.offset - cursor.anchor_start);
+  if (buffer.length > 0) await handle.read(buffer, 0, buffer.length, cursor.anchor_start);
+  return transcriptSha256(buffer) === cursor.anchor_sha256;
+}
+function transcriptCursorIdentityReason(cursor, transcriptPath, device, inode) {
+  if (cursor.device !== device || cursor.inode !== inode || cursor.transcript_path !== transcriptPath) return "transcript_replaced";
+  return null;
+}
+async function transcriptCursorBoundsReason(handle, cursor, size) {
+  if (size < cursor.offset) return "transcript_truncated";
+  if (cursor.offset > 0 && !await transcriptAnchorMatches(handle, cursor)) return "transcript_rewritten";
+  return null;
+}
+function transcriptSha256(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function transcriptObjectSha256(value) {
+  return createHash3("sha256").update(JSON.stringify(value), "utf8").digest("hex");
+}
+function isTranscriptRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isMissingTranscriptError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function transcriptTimestamp(now, fail) {
+  const value = now();
+  if (!Number.isFinite(value.getTime())) throw fail();
+  return value.toISOString();
+}
+function transcriptExpiration(now, retentionMs, fail) {
+  return new Date(Date.parse(transcriptTimestamp(now, fail)) + retentionMs).toISOString();
+}
+function createTranscriptWatcherBase(options, owner) {
+  if (typeof options.outbox_dir !== "string" || options.outbox_dir.length === 0) throw owner.invalid_outbox();
+  return {
+    outboxRetentionMs: options.retention_ms ?? owner.default_retention_ms,
+    now: options.now ?? (() => /* @__PURE__ */ new Date()),
+    log: options.log ?? ((line) => {
+      process.stderr.write(`${line}
+`);
+    }),
+    producerInstallationRef: options.producer_installation_ref
+  };
+}
+async function scanTranscriptRegistrations(registrations, scanOne) {
+  let records = 0;
+  let enqueued = 0;
+  let quarantined = 0;
+  for (const registration of registrations) {
+    const result = await scanOne(registration);
+    records += result.records;
+    enqueued += result.enqueued;
+    if (result.quarantined) quarantined += 1;
+  }
+  return { registrations: registrations.length, records, enqueued, quarantined };
+}
+function formatRetiredTranscriptLog(producerLabel, transcriptPath) {
+  return `${producerLabel} retired a transcript registration: transcript_path=${JSON.stringify(transcriptPath)}, reason=${TRANSCRIPT_MISSING_REASON}.`;
+}
+var HostTranscriptWatcher = class {
+  outboxRetentionMs;
+  now;
+  log;
+  producerInstallationRef;
+  clockFailure;
+  constructor(options, owner) {
+    const base = createTranscriptWatcherBase(options, owner);
+    this.outboxRetentionMs = base.outboxRetentionMs;
+    this.now = base.now;
+    this.log = base.log;
+    this.producerInstallationRef = base.producerInstallationRef;
+    this.clockFailure = owner.clock_failure;
+  }
+  async scanOnce() {
+    return scanTranscriptRegistrations(await this.listRegistrations(), (registration) => this.scanRegistration(registration));
+  }
+  async scanRegistration(registration) {
+    try {
+      return await this.openTranscript(registration, (handle) => this.scanOpened(handle, registration), {
+        missing: () => this.retireMissing(registration),
+        failed: (handle, error) => this.scanFailed(handle, registration, error)
+      });
+    } catch (error) {
+      if (error instanceof HostRelayCurrentPromptCapacityRefusal) return { records: 0, enqueued: 0, quarantined: false };
+      throw error;
+    }
+  }
+  async openTranscript(registration, scan, handlers) {
+    let handle;
+    try {
+      handle = await open2(this.transcriptPathOf(registration), O_RDONLY2 | O_NOFOLLOW);
+      return await scan(handle);
+    } catch (error) {
+      if (handle === void 0 && isMissingTranscriptError(error)) return handlers.missing();
+      if (hostRelayExchangeFailure(error) !== void 0 || error instanceof HostRelayCurrentPromptCapacityRefusal) throw error;
+      return handlers.failed(handle, error);
+    } finally {
+      await handle?.close();
+    }
+  }
+  /**
+   * A transcript the Host deleted never comes back, so retrying its
+   * registration once per reconcile interval is a failure with no end.
+   * Retire it at the scan that finds it missing and say so once. Only
+   * ENOENT means gone; a permission or busy failure is about this moment,
+   * not about the file, and keeps the registration for the next scan.
+   */
+  async retireMissingTranscript(transcriptPath, producerLabel, retire) {
+    await retire();
+    this.log(formatRetiredTranscriptLog(producerLabel, transcriptPath));
+    return { records: 0, enqueued: 0, quarantined: false };
+  }
+  stamp() {
+    return transcriptTimestamp(this.now, this.clockFailure);
+  }
+  expire(retentionMs) {
+    return transcriptExpiration(this.now, retentionMs, this.clockFailure);
+  }
+  sha(value) {
+    return transcriptSha256(value);
+  }
+  objectSha(value) {
+    return transcriptObjectSha256(value);
+  }
+  isRecord(value) {
+    return isTranscriptRecord(value);
+  }
+  readChunk(handle, offset, size) {
+    return readTranscriptCompleteChunk(handle, offset, size);
+  }
+  readAnchor(handle, offset, anchorBytes) {
+    return readTranscriptAnchor(handle, offset, anchorBytes);
+  }
+  cursorIdentityReason(cursor, transcriptPath, device, inode) {
+    return transcriptCursorIdentityReason(cursor, transcriptPath, device, inode);
+  }
+  cursorBoundsReason(handle, cursor, size) {
+    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() {
+    const run = this.tail.then(() => this.drainLocked());
+    this.tail = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  async drainLocked() {
+    const read = await this.host.listEnvelopes();
+    let admitted = 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;
+      }
+      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;
+        }
+      }
+      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(submissionRef) {
+    return (await this.readState()).pending[submissionRef] !== void 0;
+  }
+  async reserve(envelope) {
+    const state = await this.readState();
+    const submissionRef = this.host.submissionRefOf(envelope);
+    const existing = state.pending[submissionRef];
+    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, [submissionRef]: frames } });
+    return frames;
+  }
+  async release(submissionRef) {
+    const state = await this.readState();
+    if (state.pending[submissionRef] === void 0) return;
+    const pending = { ...state.pending };
+    delete pending[submissionRef];
+    await this.writeState({ ...state, pending });
+  }
+  async readState() {
+    try {
+      const value = JSON.parse(await readFile(this.statePath, "utf8"));
+      return this.decodeState(value);
+    } catch (error) {
+      if (errorCode2(error) !== "ENOENT") throw error;
+      return { schema_version: this.stateSchema, producer_installation_ref: this.installationRef, producer_epoch: this.epoch, next_sequence: 1, pending: {} };
+    }
+  }
+  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 = (code, message) => this.host.fail(code, 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 [submissionRef, frames] of Object.entries(value.pending)) {
+      if (!isHostSafeRef(submissionRef) || !Array.isArray(frames) || frames.length === 0) throw fail("storage", `${label} producer pending reservation is malformed.`);
+      pending[submissionRef] = 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 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 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-gateway-bridge.ts
+var HOST_GATEWAY_ACKNOWLEDGEMENT_DISPOSITIONS = ["created", "adopted", "replayed", "approval_approved", "approval_denied", "approval_replayed"];
+function isHostGatewayAcknowledgementDisposition(value) {
+  return typeof value === "string" && HOST_GATEWAY_ACKNOWLEDGEMENT_DISPOSITIONS.some((disposition) => disposition === value);
+}
+
+// host/codex/src/codex-invocation-context.ts
+function codexInvocationContextFromTurn(identity, promptRef, expiresAt, turnGenerationRef) {
+  return invocationContextFromTurn(identity, promptRef, expiresAt, { schema_version: CODEX_INVOCATION_CONTEXT_SCHEMA_VERSION, validate: validateCodexHostInvocationContext, turn_generation_ref: turnGenerationRef });
+}
+function validateCodexHostInvocationContext(value) {
+  if (!isContextShape(value)) {
+    throw new CodexHostAdapterError("storage", "Codex Host invocation context is malformed.");
+  }
+  validateIdentity(value.identity);
+  validateContextReferences(value);
+  validateContextTimes(value);
+}
+function invocationContextFromBinding(binding, turnGenerationRef) {
+  const context = {
+    schema_version: CODEX_INVOCATION_CONTEXT_SCHEMA_VERSION,
+    identity: binding.identity,
+    prompt_ref: binding.prompt_ref,
+    request_ref: binding.request_ref,
+    bound_at: binding.bound_at,
+    expires_at: binding.expires_at,
+    ...turnGenerationRef === void 0 ? {} : { turn_generation_ref: turnGenerationRef }
+  };
+  validateCodexHostInvocationContext(context);
+  return Object.freeze(context);
+}
+function validateIdentity(value) {
+  if (!isRecord3(value) || !hasHostInvocationIdentityKeys(value) || ![value.host_session_ref, value.host_turn_ref, value.host_source_ref].every(safeRef3)) {
+    throw new CodexHostAdapterError("storage", "Codex Host invocation identity is malformed.");
+  }
+}
+function isContextShape(value) {
+  return isRecord3(value) && hasHostInvocationContextKeys(value, ["request_ref", "bound_at", "turn_generation_ref"]) && value.schema_version === CODEX_INVOCATION_CONTEXT_SCHEMA_VERSION;
+}
+function validateContextReferences(value) {
+  if (!safeRef3(value.prompt_ref) || !optionalSafeRef(value.request_ref) || !optionalSafeRef(value.turn_generation_ref)) throw new CodexHostAdapterError("storage", "Codex Host invocation context is malformed.");
+}
+function validateContextTimes(value) {
+  const expiresAt = value.expires_at;
+  const boundAt = value.bound_at;
+  if (!timestamp2(expiresAt) || !optionalTimestamp(boundAt)) throw new CodexHostAdapterError("storage", "Codex Host invocation context is malformed.");
+  if (typeof boundAt === "string" && Date.parse(boundAt) > Date.parse(expiresAt)) throw new CodexHostAdapterError("storage", `Codex Host invocation context has invalid binding time (${refusalFact("bound_at", boundAt, `at or before ${expiresAt}`)}).`);
+}
+function optionalSafeRef(value) {
+  return value === void 0 || safeRef3(value);
+}
+function optionalTimestamp(value) {
+  return value === void 0 || timestamp2(value);
+}
+function safeRef3(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+}
+function timestamp2(value) {
+  return typeof value === "string" && value.length <= 64 && Number.isFinite(Date.parse(value));
+}
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// host/codex/src/codex-outbox.ts
+var SAFE_REF4 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS = 4096;
+var CodexOutboxStore = class {
+  directory;
+  entriesDirectory;
+  bindingsDirectory;
+  sessionsDirectory;
+  activeContextsDirectory;
+  turnSelectionsDirectory;
+  registrationsDirectory;
+  cursorsDirectory;
+  constructor(directory) {
+    if (typeof directory !== "string" || directory.length === 0) throw new CodexHostAdapterError("configuration", "Codex outbox directory is required.");
+    this.directory = directory;
+    this.entriesDirectory = join3(directory, "entries");
+    this.bindingsDirectory = join3(directory, "bindings");
+    this.sessionsDirectory = join3(directory, "sessions");
+    this.activeContextsDirectory = join3(directory, "active-contexts");
+    this.turnSelectionsDirectory = join3(directory, "turn-selections");
+    this.registrationsDirectory = join3(directory, "transcript-registrations");
+    this.cursorsDirectory = join3(directory, "transcript-cursors");
+  }
+  async prepare() {
+    for (const path of [this.directory, this.entriesDirectory, this.bindingsDirectory, this.sessionsDirectory, this.activeContextsDirectory, this.turnSelectionsDirectory, this.registrationsDirectory, this.cursorsDirectory]) {
+      await ensurePrivateOwnerDirectory(path);
+    }
+  }
+  async put(entry) {
+    validateEnvelope(entry);
+    await this.prepare();
+    await writeAtomicJson(this.entryPath(entry.submission_ref), entry);
+  }
+  async list() {
+    await this.prepare();
+    const entries = [];
+    let malformed = 0;
+    for (const name of await readdir(this.entriesDirectory)) {
+      if (!name.endsWith(".json")) continue;
+      try {
+        const value = JSON.parse(await readPrivateFile(join3(this.entriesDirectory, name)));
+        validateEnvelope(value);
+        entries.push(value);
+      } catch {
+        malformed += 1;
+      }
+    }
+    entries.sort((left, right) => left.created_at.localeCompare(right.created_at));
+    return { entries, malformed };
+  }
+  async remove(entry) {
+    validateEnvelope(entry);
+    try {
+      await unlink2(this.entryPath(entry.submission_ref));
+    } catch (error) {
+      if (!isNotFound(error)) throw storageError("Unable to remove the Codex outbox entry.");
+    }
+  }
+  async writeBinding(binding) {
+    validateBinding(binding);
+    await this.prepare();
+    await writeAtomicJson(this.bindingPath(binding.identity), binding);
+  }
+  /**
+   * Select the exact Host turn that model-reachable commands may use. A new
+   * prompt replaces this projection, so it cannot inherit the prior turn's
+   * Request by session alone.
+   */
+  async activateInvocationContext(identity, promptRef, expiresAt, turnGenerationRef) {
+    const context = codexInvocationContextFromTurn(identity, promptRef, expiresAt, turnGenerationRef);
+    await this.prepare();
+    const path = this.activeContextPath(identity);
+    try {
       await writeAtomicJson(path, context);
     } catch (error) {
       try {
-        await unlink(path);
+        await unlink2(path);
       } catch (unlinkError) {
         if (!isNotFound(unlinkError)) throw storageError("Unable to clear a failed Codex Host context replacement.");
       }
       throw error;
     }
   }
+  async writeInvocationTurnSelection(selection) {
+    if (!isHostInvocationTurnSelection(selection)) throw new CodexHostAdapterError("invalid_input", "Codex Host turn selection is invalid.");
+    await this.prepare();
+    await writeAtomicJson(this.turnSelectionPath(selection.host_source_ref, selection.host_session_ref), selection);
+  }
+  async readInvocationTurnSelection(hostSourceRef, hostSessionRef) {
+    if (!SAFE_REF4.test(hostSourceRef) || !SAFE_REF4.test(hostSessionRef)) throw new CodexHostAdapterError("invalid_input", "Codex Host turn selection identity is invalid.");
+    await this.prepare();
+    return readOptionalJson(this.turnSelectionPath(hostSourceRef, hostSessionRef), validateTurnSelection);
+  }
+  async attachInvocationTurnGeneration(identity, promptRef, turnGenerationRef) {
+    const selection = await this.readInvocationTurnSelection(identity.host_source_ref, identity.host_session_ref);
+    if (selection === null || selection.prompt_ref !== promptRef || selection.turn_generation_ref !== turnGenerationRef) return false;
+    const path = this.activeContextPath(identity);
+    const active = await readOptionalJson(path, validateCodexHostInvocationContext);
+    if (active === null || active.prompt_ref !== promptRef || !sameIdentity(active.identity, identity)) return false;
+    await writeAtomicJson(path, { ...active, turn_generation_ref: turnGenerationRef });
+    return true;
+  }
   /**
    * Publish a Request reference only while the acknowledged binding is still
    * the active turn. A delayed relay response therefore cannot overwrite a
@@ -1854,17 +2862,25 @@ var CodexOutboxStore = class {
     validateBinding(binding);
     const active = await this.readInvocationContext(binding.identity.host_source_ref, binding.identity.host_session_ref, now);
     if (active === null || !sameIdentity(active.identity, binding.identity)) return false;
-    await writeAtomicJson(this.activeContextPath(binding.identity), invocationContextFromBinding(binding));
+    await writeAtomicJson(this.activeContextPath(binding.identity), invocationContextFromBinding(binding, active.turn_generation_ref));
     return true;
   }
-  /** Return only the active session projection; never fall back to another turn. */
+  /** Return only the live session projection; never fall back to another turn. */
   async readInvocationContext(hostSourceRef, hostSessionRef, now = /* @__PURE__ */ new Date()) {
-    if (!SAFE_REF3.test(hostSourceRef) || !SAFE_REF3.test(hostSessionRef)) throw new CodexHostAdapterError("invalid_input", "Codex Host session identity is invalid.");
     if (!(now instanceof Date) || !Number.isFinite(now.getTime())) throw new CodexHostAdapterError("invalid_input", "Codex Host context clock is invalid.");
+    const context = await this.readRawInvocationContext(hostSourceRef, hostSessionRef);
+    return isLiveSessionProjection(context, now) && invocationTurnSelectionMatches(context, await this.readInvocationTurnSelection(hostSourceRef, hostSessionRef)) ? context : null;
+  }
+  /**
+   * The latest Codex session projection even when past expiry, so the
+   * invocation authenticator can report an expired context distinctly from
+   * 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 CodexHostAdapterError("invalid_input", "Codex Host session identity is invalid.");
     await this.prepare();
-    const context = await readOptionalJson(this.activeContextPath({ host_source_ref: hostSourceRef, host_session_ref: hostSessionRef }), validateCodexHostInvocationContext);
-    if (context === null || context.identity.host_source_ref !== hostSourceRef || context.identity.host_session_ref !== hostSessionRef) return null;
-    return Date.parse(context.expires_at) > now.getTime() ? context : null;
+    const context = await readLatestSessionProjection(this.activeContextPath({ host_source_ref: hostSourceRef, host_session_ref: hostSessionRef }), hostSourceRef, hostSessionRef, (file) => readOptionalJson(file, validateCodexHostInvocationContext));
+    return invocationTurnSelectionMatches(context, await this.readInvocationTurnSelection(hostSourceRef, hostSessionRef)) ? context : null;
   }
   /** Clear the projection only if the caller still owns its exact active turn. */
   async clearInvocationContext(identity, now = /* @__PURE__ */ new Date()) {
@@ -1872,7 +2888,7 @@ var CodexOutboxStore = class {
     const active = await this.readInvocationContext(identity.host_source_ref, identity.host_session_ref, now);
     if (active === null || !sameIdentity(active.identity, identity)) return false;
     try {
-      await unlink(this.activeContextPath(identity));
+      await unlink2(this.activeContextPath(identity));
     } catch (error) {
       if (!isNotFound(error)) throw storageError("Unable to clear the Codex Host invocation context.");
     }
@@ -1890,7 +2906,7 @@ var CodexOutboxStore = class {
   }
   async readSession(sourceRef, sessionRef) {
     const identity = { host_source_ref: sourceRef, host_session_ref: sessionRef };
-    if (!SAFE_REF3.test(sourceRef) || !SAFE_REF3.test(sessionRef)) throw new CodexHostAdapterError("invalid_input", "Codex session identity is invalid.");
+    if (!SAFE_REF4.test(sourceRef) || !SAFE_REF4.test(sessionRef)) throw new CodexHostAdapterError("invalid_input", "Codex session identity is invalid.");
     await this.prepare();
     return readOptionalJson(this.sessionPath(identity.host_source_ref, identity.host_session_ref), validateSession);
   }
@@ -1923,7 +2939,7 @@ var CodexOutboxStore = class {
     for (const name of await readdir(this.registrationsDirectory)) {
       if (!name.endsWith(".json")) continue;
       try {
-        const value = JSON.parse(await readPrivateFile(join2(this.registrationsDirectory, name)));
+        const value = JSON.parse(await readPrivateFile(join3(this.registrationsDirectory, name)));
         validateRegistration(value);
         registrations.push(value);
       } catch {
@@ -1942,7 +2958,7 @@ var CodexOutboxStore = class {
     await writeAtomicJson(this.cursorPath(cursor.host_source_ref, cursor.host_session_ref), cursor);
   }
   async findByAlias(sourceRef, sessionRef, alias) {
-    if (!SAFE_REF3.test(sourceRef) || !SAFE_REF3.test(sessionRef) || !SAFE_REF3.test(alias)) return null;
+    if (!SAFE_REF4.test(sourceRef) || !SAFE_REF4.test(sessionRef) || !SAFE_REF4.test(alias)) return null;
     const read = await this.list();
     const envelope = findEnvelopeByAlias(read.entries, sourceRef, sessionRef, alias);
     if (envelope !== null) return envelopeMatch(envelope);
@@ -1952,7 +2968,7 @@ var CodexOutboxStore = class {
     return null;
   }
   async hasPriorTurn(sourceRef, sessionRef) {
-    if (!SAFE_REF3.test(sourceRef) || !SAFE_REF3.test(sessionRef)) return false;
+    if (!SAFE_REF4.test(sourceRef) || !SAFE_REF4.test(sessionRef)) return false;
     const read = await this.list();
     if (read.entries.some((entry) => entry.identity.host_source_ref === sourceRef && entry.identity.host_session_ref === sessionRef)) return true;
     await this.prepare();
@@ -1964,34 +2980,37 @@ var CodexOutboxStore = class {
     return false;
   }
   entryPath(submissionRef) {
-    if (!SAFE_REF3.test(submissionRef)) throw storageError("Codex submission identity is malformed.");
-    return join2(this.entriesDirectory, `${cealRequestSha256(submissionRef)}.json`);
+    if (!SAFE_REF4.test(submissionRef)) throw storageError("Codex submission identity is malformed.");
+    return join3(this.entriesDirectory, `${cealRequestSha256(submissionRef)}.json`);
   }
   bindingPath(identity) {
-    return join2(this.bindingsDirectory, `${identityKey(identity)}.json`);
+    return join3(this.bindingsDirectory, `${identityKey(identity)}.json`);
   }
   sessionPath(sourceRef, sessionRef) {
-    return join2(this.sessionsDirectory, `${identityKey({ host_source_ref: sourceRef, host_session_ref: sessionRef, host_turn_ref: "session" })}.json`);
+    return join3(this.sessionsDirectory, `${identityKey({ host_source_ref: sourceRef, host_session_ref: sessionRef, host_turn_ref: "session" })}.json`);
   }
   activeContextPath(identity) {
-    return join2(this.activeContextsDirectory, `${invocationContextKey(identity)}.json`);
+    return join3(this.activeContextsDirectory, `${invocationContextKey(identity)}.json`);
+  }
+  turnSelectionPath(sourceRef, sessionRef) {
+    return join3(this.turnSelectionsDirectory, `${invocationContextKey({ host_source_ref: sourceRef, host_session_ref: sessionRef })}.json`);
   }
   registrationPath(sourceRef, sessionRef) {
-    return join2(this.registrationsDirectory, `${sessionStateKey(sourceRef, sessionRef)}.json`);
+    return join3(this.registrationsDirectory, `${sessionStateKey(sourceRef, sessionRef)}.json`);
   }
   cursorPath(sourceRef, sessionRef) {
-    return join2(this.cursorsDirectory, `${sessionStateKey(sourceRef, sessionRef)}.json`);
+    return join3(this.cursorsDirectory, `${sessionStateKey(sourceRef, sessionRef)}.json`);
   }
 };
 async function removeOwnerState(path, what) {
   try {
-    await unlink(path);
+    await unlink2(path);
   } catch (error) {
     if (!isNotFound(error)) throw storageError(`Unable to retire the Codex transcript ${what}.`);
   }
 }
 function sessionStateKey(sourceRef, sessionRef) {
-  if (!SAFE_REF3.test(sourceRef) || !SAFE_REF3.test(sessionRef)) throw storageError("Codex transcript session identity is malformed.");
+  if (!SAFE_REF4.test(sourceRef) || !SAFE_REF4.test(sessionRef)) throw storageError("Codex transcript session identity is malformed.");
   return cealRequestSha256({ host_source_ref: sourceRef, host_session_ref: sessionRef });
 }
 function envelopeMatch(envelope) {
@@ -2018,7 +3037,7 @@ async function findBindingByAlias(directory, sourceRef, sessionRef, alias) {
 }
 async function readBindingCandidate(directory, name) {
   try {
-    const value = JSON.parse(await readPrivateFile(join2(directory, name)));
+    const value = JSON.parse(await readPrivateFile(join3(directory, name)));
     validateBinding(value);
     return value;
   } catch {
@@ -2037,18 +3056,18 @@ async function writeAtomicJson(path, value) {
   if (text === void 0) throw storageError("Codex owner state cannot be serialized.");
   const temp = `${path}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
   try {
-    const handle = await open(temp, "wx", 384);
+    const handle = await open3(temp, "wx", 384);
     try {
       await handle.writeFile(text, "utf8");
       await handle.sync();
     } finally {
       await handle.close();
     }
-    await rename(temp, path);
+    await rename3(temp, path);
     await syncDirectory(dirname(path));
   } catch (error) {
     try {
-      await unlink(temp);
+      await unlink2(temp);
     } catch {
     }
     if (error instanceof CodexHostAdapterError) throw error;
@@ -2057,7 +3076,7 @@ async function writeAtomicJson(path, value) {
 }
 async function syncDirectory(path) {
   try {
-    const handle = await open(path, "r");
+    const handle = await open3(path, "r");
     try {
       await handle.sync();
     } finally {
@@ -2079,12 +3098,12 @@ async function readOptionalJson(path, validate) {
 }
 async function ensurePrivateOwnerDirectory(path) {
   try {
-    await lstat(path);
+    await lstat2(path);
   } catch (error) {
     if (!isNotFound(error)) throw storageError("Codex owner state directory is unavailable.");
-    await mkdir(path, { recursive: true, mode: 448 });
+    await mkdir3(path, { recursive: true, mode: 448 });
   }
-  const stats = await lstat(path);
+  const stats = await lstat2(path);
   const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
   if (!stats.isDirectory() || stats.isSymbolicLink()) throw storageError(`Codex owner state path is not a directory (${refusalFact("mode", `0o${stats.mode.toString(8)}`, "a directory mode (0o40xxx)")}).`);
   if ((stats.mode & 63) !== 0) throw storageError(`Codex owner state directory is readable beyond its owner (${refusalFact("permission_bits", `0o${(stats.mode & 511).toString(8)}`, "no group or other bits")}).`);
@@ -2093,7 +3112,7 @@ async function ensurePrivateOwnerDirectory(path) {
 async function readPrivateFile(path) {
   let handle;
   try {
-    handle = await open(path, O_RDONLY | O_NOFOLLOW);
+    handle = await open3(path, O_RDONLY3 | O_NOFOLLOW2);
     const stats = await handle.stat();
     const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
     if (!stats.isFile()) throw storageError(`Codex owner state path is not a regular file (${refusalFact("mode", `0o${stats.mode.toString(8)}`, "a regular-file mode (0o100xxx)")}).`);
@@ -2105,7 +3124,7 @@ async function readPrivateFile(path) {
   }
 }
 function validateEnvelope(value) {
-  if (!isRecord3(value)) throw storageError("Codex outbox entry is malformed.");
+  if (!isRecord4(value)) throw storageError("Codex 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", "codex_turn_id"])) throw storageError(`Codex outbox entry key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the outbox entry key set")}).`);
   if (value.schema_version !== CODEX_OUTBOX_SCHEMA_VERSION) throw storageError(`Codex outbox entry is malformed (${refusalFact("schema_version", value.schema_version, `expected ${CODEX_OUTBOX_SCHEMA_VERSION}`)}).`);
   validateIdentity2(value.identity);
@@ -2114,22 +3133,22 @@ function validateEnvelope(value) {
   validateEnvelopeTimestamps(value);
 }
 function validateEnvelopeReferences(value) {
-  if (!SAFE_REF3.test(String(value.host_input_ref))) throw storageError("Codex outbox input reference is malformed.");
+  if (!SAFE_REF4.test(String(value.host_input_ref))) throw storageError("Codex outbox input reference is malformed.");
   if (!isCealHostInputKind(value.input_kind)) throw storageError("Codex outbox input provenance is malformed.");
-  if (!SAFE_REF3.test(String(value.prompt_ref))) throw storageError("Codex outbox references are malformed.");
-  if (!SAFE_REF3.test(String(value.submission_ref))) throw storageError("Codex outbox references are malformed.");
-  if (value.request_ref !== void 0 && !SAFE_REF3.test(String(value.request_ref))) throw storageError("Codex outbox Request reference is malformed.");
-  if (value.codex_turn_id !== void 0 && !SAFE_REF3.test(String(value.codex_turn_id))) throw storageError("Codex outbox turn identity is malformed.");
+  if (!SAFE_REF4.test(String(value.prompt_ref))) throw storageError("Codex outbox references are malformed.");
+  if (!SAFE_REF4.test(String(value.submission_ref))) throw storageError("Codex outbox references are malformed.");
+  if (value.request_ref !== void 0 && !SAFE_REF4.test(String(value.request_ref))) throw storageError("Codex outbox Request reference is malformed.");
+  if (value.codex_turn_id !== void 0 && !SAFE_REF4.test(String(value.codex_turn_id))) throw storageError("Codex outbox turn identity is malformed.");
   if (typeof value.origin_input !== "boolean") throw storageError("Codex outbox origin disposition is malformed.");
 }
 function validateRegistration(value) {
-  if (!isRecord3(value)) throw storageError("Codex transcript registration is malformed.");
+  if (!isRecord4(value)) throw storageError("Codex transcript registration is malformed.");
   if (!sameKeys(value, ["schema_version", "host_source_ref", "host_session_ref", "codex_session_id", "transcript_path", "registered_at", "expires_at"], ["cwd"])) throw storageError(`Codex transcript registration key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the registration key set")}).`);
   if (value.schema_version !== CODEX_TRANSCRIPT_REGISTRATION_SCHEMA_VERSION) throw storageError(`Codex transcript registration is malformed (${refusalFact("schema_version", value.schema_version, `expected ${CODEX_TRANSCRIPT_REGISTRATION_SCHEMA_VERSION}`)}).`);
   validateRegistrationFields(value);
 }
 function validateRegistrationFields(value) {
-  if (![value.host_source_ref, value.host_session_ref, value.codex_session_id].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) throw storageError(`Codex transcript registration references are malformed (${refusalFacts([{ name: "host_source_ref", value: value.host_source_ref }, { name: "host_session_ref", value: value.host_session_ref }, { name: "codex_session_id", value: value.codex_session_id }])}).`);
+  if (![value.host_source_ref, value.host_session_ref, value.codex_session_id].every((candidate) => typeof candidate === "string" && SAFE_REF4.test(candidate))) throw storageError(`Codex transcript registration references are malformed (${refusalFacts([{ name: "host_source_ref", value: value.host_source_ref }, { name: "host_session_ref", value: value.host_session_ref }, { name: "codex_session_id", value: value.codex_session_id }])}).`);
   if (!validRegistrationCwd(value.cwd)) throw storageError(`Codex transcript registration working directory is malformed (${refusalFact("cwd_characters", typeof value.cwd === "string" ? value.cwd.length : 0, `an absolute path of at most ${CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS} characters`)}).`);
   if (typeof value.transcript_path !== "string") throw storageError(`Codex transcript registration path is malformed (${refusalFact("kind", typeof value.transcript_path, "string")}).`);
   if (value.transcript_path.length === 0 || value.transcript_path.length > CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS) throw storageError(`Codex transcript registration path is malformed (${refusalFact("characters", value.transcript_path.length, `from 1 through ${CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS}`)}).`);
@@ -2139,15 +3158,15 @@ function validRegistrationCwd(value) {
   return value === void 0 || typeof value === "string" && isAbsolute2(value) && value.length <= CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS && !value.includes("\0");
 }
 function validateCursor(value) {
-  if (!isRecord3(value)) throw storageError("Codex transcript cursor is malformed.");
+  if (!isRecord4(value)) throw storageError("Codex transcript cursor is malformed.");
   if (!sameKeys(value, ["schema_version", "host_source_ref", "host_session_ref", "transcript_path", "device", "inode", "offset", "last_ordinal", "anchor_start", "anchor_sha256", "header_validated", "status", "updated_at"], ["active_task", "reason"])) throw storageError(`Codex transcript cursor key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the cursor key set")}).`);
   if (value.schema_version !== CODEX_TRANSCRIPT_CURSOR_SCHEMA_VERSION) throw storageError(`Codex transcript cursor is malformed (${refusalFact("schema_version", value.schema_version, `expected ${CODEX_TRANSCRIPT_CURSOR_SCHEMA_VERSION}`)}).`);
   if (!validCursorSource(value) || !validCursorPosition(value) || !validCursorStatus(value)) throw storageError("Codex transcript cursor fields are malformed.");
   if (value.active_task !== void 0 && !validActiveTask(value.active_task)) throw storageError("Codex transcript task cursor is malformed.");
-  if (value.reason !== void 0 && !isCodexTranscriptCursorReason(value.reason)) throw storageError("Codex transcript cursor reason is malformed.");
+  if (value.reason !== void 0 && !isHostTranscriptCursorReason(value.reason)) throw storageError("Codex transcript cursor reason is malformed.");
 }
 function validCursorSource(value) {
-  return [value.host_source_ref, value.host_session_ref].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate)) && typeof value.transcript_path === "string" && value.transcript_path.length > 0 && typeof value.device === "string" && typeof value.inode === "string";
+  return [value.host_source_ref, value.host_session_ref].every((candidate) => typeof candidate === "string" && SAFE_REF4.test(candidate)) && typeof value.transcript_path === "string" && value.transcript_path.length > 0 && typeof value.device === "string" && typeof value.inode === "string";
 }
 function validCursorPosition(value) {
   return nonNegativeInteger(value.offset) && nonNegativeInteger(value.last_ordinal) && nonNegativeInteger(value.anchor_start) && typeof value.anchor_sha256 === "string" && /^[a-f0-9]{64}$/u.test(value.anchor_sha256) && typeof value.header_validated === "boolean";
@@ -2156,23 +3175,23 @@ function validCursorStatus(value) {
   return (value.status === "active" || value.status === "quarantined") && isTimestamp(value.updated_at);
 }
 function validActiveTask(value) {
-  if (!isRecord3(value) || !sameKeys(value, ["codex_turn_id", "host_turn_ref", "started_at"], ["origin_host_input_ref", "prompt_ref", "model", "token_usage", "last_total_usage", "token_usage_gap_reason"])) return false;
+  if (!isRecord4(value) || !sameKeys(value, ["codex_turn_id", "host_turn_ref", "started_at"], ["origin_host_input_ref", "prompt_ref", "model", "token_usage", "last_total_usage", "token_usage_gap_reason"])) return false;
   return validActiveTaskIdentity(value) && validActiveTaskReferences(value) && validActiveTaskUsage(value);
 }
 function validActiveTaskIdentity(value) {
-  return [value.codex_turn_id, value.host_turn_ref].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate)) && isTimestamp(value.started_at);
+  return [value.codex_turn_id, value.host_turn_ref].every((candidate) => typeof candidate === "string" && SAFE_REF4.test(candidate)) && isTimestamp(value.started_at);
 }
 function validActiveTaskReferences(value) {
   return optionalSafeRef2(value.origin_host_input_ref) && optionalSafeRef2(value.prompt_ref) && (value.model === void 0 || typeof value.model === "string" && value.model.length > 0 && value.model.length <= 256);
 }
 function optionalSafeRef2(value) {
-  return value === void 0 || typeof value === "string" && SAFE_REF3.test(value);
+  return value === void 0 || typeof value === "string" && SAFE_REF4.test(value);
 }
 function validActiveTaskUsage(value) {
   return (value.token_usage === void 0 || validTokenUsage(value.token_usage)) && (value.last_total_usage === void 0 || validTokenUsage(value.last_total_usage)) && (value.token_usage_gap_reason === void 0 || value.token_usage_gap_reason === "token_count_shape_not_attributable");
 }
 function validTokenUsage(value) {
-  if (!isRecord3(value) || !sameKeys(value, ["input_tokens", "cached_input_tokens", "cache_write_input_tokens", "output_tokens", "reasoning_output_tokens", "total_tokens"])) return false;
+  if (!isRecord4(value) || !sameKeys(value, ["input_tokens", "cached_input_tokens", "cache_write_input_tokens", "output_tokens", "reasoning_output_tokens", "total_tokens"])) return false;
   if (![value.input_tokens, value.cached_input_tokens, value.cache_write_input_tokens, value.output_tokens, value.reasoning_output_tokens, value.total_tokens].every(nonNegativeInteger)) return false;
   return value.total_tokens === Number(value.input_tokens) + Number(value.output_tokens) && Number(value.cached_input_tokens) + Number(value.cache_write_input_tokens) <= Number(value.input_tokens) && Number(value.reasoning_output_tokens) <= Number(value.output_tokens);
 }
@@ -2192,30 +3211,33 @@ function validateEnvelopeTimestamps(value) {
   if (!isTimestamp(value.expires_at)) throw storageError("Codex outbox timestamps are malformed.");
 }
 function validateBinding(value) {
-  if (!isRecord3(value)) throw storageError("Codex turn binding is malformed.");
+  if (!isRecord4(value)) throw storageError("Codex turn binding is malformed.");
   if (!sameKeys(value, ["schema_version", "identity", "prompt_ref", "request_ref", "codex_turn_ids", "bound_at", "expires_at"])) throw storageError(`Codex turn binding key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the turn binding key set")}).`);
   if (value.schema_version !== CODEX_TURN_BINDING_SCHEMA_VERSION) throw storageError(`Codex turn binding is malformed (${refusalFact("schema_version", value.schema_version, `expected ${CODEX_TURN_BINDING_SCHEMA_VERSION}`)}).`);
   validateIdentity2(value.identity);
-  if (!SAFE_REF3.test(String(value.prompt_ref)) || !SAFE_REF3.test(String(value.request_ref))) throw storageError("Codex turn binding references are malformed.");
+  if (!SAFE_REF4.test(String(value.prompt_ref)) || !SAFE_REF4.test(String(value.request_ref))) throw storageError("Codex turn binding references are malformed.");
   if (!isStringList(value.codex_turn_ids) || !isTimestamp(value.bound_at) || !isTimestamp(value.expires_at)) throw storageError("Codex turn binding fields are malformed.");
 }
 function validateSession(value) {
-  if (!isRecord3(value)) throw storageError("Codex session snapshot is malformed.");
+  if (!isRecord4(value)) throw storageError("Codex session snapshot is malformed.");
   if (!sameKeys(value, ["schema_version", "host_session_ref", "host_source_ref", "observed_at", "value", "expires_at"])) throw storageError(`Codex session snapshot key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the session snapshot key set")}).`);
   if (value.schema_version !== CODEX_SESSION_SCHEMA_VERSION) throw storageError(`Codex session snapshot is malformed (${refusalFact("schema_version", value.schema_version, `expected ${CODEX_SESSION_SCHEMA_VERSION}`)}).`);
-  if (!SAFE_REF3.test(String(value.host_session_ref)) || !SAFE_REF3.test(String(value.host_source_ref)) || !isTimestamp(value.observed_at) || !isTimestamp(value.expires_at) || !isJsonValue(value.value)) throw storageError("Codex session snapshot fields are malformed.");
+  if (!SAFE_REF4.test(String(value.host_session_ref)) || !SAFE_REF4.test(String(value.host_source_ref)) || !isTimestamp(value.observed_at) || !isTimestamp(value.expires_at) || !isJsonValue(value.value)) throw storageError("Codex session snapshot fields are malformed.");
+}
+function validateTurnSelection(value) {
+  if (!isHostInvocationTurnSelection(value)) throw storageError("Codex Host turn selection is malformed.");
 }
 function validateIdentity2(value) {
-  if (!isRecord3(value) || !hasHostInvocationIdentityKeys(value) || ![value.host_session_ref, value.host_turn_ref, value.host_source_ref].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) throw storageError("Codex Host identity is malformed.");
+  if (!isRecord4(value) || !hasHostInvocationIdentityKeys(value) || ![value.host_session_ref, value.host_turn_ref, value.host_source_ref].every((candidate) => typeof candidate === "string" && SAFE_REF4.test(candidate))) throw storageError("Codex Host identity is malformed.");
 }
 function isJsonValue(value) {
   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.every(isJsonValue);
-  return isRecord3(value) && Object.entries(value).every(([key, child]) => key.length > 0 && key.length <= 128 && isJsonValue(child));
+  return isRecord4(value) && Object.entries(value).every(([key, child]) => key.length > 0 && key.length <= 128 && isJsonValue(child));
 }
 function isStringList(value) {
-  return Array.isArray(value) && value.every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate));
+  return Array.isArray(value) && value.every((candidate) => typeof candidate === "string" && SAFE_REF4.test(candidate));
 }
 function isTimestamp(value) {
   return typeof value === "string" && value.length <= 64 && !Number.isNaN(Date.parse(value));
@@ -2225,23 +3247,23 @@ function sameKeys(value, required, optional = []) {
   const keys = Object.keys(value);
   return keys.length >= required.length && keys.length <= allowed.size && required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => allowed.has(key));
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isNotFound(error) {
-  return isRecord3(error) && error.code === "ENOENT";
+  return isRecord4(error) && error.code === "ENOENT";
 }
 function storageError(message) {
   return new CodexHostAdapterError("storage", message);
 }
 
 // host/codex/src/codex-transcript-baseline.ts
-import { createHash as createHash3 } from "node:crypto";
-import { O_NOFOLLOW as O_NOFOLLOW2, O_RDONLY as O_RDONLY2 } from "node:constants";
-import { open as open2 } from "node:fs/promises";
+import { createHash as createHash4 } from "node:crypto";
+import { O_NOFOLLOW as O_NOFOLLOW3, O_RDONLY as O_RDONLY4 } from "node:constants";
+import { open as open4 } from "node:fs/promises";
 
 // host/codex/src/codex-transcript-decoder.ts
-var SAFE_REF4 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
+var SAFE_REF5 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
 var MAX_PROMPT_BYTES = 64 * 1024;
 function decodeCodexTranscriptLine(line) {
   let value;
@@ -2250,40 +3272,40 @@ function decodeCodexTranscriptLine(line) {
   } catch {
     reject2("Codex transcript record is not valid JSON.");
   }
-  if (!isRecord4(value)) reject2("Codex transcript record envelope is malformed.");
+  if (!isRecord5(value)) reject2("Codex transcript record envelope is malformed.");
   const ordinal = safeOrdinal(value.ordinal);
-  const timestamp6 = safeTimestamp(value.timestamp);
-  if (!isRecord4(value.payload) || typeof value.type !== "string") reject2("Codex transcript record payload is malformed.");
-  if (value.type === "session_meta") return decodeSessionMeta(value.payload, ordinal, timestamp6);
-  if (value.type === "turn_context") return decodeTurnContext(value.payload, ordinal, timestamp6);
-  if (value.type === "event_msg") return decodeEventMessage(value.payload, ordinal, timestamp6);
-  if (value.type === "response_item") return decodeResponseItem(value.payload, ordinal, timestamp6);
-  return { kind: "ignored", ordinal, timestamp: timestamp6 };
-}
-function decodeTurnContext(payload, ordinal, timestamp6) {
+  const timestamp5 = safeTimestamp(value.timestamp);
+  if (!isRecord5(value.payload) || typeof value.type !== "string") reject2("Codex transcript record payload is malformed.");
+  if (value.type === "session_meta") return decodeSessionMeta(value.payload, ordinal, timestamp5);
+  if (value.type === "turn_context") return decodeTurnContext(value.payload, ordinal, timestamp5);
+  if (value.type === "event_msg") return decodeEventMessage(value.payload, ordinal, timestamp5);
+  if (value.type === "response_item") return decodeResponseItem(value.payload, ordinal, timestamp5);
+  return { kind: "ignored", ordinal, timestamp: timestamp5 };
+}
+function decodeTurnContext(payload, ordinal, timestamp5) {
   return {
     kind: "turn_context",
     ordinal,
-    timestamp: timestamp6,
-    turn_id: safeRef2(payload.turn_id, "Codex turn context identity is invalid."),
+    timestamp: timestamp5,
+    turn_id: safeRef4(payload.turn_id, "Codex turn context identity is invalid."),
     model: boundedNonEmptyText(payload.model, 256, "Codex turn context model is invalid.")
   };
 }
-function decodeSessionMeta(payload, ordinal, timestamp6) {
-  const sessionId = safeRef2(payload.id, "Codex transcript session identity is invalid.");
+function decodeSessionMeta(payload, ordinal, timestamp5) {
+  const sessionId = safeRef4(payload.id, "Codex transcript session identity is invalid.");
   const cliVersion = boundedNonEmptyText(payload.cli_version, 64, "Codex transcript version is invalid.");
-  return { kind: "session_meta", ordinal, timestamp: timestamp6, session_id: sessionId, cli_version: cliVersion };
+  return { kind: "session_meta", ordinal, timestamp: timestamp5, session_id: sessionId, cli_version: cliVersion };
 }
-function decodeEventMessage(payload, ordinal, timestamp6) {
+function decodeEventMessage(payload, ordinal, timestamp5) {
   if (payload.type === "task_started") {
-    return { kind: "task_started", ordinal, timestamp: timestamp6, turn_id: safeRef2(payload.turn_id, "Codex task identity is invalid."), started_at: safeNumber(payload.started_at) };
+    return { kind: "task_started", ordinal, timestamp: timestamp5, turn_id: safeRef4(payload.turn_id, "Codex task identity is invalid."), started_at: safeNumber(payload.started_at) };
   }
   if (payload.type === "task_complete") {
     return {
       kind: "task_complete",
       ordinal,
-      timestamp: timestamp6,
-      turn_id: safeRef2(payload.turn_id, "Codex task identity is invalid."),
+      timestamp: timestamp5,
+      turn_id: safeRef4(payload.turn_id, "Codex task identity is invalid."),
       started_at: safeNumber(payload.started_at),
       completed_at: safeNumber(payload.completed_at),
       duration_ms: safeNumber(payload.duration_ms),
@@ -2294,20 +3316,20 @@ function decodeEventMessage(payload, ordinal, timestamp6) {
     return {
       kind: "turn_aborted",
       ordinal,
-      timestamp: timestamp6,
-      turn_id: safeRef2(payload.turn_id, "Codex task identity is invalid."),
+      timestamp: timestamp5,
+      turn_id: safeRef4(payload.turn_id, "Codex task identity is invalid."),
       started_at: safeNumber(payload.started_at),
       completed_at: safeNumber(payload.completed_at),
       duration_ms: safeNumber(payload.duration_ms),
       reason: boundedText(payload.reason, 256, "Codex task abort reason is invalid.")
     };
   }
-  if (payload.type === "token_count") return decodeTokenCount(payload, ordinal, timestamp6);
-  return { kind: "ignored", ordinal, timestamp: timestamp6 };
+  if (payload.type === "token_count") return decodeTokenCount(payload, ordinal, timestamp5);
+  return { kind: "ignored", ordinal, timestamp: timestamp5 };
 }
-function decodeTokenCount(payload, ordinal, timestamp6) {
-  if (payload.info === null) return { kind: "token_count", ordinal, timestamp: timestamp6 };
-  if (!isRecord4(payload.info)) return { kind: "token_count", ordinal, timestamp: timestamp6, usage_gap_reason: "token_count_shape_not_attributable" };
+function decodeTokenCount(payload, ordinal, timestamp5) {
+  if (payload.info === null) return { kind: "token_count", ordinal, timestamp: timestamp5 };
+  if (!isRecord5(payload.info)) return { kind: "token_count", ordinal, timestamp: timestamp5, usage_gap_reason: "token_count_shape_not_attributable" };
   const lastUsage = optionalTokenUsage(payload.info.last_token_usage);
   const totalUsage = optionalTokenUsage(payload.info.total_token_usage);
   const gap = lastUsage.status === "invalid" || totalUsage.status === "invalid";
@@ -2315,7 +3337,7 @@ function decodeTokenCount(payload, ordinal, timestamp6) {
   return {
     kind: "token_count",
     ordinal,
-    timestamp: timestamp6,
+    timestamp: timestamp5,
     ...lastUsage.status === "valid" ? { last_usage: lastUsage.value } : {},
     ...totalUsage.status === "valid" ? { total_usage: totalUsage.value } : {},
     ...usageGapReason === void 0 ? {} : { usage_gap_reason: usageGapReason }
@@ -2331,7 +3353,7 @@ function optionalTokenUsage(value) {
   }
 }
 function decodeTokenUsage(value) {
-  if (!isRecord4(value)) reject2("Codex token usage is malformed.");
+  if (!isRecord5(value)) reject2("Codex token usage is malformed.");
   const usage = {
     input_tokens: safeTokenCount(value.input_tokens),
     cached_input_tokens: safeTokenCount(value.cached_input_tokens),
@@ -2343,20 +3365,20 @@ function decodeTokenUsage(value) {
   if (usage.total_tokens !== usage.input_tokens + usage.output_tokens || usage.cached_input_tokens + usage.cache_write_input_tokens > usage.input_tokens || usage.reasoning_output_tokens > usage.output_tokens) reject2("Codex token usage buckets are inconsistent.");
   return usage;
 }
-function decodeResponseItem(payload, ordinal, timestamp6) {
-  if (payload.type !== "message" || payload.role !== "user") return { kind: "ignored", ordinal, timestamp: timestamp6 };
+function decodeResponseItem(payload, ordinal, timestamp5) {
+  if (payload.type !== "message" || payload.role !== "user") return { kind: "ignored", ordinal, timestamp: timestamp5 };
   const metadata = userMessageMetadata(payload.internal_chat_message_metadata_passthrough);
   const inputKind = inputKindFromContentItems(metadata.content_item_kinds);
-  if (inputKind === void 0) return { kind: "ignored", ordinal, timestamp: timestamp6 };
+  if (inputKind === void 0) return { kind: "ignored", ordinal, timestamp: timestamp5 };
   const prompt = userTextContent(payload.content);
   return {
     kind: "user_text",
     ordinal,
-    timestamp: timestamp6,
+    timestamp: timestamp5,
     prompt,
     input_kind: inputKind,
-    message_id: safeRef2(payload.id, "Codex user message identity is invalid."),
-    turn_id: safeRef2(metadata.turn_id, "Codex user message task identity is invalid.")
+    message_id: safeRef4(payload.id, "Codex user message identity is invalid."),
+    turn_id: safeRef4(metadata.turn_id, "Codex user message task identity is invalid.")
   };
 }
 function inputKindFromContentItems(kinds) {
@@ -2365,13 +3387,13 @@ function inputKindFromContentItems(kinds) {
   return kinds[0] === "goal.internal_context" ? "host_automatic" : void 0;
 }
 function userMessageMetadata(value) {
-  if (!isRecord4(value) || !Array.isArray(value.content_item_kinds)) reject2("Codex user message provenance is malformed.");
+  if (!isRecord5(value) || !Array.isArray(value.content_item_kinds)) reject2("Codex user message provenance is malformed.");
   return { ...value, content_item_kinds: value.content_item_kinds };
 }
 function userTextContent(value) {
   if (!Array.isArray(value)) reject2(`Codex user text content is malformed (${refusalFact("kind", typeof value, "array")}).`);
   if (value.length !== 1) reject2(`Codex user text content is malformed (${refusalFact("items", value.length, "exactly one")}).`);
-  if (!isRecord4(value[0]) || value[0].type !== "input_text") reject2(`Codex user text content is malformed (${refusalFact("item_type", isRecord4(value[0]) ? value[0].type : typeof value[0], "input_text")}).`);
+  if (!isRecord5(value[0]) || value[0].type !== "input_text") reject2(`Codex user text content is malformed (${refusalFact("item_type", isRecord5(value[0]) ? value[0].type : typeof value[0], "input_text")}).`);
   return boundedText(value[0].text, MAX_PROMPT_BYTES, "Codex user text is invalid.");
 }
 function safeOrdinal(value) {
@@ -2392,8 +3414,8 @@ function safeTimestamp(value) {
   if (!Number.isFinite(Date.parse(value))) reject2(`Codex transcript timestamp is invalid (${refusalFact("parsed_ms", Date.parse(value), "a finite epoch milliseconds value")}).`);
   return value;
 }
-function safeRef2(value, message) {
-  if (typeof value !== "string" || !SAFE_REF4.test(value)) reject2(message);
+function safeRef4(value, message) {
+  if (typeof value !== "string" || !SAFE_REF5.test(value)) reject2(message);
   return value;
 }
 function boundedText(value, maximum, message) {
@@ -2407,7 +3429,7 @@ function boundedNonEmptyText(value, maximum, message) {
   if (result.length === 0) reject2(message);
   return result;
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function reject2(message) {
@@ -2420,7 +3442,7 @@ var CODEX_TRANSCRIPT_ANCHOR_BYTES = 256;
 async function captureCodexTranscriptBaseline(registration, now = () => /* @__PURE__ */ new Date()) {
   let handle;
   try {
-    handle = await open2(registration.transcript_path, O_RDONLY2 | O_NOFOLLOW2);
+    handle = await open4(registration.transcript_path, O_RDONLY4 | O_NOFOLLOW3);
     const { size, device, inode } = await ownedCodexTranscriptFile(handle);
     const empty = codexTranscriptInitialCursor(registration, device, inode, now);
     const headerLine = await firstCompleteLine(handle, size);
@@ -2440,7 +3462,7 @@ async function captureCodexTranscriptBaseline(registration, now = () => /* @__PU
       anchor_start: anchorStart,
       anchor_sha256: digest(anchor),
       header_validated: true,
-      updated_at: timestamp2(now)
+      updated_at: timestamp3(now)
     };
   } finally {
     await handle?.close();
@@ -2460,7 +3482,7 @@ function codexTranscriptInitialCursor(registration, device, inode, now) {
     anchor_sha256: digest(Buffer.alloc(0)),
     header_validated: false,
     status: "active",
-    updated_at: timestamp2(now)
+    updated_at: timestamp3(now)
   };
 }
 async function ownedCodexTranscriptFile(handle) {
@@ -2541,188 +3563,33 @@ function decodeHistoryLine(bytes) {
     throw error;
   }
 }
-async function* completeLinesBackward(handle, end) {
-  if (end <= 0) return;
-  let position = end - 1;
-  let carry = [];
-  while (position > 0) {
-    const start = Math.max(0, position - BASELINE_READ_CHUNK_BYTES);
-    const buffer = Buffer.alloc(position - start);
-    const read = await handle.read(buffer, 0, buffer.length, start);
-    if (read.bytesRead !== buffer.length) throw new CodexHostAdapterError("storage", "Codex transcript changed size during baseline capture.");
-    let lineEnd = buffer.length;
-    for (let newline = buffer.lastIndexOf(10, lineEnd - 1); newline >= 0; newline = lineEnd > 0 ? buffer.lastIndexOf(10, lineEnd - 1) : -1) {
-      yield { start: start + newline + 1, bytes: Buffer.concat([buffer.subarray(newline + 1, lineEnd), ...carry]) };
-      carry = [];
-      lineEnd = newline;
-    }
-    carry = [buffer.subarray(0, lineEnd), ...carry];
-    position = start;
-  }
-  yield { start: 0, bytes: Buffer.concat(carry) };
-}
-function digest(value) {
-  return createHash3("sha256").update(value).digest("hex");
-}
-function timestamp2(now) {
-  const value = now();
-  if (!Number.isFinite(value.getTime())) throw new CodexHostAdapterError("storage", "Codex watcher clock is invalid.");
-  return value.toISOString();
-}
-
-// host/relay/src/durable-atomic-replacement.ts
-import { O_RDONLY as O_RDONLY3 } from "node:constants";
-import { lstat as lstat2, mkdir as mkdir2, open as open3, rename as rename2, unlink as unlink2 } from "node:fs/promises";
-var DEFAULT_PORT = {
-  platform: process.platform,
-  mkdir: (path, options) => mkdir2(path, options),
-  lstat: (path) => lstat2(path),
-  open_file: (path) => open3(path, "wx", 384),
-  rename: rename2,
-  unlink: unlink2,
-  open_directory: (path) => open3(path, O_RDONLY3),
-  unique_ref: () => `${process.pid}.${crypto.randomUUID()}`
-};
-
-// 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_REF5 = /^[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 FRAME_KINDS = new Set(HOST_PRODUCER_FRAME_KINDS);
-function isHostProducerFrameKind(value) {
-  return typeof value === "string" && FRAME_KINDS.has(value);
-}
-var HostProducerFrameError = class extends Error {
-  code;
-  constructor(code, message = code) {
-    super(message);
-    this.code = code;
-  }
-};
-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;
-  try {
-    value = JSON.parse(text.decode(bytes));
-  } catch (error) {
-    if (error instanceof TypeError) throw new HostProducerFrameError("invalid_frame_encoding");
-    throw new HostProducerFrameError("frame_truncated");
-  }
-  validateFrame(value);
-  return value;
-}
-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 (!exactKeys3(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)) || !safeRef3(value.producer_installation_ref)) throw new HostProducerFrameError("invalid_producer_identity");
-  if (!positive(value.producer_epoch) || !positive(value.sequence) || !hostProducerFrameKind(value.frame_kind) || !timestamp3(value.occurred_at) || !record(value.payload)) throw new HostProducerFrameError("invalid_frame_shape");
-  validatePayload(value.frame_kind, value.payload);
-}
-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 validSession(value) {
-  return exactOptional(value, ["local_session_ref", "working_directory_ref"], ["model", "host_version", "observations"]) && safeRef3(value.local_session_ref) && safeRef3(value.working_directory_ref) && optionalText(value.model, 256) && optionalText(value.host_version, 256) && validObservations(value.observations);
-}
-function validTurn(value) {
-  return exactOptional(value, ["local_session_ref", "local_turn_ref"], ["model", "observations"]) && safeRef3(value.local_session_ref) && safeRef3(value.local_turn_ref) && optionalText(value.model, 256) && validObservations(value.observations);
-}
-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"]) && safeRef3(value.local_session_ref) && safeRef3(value.local_turn_ref) && safeRef3(value.local_input_ref) && validInputObservations(value.observations) && isCealHostInputKind(value.input_kind) && typeof value.origin_input === "boolean" && validInputOptionals(value);
-}
-function validInputObservations(value) {
-  return validObservations(value) && Array.isArray(value) && value.filter((item) => record(item) && item.observation_kind === "prompt").length === 1;
-}
-function validInputOptionals(value) {
-  return optionalRefs(value.local_turn_aliases) && (value.context_expires_at === void 0 || timestamp3(value.context_expires_at));
-}
-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"]) && safeRef3(value.local_session_ref) && safeRef3(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);
-}
-function validTerminalDisposition(state, reason) {
-  return (state === "completed" || state === "aborted") && (reason === void 0 || state === "aborted" && safeRef3(reason));
-}
-function validStatus(value) {
-  return exactOptional(value, ["status", "reason_code"], ["detail"]) && ["ready", "degraded", "stopping"].includes(String(value.status)) && safeRef3(value.reason_code) && optionalText(value.detail, 4096);
-}
-function optionalText(value, maxLength) {
-  return value === void 0 || typeof value === "string" && value.length > 0 && value.length <= maxLength;
-}
-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(safeRef3);
-}
-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 safeRef3(value) {
-  return typeof value === "string" && SAFE_REF5.test(value);
-}
-function positive(value) {
-  return Number.isSafeInteger(value) && Number(value) > 0;
-}
-function timestamp3(value) {
-  return typeof value === "string" && Number.isFinite(Date.parse(value));
-}
-function hostProducerFrameKind(value) {
-  return isHostProducerFrameKind(value);
-}
-function exactKeys3(value, keys) {
-  return JSON.stringify(Object.keys(value).sort()) === JSON.stringify([...keys].sort());
+async function* completeLinesBackward(handle, end) {
+  if (end <= 0) return;
+  let position = end - 1;
+  let carry = [];
+  while (position > 0) {
+    const start = Math.max(0, position - BASELINE_READ_CHUNK_BYTES);
+    const buffer = Buffer.alloc(position - start);
+    const read = await handle.read(buffer, 0, buffer.length, start);
+    if (read.bytesRead !== buffer.length) throw new CodexHostAdapterError("storage", "Codex transcript changed size during baseline capture.");
+    let lineEnd = buffer.length;
+    for (let newline = buffer.lastIndexOf(10, lineEnd - 1); newline >= 0; newline = lineEnd > 0 ? buffer.lastIndexOf(10, lineEnd - 1) : -1) {
+      yield { start: start + newline + 1, bytes: Buffer.concat([buffer.subarray(newline + 1, lineEnd), ...carry]) };
+      carry = [];
+      lineEnd = newline;
+    }
+    carry = [buffer.subarray(0, lineEnd), ...carry];
+    position = start;
+  }
+  yield { start: 0, bytes: Buffer.concat(carry) };
 }
-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));
+function digest(value) {
+  return createHash4("sha256").update(value).digest("hex");
 }
-
-// host/relay/src/relay-request-binding-store.ts
-var MAX_STATE_BYTES = 8 * 1024 * 1024;
-
-// host/relay/src/relay-gateway-bridge.ts
-var HOST_GATEWAY_ACKNOWLEDGEMENT_DISPOSITIONS = ["created", "adopted", "replayed", "approval_approved", "approval_denied", "approval_replayed"];
-function isHostGatewayAcknowledgementDisposition(value) {
-  return typeof value === "string" && HOST_GATEWAY_ACKNOWLEDGEMENT_DISPOSITIONS.some((disposition) => disposition === value);
+function timestamp3(now) {
+  const value = now();
+  if (!Number.isFinite(value.getTime())) throw new CodexHostAdapterError("storage", "Codex watcher clock is invalid.");
+  return value.toISOString();
 }
 
 // host/codex/src/codex-adapter.ts
@@ -2748,7 +3615,7 @@ function createCodexHostObservationAdapter(options) {
   });
 }
 async function registerSession(event, options, store, now, retentionMs) {
-  const defaultRoot = join3(process.env.CODEX_HOME || join3(homedir(), ".codex"), "sessions");
+  const defaultRoot = join4(process.env.CODEX_HOME || join4(homedir(), ".codex"), "sessions");
   const transcriptPath = sourceBoundTranscriptPath(event.transcript_path, options.codex_sessions_root ?? defaultRoot);
   const hostSessionRef = hostSessionReference(options.host_source_ref, event.session_id);
   const observedAt = timestamp4(now);
@@ -2763,20 +3630,59 @@ async function registerSession(event, options, store, now, retentionMs) {
     registered_at: observedAt,
     expires_at: expiresAt
   };
+  const currentTurn = await selectCurrentTurn(event, options, store, hostSessionRef);
   const existing = (await store.listTranscriptRegistrations()).find((candidate) => candidate.host_source_ref === registration.host_source_ref && candidate.host_session_ref === registration.host_session_ref);
   if (existing === void 0) {
     await store.writeTranscriptCursor(await captureCodexTranscriptBaseline(registration, now));
   }
   await store.registerTranscript(registration);
-  await store.saveSession({
-    schema_version: "ceal.codex_session.v1",
-    host_session_ref: hostSessionRef,
+  if (existing !== void 0 && currentTurn !== void 0 && (await store.readTranscriptCursor(registration))?.status === "quarantined") {
+    await store.writeTranscriptCursor(await captureCodexTranscriptBaseline(registration, now));
+  }
+  if (event.event === "SessionStart") {
+    await store.saveSession({
+      schema_version: "ceal.codex_session.v1",
+      host_session_ref: hostSessionRef,
+      host_source_ref: options.host_source_ref,
+      observed_at: observedAt,
+      value: sessionObservationValue(event),
+      expires_at: expiresAt
+    });
+  } else if (currentTurn !== void 0) {
+    await store.attachInvocationTurnGeneration({ host_source_ref: options.host_source_ref, host_session_ref: hostSessionRef, host_turn_ref: currentTurn.host_turn_ref }, currentTurn.prompt_ref, currentTurn.turn_generation_ref);
+  }
+  return { event: event.event, disposition: "ignored", reason: "transcript_registered", ...currentTurn === void 0 ? {} : { host_turn_ref: currentTurn.host_turn_ref } };
+}
+async function selectCurrentTurn(event, options, store, hostSessionRef) {
+  if (event.event !== "UserPromptSubmit") return void 0;
+  const host_turn_ref = hostTurnReference(options.host_source_ref, hostSessionRef, event.turn_id);
+  const steered = await liveSteeredTurn(options, store, hostSessionRef, host_turn_ref);
+  if (steered !== void 0) return steered;
+  const currentTurn = {
+    host_turn_ref,
+    prompt_ref: hostProducerPromptRef(promptObservationValue(event.prompt).body_sha256),
+    turn_generation_ref: options.random_uuid?.() ?? randomUUID()
+  };
+  await store.writeInvocationTurnSelection({
+    schema_version: "ceal.host_invocation_turn_selection.v1",
     host_source_ref: options.host_source_ref,
-    observed_at: observedAt,
-    value: sessionObservationValue(event),
-    expires_at: expiresAt
+    host_session_ref: hostSessionRef,
+    prompt_ref: currentTurn.prompt_ref,
+    turn_generation_ref: currentTurn.turn_generation_ref
   });
-  return { event: "SessionStart", disposition: "ignored", reason: "transcript_registered" };
+  return currentTurn;
+}
+async function liveSteeredTurn(options, store, hostSessionRef, hostTurnRef) {
+  let live;
+  try {
+    live = await store.readInvocationContext(options.host_source_ref, hostSessionRef, (options.now ?? (() => /* @__PURE__ */ new Date()))());
+  } catch {
+    return void 0;
+  }
+  if (live === null || live.identity.host_turn_ref !== hostTurnRef) return void 0;
+  const selection = await store.readInvocationTurnSelection(options.host_source_ref, hostSessionRef).catch(() => null);
+  if (selection === null || selection.prompt_ref !== live.prompt_ref || selection.turn_generation_ref !== live.turn_generation_ref) return void 0;
+  return { host_turn_ref: hostTurnRef, prompt_ref: selection.prompt_ref, turn_generation_ref: selection.turn_generation_ref };
 }
 function sourceBoundTranscriptPath(path, sessionsRoot) {
   if (!isAbsolute3(path) || !isAbsolute3(sessionsRoot)) throw new CodexHostAdapterError("configuration", "Codex transcript registration paths must be absolute.");
@@ -2884,7 +3790,7 @@ async function submitWithDeadline(gateway, submission, timeoutMs, signal) {
   });
   try {
     const acknowledgement = await Promise.race([gateway.submitHostTurn(submission, controller.signal), timeout]);
-    if (!isRecord5(acknowledgement) || !SAFE_REF6.test(String(acknowledgement.request_ref)) || !isHostGatewayAcknowledgementDisposition(acknowledgement.disposition)) {
+    if (!isRecord6(acknowledgement) || !SAFE_REF6.test(String(acknowledgement.request_ref)) || !isHostGatewayAcknowledgementDisposition(acknowledgement.disposition)) {
       throw new CodexHostAdapterError("payload_rejected", "Gateway Host acknowledgement is invalid.");
     }
     return acknowledgement;
@@ -2914,12 +3820,12 @@ function timestamp4(now) {
   return value.toISOString();
 }
 function validateOptions(options) {
-  if (!isRecord5(options)) throw new CodexHostAdapterError("configuration", "Codex adapter options are invalid.");
+  if (!isRecord6(options)) throw new CodexHostAdapterError("configuration", "Codex adapter options are invalid.");
   validateAdapterOwner(options);
   validateAdapterBehavior(options);
 }
 function validateAdapterOwner(options) {
-  if (!SAFE_REF6.test(options.host_source_ref) || options.outbox_dir.length === 0 || !isRecord5(options.gateway) || typeof options.gateway.submitHostTurn !== "function") {
+  if (!SAFE_REF6.test(options.host_source_ref) || options.outbox_dir.length === 0 || !isRecord6(options.gateway) || typeof options.gateway.submitHostTurn !== "function") {
     throw new CodexHostAdapterError("configuration", "Codex adapter options are invalid.");
   }
   if (options.codex_sessions_root !== void 0 && !isAbsolute3(options.codex_sessions_root)) throw new CodexHostAdapterError("configuration", "Codex sessions root is invalid.");
@@ -2931,7 +3837,7 @@ function validateAdapterBehavior(options) {
 function safeReason(error) {
   return error instanceof CodexHostAdapterError ? error.message.slice(0, 128) : "codex_session_registration_rejected";
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
@@ -2939,7 +3845,7 @@ function isRecord5(value) {
 import { posix as posix3, win32 as win323 } from "node:path";
 
 // host/runtime-source-paths.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { posix as posix2, win32 as win322 } from "node:path";
 
 // host/absolute-path.ts
@@ -2961,7 +3867,7 @@ function hostRuntimeSourcePaths(stateRoot, sourceRef, platform = process.platfor
   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-${createHash4("sha256").update(`${stateRoot}\0${sourceRef}`).digest("hex").slice(0, 24)}` : path.join(runtimeRoot, `${sourceId}.sock`);
+  const endpoint = platform === "win32" ? `\\\\.\\pipe\\ceal-host-${createHash5("sha256").update(`${stateRoot}\0${sourceRef}`).digest("hex").slice(0, 24)}` : path.join(runtimeRoot, `${sourceId}.sock`);
   assertHostRuntimeIpcLength(endpoint, platform);
   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 };
 }
@@ -2977,7 +3883,7 @@ function assertHostProducerSourcePaths(stateRoot, config, producer, platform = p
 
 // host/producer-service.ts
 import { constants } from "node:fs";
-import { lstat as lstat3, open as open4 } from "node:fs/promises";
+import { lstat as lstat3, open as open5 } from "node:fs/promises";
 var SAFE_REF7 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 var HOST_PRODUCER_CONFIG_FLAG = "--ceal-host-config";
 var HostProducerServiceError = class extends Error {
@@ -3043,7 +3949,7 @@ async function readProducerConfigText(configPath, platform, error) {
 }
 function decodeProducerConfigCore(text, options) {
   const value = parseCanonicalJson(text, options.error);
-  if (!isRecord6(value) || !hasConfigKeys(value, options.keys) || value.schema_version !== options.schema) throw options.error("invalid_config");
+  if (!isRecord7(value) || !hasConfigKeys(value, options.keys) || value.schema_version !== options.schema) throw options.error("invalid_config");
   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 = validateIdentity3(hostSourceRef, installationRef, value.producer_epoch, options.error);
@@ -3088,7 +3994,7 @@ function validateConfigFile(value, platform, error) {
 }
 async function openConfigFile(configPath, flags, error) {
   try {
-    return await open4(configPath, flags);
+    return await open5(configPath, flags);
   } catch {
     throw error("config_unavailable");
   }
@@ -3105,363 +4011,83 @@ async function readBoundedConfig(handle, expectedBytes, error) {
     if (bytesRead === 0) break;
     offset += bytesRead;
   }
-  if (offset !== expectedBytes) throw error("invalid_config", refusalFact("bytes_read", offset, `the opened file's ${expectedBytes} bytes without growth or truncation`));
-  try {
-    return new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, offset));
-  } catch {
-    throw error("invalid_config");
-  }
-}
-function parseCanonicalJson(text, error) {
-  try {
-    const value = JSON.parse(text);
-    const canonical = JSON.stringify(value);
-    if (canonical !== text.trim()) throw new Error(`noncanonical: ${refusalFacts([{ name: "config_bytes", value: Buffer.byteLength(text.trim(), "utf8"), expected: `the ${Buffer.byteLength(canonical, "utf8")} bytes of its canonical form` }, { name: "first_difference_index", value: firstDifferenceIndex(text.trim(), canonical) }])}`);
-    return value;
-  } catch (parseError) {
-    throw error("invalid_config", refusalFacts([{ name: "parse_error", value: parseError }, { name: "config_bytes", value: Buffer.byteLength(text, "utf8"), expected: "canonical JSON" }]));
-  }
-}
-function firstDifferenceIndex(left, right) {
-  const shared = Math.min(left.length, right.length);
-  for (let index = 0; index < shared; index += 1) if (left[index] !== right[index]) return index;
-  return shared;
-}
-function validateIdentity3(sourceRef, installationRef, epoch, error) {
-  if (!SAFE_REF7.test(sourceRef) || !SAFE_REF7.test(installationRef) || !positive2(epoch, 2147483647)) throw error("invalid_config");
-  return epoch;
-}
-function validateIntervals(reconcile, retry, timeout, error) {
-  if (!boundedMilliseconds(reconcile) || !boundedMilliseconds(retry) || !boundedMilliseconds(timeout)) throw error("invalid_config");
-  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 isRecord6(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function positive2(value, maximum) {
-  return Number.isSafeInteger(value) && Number(value) > 0 && Number(value) <= maximum;
-}
-function boundedMilliseconds(value) {
-  return positive2(value, 6e4) && Number(value) >= 25;
-}
-
-// host/relay/src/relay-quarantine-store.ts
-var RELAY_QUARANTINE_MAX_BYTES = 16 * 1024 * 1024;
-
-// 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/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_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_INVOCATION_MINT_REFUSAL_REASONS = vocabulary([
-  "context_stale",
-  "context_expired",
-  "host_source_refused",
-  "host_credential_refused",
-  "gateway_unavailable",
-  "gateway_refused",
-  "gateway_response_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_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(code, message = code, failure) {
-    super(message);
-    this.code = code;
-    this.failure = failure;
-  }
-};
-function socketErrorFailure(error) {
-  switch (errorCode(error)) {
-    case "EACCES":
-    case "EPERM":
-      return "permission_denied";
-    case "ENOENT":
-      return "socket_missing";
-    case "ECONNREFUSED":
-      return "connection_refused";
-    default:
-      return "unavailable";
-  }
-}
-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 exchange(endpoint, encoded, timeoutMs, decode, signal) {
-  return new Promise((resolve3, reject3) => {
-    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) reject3(error);
-      else if (response2 !== void 0) resolve3(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 failure = socketErrorFailure(error);
-      finish(new HostRelayIpcError("relay_unavailable", `Host Relay IPC is unavailable: ${failure}.`, failure));
-    });
-    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;
+  if (offset !== expectedBytes) throw error("invalid_config", refusalFact("bytes_read", offset, `the opened file's ${expectedBytes} bytes without growth or truncation`));
   try {
-    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(HOST_RELAY_IPC_LENGTH_BYTES)));
+    return new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, offset));
   } catch {
-    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC response is invalid.");
+    throw error("invalid_config");
   }
-  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 parseCanonicalJson(text, error) {
+  try {
+    const value = JSON.parse(text);
+    const canonical = JSON.stringify(value);
+    if (canonical !== text.trim()) throw new Error(`noncanonical: ${refusalFacts([{ name: "config_bytes", value: Buffer.byteLength(text.trim(), "utf8"), expected: `the ${Buffer.byteLength(canonical, "utf8")} bytes of its canonical form` }, { name: "first_difference_index", value: firstDifferenceIndex(text.trim(), canonical) }])}`);
+    return value;
+  } catch (parseError) {
+    throw error("invalid_config", refusalFacts([{ name: "parse_error", value: parseError }, { name: "config_bytes", value: Buffer.byteLength(text, "utf8"), expected: "canonical JSON" }]));
+  }
 }
-function record2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function firstDifferenceIndex(left, right) {
+  const shared = Math.min(left.length, right.length);
+  for (let index = 0; index < shared; index += 1) if (left[index] !== right[index]) return index;
+  return shared;
 }
-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 validateIdentity3(sourceRef, installationRef, epoch, error) {
+  if (!SAFE_REF7.test(sourceRef) || !SAFE_REF7.test(installationRef) || !positive2(epoch, 2147483647)) throw error("invalid_config");
+  return epoch;
 }
-function decodeCurrentPromptResponseBuffer(buffer) {
-  const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES);
-  if (value === null) return null;
-  if (!record2(value) || !exactKeys4(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 validateIntervals(reconcile, retry, timeout, error) {
+  if (!boundedMilliseconds(reconcile) || !boundedMilliseconds(retry) || !boundedMilliseconds(timeout)) throw error("invalid_config");
+  return [reconcile, retry, timeout];
 }
-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 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 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 isRecord7(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function exactKeys4(value, keys) {
-  return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+function positive2(value, maximum) {
+  return Number.isSafeInteger(value) && Number(value) > 0 && Number(value) <= maximum;
 }
-function errorCode(error) {
-  return record2(error) && typeof error.code === "string" ? error.code : null;
+function boundedMilliseconds(value) {
+  return positive2(value, 6e4) && Number(value) >= 25;
 }
 
 // host/codex/src/codex-producer.ts
-import { createHash as createHash5 } from "node:crypto";
-import { mkdir as mkdir3, readFile, rename as rename3, writeFile } from "node:fs/promises";
-import { join as join4 } from "node:path";
-var STATE_SCHEMA = "ceal.codex_producer_state.v1";
+import { createHash as createHash6 } from "node:crypto";
 var SAFE_REF8 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 var CodexProducer = class {
+  producer_id = "codex";
+  producer_label = "Codex";
+  outbox_directory;
   store;
-  statePath;
-  installationRef;
-  epoch;
-  relay;
-  now;
-  tail = Promise.resolve();
+  core;
   constructor(options) {
-    if (!SAFE_REF8.test(options.producer_installation_ref)) throw new CodexHostAdapterError("configuration", "Codex producer installation identity is invalid.");
-    const epoch = options.producer_epoch ?? 1;
-    if (!Number.isSafeInteger(epoch) || epoch <= 0) throw new CodexHostAdapterError("configuration", "Codex producer epoch is invalid.");
     this.store = new CodexOutboxStore(options.outbox_dir);
-    this.statePath = join4(options.outbox_dir, "codex-producer-state.json");
-    this.installationRef = options.producer_installation_ref;
-    this.epoch = epoch;
-    this.relay = options.relay;
-    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.outbox_directory = this.store.directory;
+    this.core = new HostProducerDrainCore(this, options);
   }
   drainOutbox() {
-    const run = this.tail.then(() => this.drainLocked());
-    this.tail = run.then(() => void 0, () => void 0);
-    return run;
+    return this.core.drainOutbox();
   }
-  async drainLocked() {
-    const read = await this.store.list();
-    let admitted = 0;
-    let expired = 0;
-    let retained = 0;
-    for (const envelope of read.entries) {
-      const reserved = await this.hasReservation(envelope.submission_ref);
-      if (!reserved && Date.parse(envelope.expires_at) <= this.now().getTime()) {
-        await this.store.remove(envelope);
-        expired += 1;
-        continue;
-      }
-      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;
-        }
-      }
-      if (!complete) {
-        retained += 1;
-        break;
-      }
-      await this.store.remove(envelope);
-      await this.release(envelope.submission_ref);
-      admitted += 1;
-    }
-    return { admitted, retained: retained + Math.max(0, read.entries.length - admitted - expired - retained), expired, malformed: read.malformed };
+  fail(code, message) {
+    return new CodexHostAdapterError(code, message);
   }
-  async hasReservation(submissionRef) {
-    return (await this.readState()).pending[submissionRef] !== void 0;
+  listEnvelopes() {
+    return this.store.list();
   }
-  async reserve(envelope) {
-    const state = await this.readState();
-    const existing = state.pending[envelope.submission_ref];
-    if (existing !== void 0) return existing;
-    const drafts = await this.mapEnvelope(envelope);
-    const frames = drafts.map((draft, offset) => ({
-      schema_version: "ceal.host_producer_frame.v1",
-      producer_id: "codex",
-      producer_installation_ref: this.installationRef,
-      producer_epoch: this.epoch,
-      sequence: state.next_sequence + offset,
-      frame_kind: draft.frame_kind,
-      occurred_at: envelope.created_at,
-      payload: draft.payload
-    }));
-    await this.writeState({ ...state, next_sequence: state.next_sequence + frames.length, pending: { ...state.pending, [envelope.submission_ref]: frames } });
-    return frames;
+  removeEnvelope(envelope) {
+    return this.store.remove(envelope);
   }
-  async release(submissionRef) {
-    const state = await this.readState();
-    if (state.pending[submissionRef] === void 0) return;
-    const pending = { ...state.pending };
-    delete pending[submissionRef];
-    await this.writeState({ ...state, pending });
+  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");
@@ -3477,7 +4103,7 @@ var CodexProducer = class {
       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: `workspace:${createHash5("sha256").update(directoryIdentity, "utf8").digest("hex")}`,
+        working_directory_ref: `workspace:${createHash6("sha256").update(directoryIdentity, "utf8").digest("hex")}`,
         model: recordText(session.value, "model"),
         host_version: nestedText(session.value, "host_version"),
         observations: [session]
@@ -3502,21 +4128,6 @@ var CodexProducer = class {
     }) });
     return drafts;
   }
-  async readState() {
-    try {
-      const value = JSON.parse(await readFile(this.statePath, "utf8"));
-      return decodeState(value, this.installationRef, this.epoch);
-    } catch (error) {
-      if (errorCode2(error) !== "ENOENT") throw error;
-      return { schema_version: STATE_SCHEMA, producer_installation_ref: this.installationRef, producer_epoch: this.epoch, next_sequence: 1, pending: {} };
-    }
-  }
-  async writeState(state) {
-    await mkdir3(this.store.directory, { recursive: true, mode: 448 });
-    const temporary = `${this.statePath}.${process.pid}.new`;
-    await writeFile(temporary, JSON.stringify(state), { mode: 384 });
-    await rename3(temporary, this.statePath);
-  }
 };
 function mapTerminal(envelope) {
   const timing = observation(envelope, "timing");
@@ -3544,7 +4155,7 @@ function compact(value) {
   return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== void 0));
 }
 function asRecord(value) {
-  return isRecord7(value) ? value : void 0;
+  return isRecord8(value) ? value : void 0;
 }
 function recordText(value, key) {
   const record3 = asRecord(value);
@@ -3558,122 +4169,60 @@ function nonNegativeNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
 function safeReasonRef(value) {
-  return SAFE_REF8.test(value) ? value : `reason:${createHash5("sha256").update(value, "utf8").digest("hex")}`;
-}
-function errorCode2(error) {
-  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : null;
-}
-function decodeState(value, installationRef, epoch) {
-  if (!validStateHeader(value, installationRef)) {
-    throw new CodexHostAdapterError("storage", `Codex producer state header is malformed or belongs to another installation (${refusalFacts([
-      { name: "schema_version", value: isRecord7(value) ? value.schema_version : void 0, expected: STATE_SCHEMA },
-      { name: "producer_installation_ref", value: isRecord7(value) ? value.producer_installation_ref : void 0, expected: installationRef }
-    ])}).`);
-  }
-  if (Number(value.producer_epoch) > epoch) throw new CodexHostAdapterError("storage", `Codex producer state epoch is ahead of this installation (${refusalFact("producer_epoch", value.producer_epoch, `at most ${epoch}`)}).`);
-  const pending = {};
-  for (const [submissionRef, frames] of Object.entries(value.pending)) {
-    if (!SAFE_REF8.test(submissionRef) || !Array.isArray(frames) || frames.length === 0) throw new CodexHostAdapterError("storage", "Codex producer pending reservation is malformed.");
-    pending[submissionRef] = frames.map((frame) => decodeStoredFrame(frame, installationRef, Number(value.producer_epoch)));
-  }
-  return { schema_version: STATE_SCHEMA, producer_installation_ref: installationRef, producer_epoch: epoch, next_sequence: Number(value.next_sequence), pending };
-}
-function validStateHeader(value, installationRef) {
-  return isRecord7(value) && value.schema_version === STATE_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 && isRecord7(value.pending);
-}
-function decodeStoredFrame(value, installationRef, epoch) {
-  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 !== "codex" || frame.producer_installation_ref !== installationRef || frame.producer_epoch > epoch) throw new CodexHostAdapterError("storage", `Codex producer pending frame identity is malformed (${refusalFacts([
-    { name: "producer_id", value: frame.producer_id, expected: "codex" },
-    { name: "producer_installation_ref", value: frame.producer_installation_ref, expected: installationRef },
-    { name: "producer_epoch", value: frame.producer_epoch, expected: `at most ${epoch}` }
-  ])}).`);
-  return frame;
+  return SAFE_REF8.test(value) ? value : `reason:${createHash6("sha256").update(value, "utf8").digest("hex")}`;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
 // host/codex/src/codex-transcript-watcher.ts
-import { createHash as createHash6 } from "node:crypto";
-import { O_NOFOLLOW as O_NOFOLLOW3, O_RDONLY as O_RDONLY4 } from "node:constants";
-import { open as open5 } from "node:fs/promises";
-var READ_CHUNK_BYTES = 256 * 1024;
-var TRANSCRIPT_MISSING_REASON = "transcript_missing";
-var CodexTranscriptWatcher = class {
+var CodexTranscriptWatcher = class extends HostTranscriptWatcher {
   store;
-  outboxRetentionMs;
-  now;
-  log;
-  producerInstallationRef;
   registerCurrentPrompt;
+  releaseCurrentPrompt;
+  diagnostic;
   constructor(options) {
-    if (typeof options.outbox_dir !== "string" || options.outbox_dir.length === 0) throw new CodexHostAdapterError("configuration", "Codex transcript watcher outbox is invalid.");
-    this.store = new CodexOutboxStore(options.outbox_dir);
-    this.outboxRetentionMs = options.retention_ms ?? CODEX_DEFAULT_RETENTION_MS;
-    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
-    this.log = options.log ?? ((line) => {
-      process.stderr.write(`${line}
-`);
+    super(options, {
+      default_retention_ms: CODEX_DEFAULT_RETENTION_MS,
+      invalid_outbox: () => new CodexHostAdapterError("configuration", "Codex transcript watcher outbox is invalid."),
+      clock_failure: () => new CodexHostAdapterError("storage", "Codex watcher clock is invalid.")
     });
-    this.producerInstallationRef = options.producer_installation_ref;
+    this.store = new CodexOutboxStore(options.outbox_dir);
     this.registerCurrentPrompt = options.register_current_prompt;
+    this.releaseCurrentPrompt = options.release_current_prompt;
+    this.diagnostic = options.diagnostic ?? (() => void 0);
   }
-  async scanOnce() {
-    const registrations = await this.store.listTranscriptRegistrations();
-    let records = 0;
-    let enqueued = 0;
-    let quarantined = 0;
-    for (const registration of registrations) {
-      const result = await this.scanRegistration(registration);
-      records += result.records;
-      enqueued += result.enqueued;
-      if (result.quarantined) quarantined += 1;
-    }
-    return { registrations: registrations.length, records, enqueued, quarantined };
+  transcriptPathOf(registration) {
+    return registration.transcript_path;
   }
-  async scanRegistration(registration) {
-    let handle;
-    try {
-      handle = await open5(registration.transcript_path, O_RDONLY4 | O_NOFOLLOW3);
-      const { size, device, inode } = await ownedCodexTranscriptFile(handle);
-      const preflight = await this.preflight(registration, handle, size, device, inode);
-      if (preflight.cursor === null) return preflight.result;
-      const complete = await readCompleteChunk(handle, preflight.cursor, size);
-      if (complete === "empty" || complete === "partial") return { records: 0, enqueued: 0, quarantined: false };
-      return await this.consumeCompleteChunk(registration, handle, preflight.cursor, complete, device, inode);
-    } catch (error) {
-      if (handle === void 0 && isMissingTranscript(error)) return await this.retireRegistration(registration);
-      await this.quarantineFailure(registration, handle);
-      return { records: 0, enqueued: 0, quarantined: true };
-    } finally {
-      await handle?.close();
-    }
+  async listRegistrations() {
+    return this.store.listTranscriptRegistrations();
   }
-  /**
-   * A transcript the Host deleted never comes back, so retrying its
-   * registration once per reconcile interval is a failure with no end: a
-   * long-lived installation collects one permanently failing registration for
-   * every session Codex or the operator removes. Retire it at the scan that
-   * finds it missing and say so once, so the removal is readable and the next
-   * scan has nothing left to retry. Only ENOENT means gone; a permission or
-   * busy failure is about this moment, not about the file, and keeps the
-   * registration for the next scan.
-   */
-  async retireRegistration(registration) {
-    await this.store.retireTranscriptRegistration(registration);
-    this.log(`Codex retired a transcript registration: transcript_path=${JSON.stringify(registration.transcript_path)}, reason=${TRANSCRIPT_MISSING_REASON}.`);
-    return { records: 0, enqueued: 0, quarantined: false };
+  async scanOpened(handle, registration) {
+    const { size, device, inode } = await ownedCodexTranscriptFile(handle);
+    const preflight = await this.preflight(registration, handle, size, device, inode);
+    if (preflight.cursor === null) return preflight.result;
+    const complete = await this.readChunk(handle, preflight.cursor.offset, size);
+    if (complete === "empty" || complete === "partial") return { records: 0, enqueued: 0, quarantined: false };
+    return await this.consumeCompleteChunk(registration, handle, preflight.cursor, complete, device, inode);
+  }
+  async scanFailed(handle, registration, error) {
+    this.diagnostic("watcher_scan_failed", codexTranscriptScanFailureKind(error));
+    await this.quarantineFailure(registration, handle);
+    return { records: 0, enqueued: 0, quarantined: true };
+  }
+  async retireMissing(registration) {
+    await this.releaseStoredPromptBestEffort(registration.host_session_ref, await this.store.readTranscriptCursor(registration).catch(() => null));
+    return this.retireMissingTranscript(registration.transcript_path, "Codex", () => this.store.retireTranscriptRegistration(registration));
   }
   async preflight(registration, handle, size, device, inode) {
     const existing = await this.store.readTranscriptCursor(registration);
     let cursor = existing ?? codexTranscriptInitialCursor(registration, device, inode, this.now);
-    if (cursor.status === "quarantined") return { cursor: null, result: { records: 0, enqueued: 0, quarantined: true } };
-    const reason = await cursorFailureReason(registration, handle, cursor, size, device, inode);
+    if (cursor.status === "quarantined") {
+      if (cursor.reason !== "transcript_malformed") await this.releaseStoredPromptBestEffort(registration.host_session_ref, cursor);
+      return { cursor: null, result: { records: 0, enqueued: 0, quarantined: true } };
+    }
+    const reason = this.cursorIdentityReason(cursor, registration.transcript_path, device, inode) ?? await this.cursorBoundsReason(handle, cursor, size);
     if (reason === null) return { cursor, result: { records: 0, enqueued: 0, quarantined: false } };
     await this.quarantine(registration, cursor, device, inode, reason);
     return { cursor: null, result: { records: 0, enqueued: 0, quarantined: true } };
@@ -3699,39 +4248,53 @@ var CodexTranscriptWatcher = class {
   async observeSessionMetadata(registration, record3) {
     if (record3.kind !== "session_meta") return;
     const session = await this.store.readSession(registration.host_source_ref, registration.host_session_ref);
-    if (session !== null && isRecord8(session.value)) await this.store.saveSession({ ...session, value: { ...session.value, host_version: record3.cli_version } });
+    if (session !== null && this.isRecord(session.value)) await this.store.saveSession({ ...session, value: { ...session.value, host_version: record3.cli_version } });
   }
   async commitCursor(registration, handle, cursor, consumedBytes, device, inode, lastOrdinal, activeTask) {
     const offset = cursor.offset + consumedBytes;
-    const anchorStart = Math.max(0, offset - CODEX_TRANSCRIPT_ANCHOR_BYTES);
-    const anchor = Buffer.alloc(offset - anchorStart);
-    if (anchor.length > 0) await handle.read(anchor, 0, anchor.length, anchorStart);
-    await this.store.writeTranscriptCursor({ schema_version: "ceal.codex_transcript_cursor.v1", host_source_ref: registration.host_source_ref, host_session_ref: registration.host_session_ref, transcript_path: registration.transcript_path, device, inode, offset, last_ordinal: lastOrdinal, anchor_start: anchorStart, anchor_sha256: sha2562(anchor), header_validated: true, ...activeTask === void 0 ? {} : { active_task: activeTask }, status: "active", updated_at: timestamp5(this.now) });
+    const anchor = await this.readAnchor(handle, offset, CODEX_TRANSCRIPT_ANCHOR_BYTES);
+    await this.store.writeTranscriptCursor({ schema_version: "ceal.codex_transcript_cursor.v1", host_source_ref: registration.host_source_ref, host_session_ref: registration.host_session_ref, transcript_path: registration.transcript_path, device, inode, offset, last_ordinal: lastOrdinal, anchor_start: anchor.start, anchor_sha256: anchor.sha256, header_validated: true, ...activeTask === void 0 ? {} : { active_task: activeTask }, status: "active", updated_at: this.stamp() });
   }
   async quarantineFailure(registration, handle) {
     if (handle === void 0) return;
     const stats = await handle.stat().catch(() => null);
     if (stats === null) return;
     const existing = await this.store.readTranscriptCursor(registration).catch(() => null);
-    await this.quarantine(registration, existing ?? codexTranscriptInitialCursor(registration, String(stats.dev), String(stats.ino), this.now), String(stats.dev), String(stats.ino), "transcript_malformed");
+    const quarantined = {
+      ...existing ?? codexTranscriptInitialCursor(registration, String(stats.dev), String(stats.ino), this.now),
+      transcript_path: registration.transcript_path,
+      device: String(stats.dev),
+      inode: String(stats.ino),
+      status: "quarantined",
+      reason: "transcript_malformed",
+      updated_at: this.stamp()
+    };
+    await this.store.writeTranscriptCursor(quarantined);
   }
   async processRecord(registration, activeTask, record3) {
-    if (record3.kind === "task_started") {
-      return { activeTask: { codex_turn_id: record3.turn_id, host_turn_ref: hostTurnReference(registration.host_source_ref, registration.host_session_ref, record3.turn_id), started_at: record3.timestamp }, enqueued: 0 };
-    }
+    if (record3.kind === "task_started") return this.processTaskStarted(registration, activeTask, record3);
     if (record3.kind === "turn_context") return { ...activeTask === void 0 ? {} : { activeTask: record3.turn_id === activeTask.codex_turn_id ? { ...activeTask, model: record3.model } : activeTask }, enqueued: 0 };
     if (record3.kind === "token_count") return { ...activeTask === void 0 ? {} : { activeTask: accumulateTokenCount(activeTask, record3) }, enqueued: 0 };
     if (record3.kind === "user_text") return this.processUserInput(registration, activeTask, record3);
     if (record3.kind === "task_complete" || record3.kind === "turn_aborted") return this.processTerminal(registration, activeTask, record3);
     return { ...activeTask === void 0 ? {} : { activeTask }, enqueued: 0 };
   }
+  async processTaskStarted(registration, activeTask, record3) {
+    if (activeTask !== void 0 && activeTask.codex_turn_id !== record3.turn_id && activeTask.prompt_ref !== void 0) await this.releasePrompt(registration.host_session_ref, activeTask, activeTask.prompt_ref);
+    return { activeTask: { codex_turn_id: record3.turn_id, host_turn_ref: hostTurnReference(registration.host_source_ref, registration.host_session_ref, record3.turn_id), started_at: record3.timestamp }, enqueued: 0 };
+  }
   async processUserInput(registration, activeTask, record3) {
-    if (activeTask === void 0 || activeTask.codex_turn_id !== record3.turn_id) return { ...activeTask === void 0 ? {} : { activeTask }, enqueued: 0 };
+    if (activeTask === void 0 || activeTask.codex_turn_id !== record3.turn_id) {
+      const adopted = await this.adoptHookCorrelatedTurn(registration, activeTask, record3);
+      if (adopted === void 0) return { ...activeTask === void 0 ? {} : { activeTask }, enqueued: 0 };
+      activeTask = adopted;
+    }
     const hostInputRef = hostInputReference(registration.host_source_ref, registration.host_session_ref, record3.turn_id, record3.message_id, record3.ordinal, record3.prompt);
     const origin = activeTask.origin_host_input_ref === void 0;
     const promptValue = promptObservationValue(record3.prompt);
     const currentPromptRef = hostProducerPromptRef(promptValue.body_sha256);
     const promptRef = activeTask.prompt_ref ?? currentPromptRef;
+    const steeredPromptRef = await this.steeredPromptRef(registration, activeTask, origin, currentPromptRef);
     const identity = { host_source_ref: registration.host_source_ref, host_session_ref: registration.host_session_ref, host_turn_ref: activeTask.host_turn_ref };
     const observations = [{
       observation_ref: observationRef("transcript_user_text", hostInputRef, record3.prompt),
@@ -3755,16 +4318,90 @@ var CodexTranscriptWatcher = class {
       origin_input: origin,
       submission_ref: codexSubmissionReference(hostInputRef, "input", record3.ordinal),
       created_at: record3.timestamp,
-      expires_at: expiration(this.now, this.outboxRetentionMs)
+      expires_at: this.expire(this.outboxRetentionMs)
+    };
+    const persisted = await this.persistUserInputTurn(registration, activeTask, record3, hostInputRef, origin, currentPromptRef, promptRef, identity, envelope);
+    if (steeredPromptRef !== null) await this.activateTranscriptTurnContext(identity, steeredPromptRef, envelope.expires_at);
+    return persisted;
+  }
+  /**
+   * The steered prompt to re-activate under the running task, or null when
+   * there is nothing to repair. A steered message joins the running turn
+   * with new prompt bytes but no task_started. When the steer hook already
+   * replaced the turn selection (a turn id the hook did not recognize as
+   * the running one, or a hook that ran before any context was live), the
+   * running task's context no longer matches and the next invocation would
+   * wait for a boundary that never comes. When the hook kept the live
+   * selection, the context still matches and this stays null.
+   */
+  async steeredPromptRef(registration, activeTask, origin, currentPromptRef) {
+    if (origin || activeTask.prompt_ref === void 0 || activeTask.prompt_ref === currentPromptRef) return null;
+    const selection = await this.store.readInvocationTurnSelection(registration.host_source_ref, registration.host_session_ref).catch(() => null);
+    return selection?.prompt_ref === currentPromptRef ? currentPromptRef : null;
+  }
+  /**
+   * Adopt the live hooked turn when its transcript message arrives before
+   * (or without) its task_started, as an interrupted turn's follow-up can.
+   * The UserPromptSubmit hook names the exact hooked prompt, so only a
+   * message carrying those bytes adopts; inherited history and other turns
+   * stay ignored. A stale active task for another turn releases first, the
+   * same as a task_started supersession.
+   */
+  async adoptHookCorrelatedTurn(registration, activeTask, record3) {
+    const currentPromptRef = hostProducerPromptRef(promptObservationValue(record3.prompt).body_sha256);
+    const selection = await this.store.readInvocationTurnSelection(registration.host_source_ref, registration.host_session_ref);
+    if (selection?.prompt_ref !== currentPromptRef) return void 0;
+    if (activeTask !== void 0 && activeTask.codex_turn_id !== record3.turn_id && activeTask.prompt_ref !== void 0) {
+      await this.releasePrompt(registration.host_session_ref, activeTask, activeTask.prompt_ref);
+    }
+    return {
+      codex_turn_id: record3.turn_id,
+      host_turn_ref: hostTurnReference(registration.host_source_ref, registration.host_session_ref, record3.turn_id),
+      started_at: record3.timestamp
     };
-    await this.registerPrompt(origin, registration, activeTask, currentPromptRef, record3.prompt, envelope.expires_at);
-    await this.store.put(envelope);
-    if (origin) await this.store.activateInvocationContext(identity, promptRef, envelope.expires_at);
+  }
+  async persistUserInputTurn(registration, activeTask, record3, hostInputRef, origin, currentPromptRef, promptRef, identity, envelope) {
+    const custodyRegistered = await this.registerPrompt(origin, registration, activeTask, currentPromptRef, record3.prompt, envelope.expires_at);
+    if (custodyRegistered) this.diagnostic("watcher_turn_observed");
+    try {
+      await this.store.put(envelope);
+      if (origin) await this.activateTranscriptTurnContext(identity, promptRef, envelope.expires_at);
+    } catch (error) {
+      if (custodyRegistered) await this.releasePrompt(registration.host_session_ref, activeTask, currentPromptRef).catch(() => void 0);
+      throw error;
+    }
     return { activeTask: { ...activeTask, origin_host_input_ref: activeTask.origin_host_input_ref ?? hostInputRef, prompt_ref: activeTask.prompt_ref ?? currentPromptRef }, enqueued: 1 };
   }
   async registerPrompt(origin, registration, activeTask, promptRef, prompt, expiresAt) {
-    if (!origin || this.producerInstallationRef === void 0 || this.registerCurrentPrompt === void 0) return;
-    await this.registerCurrentPrompt({ producer_id: "codex", producer_installation_ref: this.producerInstallationRef, local_session_ref: registration.host_session_ref, local_turn_ref: activeTask.host_turn_ref, prompt_ref: promptRef, current_prompt: prompt, context_expires_at: expiresAt });
+    if (!origin || this.producerInstallationRef === void 0 || this.registerCurrentPrompt === void 0) return false;
+    const register = this.registerCurrentPrompt;
+    const installationRef = this.producerInstallationRef;
+    return registerHostCurrentPromptDiagnosed(
+      () => register({ producer_id: "codex", producer_installation_ref: installationRef, local_session_ref: registration.host_session_ref, local_turn_ref: activeTask.host_turn_ref, prompt_ref: promptRef, current_prompt: prompt, context_expires_at: expiresAt }),
+      (event) => this.diagnostic(event)
+    );
+  }
+  async activateTranscriptTurnContext(identity, promptRef, expiresAt) {
+    try {
+      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.store.activateInvocationContext(identity, promptRef, expiresAt, turnGenerationRef);
+      this.diagnostic("activation_recorded");
+    } catch (error) {
+      this.diagnostic("activation_failed");
+      throw error;
+    }
+  }
+  async releasePrompt(sessionRef, activeTask, promptRef) {
+    if (this.producerInstallationRef === void 0 || this.releaseCurrentPrompt === void 0) return;
+    await this.releaseCurrentPrompt({ producer_id: "codex", producer_installation_ref: this.producerInstallationRef, local_session_ref: sessionRef, local_turn_ref: activeTask.host_turn_ref, prompt_ref: promptRef });
+  }
+  async releaseStoredPromptBestEffort(sessionRef, cursor) {
+    await this.releaseActiveTaskBestEffort(sessionRef, cursor?.active_task);
+  }
+  async releaseActiveTaskBestEffort(sessionRef, activeTask) {
+    if (activeTask?.prompt_ref === void 0) return;
+    await this.releasePrompt(sessionRef, activeTask, activeTask.prompt_ref).catch(() => void 0);
   }
   async processTerminal(registration, activeTask, record3) {
     if (activeTask === void 0 || activeTask.codex_turn_id !== record3.turn_id || activeTask.origin_host_input_ref === void 0 || activeTask.prompt_ref === void 0) return { ...activeTask === void 0 ? {} : { activeTask }, enqueued: 0 };
@@ -3782,16 +4419,26 @@ var CodexTranscriptWatcher = class {
       origin_input: false,
       submission_ref: codexSubmissionReference(activeTask.origin_host_input_ref, "terminal", record3.ordinal),
       created_at: record3.timestamp,
-      expires_at: expiration(this.now, this.outboxRetentionMs)
+      expires_at: this.expire(this.outboxRetentionMs)
     });
+    await this.releasePrompt(registration.host_session_ref, activeTask, activeTask.prompt_ref);
     await this.store.clearInvocationContext(identity, this.now());
     return { enqueued: 1 };
   }
   async quarantine(registration, cursor, device, inode, reason) {
-    const quarantined = { ...cursor, transcript_path: registration.transcript_path, device, inode, status: "quarantined", reason, updated_at: timestamp5(this.now) };
+    await this.releaseStoredPromptBestEffort(registration.host_session_ref, cursor);
+    const quarantined = { ...cursor, transcript_path: registration.transcript_path, device, inode, status: "quarantined", reason, updated_at: this.stamp() };
     await this.store.writeTranscriptCursor(quarantined);
   }
 };
+function codexTranscriptScanFailureKind(error) {
+  return transcriptScanFailureKind(error, (candidate) => {
+    if (!(candidate instanceof CodexHostAdapterError)) return void 0;
+    if (candidate.code === "payload_rejected") return "payload_rejected";
+    if (candidate.code === "storage") return "read_error";
+    return void 0;
+  });
+}
 function accumulateTokenCount(activeTask, record3) {
   if (record3.usage_gap_reason !== void 0) return { ...activeTask, token_usage_gap_reason: record3.usage_gap_reason };
   const last = record3.last_usage;
@@ -3825,19 +4472,18 @@ function terminalCostValue() {
   return notRecorded("provider_cost_not_observed");
 }
 function notRecorded(reason) {
-  return { status: "not_recorded", reason };
+  return hostObservationNotRecorded(reason);
 }
 function tokenObservationValue(usage) {
   return {
-    status: "available",
-    unit: "tokens",
-    input: usage.input_tokens,
-    output: usage.output_tokens,
-    total: usage.total_tokens,
-    cached_input: usage.cached_input_tokens,
-    cache_write_input: usage.cache_write_input_tokens,
-    reasoning_output: usage.reasoning_output_tokens,
-    source: "codex_transcript.event_msg.token_count.info.last_token_usage",
+    ...createHostTokenObservationValue({
+      input: usage.input_tokens,
+      output: usage.output_tokens,
+      total: usage.total_tokens,
+      cached_input: usage.cached_input_tokens,
+      cache_write_input: usage.cache_write_input_tokens,
+      reasoning_output: usage.reasoning_output_tokens
+    }, "codex_transcript.event_msg.token_count.info.last_token_usage"),
     attribution: "sequential_active_task",
     total_usage_role: "dedup_and_reset_detection_only"
   };
@@ -3871,65 +4517,24 @@ function looksLikeStaleRegression(current, previous, last) {
   if (previous.total_tokens <= 0 || current.total_tokens <= 0 || last.total_tokens <= 0) return false;
   return current.total_tokens * 100 >= previous.total_tokens * 98 || current.total_tokens + last.total_tokens * 2 >= previous.total_tokens;
 }
-function isMissingTranscript(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-async function cursorFailureReason(registration, handle, cursor, size, device, inode) {
-  if (cursor.device !== device || cursor.inode !== inode || cursor.transcript_path !== registration.transcript_path) return "transcript_replaced";
-  if (size < cursor.offset) return "transcript_truncated";
-  if (cursor.offset > 0 && !await anchorMatches(handle, cursor)) return "transcript_rewritten";
-  return null;
-}
-async function readCompleteChunk(handle, cursor, size) {
-  const available = Math.max(0, size - cursor.offset);
-  if (available === 0) return "empty";
-  const chunks = [];
-  let position = cursor.offset;
-  let total = 0;
-  let lastNewline = -1;
-  while (position < size) {
-    const buffer = Buffer.alloc(Math.min(READ_CHUNK_BYTES, size - position));
-    const read = await handle.read(buffer, 0, buffer.length, position);
-    if (read.bytesRead === 0) break;
-    const chunk = buffer.subarray(0, read.bytesRead);
-    chunks.push(chunk);
-    const newline = chunk.lastIndexOf(10);
-    if (newline >= 0) lastNewline = total + newline;
-    total += chunk.length;
-    position += chunk.length;
-    if (lastNewline >= 0) break;
-  }
-  if (lastNewline < 0) return "partial";
-  return Buffer.concat(chunks, total).subarray(0, lastNewline + 1);
-}
 function assertRecordSequence(registration, cursor, records, lastOrdinal, record3) {
   if ((cursor.header_validated || records > 0) && record3.ordinal <= lastOrdinal) throw new CodexHostAdapterError("payload_rejected", `Codex transcript ordinal is not monotonic (${refusalFact("ordinal", record3.ordinal, `greater than ${lastOrdinal}`)}).`);
   if (!cursor.header_validated && records === 0) assertCodexTranscriptHeader(registration, record3);
 }
-async function anchorMatches(handle, cursor) {
-  const buffer = Buffer.alloc(cursor.offset - cursor.anchor_start);
-  if (buffer.length > 0) await handle.read(buffer, 0, buffer.length, cursor.anchor_start);
-  return sha2562(buffer) === cursor.anchor_sha256;
-}
-function sha2562(value) {
-  return createHash6("sha256").update(value).digest("hex");
-}
-function isRecord8(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function timestamp5(now) {
-  const value = now();
-  if (!Number.isFinite(value.getTime())) throw new CodexHostAdapterError("storage", "Codex watcher clock is invalid.");
-  return value.toISOString();
-}
-function expiration(now, retentionMs) {
-  return new Date(Date.parse(timestamp5(now)) + retentionMs).toISOString();
-}
 
 // host/codex/src/codex-producer-runtime.ts
 async function drainCodexProducerOnce(options) {
   const promptPort = new HostRelayCurrentPromptPort(options.relay_endpoint, options.timeout_ms);
-  const scan = await new CodexTranscriptWatcher({ outbox_dir: options.outbox_dir, producer_installation_ref: options.producer_installation_ref, register_current_prompt: (input) => promptPort.register(input) }).scanOnce();
+  const scan = await new CodexTranscriptWatcher({
+    outbox_dir: options.outbox_dir,
+    producer_installation_ref: options.producer_installation_ref,
+    register_current_prompt: (input) => promptPort.register(input),
+    release_current_prompt: (identity) => promptPort.release(identity),
+    diagnostic: (event, failure_kind) => writeHostServiceDiagnostic("codex", event, failure_kind)
+  }).scanOnce().catch((error) => {
+    writeHostServiceDiagnostic("codex", "watcher_scan_failed", codexTranscriptScanFailureKind(error));
+    throw error;
+  });
   const producer = new CodexProducer({ 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 } });
   return { scanned: scan.enqueued, ...await producer.drainOutbox() };
 }
@@ -3953,7 +4558,7 @@ var CODEX_PRODUCER_DESCRIPTOR = {
 };
 
 // host/codex/src/codex-hook-runner.ts
-var MAX_STDIN_BYTES = 64 * 1024;
+var MAX_STDIN_BYTES = 512 * 1024;
 async function runCodexHookFromStdin(event, stdin, options) {
   const adapter = createCodexHostObservationAdapter(options);
   return adapter.handle(event, await readStdin(stdin));