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

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

@@ -3,20 +3,29 @@ import { createRequire as __cealCreateRequire } from "node:module";
 const require = __cealCreateRequire(import.meta.url);
 
 // host/claude/src/claude-types.ts
-var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "Stop", "StopFailure"];
-var CLAUDE_HOST_ERROR_CODES = ["invalid_input", "storage", "configuration"];
+var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit"];
+var CLAUDE_HOST_ERROR_CODES = ["invalid_input", "payload_rejected", "storage", "configuration"];
 function isClaudeHostErrorCode(value) {
-  return typeof value === "string" && CLAUDE_HOST_ERROR_CODES.some((code3) => code3 === value);
+  return typeof value === "string" && CLAUDE_HOST_ERROR_CODES.some((code2) => code2 === value);
 }
-var CLAUDE_OUTBOX_SCHEMA = "ceal.claude_hook_outbox.v1";
 var CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION = "ceal.claude_invocation_context.v1";
+var CLAUDE_OUTBOX_SCHEMA_VERSION = "ceal.claude_observation_outbox.v1";
+var CLAUDE_SESSION_SCHEMA_VERSION = "ceal.claude_session.v1";
+var CLAUDE_TRANSCRIPT_REGISTRATION_SCHEMA_VERSION = "ceal.claude_transcript_registration.v1";
+var CLAUDE_TRANSCRIPT_CURSOR_SCHEMA_VERSION = "ceal.claude_transcript_cursor.v1";
+var CLAUDE_DEFAULT_RETENTION_MS = 24 * 60 * 60 * 1e3;
+var CLAUDE_TRANSCRIPT_MAX_TURN_MESSAGES = 1024;
+var CLAUDE_TRANSCRIPT_MAX_SUBAGENT_FILES = 64;
+var CLAUDE_TRANSCRIPT_ANCHOR_BYTES = 256;
 var ClaudeHostError = class extends Error {
   name = "ClaudeHostError";
   code;
-  constructor(code3, message) {
+  diagnostic_kind;
+  constructor(code2, message, diagnostic_kind) {
     super(message);
-    if (!isClaudeHostErrorCode(code3)) throw new TypeError("Claude Host error code is invalid.");
-    this.code = code3;
+    if (!isClaudeHostErrorCode(code2)) throw new TypeError("Claude Host error code is invalid.");
+    this.code = code2;
+    this.diagnostic_kind = diagnostic_kind;
   }
 };
 function isClaudeHookEvent(value) {
@@ -133,6 +142,9 @@ var client_wire_contract_default = {
       "document"
     ],
     optional_fields: [
+      "operation_id",
+      "visible_output_max_bytes",
+      "local_delivery",
       "verified_artifact"
     ],
     bare_document_fields: [
@@ -246,6 +258,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",
@@ -269,6 +282,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",
@@ -322,10 +336,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.
@@ -373,7 +397,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);
@@ -430,9 +505,9 @@ var CEAL_OPERATION_APPROVAL_DISPOSITIONS = vocabulary([
 var CealProtocolValidationError = class extends Error {
   name = "CealProtocolValidationError";
   code;
-  constructor(code3) {
-    super(code3 === "invalid_gateway_request" ? "Ceal Gateway request is invalid." : "Ceal client response is invalid.");
-    this.code = code3;
+  constructor(code2) {
+    super(code2 === "invalid_gateway_request" ? "Ceal Gateway request is invalid." : "Ceal client response is invalid.");
+    this.code = code2;
   }
 };
 var SAFE_REF = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
@@ -465,10 +540,10 @@ function assertSafeJsonArray(value, options, depth, count) {
   if (value.length > CEAL_WIRE_SAFE_ARRAY_MAX_ITEMS) invalidByContext(options);
   for (const item of value) assertSafeJsonValue(item, options, depth + 1, count);
 }
-function assertSafeJsonRecord(record7, options, depth, count) {
-  const entries = Object.entries(record7);
+function assertSafeJsonRecord(record6, options, depth, count) {
+  const entries = Object.entries(record6);
   if (entries.length > CEAL_WIRE_SAFE_ARRAY_MAX_ITEMS) invalidByContext(options);
-  const sourceUrlColumn = options.allowHttpsUrl ? compactSourceUrlColumn(record7.fields) : null;
+  const sourceUrlColumn = options.allowHttpsUrl ? compactSourceUrlColumn(record6.fields) : null;
   for (const [key, child] of entries) {
     if (key === "credential_material_included" && child !== false) invalidByContext(options);
     if (!isSafeNegativeMaterialAssertion(key, child)) assertSafeJsonKey(key, options);
@@ -643,21 +718,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
@@ -833,7 +902,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",
@@ -927,41 +996,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"]);
@@ -973,7 +1007,7 @@ var OPTIONAL_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_o
 // packages/ceal-client-protocol/src/resource-row.ts
 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", "include_replies", "kinds", "container_ref", "container_refs", "container_names", "addressed_to_me", "unread"]);
+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"]);
 var CEAL_RESOURCE_TIME_BASES = vocabulary(["created", "modified", "viewed"]);
 var CEAL_REPOSITORY_VISIBILITIES = vocabulary(["public", "private", "internal"]);
 var CEAL_ACTIVITY_V3_KINDS = vocabulary(["authored", "edited", "messaged", "responded"]);
@@ -994,6 +1028,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",
@@ -1001,7 +1036,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([
@@ -1052,6 +1087,7 @@ var RESOURCE_ROW_KEY_RULES = Object.freeze({
   ref: { required: true, timestamp: false },
   next: { required: true, timestamp: false },
   kind: { required: true, timestamp: false },
+  matched_kinds: { required: false, timestamp: false },
   title: { required: true, timestamp: false },
   container_label: { required: true, timestamp: false },
   container_ref: { required: false, timestamp: false },
@@ -1065,6 +1101,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 },
@@ -1098,6 +1136,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"]);
@@ -1125,7 +1172,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
@@ -1158,7 +1209,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 },
@@ -1182,7 +1233,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
 };
@@ -1241,6 +1293,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 } },
@@ -1305,12 +1358,49 @@ 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 record7 = operationRecord(value, "Ceal Host observation draft is invalid.");
-  requirePrefixedRef(record7.observation_ref, CEAL_HOST_OBSERVATION_REF_PREFIX, "Ceal Host observation reference is invalid.");
-  requireClosedValue(record7.observation_kind, CEAL_HOST_OBSERVATION_KINDS, "Ceal Host observation kind is invalid.");
-  requireIsoTimestamp(record7.observed_at, "Ceal Host observation time is invalid.");
-  assertHostObservationValue(record7.value, record7.observation_kind);
+  const record6 = operationRecord(value, "Ceal Host observation draft is invalid.");
+  requirePrefixedRef(record6.observation_ref, CEAL_HOST_OBSERVATION_REF_PREFIX, "Ceal Host observation reference is invalid.");
+  requireClosedValue(record6.observation_kind, CEAL_HOST_OBSERVATION_KINDS, "Ceal Host observation kind is invalid.");
+  requireIsoTimestamp(record6.observed_at, "Ceal Host observation time is invalid.");
+  assertHostObservationValue(record6.value, record6.observation_kind);
 }
 var CEAL_REQUEST_MAX_OBSERVATION_VALUE_BYTES = 64 * 1024;
 var CEAL_HOST_OBSERVATION_KINDS = vocabulary(["prompt", "session", "turn", "model", "token", "cost", "timing"]);
@@ -1446,12 +1536,94 @@ var CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_MAX_BYTES = new TextEncoder().enc
   expires_at: (/* @__PURE__ */ new Date("+010000-01-01T00:00:00.000Z")).toISOString()
 })}
 `).byteLength;
+var CEAL_HOST_MINT_REQUEST_CONTEXT_REFUSAL_REASONS = vocabulary([
+  "request_authority_unavailable",
+  "request_missing",
+  "authority_mismatch",
+  "host_source_mismatch",
+  "host_session_mismatch",
+  "host_turn_mismatch",
+  "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; run `ceal-host install` to repair the Host hook registration, then retry this command on a fresh Host turn" }),
+  context_replaced: Object.freeze({ classification: "host_invocation_context_stale", next_action: "refresh_host_invocation_context" }),
+  no_binding: Object.freeze({ classification: "host_binding_unavailable", next_action: "refresh_host_invocation_context" }),
+  context_stale: Object.freeze({ classification: "host_invocation_context_stale", next_action: "refresh_host_invocation_context" }),
+  context_expired: Object.freeze({ classification: "host_invocation_context_expired", next_action: "refresh_host_invocation_context" }),
+  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",
+  "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"]);
-var FIELDS = /* @__PURE__ */ new Set([...REQUIRED_FIELDS2, "read_argv", "local_result_root", "continue_argv", "model_disclosure", "item_read_argv"]);
+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/session-start-affordance.ts
 var CEAL_SESSION_ENTRY_INVOCATION = "ceal";
@@ -1484,14 +1656,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"]);
 
@@ -1504,6 +1668,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",
@@ -1527,7 +1703,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"]);
@@ -1554,10 +1734,7 @@ var FAILURE_RESPONSE_KEYS = Object.freeze(["error", "ok", "proof_ref_or_unavaila
 
 // host/claude/src/claude-decoder.ts
 var MAX_HOOK_BYTES = 256 * 1024;
-var MAX_TEXT = 128 * 1024;
 var SESSION_SOURCES = ["startup", "resume", "clear", "compact", "fork"];
-var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
-var STOP_FAILURES = ["rate_limit", "overloaded", "authentication_failed", "oauth_org_not_allowed", "account_on_hold", "billing_error", "invalid_request", "model_not_found", "server_error", "max_output_tokens", "unknown"];
 function decodeClaudeHookInput(event, raw) {
   const rawBytes = Buffer.byteLength(raw, "utf8");
   if (rawBytes > MAX_HOOK_BYTES) throw invalid2(`Claude hook input is too large (${refusalFact("bytes", rawBytes, `at most ${MAX_HOOK_BYTES} UTF-8 bytes`)}).`);
@@ -1568,70 +1745,33 @@ function decodeClaudeHookInput(event, raw) {
     throw invalid2("Claude hook input is not valid JSON.");
   }
   if (!record(value) || value.hook_event_name !== event) throw invalid2(`Claude hook event identity does not match the configured event (${refusalFact("hook_event_name", record(value) ? value.hook_event_name : value, `expected ${event}`)}).`);
-  const common = decodeCommon(value, event);
-  if (event === "SessionStart") return decodeSessionStart(value, common);
-  const promptId = requiredText(value.prompt_id, 256, "Claude turn hook is missing prompt_id.");
-  if (event === "UserPromptSubmit") return decodeUserPrompt(value, common, promptId);
-  return event === "Stop" ? decodeStop(value, common, promptId) : decodeStopFailure(value, common, promptId);
-}
-function decodeSessionStart(value, common) {
+  const common = {
+    session_id: requiredText(value.session_id, 256, "Claude session identity is invalid."),
+    transcript_path: requiredAbsolutePath(value.transcript_path, "Claude transcript path is invalid."),
+    cwd: requiredAbsolutePath(value.cwd, "Claude working directory is invalid.")
+  };
+  if (event === "UserPromptSubmit") {
+    return { event, ...common, hook_event_name: event, prompt: requiredText(value.prompt, 256 * 1024, "Claude submitted prompt is invalid.") };
+  }
   if (!isSessionSource(value.source)) throw invalid2("Claude SessionStart source is invalid.");
   const model = optionalText(value.model, 256);
-  return { ...common, hook_event_name: "SessionStart", source: value.source, ...model === void 0 ? {} : { model } };
-}
-function decodeUserPrompt(value, common, promptId) {
-  return { ...common, hook_event_name: "UserPromptSubmit", prompt_id: promptId, prompt: requiredText(value.prompt, MAX_TEXT, "Claude prompt is invalid.") };
-}
-function decodeStop(value, common, promptId) {
-  if (typeof value.stop_hook_active !== "boolean") throw invalid2("Claude Stop state is invalid.");
-  return { ...common, hook_event_name: "Stop", prompt_id: promptId, stop_hook_active: value.stop_hook_active, last_assistant_message: requiredText(value.last_assistant_message, MAX_TEXT, "Claude Stop response is invalid.") };
-}
-function decodeStopFailure(value, common, promptId) {
-  if (!isStopFailure(value.error)) throw invalid2("Claude StopFailure error is invalid.");
-  const errorDetails = optionalText(value.error_details, 4096);
-  const lastMessage = optionalText(value.last_assistant_message, MAX_TEXT);
-  return { ...common, hook_event_name: "StopFailure", prompt_id: promptId, error: value.error, ...errorDetails === void 0 ? {} : { error_details: errorDetails }, ...lastMessage === void 0 ? {} : { last_assistant_message: lastMessage } };
+  return { event, ...common, hook_event_name: "SessionStart", source: value.source, ...model === void 0 ? {} : { model } };
 }
 function claudeLocalSessionRef(sessionId) {
   return `claude-session:${digest(sessionId)}`;
 }
-function claudeLocalTurnRef(sessionId, promptId) {
-  return `claude-turn:${cealRequestSha256({ session_id: sessionId, prompt_id: promptId })}`;
+function claudeLocalTurnRef(sessionId, turnId) {
+  return `claude-turn:${cealRequestSha256({ session_id: sessionId, prompt_id: turnId })}`;
 }
-function claudeLocalInputRef(sessionId, promptId) {
-  return `claude-input:${cealRequestSha256({ session_id: sessionId, prompt_id: promptId })}`;
+function claudeLocalInputRef(sessionId, turnId) {
+  return `claude-input:${cealRequestSha256({ session_id: sessionId, prompt_id: turnId })}`;
 }
 function claudeWorkspaceRef(cwd) {
   return `workspace:${digest(cwd)}`;
 }
-function decodeCommon(value, event) {
-  const effort = decodeEffort(value.effort);
-  const promptId = optionalText(value.prompt_id, 256);
-  const permissionMode = optionalText(value.permission_mode, 64);
-  return {
-    session_id: requiredText(value.session_id, 256, "Claude session identity is invalid."),
-    ...promptId === void 0 ? {} : { prompt_id: promptId },
-    transcript_path: requiredAbsolutePath(value.transcript_path, "Claude transcript path is invalid."),
-    cwd: requiredAbsolutePath(value.cwd, "Claude working directory is invalid."),
-    ...permissionMode === void 0 ? {} : { permission_mode: permissionMode },
-    ...effort === void 0 ? {} : { effort },
-    hook_event_name: event
-  };
-}
-function decodeEffort(value) {
-  if (value === void 0) return void 0;
-  if (!record(value) || !isEffortLevel(value.level)) throw invalid2("Claude effort is invalid.");
-  return { level: value.level };
-}
 function isSessionSource(value) {
   return typeof value === "string" && SESSION_SOURCES.some((source) => source === value);
 }
-function isEffortLevel(value) {
-  return typeof value === "string" && EFFORT_LEVELS.some((effort) => effort === value);
-}
-function isStopFailure(value) {
-  return typeof value === "string" && STOP_FAILURES.some((failure) => failure === value);
-}
 function requiredAbsolutePath(value, message) {
   const text = requiredText(value, 4096, message);
   if (!text.startsWith("/") || text.includes("\0")) throw invalid2(message);
@@ -1659,8 +1799,62 @@ function invalid2(message) {
 }
 
 // host/claude/src/claude-outbox.ts
-import { open as open2, mkdir as mkdir2, readdir, readFile, unlink as unlink2 } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { mkdir as mkdir3, readdir, readFile as readFile2, unlink as unlink2 } from "node:fs/promises";
+import { isAbsolute, join as join3 } from "node:path";
+
+// host/invocation-context.ts
+var HOST_INVOCATION_IDENTITY_KEYS = ["host_session_ref", "host_turn_ref", "host_source_ref"];
+var HOST_INVOCATION_CONTEXT_REQUIRED_KEYS = ["schema_version", "identity", "prompt_ref", "expires_at"];
+function invocationContextKey(identity) {
+  return cealRequestSha256({ host_source_ref: identity.host_source_ref, host_session_ref: identity.host_session_ref });
+}
+function hasHostInvocationIdentityKeys(value) {
+  return exactKeys(value, HOST_INVOCATION_IDENTITY_KEYS);
+}
+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 isRecord(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 exactKeys(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));
+}
+function requiredKeys(value, required, optional) {
+  const actual = Object.keys(value);
+  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 isRecord(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/relay/src/producer-frame.ts
 var HOST_PRODUCER_FRAME_SCHEMA = "ceal.host_producer_frame.v1";
@@ -1673,11 +1867,20 @@ var FRAME_KINDS = new Set(HOST_PRODUCER_FRAME_KINDS);
 function isHostProducerFrameKind(value) {
   return typeof value === "string" && FRAME_KINDS.has(value);
 }
+var HOST_PRODUCER_FRAME_ERROR_CODES = [
+  "invalid_frame_encoding",
+  "invalid_frame_length",
+  "frame_truncated",
+  "unsupported_frame_schema",
+  "invalid_frame_shape",
+  "invalid_producer_identity",
+  "frame_too_large"
+];
 var HostProducerFrameError = class extends Error {
   code;
-  constructor(code3, message = code3) {
+  constructor(code2, message = code2) {
     super(message);
-    this.code = code3;
+    this.code = code2;
   }
 };
 function encodeHostProducerFrame(frame) {
@@ -1707,11 +1910,14 @@ function decodeHostProducerFrame(input) {
   validateFrame(value);
   return value;
 }
+function isHostSafeRef(value) {
+  return safeRef2(value);
+}
 function validateFrame(value) {
   if (!record2(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 (!exactKeys(value, ["schema_version", "producer_id", "producer_installation_ref", "producer_epoch", "sequence", "frame_kind", "occurred_at", "payload"])) throw new HostProducerFrameError("invalid_frame_shape");
-  if (!PRODUCERS.has(String(value.producer_id)) || !safeRef(value.producer_installation_ref)) throw new HostProducerFrameError("invalid_producer_identity");
+  if (!exactKeys2(value, ["schema_version", "producer_id", "producer_installation_ref", "producer_epoch", "sequence", "frame_kind", "occurred_at", "payload"])) throw new HostProducerFrameError("invalid_frame_shape");
+  if (!PRODUCERS.has(String(value.producer_id)) || !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) || !record2(value.payload)) throw new HostProducerFrameError("invalid_frame_shape");
   validatePayload(value.frame_kind, value.payload);
 }
@@ -1720,13 +1926,13 @@ function validatePayload(kind, 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"]) && safeRef(value.local_session_ref) && safeRef(value.working_directory_ref) && optionalText2(value.model, 256) && optionalText2(value.host_version, 256) && validObservations(value.observations);
+  return exactOptional(value, ["local_session_ref", "working_directory_ref"], ["model", "host_version", "observations"]) && safeRef2(value.local_session_ref) && safeRef2(value.working_directory_ref) && optionalText2(value.model, 256) && optionalText2(value.host_version, 256) && validObservations(value.observations);
 }
 function validTurn(value) {
-  return exactOptional(value, ["local_session_ref", "local_turn_ref"], ["model", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && optionalText2(value.model, 256) && validObservations(value.observations);
+  return exactOptional(value, ["local_session_ref", "local_turn_ref"], ["model", "observations"]) && safeRef2(value.local_session_ref) && safeRef2(value.local_turn_ref) && optionalText2(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"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && safeRef(value.local_input_ref) && validInputObservations(value.observations) && isCealHostInputKind(value.input_kind) && typeof value.origin_input === "boolean" && validInputOptionals(value);
+  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 validInputObservations(value) {
   return validObservations(value) && Array.isArray(value) && value.filter((item) => record2(item) && item.observation_kind === "prompt").length === 1;
@@ -1735,13 +1941,13 @@ function validInputOptionals(value) {
   return optionalRefs(value.local_turn_aliases) && (value.context_expires_at === void 0 || timestamp(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"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && validTerminalDisposition(value.terminal_state, value.abort_reason) && optionalNonNegative(value.duration_ms) && optionalNonNegative(value.time_to_first_token_ms) && (value.usage === void 0 || jsonValue(value.usage)) && validObservations(value.observations);
+  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" && safeRef(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)) && safeRef(value.reason_code) && optionalText2(value.detail, 4096);
+  return exactOptional(value, ["status", "reason_code"], ["detail"]) && ["ready", "degraded", "stopping"].includes(String(value.status)) && safeRef2(value.reason_code) && optionalText2(value.detail, 4096);
 }
 function optionalText2(value, maxLength) {
   return value === void 0 || typeof value === "string" && value.length > 0 && value.length <= maxLength;
@@ -1750,7 +1956,7 @@ function optionalNonNegative(value) {
   return value === void 0 || typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 function optionalRefs(value) {
-  return value === void 0 || Array.isArray(value) && value.length <= 16 && value.every(safeRef);
+  return value === void 0 || Array.isArray(value) && value.length <= 16 && value.every(safeRef2);
 }
 function validObservations(value) {
   if (value === void 0) return true;
@@ -1774,7 +1980,7 @@ function jsonValue(value, depth = 0) {
 function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function safeRef(value) {
+function safeRef2(value) {
   return typeof value === "string" && SAFE_REF2.test(value);
 }
 function positive(value) {
@@ -1786,7 +1992,7 @@ function timestamp(value) {
 function hostProducerFrameKind(value) {
   return isHostProducerFrameKind(value);
 }
-function exactKeys(value, keys) {
+function exactKeys2(value, keys) {
   return JSON.stringify(Object.keys(value).sort()) === JSON.stringify([...keys].sort());
 }
 function exactOptional(value, required, optional) {
@@ -1794,6 +2000,15 @@ function exactOptional(value, required, optional) {
   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";
@@ -1882,17 +2097,6 @@ function errorCode(error) {
 // host/relay/src/relay-request-binding-store.ts
 var MAX_STATE_BYTES = 8 * 1024 * 1024;
 
-// 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;
 
@@ -1925,10 +2129,31 @@ var HOST_RELAY_INVOCATION_MINT_REFUSAL_REASONS = vocabulary([
   "gateway_unavailable",
   "gateway_refused",
   "gateway_response_invalid",
+  "gateway_rate_limited",
+  "producer_frame_invalid",
   "deadline",
   "cancelled",
   "mint_failed",
-  "relay_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([
@@ -1945,12 +2170,15 @@ var HostRelayIpcError = class extends Error {
   code;
   /** Set only when the client-side socket exchange itself failed. */
   failure;
-  constructor(code3, message = code3, failure) {
+  constructor(code2, message = code2, failure) {
     super(message);
-    this.code = code3;
+    this.code = code2;
     this.failure = failure;
   }
 };
+function hostRelayExchangeFailure(error) {
+  return error instanceof HostRelayIpcError ? error.failure : void 0;
+}
 function socketErrorFailure(error) {
   switch (errorCode2(error)) {
     case "EACCES":
@@ -1994,7 +2222,7 @@ function submitHostProducerFrame(endpoint, frame, timeoutMs = 5e3) {
   return exchange(endpoint, encodeHostProducerFrame(frame), timeoutMs, decodeResponseBuffer);
 }
 function exchange(endpoint, encoded, timeoutMs, decode, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const socket = createConnection(endpoint);
     let buffer = Buffer.alloc(0);
     let settled = false;
@@ -2005,7 +2233,7 @@ function exchange(endpoint, encoded, timeoutMs, decode, signal) {
       signal?.removeEventListener("abort", aborted);
       socket.destroy();
       if (error !== null) reject(error);
-      else if (response2 !== void 0) resolve(response2);
+      else if (response2 !== void 0) resolve2(response2);
     };
     if (timeoutMs !== void 0) socket.setTimeout(timeoutMs, () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC timed out.", "timed_out")));
     if (signal?.aborted === true) {
@@ -2071,7 +2299,7 @@ function decodeResponseBuffer(buffer) {
 function decodeCurrentPromptResponseBuffer(buffer) {
   const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES);
   if (value === null) return null;
-  if (!record3(value) || !exactKeys2(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");
+  if (!record3(value) || !exactKeys3(value, ["schema_version", "status"]) || value.schema_version !== HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA || value.status !== "registered" && value.status !== "current_prompt_unavailable") throw new HostRelayIpcError("relay_unavailable");
   return { schema_version: HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA, status: value.status };
 }
 function decodeLengthPrefixedJson(input, maximum) {
@@ -2093,327 +2321,1490 @@ function encodeLengthPrefixed(value) {
   body.copy(output, HOST_RELAY_IPC_LENGTH_BYTES);
   return output;
 }
-function exactKeys2(value, keys) {
-  return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+function exactKeys3(value, required, optional = []) {
+  const keys = Object.keys(value);
+  return required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => required.includes(key) || optional.includes(key));
 }
 function errorCode2(error) {
   return record3(error) && typeof error.code === "string" ? error.code : null;
 }
 
-// host/invocation-context.ts
-var HOST_INVOCATION_IDENTITY_KEYS = ["host_session_ref", "host_turn_ref", "host_source_ref"];
-var HOST_INVOCATION_CONTEXT_REQUIRED_KEYS = ["schema_version", "identity", "prompt_ref", "expires_at"];
-function invocationContextKey(identity) {
-  return cealRequestSha256({ host_source_ref: identity.host_source_ref, host_session_ref: identity.host_session_ref });
-}
-function hasHostInvocationIdentityKeys(value) {
-  return exactKeys3(value, HOST_INVOCATION_IDENTITY_KEYS);
-}
-function hasHostInvocationContextKeys(value, optional = []) {
-  return requiredKeys(value, HOST_INVOCATION_CONTEXT_REQUIRED_KEYS, optional);
-}
-function invocationContextFromTurn(identity, promptRef, expiresAt, descriptor) {
-  const context = {
-    schema_version: descriptor.schema_version,
-    identity,
-    prompt_ref: promptRef,
-    expires_at: expiresAt,
-    ...descriptor.working_directory === void 0 ? {} : { working_directory: descriptor.working_directory }
-  };
-  descriptor.validate(context);
-  return Object.freeze(context);
-}
-function exactKeys3(value, keys) {
-  const actual = Object.keys(value);
-  return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key)) && actual.every((key) => keys.includes(key));
-}
-function requiredKeys(value, required, optional) {
-  const actual = Object.keys(value);
-  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));
-}
-
-// host/claude/src/claude-invocation-context.ts
-function claudeInvocationContextFromTurn(identity, promptRef, expiresAt, workingDirectory) {
-  return invocationContextFromTurn(identity, promptRef, expiresAt, { schema_version: CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION, validate: validateClaudeHostInvocationContext, working_directory: workingDirectory });
-}
-function validateClaudeHostInvocationContext(value) {
-  if (!contextShape(value)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
-  validateIdentity(value.identity);
-  validateContextReferences(value);
-  validateContextTimes(value);
-}
-function validateClaudeIdentity(value) {
-  if (!validIdentity(value)) throw new ClaudeHostError("invalid_input", "Claude Host session identity is invalid.");
-}
-function contextShape(value) {
-  return record4(value) && value.schema_version === CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION && hasHostInvocationContextKeys(value, ["request_ref", "bound_at", "working_directory"]);
+// 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 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;
 }
-function validateIdentity(value) {
-  if (!validIdentity(value)) throw new ClaudeHostError("storage", "Claude Host invocation identity is malformed.");
+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 validateContextReferences(value) {
-  if (!safeRef2(value.prompt_ref) || !optionalSafeRef(value.request_ref)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
+function transcriptSha256(value) {
+  return createHash3("sha256").update(value).digest("hex");
 }
-function validateContextTimes(value) {
-  if (!timestamp2(value.expires_at) || !optionalTimestamp(value.bound_at) || !optionalDirectory(value.working_directory)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
-  if (typeof value.bound_at === "string" && Date.parse(value.bound_at) > Date.parse(String(value.expires_at))) throw new ClaudeHostError("storage", `Claude Host invocation context has invalid binding time (${refusalFact("bound_at", value.bound_at, `at or before ${String(value.expires_at)}`)}).`);
+function transcriptObjectSha256(value) {
+  return createHash3("sha256").update(JSON.stringify(value), "utf8").digest("hex");
 }
-function validIdentity(value) {
-  return record4(value) && hasHostInvocationIdentityKeys(value) && [value.host_session_ref, value.host_turn_ref, value.host_source_ref].every(safeRef2);
+function isTranscriptRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function optionalSafeRef(value) {
-  return value === void 0 || safeRef2(value);
+function isMissingTranscriptError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function optionalTimestamp(value) {
-  return value === void 0 || timestamp2(value);
+function transcriptTimestamp(now, fail) {
+  const value = now();
+  if (!Number.isFinite(value.getTime())) throw fail();
+  return value.toISOString();
 }
-function optionalDirectory(value) {
-  return value === void 0 || typeof value === "string" && value.startsWith("/") && !value.includes("\0") && value.length <= 4096;
+function transcriptExpiration(now, retentionMs, fail) {
+  return new Date(Date.parse(transcriptTimestamp(now, fail)) + retentionMs).toISOString();
 }
-function safeRef2(value) {
-  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+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
+  };
 }
-function timestamp2(value) {
-  return typeof value === "string" && value.length <= 64 && Number.isFinite(Date.parse(value));
+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 record4(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function formatRetiredTranscriptLog(producerLabel, transcriptPath) {
+  return `${producerLabel} retired a transcript registration: transcript_path=${JSON.stringify(transcriptPath)}, reason=${TRANSCRIPT_MISSING_REASON}.`;
 }
-
-// host/claude/src/claude-outbox.ts
-var SAFE_REF3 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-var ClaudeOutboxStore = class {
-  entries;
-  directory;
-  activeContexts;
-  constructor(directory) {
-    if (!directory.startsWith("/")) throw new ClaudeHostError("configuration", "Claude outbox directory must be absolute.");
-    this.directory = directory;
-    this.entries = join2(directory, "entries");
-    this.activeContexts = join2(directory, "active-contexts");
+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 prepare() {
-    await mkdir2(this.entries, { recursive: true, mode: 448 });
-    await mkdir2(this.activeContexts, { recursive: true, mode: 448 });
+  async scanOnce() {
+    return scanTranscriptRegistrations(await this.listRegistrations(), (registration) => this.scanRegistration(registration));
   }
-  async activateInvocationContext(identity, promptRef, expiresAt, workingDirectory) {
-    const context = claudeInvocationContextFromTurn(identity, promptRef, expiresAt, workingDirectory);
-    await this.prepare();
-    await durableAtomicReplace(this.activeContextPath(identity), JSON.stringify(context));
+  async scanRegistration(registration) {
+    return this.openTranscript(registration, (handle) => this.scanOpened(handle, registration), {
+      missing: () => this.retireMissing(registration),
+      failed: (handle, error) => this.scanFailed(handle, registration, error)
+    });
   }
-  async readInvocationContext(hostSourceRef, hostSessionRef, now = /* @__PURE__ */ new Date()) {
-    validateInvocationContextReadArguments(hostSourceRef, hostSessionRef, now);
-    await this.prepare();
-    return readInvocationContextFile(this.activeContextPath({ host_source_ref: hostSourceRef, host_session_ref: hostSessionRef }), hostSourceRef, hostSessionRef, now);
+  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) throw error;
+      return handlers.failed(handle, error);
+    } finally {
+      await handle?.close();
+    }
   }
-  async listInvocationContexts(now = /* @__PURE__ */ new Date()) {
-    await this.prepare();
-    const contexts = [];
-    for (const name of await readdir(this.activeContexts)) {
-      if (!name.endsWith(".json")) continue;
-      try {
-        const value = JSON.parse(await readFile(join2(this.activeContexts, name), "utf8"));
+  /**
+   * 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(submissionRef2) {
+    return (await this.readState()).pending[submissionRef2] !== void 0;
+  }
+  async reserve(envelope) {
+    const state = await this.readState();
+    const submissionRef2 = this.host.submissionRefOf(envelope);
+    const existing = state.pending[submissionRef2];
+    if (existing !== void 0) return existing;
+    const drafts = await this.host.mapEnvelope(envelope);
+    const frames = drafts.map((draft, offset) => ({
+      schema_version: "ceal.host_producer_frame.v1",
+      producer_id: this.host.producer_id,
+      producer_installation_ref: this.installationRef,
+      producer_epoch: this.epoch,
+      sequence: state.next_sequence + offset,
+      frame_kind: draft.frame_kind,
+      occurred_at: this.host.createdAtOf(envelope),
+      payload: draft.payload
+    }));
+    await this.writeState({ ...state, next_sequence: state.next_sequence + frames.length, pending: { ...state.pending, [submissionRef2]: frames } });
+    return frames;
+  }
+  async release(submissionRef2) {
+    const state = await this.readState();
+    if (state.pending[submissionRef2] === void 0) return;
+    const pending = { ...state.pending };
+    delete pending[submissionRef2];
+    await this.writeState({ ...state, pending });
+  }
+  async readState() {
+    try {
+      const value = JSON.parse(await readFile(this.statePath, "utf8"));
+      return this.decodeState(value);
+    } catch (error) {
+      if (errorCode3(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 = (code2, message) => this.host.fail(code2, message);
+    if (!isDrainStateHeader(value, this.stateSchema, this.installationRef)) {
+      throw fail("storage", `${label} producer state header is malformed or belongs to another installation (${refusalFacts([
+        { name: "schema_version", value: isTranscriptRecord(value) ? value.schema_version : void 0, expected: this.stateSchema },
+        { name: "producer_installation_ref", value: isTranscriptRecord(value) ? value.producer_installation_ref : void 0, expected: this.installationRef }
+      ])}).`);
+    }
+    if (Number(value.producer_epoch) > this.epoch) throw fail("storage", `${label} producer state epoch is ahead of this installation (${refusalFact("producer_epoch", value.producer_epoch, `at most ${this.epoch}`)}).`);
+    const pending = {};
+    const storedEpoch = Number(value.producer_epoch);
+    for (const [submissionRef2, frames] of Object.entries(value.pending)) {
+      if (!isHostSafeRef(submissionRef2) || !Array.isArray(frames) || frames.length === 0) throw fail("storage", `${label} producer pending reservation is malformed.`);
+      pending[submissionRef2] = frames.map((frame) => this.decodeStoredFrame(frame, storedEpoch));
+    }
+    return { schema_version: this.stateSchema, producer_installation_ref: this.installationRef, producer_epoch: this.epoch, next_sequence: Number(value.next_sequence), pending };
+  }
+  decodeStoredFrame(value, storedEpoch) {
+    const label = this.host.producer_label;
+    const json = Buffer.from(JSON.stringify(value), "utf8");
+    const encoded = Buffer.allocUnsafe(json.length + 4);
+    encoded.writeUInt32BE(json.length, 0);
+    json.copy(encoded, 4);
+    const frame = decodeHostProducerFrame(encoded);
+    if (frame.producer_id !== this.host.producer_id || frame.producer_installation_ref !== this.installationRef || frame.producer_epoch > storedEpoch) throw this.host.fail("storage", `${label} producer pending frame identity is malformed (${refusalFacts([
+      { name: "producer_id", value: frame.producer_id, expected: this.host.producer_id },
+      { name: "producer_installation_ref", value: frame.producer_installation_ref, expected: this.installationRef },
+      { name: "producer_epoch", value: frame.producer_epoch, expected: `at most ${storedEpoch}` }
+    ])}).`);
+    return frame;
+  }
+};
+function 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 errorCode3(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/claude/src/claude-invocation-context.ts
+function claudeInvocationContextFromTurn(identity, promptRef, expiresAt, workingDirectory, turnGenerationRef) {
+  return invocationContextFromTurn(identity, promptRef, expiresAt, { schema_version: CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION, validate: validateClaudeHostInvocationContext, working_directory: workingDirectory, turn_generation_ref: turnGenerationRef });
+}
+function validateClaudeHostInvocationContext(value) {
+  if (!contextShape(value)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
+  validateIdentity(value.identity);
+  validateContextReferences(value);
+  validateContextTimes(value);
+}
+function contextShape(value) {
+  return record4(value) && value.schema_version === CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION && hasHostInvocationContextKeys(value, ["request_ref", "bound_at", "working_directory", "turn_generation_ref"]);
+}
+function validateIdentity(value) {
+  if (!validIdentity(value)) throw new ClaudeHostError("storage", "Claude Host invocation identity is malformed.");
+}
+function validateContextReferences(value) {
+  if (!safeRef3(value.prompt_ref) || !optionalSafeRef(value.request_ref) || !optionalSafeRef(value.turn_generation_ref)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
+}
+function validateContextTimes(value) {
+  if (!timestamp2(value.expires_at) || !optionalTimestamp(value.bound_at) || !optionalDirectory(value.working_directory)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
+  if (typeof value.bound_at === "string" && Date.parse(value.bound_at) > Date.parse(String(value.expires_at))) throw new ClaudeHostError("storage", `Claude Host invocation context has invalid binding time (${refusalFact("bound_at", value.bound_at, `at or before ${String(value.expires_at)}`)}).`);
+}
+function validIdentity(value) {
+  return record4(value) && hasHostInvocationIdentityKeys(value) && [value.host_session_ref, value.host_turn_ref, value.host_source_ref].every(safeRef3);
+}
+function optionalSafeRef(value) {
+  return value === void 0 || safeRef3(value);
+}
+function optionalTimestamp(value) {
+  return value === void 0 || timestamp2(value);
+}
+function optionalDirectory(value) {
+  return value === void 0 || typeof value === "string" && value.startsWith("/") && !value.includes("\0") && value.length <= 4096;
+}
+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 record4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// host/claude/src/claude-outbox.ts
+var SAFE_REF3 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var CLAUDE_TRANSCRIPT_PATH_MAX_CHARACTERS = 4096;
+var CLAUDE_TRANSCRIPT_SUBAGENT_NAME_MAX_CHARACTERS = 256;
+var ClaudeOutboxStore = class {
+  envelopes;
+  sessions;
+  registrations;
+  cursors;
+  directory;
+  activeContexts;
+  turnSelections;
+  constructor(directory) {
+    if (!directory.startsWith("/")) throw new ClaudeHostError("configuration", "Claude outbox directory must be absolute.");
+    this.directory = directory;
+    this.envelopes = join3(directory, "envelopes");
+    this.sessions = join3(directory, "sessions");
+    this.registrations = join3(directory, "transcript-registrations");
+    this.cursors = join3(directory, "transcript-cursors");
+    this.activeContexts = join3(directory, "active-contexts");
+    this.turnSelections = join3(directory, "turn-selections");
+  }
+  async prepare() {
+    for (const path of [this.envelopes, this.sessions, this.registrations, this.cursors, this.activeContexts, this.turnSelections]) {
+      await mkdir3(path, { recursive: true, mode: 448 });
+    }
+  }
+  async activateInvocationContext(identity, promptRef, expiresAt, workingDirectory, turnGenerationRef) {
+    const context = claudeInvocationContextFromTurn(identity, promptRef, expiresAt, workingDirectory, turnGenerationRef);
+    await this.prepare();
+    await durableAtomicReplace(this.activeContextPath(identity), JSON.stringify(context));
+  }
+  async readInvocationContext(hostSourceRef, hostSessionRef, now = /* @__PURE__ */ new Date()) {
+    validateInvocationContextReadArguments(hostSourceRef, hostSessionRef, now);
+    const context = await this.readRawInvocationContext(hostSourceRef, hostSessionRef);
+    return isLiveSessionProjection(context, now) ? context : null;
+  }
+  async writeInvocationTurnSelection(selection) {
+    if (!isHostInvocationTurnSelection(selection)) throw new ClaudeHostError("invalid_input", "Claude Host turn selection is invalid.");
+    await this.prepare();
+    await durableAtomicReplace(this.turnSelectionPath(selection.host_source_ref, selection.host_session_ref), JSON.stringify(selection));
+  }
+  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 readProjectionFile(path);
+    if (active === null || active.prompt_ref !== promptRef || active.identity.host_turn_ref !== identity.host_turn_ref) return false;
+    const updated = { ...active, turn_generation_ref: turnGenerationRef };
+    validateClaudeHostInvocationContext(updated);
+    await durableAtomicReplace(path, JSON.stringify(updated));
+    return true;
+  }
+  /**
+   * The latest Claude 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_REF3.test(hostSourceRef) || !SAFE_REF3.test(hostSessionRef)) throw new ClaudeHostError("invalid_input", "Claude Host context identity or clock is invalid.");
+    await this.prepare();
+    const context = await readLatestSessionProjection(this.activeContextPath({ host_source_ref: hostSourceRef, host_session_ref: hostSessionRef }), hostSourceRef, hostSessionRef, readProjectionFile);
+    return invocationTurnSelectionMatches(context, await this.readInvocationTurnSelection(hostSourceRef, hostSessionRef)) ? context : null;
+  }
+  async listInvocationContexts(now = /* @__PURE__ */ new Date()) {
+    await this.prepare();
+    const contexts = [];
+    for (const name of await readdir(this.activeContexts)) {
+      if (!name.endsWith(".json")) continue;
+      try {
+        const value = JSON.parse(await readFile2(join3(this.activeContexts, name), "utf8"));
         validateClaudeHostInvocationContext(value);
-        if (Date.parse(value.expires_at) > now.getTime()) contexts.push(value);
+        if (Date.parse(value.expires_at) > now.getTime() && invocationTurnSelectionMatches(value, await this.readInvocationTurnSelection(value.identity.host_source_ref, value.identity.host_session_ref))) contexts.push(value);
       } catch {
       }
     }
     return contexts;
   }
-  async put(batch) {
-    validateBatch(batch);
+  async putEnvelope(entry) {
+    validateEnvelope(entry);
     await this.prepare();
-    const path = this.path(batch.batch_ref);
-    try {
-      const handle = await open2(path, "wx", 384);
+    await durableAtomicReplace(this.envelopePath(entry.submission_ref), JSON.stringify(entry));
+  }
+  async listEnvelopes() {
+    await this.prepare();
+    const entries = [];
+    let malformed = 0;
+    for (const name of await readdir(this.envelopes)) {
+      if (!name.endsWith(".json")) continue;
       try {
-        await handle.writeFile(JSON.stringify(batch));
-        await handle.sync();
-      } finally {
-        await handle.close();
+        const value = JSON.parse(await readFile2(join3(this.envelopes, name), "utf8"));
+        validateEnvelope(value);
+        entries.push(value);
+      } catch {
+        malformed += 1;
       }
+    }
+    entries.sort((left, right) => left.created_at.localeCompare(right.created_at));
+    return { entries, malformed };
+  }
+  async removeEnvelope(entry) {
+    validateEnvelope(entry);
+    try {
+      await unlink2(this.envelopePath(entry.submission_ref));
     } catch (error) {
-      if (code(error) !== "EEXIST") throw new ClaudeHostError("storage", `Unable to persist Claude hook batch (${refusalFact("error_code", code(error), "EEXIST for an idempotent retry")}).`);
-      const existing = JSON.parse(await readFile(path, "utf8"));
-      validateBatch(existing);
-      if (JSON.stringify(existing) !== JSON.stringify(batch)) throw new ClaudeHostError("storage", "Claude hook batch identity conflicts with different bytes.");
+      if (code(error) !== "ENOENT") throw error;
     }
   }
-  async list() {
+  async saveSession(snapshot) {
+    validateSession(snapshot);
     await this.prepare();
-    const batches = [];
-    let malformed = 0;
-    for (const name of await readdir(this.entries)) {
+    await durableAtomicReplace(join3(this.sessions, `${cealRequestSha256({ source: snapshot.host_source_ref, session: snapshot.host_session_ref })}.json`), JSON.stringify(snapshot));
+  }
+  async readSession(sourceRef, sessionRef) {
+    if (!SAFE_REF3.test(sourceRef) || !SAFE_REF3.test(sessionRef)) throw new ClaudeHostError("invalid_input", "Claude session identity is invalid.");
+    await this.prepare();
+    try {
+      const value = JSON.parse(await readFile2(join3(this.sessions, `${cealRequestSha256({ source: sourceRef, session: sessionRef })}.json`), "utf8"));
+      validateSession(value);
+      return value;
+    } catch (error) {
+      if (code(error) === "ENOENT") return null;
+      throw error instanceof ClaudeHostError ? error : new ClaudeHostError("storage", "Claude session snapshot is malformed.");
+    }
+  }
+  async registerTranscript(registration) {
+    validateRegistration(registration);
+    await this.prepare();
+    const path = this.registrationPath(registration.host_source_ref, registration.host_session_ref);
+    const existing = await this.readRegistrationFile(path);
+    if (existing !== null && (existing.claude_session_id !== registration.claude_session_id || existing.transcript_path !== registration.transcript_path)) {
+      throw new ClaudeHostError("storage", "Claude transcript registration conflicts with the source-bound session.");
+    }
+    await durableAtomicReplace(path, JSON.stringify(registration));
+  }
+  /**
+   * End a registration whose transcript the Host has deleted. The cursor is
+   * keyed by the same session and describes byte offsets of a file that no
+   * longer exists, so it leaves with the registration.
+   */
+  async retireTranscriptRegistration(registration) {
+    validateRegistration(registration);
+    await this.prepare();
+    await this.removeStateFile(this.registrationPath(registration.host_source_ref, registration.host_session_ref));
+    await this.removeStateFile(this.cursorPath(registration.host_source_ref, registration.host_session_ref));
+  }
+  async listTranscriptRegistrations() {
+    await this.prepare();
+    const registrations = [];
+    for (const name of await readdir(this.registrations)) {
       if (!name.endsWith(".json")) continue;
       try {
-        const value = JSON.parse(await readFile(join2(this.entries, name), "utf8"));
-        validateBatch(value);
-        batches.push(value);
+        const value = JSON.parse(await readFile2(join3(this.registrations, name), "utf8"));
+        validateRegistration(value);
+        registrations.push(value);
       } catch {
-        malformed += 1;
       }
     }
-    batches.sort(compareBatch);
-    return { entries: batches, malformed };
+    return registrations.sort((left, right) => left.registered_at.localeCompare(right.registered_at));
   }
-  async remove(batch) {
+  async readInvocationTurnSelection(hostSourceRef, hostSessionRef) {
+    if (!SAFE_REF3.test(hostSourceRef) || !SAFE_REF3.test(hostSessionRef)) throw new ClaudeHostError("invalid_input", "Claude Host turn selection identity is invalid.");
+    await this.prepare();
     try {
-      await unlink2(this.path(batch.batch_ref));
+      const value = JSON.parse(await readFile2(this.turnSelectionPath(hostSourceRef, hostSessionRef), "utf8"));
+      if (!isHostInvocationTurnSelection(value) || value.host_source_ref !== hostSourceRef || value.host_session_ref !== hostSessionRef) throw new ClaudeHostError("storage", "Claude Host turn selection is malformed.");
+      return value;
     } catch (error) {
-      if (code(error) !== "ENOENT") throw error;
+      if (code(error) === "ENOENT") return null;
+      throw error instanceof ClaudeHostError ? error : new ClaudeHostError("storage", "Unable to read the Claude Host turn selection.");
     }
   }
-  path(ref) {
-    return join2(this.entries, `${cealRequestSha256(ref)}.json`);
+  async readTranscriptCursor(registration) {
+    validateRegistration(registration);
+    await this.prepare();
+    try {
+      const value = JSON.parse(await readFile2(this.cursorPath(registration.host_source_ref, registration.host_session_ref), "utf8"));
+      validateCursor(value);
+      return value;
+    } catch (error) {
+      if (code(error) === "ENOENT") return null;
+      throw error instanceof ClaudeHostError ? error : new ClaudeHostError("storage", "Claude transcript cursor is malformed.");
+    }
+  }
+  async writeTranscriptCursor(cursor) {
+    validateCursor(cursor);
+    await this.prepare();
+    await durableAtomicReplace(this.cursorPath(cursor.host_source_ref, cursor.host_session_ref), JSON.stringify(cursor));
+  }
+  envelopePath(ref) {
+    return join3(this.envelopes, `${cealRequestSha256(ref)}.json`);
+  }
+  registrationPath(sourceRef, sessionRef) {
+    return join3(this.registrations, `${cealRequestSha256({ source: sourceRef, session: sessionRef })}.json`);
+  }
+  turnSelectionPath(sourceRef, sessionRef) {
+    return join3(this.turnSelections, `${cealRequestSha256({ source: sourceRef, session: sessionRef })}.json`);
+  }
+  cursorPath(sourceRef, sessionRef) {
+    return join3(this.cursors, `${cealRequestSha256({ source: sourceRef, session: sessionRef })}.json`);
+  }
+  async readRegistrationFile(path) {
+    try {
+      const value = JSON.parse(await readFile2(path, "utf8"));
+      validateRegistration(value);
+      return value;
+    } catch (error) {
+      if (code(error) === "ENOENT") return null;
+      throw error instanceof ClaudeHostError ? error : new ClaudeHostError("storage", "Claude transcript registration is malformed.");
+    }
+  }
+  async removeStateFile(path) {
+    try {
+      await unlink2(path);
+    } catch (error) {
+      if (code(error) !== "ENOENT") throw error;
+    }
   }
   activeContextPath(identity) {
-    return join2(this.activeContexts, `${invocationContextKey(identity)}.json`);
+    return join3(this.activeContexts, `${invocationContextKey(identity)}.json`);
   }
 };
 function validateInvocationContextReadArguments(hostSourceRef, hostSessionRef, now) {
   if (!SAFE_REF3.test(hostSourceRef) || !SAFE_REF3.test(hostSessionRef) || !(now instanceof Date) || !Number.isFinite(now.getTime())) throw new ClaudeHostError("invalid_input", "Claude Host context identity or clock is invalid.");
 }
-async function readInvocationContextFile(file, hostSourceRef, hostSessionRef, now) {
+async function readProjectionFile(file) {
   try {
-    const context = JSON.parse(await readFile(file, "utf8"));
+    const context = JSON.parse(await readFile2(file, "utf8"));
     validateClaudeHostInvocationContext(context);
-    return contextMatches(context, hostSourceRef, hostSessionRef) && Date.parse(context.expires_at) > now.getTime() ? context : null;
+    return context;
   } catch (error) {
     if (code(error) === "ENOENT") return null;
     if (error instanceof ClaudeHostError) throw error;
     throw new ClaudeHostError("storage", "Unable to read the Claude Host invocation context.");
   }
 }
-function contextMatches(context, hostSourceRef, hostSessionRef) {
-  return context.identity.host_source_ref === hostSourceRef && context.identity.host_session_ref === hostSessionRef;
+function safeRef4(value) {
+  return typeof value === "string" && SAFE_REF3.test(value);
 }
-function compareBatch(left, right) {
-  return rank(left.hook_event) - rank(right.hook_event) || left.occurred_at.localeCompare(right.occurred_at) || left.batch_ref.localeCompare(right.batch_ref);
+function timestamp3(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
 }
-function rank(event) {
-  return event === "SessionStart" ? 0 : event === "UserPromptSubmit" ? 1 : 2;
+function record5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function code(error) {
+  return record5(error) && typeof error.code === "string" ? error.code : null;
 }
-function validateBatch(value) {
-  if (!validBatchHeader(value)) throw new ClaudeHostError("storage", "Claude hook batch is malformed.");
-  for (const [index, draft] of value.frames.entries()) {
-    if (!record5(draft) || !hostFrameKind(draft.frame_kind) || !record5(draft.payload)) throw new ClaudeHostError("storage", "Claude frame draft is malformed.");
-    encodeHostProducerFrame({ schema_version: "ceal.host_producer_frame.v1", producer_id: "claude", producer_installation_ref: "validation", producer_epoch: 1, sequence: index + 1, frame_kind: draft.frame_kind, occurred_at: value.occurred_at, payload: draft.payload });
+function validateEnvelope(value) {
+  if (!record5(value)) throw new ClaudeHostError("storage", "Claude outbox entry is malformed.");
+  if (!sameKeys(value, ["schema_version", "identity", "host_input_ref", "input_kind", "prompt_ref", "observations", "origin_input", "submission_ref", "created_at", "expires_at"], ["request_ref"])) {
+    throw new ClaudeHostError("storage", `Claude outbox entry key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the outbox entry key set")}).`);
+  }
+  if (value.schema_version !== CLAUDE_OUTBOX_SCHEMA_VERSION) throw new ClaudeHostError("storage", `Claude outbox entry is malformed (${refusalFact("schema_version", value.schema_version, `expected ${CLAUDE_OUTBOX_SCHEMA_VERSION}`)}).`);
+  validateEnvelopeIdentity(value);
+  validateEnvelopeObservations(value.observations);
+  if (typeof value.origin_input !== "boolean") throw new ClaudeHostError("storage", "Claude outbox origin disposition is malformed.");
+  if (!timestamp3(value.created_at) || !timestamp3(value.expires_at)) throw new ClaudeHostError("storage", "Claude outbox timestamps are malformed.");
+}
+function validateEnvelopeIdentity(value) {
+  validateIdentity2(value.identity);
+  if (!safeRef4(value.host_input_ref)) throw new ClaudeHostError("storage", "Claude outbox input reference is malformed.");
+  if (!isCealHostInputKind(value.input_kind)) throw new ClaudeHostError("storage", "Claude outbox input provenance is malformed.");
+  if (!safeRef4(value.prompt_ref) || !safeRef4(value.submission_ref)) throw new ClaudeHostError("storage", "Claude outbox references are malformed.");
+  if (value.request_ref !== void 0 && !safeRef4(value.request_ref)) throw new ClaudeHostError("storage", "Claude outbox Request reference is malformed.");
+}
+function validateEnvelopeObservations(value) {
+  if (!Array.isArray(value)) throw new ClaudeHostError("storage", "Claude outbox observations are malformed.");
+  try {
+    for (const observation2 of value) validateCealHostObservationDraft(observation2);
+  } catch {
+    throw new ClaudeHostError("storage", "Claude outbox observations are malformed.");
   }
 }
-function validBatchHeader(value) {
-  return record5(value) && value.schema_version === CLAUDE_OUTBOX_SCHEMA && safeRef3(value.batch_ref) && claudeEvent(value.hook_event) && safeRef3(value.local_session_ref) && optionalRef(value.local_turn_ref) && timestamp3(value.occurred_at) && Array.isArray(value.frames) && value.frames.length > 0 && value.frames.length <= 3;
+function validateSession(value) {
+  if (!record5(value)) throw new ClaudeHostError("storage", "Claude session snapshot is malformed.");
+  if (!sameKeys(value, ["schema_version", "host_session_ref", "host_source_ref", "observed_at", "value", "expires_at"])) {
+    throw new ClaudeHostError("storage", `Claude session snapshot key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the session snapshot key set")}).`);
+  }
+  if (value.schema_version !== CLAUDE_SESSION_SCHEMA_VERSION) throw new ClaudeHostError("storage", `Claude session snapshot is malformed (${refusalFact("schema_version", value.schema_version, `expected ${CLAUDE_SESSION_SCHEMA_VERSION}`)}).`);
+  if (!safeRef4(value.host_session_ref) || !safeRef4(value.host_source_ref) || !timestamp3(value.observed_at) || !timestamp3(value.expires_at)) {
+    throw new ClaudeHostError("storage", "Claude session snapshot fields are malformed.");
+  }
 }
-function claudeEvent(value) {
-  return typeof value === "string" && ["SessionStart", "UserPromptSubmit", "Stop", "StopFailure"].includes(value);
+function validateRegistration(value) {
+  if (!record5(value)) throw new ClaudeHostError("storage", "Claude transcript registration is malformed.");
+  if (!sameKeys(value, ["schema_version", "host_source_ref", "host_session_ref", "claude_session_id", "transcript_path", "registered_at", "expires_at"], ["cwd"])) {
+    throw new ClaudeHostError("storage", `Claude transcript registration key set is malformed (${refusalFact("keys", Object.keys(value), "exactly the registration key set")}).`);
+  }
+  if (value.schema_version !== CLAUDE_TRANSCRIPT_REGISTRATION_SCHEMA_VERSION) throw new ClaudeHostError("storage", "Claude transcript registration is malformed.");
+  if (![value.host_source_ref, value.host_session_ref, value.claude_session_id].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) {
+    throw new ClaudeHostError("storage", "Claude transcript registration references are malformed.");
+  }
+  validateRegistrationPaths(value.cwd, value.transcript_path);
+  if (!timestamp3(value.registered_at) || !timestamp3(value.expires_at)) throw new ClaudeHostError("storage", "Claude transcript registration timestamps are malformed.");
 }
-function hostFrameKind(value) {
-  return isHostProducerFrameKind(value);
+function validateRegistrationPaths(cwd, transcriptPath) {
+  if (cwd !== void 0 && (typeof cwd !== "string" || !isAbsolute(cwd) || cwd.length > CLAUDE_TRANSCRIPT_PATH_MAX_CHARACTERS || cwd.includes("\0"))) {
+    throw new ClaudeHostError("storage", "Claude transcript registration working directory is malformed.");
+  }
+  if (typeof transcriptPath !== "string" || transcriptPath.length === 0 || transcriptPath.length > CLAUDE_TRANSCRIPT_PATH_MAX_CHARACTERS) {
+    throw new ClaudeHostError("storage", "Claude transcript registration path is malformed.");
+  }
 }
-function safeRef3(value) {
-  return typeof value === "string" && SAFE_REF3.test(value);
+function validateCursor(value) {
+  if (!record5(value)) throw new ClaudeHostError("storage", "Claude transcript cursor is malformed.");
+  if (!sameKeys(value, ["schema_version", "host_source_ref", "host_session_ref", "transcript_path", "offset", "anchor_start", "anchor_sha256", "subagents", "status", "updated_at"], ["device", "inode", "open_turn", "unattributed", "session_observed", "reason"])) {
+    throw new ClaudeHostError("storage", "Claude transcript cursor key set is malformed.");
+  }
+  if (value.schema_version !== CLAUDE_TRANSCRIPT_CURSOR_SCHEMA_VERSION) throw new ClaudeHostError("storage", "Claude transcript cursor is malformed.");
+  if (![value.host_source_ref, value.host_session_ref].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) throw new ClaudeHostError("storage", "Claude transcript cursor references are malformed.");
+  if (typeof value.transcript_path !== "string" || value.transcript_path.length === 0) throw new ClaudeHostError("storage", "Claude transcript cursor path is malformed.");
+  validateCursorPosition(value);
+  validateCursorTurn(value.open_turn, value.unattributed, value.session_observed);
+  validateSubagentCursors(value.subagents);
+  if (value.reason !== void 0 && !isHostTranscriptCursorReason(value.reason)) throw new ClaudeHostError("storage", "Claude transcript cursor reason is malformed.");
+}
+function validateCursorPosition(value) {
+  if (!validCursorPosition(value)) throw new ClaudeHostError("storage", "Claude transcript cursor position is malformed.");
+  if (value.device !== void 0 && typeof value.device !== "string") throw new ClaudeHostError("storage", "Claude transcript cursor device is malformed.");
+  if (value.inode !== void 0 && typeof value.inode !== "string") throw new ClaudeHostError("storage", "Claude transcript cursor inode is malformed.");
+  if (value.device === void 0 && value.offset !== 0) throw new ClaudeHostError("storage", "Claude transcript cursor is unpinned past its start.");
+  if (value.status !== "active" && value.status !== "quarantined" || !timestamp3(value.updated_at)) throw new ClaudeHostError("storage", "Claude transcript cursor status is malformed.");
+}
+function validateCursorTurn(openTurn, unattributed, sessionObserved) {
+  if (openTurn !== void 0 && !validOpenTurn(openTurn)) throw new ClaudeHostError("storage", "Claude transcript turn cursor is malformed.");
+  if (unattributed !== void 0 && !validUnattributed(unattributed)) throw new ClaudeHostError("storage", "Claude transcript unattributed cursor is malformed.");
+  if (sessionObserved !== void 0 && typeof sessionObserved !== "boolean") throw new ClaudeHostError("storage", "Claude transcript cursor session marker is malformed.");
+}
+function validateSubagentCursors(value) {
+  if (!record5(value)) throw new ClaudeHostError("storage", "Claude transcript subagent cursors are malformed.");
+  for (const [name, entry] of Object.entries(value)) validateSubagentEntry(name, entry);
+}
+function validateSubagentEntry(name, entry) {
+  if (name.length === 0 || name.length > CLAUDE_TRANSCRIPT_SUBAGENT_NAME_MAX_CHARACTERS || name.includes("/")) throw new ClaudeHostError("storage", "Claude transcript subagent cursor is malformed.");
+  if (name.includes("\0")) throw new ClaudeHostError("storage", "Claude transcript subagent cursor is malformed.");
+  if (!record5(entry) || !sameKeys(entry, ["offset", "anchor_start", "anchor_sha256"], ["device", "inode"]) || !nonNegativeInteger(entry.offset)) throw new ClaudeHostError("storage", "Claude transcript subagent cursor is malformed.");
+  validateSubagentIdentity(entry);
+}
+function validateSubagentIdentity(entry) {
+  if (entry.device !== void 0 && typeof entry.device !== "string" || entry.inode !== void 0 && typeof entry.inode !== "string") {
+    throw new ClaudeHostError("storage", "Claude transcript subagent cursor is malformed.");
+  }
+  if (!nonNegativeInteger(entry.anchor_start) || typeof entry.anchor_sha256 !== "string" || !/^[a-f0-9]{64}$/u.test(entry.anchor_sha256)) {
+    throw new ClaudeHostError("storage", "Claude transcript subagent cursor is malformed.");
+  }
+  if (entry.device === void 0 && Number(entry.offset) !== 0) throw new ClaudeHostError("storage", "Claude transcript subagent cursor is unpinned past its start.");
+}
+function validCursorPosition(value) {
+  return nonNegativeInteger(value.offset) && nonNegativeInteger(value.anchor_start) && typeof value.anchor_sha256 === "string" && /^[a-f0-9]{64}$/u.test(value.anchor_sha256);
+}
+function validOpenTurn(value) {
+  if (!record5(value) || !sameKeys(value, ["turn_key", "user_uuid", "prompt_ref", "host_input_ref", "started_at", "last_observed_at", "message_ids", "counts"], ["last_terminal_digest"])) return false;
+  if (![value.turn_key, value.user_uuid, value.prompt_ref, value.host_input_ref].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) return false;
+  if (!timestamp3(value.started_at) || !timestamp3(value.last_observed_at)) return false;
+  if (!validMessageIds(value.message_ids)) return false;
+  if (!validTurnCounts(value.counts)) return false;
+  return value.last_terminal_digest === void 0 || typeof value.last_terminal_digest === "string" && /^[a-f0-9]{64}$/u.test(value.last_terminal_digest);
+}
+function validMessageIds(value) {
+  if (!Array.isArray(value) || value.length > CLAUDE_TRANSCRIPT_MAX_TURN_MESSAGES) return false;
+  if (!value.every((candidate) => typeof candidate === "string" && candidate.length > 0 && candidate.length <= 256)) return false;
+  return new Set(value).size === value.length;
+}
+function validUnattributed(value) {
+  if (!record5(value) || !sameKeys(value, ["input", "cached_input", "cache_write_input", "output", "message_ids", "last_observed_at"])) return false;
+  if (!validMessageIds(value.message_ids) || value.message_ids.length === 0) return false;
+  if (!timestamp3(value.last_observed_at)) return false;
+  return validTurnCounts(value);
+}
+function validTurnCounts(value) {
+  if (!record5(value) || !sameKeys(value, ["input", "cached_input", "cache_write_input", "output"])) return false;
+  return [value.input, value.cached_input, value.cache_write_input, value.output].every(nonNegativeInteger);
+}
+function validateIdentity2(value) {
+  if (!record5(value) || ![value.host_session_ref, value.host_turn_ref, value.host_source_ref].every((candidate) => typeof candidate === "string" && SAFE_REF3.test(candidate))) {
+    throw new ClaudeHostError("storage", "Claude Host identity is malformed.");
+  }
 }
-function optionalRef(value) {
-  return value === void 0 || typeof value === "string" && SAFE_REF3.test(value);
+function nonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && Number(value) >= 0;
 }
-function timestamp3(value) {
-  return typeof value === "string" && Number.isFinite(Date.parse(value));
+function sameKeys(value, required, optional = []) {
+  return required.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
 }
-function record5(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+
+// host/claude/src/claude-transcript-watcher.ts
+import { O_NOFOLLOW as O_NOFOLLOW2, O_RDONLY as O_RDONLY3 } from "node:constants";
+import { open as open3, readdir as readdir2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var TOKEN_OBSERVATION_SOURCE = "claude_transcript.message.usage";
+var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
+  store;
+  registerCurrentPrompt;
+  diagnostic;
+  constructor(options) {
+    super(options, {
+      default_retention_ms: CLAUDE_DEFAULT_RETENTION_MS,
+      invalid_outbox: () => new ClaudeHostError("configuration", "Claude transcript watcher outbox is invalid."),
+      clock_failure: () => new ClaudeHostError("storage", "Claude watcher clock is invalid.")
+    });
+    this.store = new ClaudeOutboxStore(options.outbox_dir);
+    this.registerCurrentPrompt = options.register_current_prompt;
+    this.diagnostic = options.diagnostic ?? (() => void 0);
+  }
+  transcriptPathOf(registration) {
+    return registration.transcript_path;
+  }
+  async listRegistrations() {
+    return this.store.listTranscriptRegistrations();
+  }
+  async scanOpened(handle, registration) {
+    const { size, device, inode } = await ownedClaudeTranscriptFile(handle);
+    const cursor = await this.preflight(registration, handle, size, device, inode);
+    if (cursor === null) return { records: 0, enqueued: 0, quarantined: true };
+    if (cursor.status === "quarantined") return { records: 0, enqueued: 0, quarantined: true };
+    const draft = mutableCursor(cursor);
+    await this.scanOpenedTranscript(registration, handle, draft, size, device, inode);
+    return { records: draft.consumed, enqueued: draft.enqueued, quarantined: false };
+  }
+  async scanFailed(handle, registration, error) {
+    this.diagnostic("watcher_scan_failed", claudeTranscriptScanFailureKind(error));
+    if (handle === void 0 && isSymlinkTranscript(error)) return await this.quarantineUnopened(registration, "transcript_malformed");
+    if (error instanceof ClaudeHostError && error.code === "payload_rejected") return await this.quarantineDraft(await this.preservedCursor(registration));
+    await this.quarantineFailure(registration, handle);
+    return { records: 0, enqueued: 0, quarantined: true };
+  }
+  async retireMissing(registration) {
+    return this.retireMissingTranscript(registration.transcript_path, "Claude", () => this.store.retireTranscriptRegistration(registration));
+  }
+  initialCursor(registration) {
+    return {
+      schema_version: CLAUDE_TRANSCRIPT_CURSOR_SCHEMA_VERSION,
+      host_source_ref: registration.host_source_ref,
+      host_session_ref: registration.host_session_ref,
+      transcript_path: registration.transcript_path,
+      offset: 0,
+      anchor_start: 0,
+      anchor_sha256: this.sha(Buffer.alloc(0)),
+      subagents: {},
+      status: "active",
+      updated_at: this.stamp()
+    };
+  }
+  async scanOpenedTranscript(registration, handle, draft, size, device, inode) {
+    const main2 = await this.readChunk(handle, draft.offset, size);
+    if (main2 !== "empty" && main2 !== "partial") {
+      await this.consumeMainChunk(registration, main2, draft);
+      draft.offset += main2.length;
+    }
+    draft.consumed += await this.consumeSubagents(registration, draft);
+    await this.emitOpenTerminal(registration, draft);
+    await this.commitCursor(registration, handle, draft, device, inode);
+  }
+  async preflight(registration, handle, size, device, inode) {
+    const existing = await this.store.readTranscriptCursor(registration);
+    if (existing?.status === "quarantined") return existing;
+    const cursor = existing ?? this.initialCursor(registration);
+    if (cursor.device === void 0) {
+      if (cursor.offset !== 0) return await this.quarantineStored(cursor, device, inode, "transcript_replaced");
+      return { ...cursor, device, inode };
+    }
+    const reason = this.cursorIdentityReason(cursor, registration.transcript_path, device, inode) ?? await this.cursorBoundsReason(handle, cursor, size);
+    if (reason !== null) return await this.quarantineStored(cursor, device, inode, reason);
+    return cursor;
+  }
+  async consumeMainChunk(registration, complete, draft) {
+    for (const line of complete.toString("utf8").split("\n").filter((value) => value.length > 0)) {
+      draft.consumed += 1;
+      const record6 = parseTranscriptLine(line);
+      if (record6 === null) throw new ClaudeHostError("payload_rejected", "Claude transcript line is not valid JSON.", "malformed_line");
+      if (isUserTurnLine(record6)) await this.openTurn(registration, draft, record6);
+      else if (isAssistantUsageLine(record6)) this.accumulateUsage(draft, toUsage(record6.uuid, record6.timestamp, record6.message.usage));
+      else if (isAssistantLine(record6) && record6.message.usage !== void 0) throw new ClaudeHostError("payload_rejected", "Claude transcript usage is malformed.");
+    }
+  }
+  async openTurn(registration, draft, record6) {
+    this.diagnostic("watcher_turn_observed");
+    await this.closeTurn(registration, draft, record6.timestamp);
+    const sessionRef = registration.host_session_ref;
+    const turnRef = claudeLocalTurnRef(registration.claude_session_id, record6.uuid);
+    const inputRef = claudeLocalInputRef(registration.claude_session_id, record6.uuid);
+    const promptRef = hostProducerPromptRef(this.sha(record6.message.content));
+    const identity = { host_source_ref: registration.host_source_ref, host_session_ref: sessionRef, host_turn_ref: turnRef };
+    const observations = [
+      { observation_ref: observationRef("transcript_user_text", inputRef, record6.message.content), observation_kind: "prompt", observed_at: record6.timestamp, value: { body_sha256: this.sha(record6.message.content) } },
+      { observation_ref: observationRef("transcript_turn_started", turnRef, record6.uuid), observation_kind: "turn", observed_at: record6.timestamp, value: { status: "started", host_session_id_sha256: this.sha(registration.claude_session_id), host_turn_ref: turnRef } }
+    ];
+    if (!draft.session_observed) {
+      const session = await this.store.readSession(registration.host_source_ref, sessionRef);
+      if (session !== null) observations.push({ observation_ref: observationRef("transcript_session", sessionRef, session.value), observation_kind: "session", observed_at: record6.timestamp, value: session.value });
+      draft.session_observed = true;
+    }
+    await this.store.putEnvelope({
+      schema_version: "ceal.claude_observation_outbox.v1",
+      identity,
+      host_input_ref: inputRef,
+      input_kind: "human",
+      prompt_ref: promptRef,
+      observations,
+      origin_input: true,
+      submission_ref: submissionRef("input", turnRef, inputRef, promptRef),
+      created_at: record6.timestamp,
+      expires_at: this.expire(this.outboxRetentionMs)
+    });
+    draft.enqueued += 1;
+    await this.registerPrompt(sessionRef, turnRef, promptRef, record6.message.content);
+    const selection = await this.store.readInvocationTurnSelection(identity.host_source_ref, identity.host_session_ref);
+    const turnGenerationRef = selection?.prompt_ref === promptRef ? selection.turn_generation_ref : void 0;
+    await this.activateContext(identity, promptRef, turnGenerationRef);
+    const folded = foldUnattributed(draft.unattributed);
+    draft.open_turn = {
+      turn_key: turnRef,
+      user_uuid: record6.uuid,
+      prompt_ref: promptRef,
+      host_input_ref: inputRef,
+      started_at: record6.timestamp,
+      last_observed_at: folded?.last_observed_at ?? record6.timestamp,
+      message_ids: folded?.message_ids ?? [],
+      counts: folded?.counts ?? zeroCounts()
+    };
+    draft.unattributed = void 0;
+  }
+  async closeTurn(registration, draft, at) {
+    const turn = draft.open_turn;
+    draft.open_turn = void 0;
+    if (turn === void 0) return;
+    const digest2 = terminalDigest(turn);
+    if (digest2 === turn.last_terminal_digest) return;
+    await this.putTerminalEnvelope(registration, turn, digest2, turn.message_ids.length === 0 ? at : void 0);
+    draft.enqueued += 1;
+  }
+  accumulateUsage(draft, usage) {
+    const turn = draft.open_turn;
+    if (turn === void 0) {
+      draft.unattributed = accumulateUnattributed(draft.unattributed, usage);
+      return;
+    }
+    if (turn.message_ids.includes(usage.uuid)) return;
+    if (turn.message_ids.length >= CLAUDE_TRANSCRIPT_MAX_TURN_MESSAGES) throw new ClaudeHostError("payload_rejected", "Claude transcript turn exceeds its usage message bound.", "size_budget");
+    draft.open_turn = {
+      ...turn,
+      last_observed_at: usage.observed_at > turn.last_observed_at ? usage.observed_at : turn.last_observed_at,
+      message_ids: [...turn.message_ids, usage.uuid],
+      counts: addCounts(turn.counts, usage)
+    };
+  }
+  /**
+   * Subagent transcripts live beside the session transcript at
+   * `<session-id>/subagents/*.jsonl` with a `.meta.json` sibling the scan
+   * ignores. Their usage belongs to the turn open when the scan runs: a
+   * subagent only runs while its parent turn is in flight. A straggler line
+   * that lands after the next user message therefore attributes to the open
+   * turn, never to a closed one.
+   */
+  async consumeSubagents(registration, draft) {
+    const directory = subagentsDirectory(registration.transcript_path);
+    let names;
+    try {
+      names = (await readdir2(directory)).filter((name) => name.endsWith(".jsonl") && !name.endsWith(".meta.json")).sort();
+    } catch (error) {
+      if (isMissingTranscriptError(error) || isNotDirectory(error)) return 0;
+      throw new ClaudeHostError("payload_rejected", "Claude subagent transcript directory is unavailable.");
+    }
+    if (names.length > CLAUDE_TRANSCRIPT_MAX_SUBAGENT_FILES) {
+      this.log(`Claude ignored subagent transcripts past its file bound: transcript_path=${JSON.stringify(registration.transcript_path)}, files=${names.length}.`);
+      names = names.slice(0, CLAUDE_TRANSCRIPT_MAX_SUBAGENT_FILES);
+    }
+    let consumed = 0;
+    for (const name of names) {
+      consumed += await this.consumeSubagentFile(draft, directory, name);
+    }
+    return consumed;
+  }
+  async consumeSubagentFile(draft, directory, name) {
+    const path = join4(directory, name);
+    let handle;
+    try {
+      handle = await open3(path, O_RDONLY3 | O_NOFOLLOW2);
+      const { size, device, inode } = await ownedClaudeTranscriptFile(handle);
+      const entry = draft.subagents[name] ?? { offset: 0, anchor_start: 0, anchor_sha256: this.sha(Buffer.alloc(0)) };
+      const pinned = await this.preflightSubagent(entry, size, device, inode);
+      const chunk = await this.readChunk(handle, pinned.offset, size);
+      if (chunk === "empty" || chunk === "partial") {
+        draft.subagents[name] = pinned;
+        return 0;
+      }
+      const consumed = this.consumeSubagentLines(draft, chunk);
+      const offset = pinned.offset + chunk.length;
+      const anchor = await this.readAnchor(handle, offset, CLAUDE_TRANSCRIPT_ANCHOR_BYTES);
+      draft.subagents[name] = { device, inode, offset, anchor_start: anchor.start, anchor_sha256: anchor.sha256 };
+      return consumed;
+    } catch (error) {
+      if (isMissingTranscriptError(error)) {
+        delete draft.subagents[name];
+        return 0;
+      }
+      throw error instanceof ClaudeHostError ? error : new ClaudeHostError("payload_rejected", "Claude subagent transcript is unavailable.");
+    } finally {
+      await handle?.close();
+    }
+  }
+  consumeSubagentLines(draft, chunk) {
+    let consumed = 0;
+    for (const line of chunk.toString("utf8").split("\n").filter((value) => value.length > 0)) {
+      consumed += 1;
+      const record6 = parseTranscriptLine(line);
+      if (record6 === null) throw new ClaudeHostError("payload_rejected", "Claude subagent transcript line is not valid JSON.", "malformed_line");
+      if (isAssistantUsageLine(record6)) this.accumulateUsage(draft, toUsage(record6.uuid, record6.timestamp, record6.message.usage));
+      else if (isAssistantLine(record6) && record6.message.usage !== void 0) throw new ClaudeHostError("payload_rejected", "Claude subagent transcript usage is malformed.");
+    }
+    return consumed;
+  }
+  async preflightSubagent(entry, size, device, inode) {
+    if (entry.device === void 0) {
+      if (entry.offset !== 0) throw new ClaudeHostError("payload_rejected", "Claude subagent transcript cursor is unpinned past its start.");
+      return { device, inode, offset: 0, anchor_start: 0, anchor_sha256: this.sha(Buffer.alloc(0)) };
+    }
+    if (entry.device !== device || entry.inode !== inode) throw new ClaudeHostError("payload_rejected", "Claude subagent transcript was replaced.");
+    if (size < entry.offset) throw new ClaudeHostError("payload_rejected", "Claude subagent transcript was truncated.");
+    return { device, inode, offset: entry.offset, anchor_start: entry.anchor_start, anchor_sha256: entry.anchor_sha256 };
+  }
+  /**
+   * The open turn's terminal is emitted optimistically on every scan whose
+   * new lines changed its totals, so usage is visible before the next user
+   * message closes the turn. The emission digest changes with the content,
+   * so a repeated scan over unchanged state emits nothing.
+   */
+  async emitOpenTerminal(registration, draft) {
+    const turn = draft.open_turn;
+    if (turn === void 0 || turn.message_ids.length === 0) return;
+    const digest2 = terminalDigest(turn);
+    if (digest2 === turn.last_terminal_digest) return;
+    await this.putTerminalEnvelope(registration, turn, digest2, void 0);
+    draft.enqueued += 1;
+    draft.open_turn = { ...turn, last_terminal_digest: digest2 };
+  }
+  async putTerminalEnvelope(registration, turn, digest2, gapAt) {
+    const observedAt = gapAt ?? turn.last_observed_at;
+    const tokenValue = turn.message_ids.length === 0 ? hostObservationNotRecorded("claude_turn_usage_not_observed") : availableTokenValue(turn.counts);
+    const identity = { host_source_ref: registration.host_source_ref, host_session_ref: registration.host_session_ref, host_turn_ref: turn.turn_key };
+    await this.store.putEnvelope({
+      schema_version: "ceal.claude_observation_outbox.v1",
+      identity,
+      host_input_ref: turn.host_input_ref,
+      input_kind: "host_automatic",
+      prompt_ref: turn.prompt_ref,
+      observations: [
+        { observation_ref: observationRef("transcript_terminal", turn.turn_key, digest2), observation_kind: "turn", observed_at: observedAt, value: { status: "stopped", host_session_id_sha256: this.sha(registration.claude_session_id), host_turn_ref: turn.turn_key } },
+        { observation_ref: observationRef("transcript_token", turn.turn_key, digest2), observation_kind: "token", observed_at: observedAt, value: tokenValue },
+        { observation_ref: observationRef("transcript_cost", turn.turn_key, digest2), observation_kind: "cost", observed_at: observedAt, value: hostObservationNotRecorded("provider_cost_not_observed") }
+      ],
+      origin_input: false,
+      submission_ref: submissionRef("terminal", turn.turn_key, digest2, turn.prompt_ref),
+      created_at: observedAt,
+      expires_at: this.expire(this.outboxRetentionMs)
+    });
+  }
+  async commitCursor(registration, handle, draft, device, inode) {
+    const anchor = await this.readAnchor(handle, draft.offset, CLAUDE_TRANSCRIPT_ANCHOR_BYTES);
+    await this.store.writeTranscriptCursor({
+      schema_version: CLAUDE_TRANSCRIPT_CURSOR_SCHEMA_VERSION,
+      host_source_ref: registration.host_source_ref,
+      host_session_ref: registration.host_session_ref,
+      transcript_path: registration.transcript_path,
+      device,
+      inode,
+      offset: draft.offset,
+      anchor_start: anchor.start,
+      anchor_sha256: anchor.sha256,
+      subagents: draft.subagents,
+      ...draft.open_turn === void 0 ? {} : { open_turn: draft.open_turn },
+      ...draft.unattributed === void 0 ? {} : { unattributed: draft.unattributed },
+      ...draft.session_observed ? { session_observed: true } : {},
+      status: "active",
+      updated_at: this.stamp()
+    });
+  }
+  async registerPrompt(sessionRef, turnRef, promptRef, prompt) {
+    if (this.producerInstallationRef === void 0 || this.registerCurrentPrompt === void 0) return;
+    try {
+      await this.registerCurrentPrompt({
+        producer_id: "claude",
+        producer_installation_ref: this.producerInstallationRef,
+        local_session_ref: sessionRef,
+        local_turn_ref: turnRef,
+        prompt_ref: promptRef,
+        current_prompt: prompt,
+        context_expires_at: this.expire(this.outboxRetentionMs)
+      });
+      this.diagnostic("current_prompt_registered");
+    } catch (error) {
+      this.diagnostic("current_prompt_registration_failed");
+      throw error;
+    }
+  }
+  async activateContext(identity, promptRef, turnGenerationRef) {
+    try {
+      await this.store.activateInvocationContext(identity, promptRef, this.expire(this.outboxRetentionMs), void 0, turnGenerationRef);
+      this.diagnostic("activation_recorded");
+    } catch (error) {
+      this.diagnostic("activation_failed");
+      throw error;
+    }
+  }
+  async quarantineStored(cursor, device, inode, reason) {
+    await this.store.writeTranscriptCursor({ ...cursor, device, inode, status: "quarantined", reason, updated_at: this.stamp() });
+    return null;
+  }
+  async quarantineUnopened(registration, reason) {
+    const existing = await this.store.readTranscriptCursor(registration).catch(() => null);
+    await this.store.writeTranscriptCursor({ ...existing ?? this.initialCursor(registration), transcript_path: registration.transcript_path, status: "quarantined", reason, updated_at: this.stamp() });
+    return { records: 0, enqueued: 0, quarantined: true };
+  }
+  async quarantineDraft(cursor) {
+    await this.store.writeTranscriptCursor({ ...cursor, status: "quarantined", reason: "transcript_malformed", updated_at: this.stamp() });
+    return { records: 0, enqueued: 0, quarantined: true };
+  }
+  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);
+    const cursor = existing ?? this.initialCursor(registration);
+    await this.store.writeTranscriptCursor({ ...cursor, device: String(stats.dev), inode: String(stats.ino), status: "quarantined", reason: "transcript_malformed", updated_at: this.stamp() });
+  }
+  async preservedCursor(registration) {
+    return await this.store.readTranscriptCursor(registration).catch(() => null) ?? this.initialCursor(registration);
+  }
+};
+function mutableCursor(cursor) {
+  return {
+    offset: cursor.offset,
+    ...cursor.open_turn === void 0 ? {} : { open_turn: cursor.open_turn },
+    ...cursor.unattributed === void 0 ? {} : { unattributed: cursor.unattributed },
+    subagents: Object.fromEntries(Object.entries(cursor.subagents).map(([name, entry]) => [name, { ...entry }])),
+    session_observed: cursor.session_observed ?? false,
+    consumed: 0,
+    enqueued: 0
+  };
 }
-function code(error) {
-  return record5(error) && typeof error.code === "string" ? error.code : null;
+function zeroCounts() {
+  return { input: 0, cached_input: 0, cache_write_input: 0, output: 0 };
+}
+function terminalDigest(turn) {
+  return transcriptObjectSha256({ turn: turn.turn_key, messages: turn.message_ids, counts: turn.counts });
+}
+function availableTokenValue(counts) {
+  const input = counts.input;
+  const output = counts.output;
+  if (!Number.isSafeInteger(input + output)) throw new ClaudeHostError("payload_rejected", "Claude transcript usage exceeds the supported range.");
+  return createHostTokenObservationValue({
+    input,
+    output,
+    total: input + output,
+    cached_input: counts.cached_input,
+    cache_write_input: counts.cache_write_input
+  }, TOKEN_OBSERVATION_SOURCE);
+}
+function addCounts(current, next) {
+  const counts = {
+    input: current.input + next.input,
+    cached_input: current.cached_input + next.cached_input,
+    cache_write_input: current.cache_write_input + next.cache_write_input,
+    output: current.output + next.output
+  };
+  if (![counts.input, counts.cached_input, counts.cache_write_input, counts.output].every((value) => Number.isSafeInteger(value) && value >= 0)) {
+    throw new ClaudeHostError("payload_rejected", "Claude transcript usage exceeds the supported range.");
+  }
+  return counts;
+}
+function accumulateUnattributed(current, usage) {
+  const base = current ?? { input: 0, cached_input: 0, cache_write_input: 0, output: 0, message_ids: [], last_observed_at: usage.observed_at };
+  if (base.message_ids.includes(usage.uuid)) return base;
+  if (base.message_ids.length >= CLAUDE_TRANSCRIPT_MAX_TURN_MESSAGES) throw new ClaudeHostError("payload_rejected", "Claude transcript turn exceeds its usage message bound.", "size_budget");
+  const counts = addCounts(base, usage);
+  return {
+    ...counts,
+    message_ids: [...base.message_ids, usage.uuid],
+    last_observed_at: usage.observed_at > base.last_observed_at ? usage.observed_at : base.last_observed_at
+  };
+}
+function foldUnattributed(bucket) {
+  if (bucket === void 0) return void 0;
+  if (![bucket.input, bucket.cached_input, bucket.cache_write_input, bucket.output].every((value) => Number.isSafeInteger(value) && value >= 0)) {
+    throw new ClaudeHostError("payload_rejected", "Claude transcript usage exceeds the supported range.");
+  }
+  return { message_ids: [...bucket.message_ids], counts: { input: bucket.input, cached_input: bucket.cached_input, cache_write_input: bucket.cache_write_input, output: bucket.output }, last_observed_at: bucket.last_observed_at };
+}
+function toUsage(uuid, observedAt, usage) {
+  const input = usageNumber(usage.input_tokens);
+  const cached = usageNumber(usage.cache_read_input_tokens ?? 0);
+  const created = usageNumber(usage.cache_creation_input_tokens ?? 0);
+  const output = usageNumber(usage.output_tokens);
+  if (input === null || cached === null || created === null || output === null) throw new ClaudeHostError("payload_rejected", "Claude transcript usage is malformed.");
+  const total = input + cached + created;
+  if (![total, output].every((value) => Number.isSafeInteger(value) && value >= 0)) throw new ClaudeHostError("payload_rejected", "Claude transcript usage exceeds the supported range.");
+  return { uuid, observed_at: observedAt, input: total, cached_input: cached, cache_write_input: created, output };
+}
+function usageNumber(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function parseTranscriptLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function lineIdentity(record6) {
+  if (typeof record6.uuid !== "string" || record6.uuid.length === 0 || record6.uuid.length > 256) return null;
+  if (typeof record6.timestamp !== "string" || !Number.isFinite(Date.parse(record6.timestamp))) return null;
+  return { uuid: record6.uuid, timestamp: record6.timestamp };
+}
+function isUserTurnLine(record6) {
+  if (!isTranscriptRecord(record6) || record6.type !== "user") return false;
+  if (!isTranscriptRecord(record6.message) || typeof record6.message.content !== "string") return false;
+  if (record6.isMeta === true && (!isTranscriptRecord(record6.origin) || typeof record6.origin.kind !== "string")) return false;
+  const identity = lineIdentity(record6);
+  if (identity === null) throw new ClaudeHostError("payload_rejected", "Claude transcript user line is malformed.");
+  return true;
+}
+function claudeTranscriptScanFailureKind(error) {
+  if (isSymlinkTranscript(error)) return "symlink";
+  if (error instanceof ClaudeHostError) {
+    if (error.diagnostic_kind !== void 0) return error.diagnostic_kind;
+    if (error.code === "payload_rejected") return "payload_rejected";
+    if (error.code === "storage") return "read_error";
+  }
+  const code2 = transcriptErrorCode(error);
+  if (code2 === "EFBIG") return "size_budget";
+  if (["EBADF", "EACCES", "EIO", "EMFILE", "ENFILE", "ENOENT", "ENOTDIR", "EPERM"].includes(code2 ?? "")) return "read_error";
+  return "other";
+}
+function isAssistantLine(record6) {
+  return isTranscriptRecord(record6) && record6.type === "assistant" && isTranscriptRecord(record6.message);
+}
+function isAssistantUsageLine(record6) {
+  if (!isTranscriptRecord(record6)) return false;
+  if (!isAssistantLine(record6) || record6.message.usage === void 0) return false;
+  const identity = lineIdentity(record6);
+  if (identity === null || !isTranscriptRecord(record6.message.usage)) throw new ClaudeHostError("payload_rejected", "Claude transcript usage line is malformed.");
+  return true;
+}
+function subagentsDirectory(transcriptPath) {
+  const stem = transcriptPath.endsWith(".jsonl") ? transcriptPath.slice(0, -".jsonl".length) : transcriptPath;
+  return join4(stem, "subagents");
+}
+function observationRef(event, identity, value) {
+  return cealHostObservationRef("claude", transcriptObjectSha256({ event, identity, value }));
+}
+function submissionRef(kind, turn, digest2, prompt) {
+  return `claude-submission:${transcriptObjectSha256({ kind, turn, digest: digest2, prompt })}`;
+}
+async function ownedClaudeTranscriptFile(handle) {
+  const stats = await handle.stat();
+  const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
+  if (!stats.isFile()) throw new ClaudeHostError("payload_rejected", "Claude transcript source is not a regular file.");
+  if (stats.uid !== uid) throw new ClaudeHostError("payload_rejected", "Claude transcript source is owned by another user.");
+  return { size: stats.size, device: String(stats.dev), inode: String(stats.ino) };
+}
+function isNotDirectory(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOTDIR";
+}
+function isSymlinkTranscript(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ELOOP";
+}
+function transcriptErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
 }
 
 // host/claude/src/claude-adapter.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4, randomUUID } 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";
+import { homedir } from "node:os";
+import { isAbsolute as isAbsolute2, join as join5, relative, resolve } from "node:path";
 var ClaudeHookAdapter = class {
   store;
   now;
+  optionsSourceRef;
+  transcriptsRoot;
+  randomUuid;
   constructor(options) {
     this.store = new ClaudeOutboxStore(options.outbox_dir);
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.optionsSourceRef = options.host_source_ref ?? "claude-host:local";
-    this.producerInstallationRef = options.producer_installation_ref;
-    this.registerCurrentPrompt = options.register_current_prompt;
+    this.transcriptsRoot = options.claude_transcripts_root;
+    this.randomUuid = options.random_uuid ?? randomUUID;
   }
   async handle(event, raw) {
     let input;
     try {
       input = decodeClaudeHookInput(event, raw);
     } catch (error) {
-      return { event, disposition: "rejected", reason: error instanceof Error ? refusalFact("error", error) : "invalid_claude_hook_input" };
+      return { event, disposition: "rejected", reason: error instanceof Error ? error.message.slice(0, 128) : "invalid_claude_hook_input" };
     }
-    const occurredAt = timestamp4(this.now);
-    const sessionRef = claudeLocalSessionRef(input.session_id);
-    const turnRef = input.prompt_id === void 0 ? void 0 : claudeLocalTurnRef(input.session_id, input.prompt_id);
-    const frames = mapFrames(input, occurredAt);
-    if (input.hook_event_name === "UserPromptSubmit" && turnRef !== void 0 && this.producerInstallationRef !== void 0 && this.registerCurrentPrompt !== void 0) {
-      const promptRef = hostProducerPromptRef(createHash3("sha256").update(input.prompt, "utf8").digest("hex"));
-      await this.registerCurrentPrompt({ producer_id: "claude", producer_installation_ref: this.producerInstallationRef, local_session_ref: sessionRef, local_turn_ref: turnRef, prompt_ref: promptRef, current_prompt: input.prompt, context_expires_at: new Date(Date.parse(occurredAt) + 24 * 60 * 60 * 1e3).toISOString() });
+    try {
+      return input.event === "SessionStart" ? await this.registerSession(input) : await this.registerCurrentTurn(input);
+    } catch (error) {
+      return { event, disposition: "rejected", reason: error instanceof Error ? error.message.slice(0, 128) : "claude_hook_failed" };
     }
-    const batchRef = `claude-batch:${cealRequestSha256({ event, session_ref: sessionRef, turn_ref: turnRef ?? null, occurred_at: occurredAt, frames })}`;
-    const batch = { schema_version: CLAUDE_OUTBOX_SCHEMA, batch_ref: batchRef, hook_event: event, local_session_ref: sessionRef, ...turnRef === void 0 ? {} : { local_turn_ref: turnRef }, occurred_at: occurredAt, frames };
-    await this.store.put(batch);
-    await this.activatePromptContext(input, frames, sessionRef, turnRef);
-    return { event, disposition: "queued", batch_ref: batchRef, local_session_ref: sessionRef, ...turnRef === void 0 ? {} : { local_turn_ref: turnRef } };
-  }
-  async activatePromptContext(input, frames, sessionRef, turnRef) {
-    if (input.hook_event_name !== "UserPromptSubmit" || turnRef === void 0) return;
-    const identity = { host_source_ref: this.optionsSourceRef, host_session_ref: sessionRef, host_turn_ref: turnRef };
-    validateClaudeIdentity(identity);
-    const inputFrame = frames.find((frame) => frame.frame_kind === "user_input");
-    const expiresAt = inputFrame?.payload.context_expires_at;
-    if (typeof expiresAt !== "string") throw new ClaudeHostError("storage", "Claude prompt context expiry is unavailable.");
-    const observations = inputFrame?.payload.observations;
-    const prompt = Array.isArray(observations) ? observations.find((observation) => isRecord(observation) && observation.observation_kind === "prompt") : void 0;
-    const promptValue = isRecord(prompt) ? prompt.value : void 0;
-    if (!isCealHostPromptObservationValue(promptValue)) throw new ClaudeHostError("storage", "Claude prompt observation is unavailable.");
-    await this.store.activateInvocationContext(identity, hostProducerPromptRef(promptValue.body_sha256), expiresAt, input.cwd);
   }
-  optionsSourceRef;
-  producerInstallationRef;
-  registerCurrentPrompt;
+  async registerSession(input) {
+    const defaultRoot = join5(homedir(), ".claude", "projects");
+    const transcriptPath = sourceBoundTranscriptPath(input.transcript_path, this.transcriptsRoot ?? defaultRoot);
+    const hostSessionRef = claudeLocalSessionRef(input.session_id);
+    const observedAt = timestamp4(this.now);
+    const expiresAt = new Date(Date.parse(observedAt) + CLAUDE_DEFAULT_RETENTION_MS).toISOString();
+    const registration = {
+      schema_version: "ceal.claude_transcript_registration.v1",
+      host_source_ref: this.optionsSourceRef,
+      host_session_ref: hostSessionRef,
+      claude_session_id: input.session_id,
+      cwd: input.cwd,
+      transcript_path: transcriptPath,
+      registered_at: observedAt,
+      expires_at: expiresAt
+    };
+    const existing = (await this.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 this.store.writeTranscriptCursor((await captureClaudeTranscriptBaseline(registration, this.now)).cursor);
+    }
+    await this.store.registerTranscript(registration);
+    const snapshot = {
+      schema_version: "ceal.claude_session.v1",
+      host_session_ref: hostSessionRef,
+      host_source_ref: this.optionsSourceRef,
+      observed_at: observedAt,
+      value: sessionObservationValue(input),
+      expires_at: expiresAt
+    };
+    await this.store.saveSession(snapshot);
+    return { event: input.event, disposition: "ignored", reason: "transcript_registered", local_session_ref: hostSessionRef };
+  }
+  async registerCurrentTurn(input) {
+    const transcriptPath = sourceBoundTranscriptPath(input.transcript_path, this.transcriptsRoot ?? join5(homedir(), ".claude", "projects"));
+    const hostSessionRef = claudeLocalSessionRef(input.session_id);
+    const observedAt = timestamp4(this.now);
+    const expiresAt = new Date(Date.parse(observedAt) + CLAUDE_DEFAULT_RETENTION_MS).toISOString();
+    const registration = {
+      schema_version: "ceal.claude_transcript_registration.v1",
+      host_source_ref: this.optionsSourceRef,
+      host_session_ref: hostSessionRef,
+      claude_session_id: input.session_id,
+      cwd: input.cwd,
+      transcript_path: transcriptPath,
+      registered_at: observedAt,
+      expires_at: expiresAt
+    };
+    const promptRef = hostProducerPromptRef(createHash4("sha256").update(input.prompt, "utf8").digest("hex"));
+    const turnGenerationRef = this.randomUuid();
+    const selection = { schema_version: "ceal.host_invocation_turn_selection.v1", host_source_ref: this.optionsSourceRef, host_session_ref: hostSessionRef, prompt_ref: promptRef, turn_generation_ref: turnGenerationRef };
+    await this.store.writeInvocationTurnSelection(selection);
+    const existing = (await this.store.listTranscriptRegistrations()).find((candidate) => candidate.host_source_ref === registration.host_source_ref && candidate.host_session_ref === registration.host_session_ref);
+    const baseline = await captureClaudeTranscriptBaseline(registration, this.now, input.prompt);
+    const transcriptTurnRef = baseline.current_turn_ref;
+    if (existing === void 0) await this.store.writeTranscriptCursor(baseline.cursor);
+    else await refreshCurrentTurnCursor(this.store, registration, baseline, promptRef, turnGenerationRef, transcriptTurnRef);
+    await this.store.registerTranscript(registration);
+    return { event: input.event, disposition: "ignored", reason: "transcript_registered", local_session_ref: hostSessionRef, ...transcriptTurnRef === void 0 ? {} : { local_turn_ref: transcriptTurnRef } };
+  }
 };
-function mapFrames(input, at) {
-  if (input.hook_event_name === "SessionStart") return sessionFrames(input, at);
-  if (input.hook_event_name === "UserPromptSubmit") return inputFrames(input, at);
-  return terminalFrames(input, at);
-}
-function sessionFrames(input, at) {
-  const sessionRef = claudeLocalSessionRef(input.session_id);
-  const observation = obs("session", sessionRef, at, { status: "started", host_kind: "claude", source: input.source, model: input.model ?? "unavailable", decoder_evidence_version: "claude-code-2.1.258" });
-  return [{ frame_kind: "session_started", payload: compact({ local_session_ref: sessionRef, working_directory_ref: claudeWorkspaceRef(input.cwd), model: input.model, observations: [observation] }) }];
-}
-function inputFrames(input, at) {
-  const sessionRef = claudeLocalSessionRef(input.session_id);
-  const turnRef = claudeLocalTurnRef(input.session_id, input.prompt_id);
-  const promptDigest = createHash3("sha256").update(input.prompt, "utf8").digest("hex");
-  const turn = obs("turn", turnRef, at, { status: "started", prompt_id_sha256: createHash3("sha256").update(input.prompt_id, "utf8").digest("hex"), effort: input.effort?.level ?? "unavailable" });
-  const prompt = obs("prompt", claudeLocalInputRef(input.session_id, input.prompt_id), at, { body_sha256: promptDigest });
-  return [{ frame_kind: "turn_started", payload: { local_session_ref: sessionRef, local_turn_ref: turnRef, observations: [turn] } }, { frame_kind: "user_input", payload: compact({ local_session_ref: sessionRef, local_turn_ref: turnRef, local_input_ref: claudeLocalInputRef(input.session_id, input.prompt_id), input_kind: "human", origin_input: true, local_turn_aliases: [safeAlias(input.prompt_id)], context_expires_at: new Date(Date.parse(at) + 24 * 60 * 60 * 1e3).toISOString(), observations: [prompt] }) }];
-}
-function terminalFrames(input, at) {
-  const sessionRef = claudeLocalSessionRef(input.session_id);
-  const turnRef = claudeLocalTurnRef(input.session_id, input.prompt_id);
-  const aborted = input.hook_event_name === "StopFailure";
-  const reason = aborted ? `api_${input.error}` : void 0;
-  const terminal = obs("turn", `${turnRef}:${aborted ? "failed" : "stopped"}`, at, compact({ status: aborted ? "aborted" : "completed", reason }));
-  const timing = obs("timing", `${turnRef}:timing`, at, { status: "unavailable", reason: "claude_hook_does_not_expose_timing_or_usage" });
-  return [{ frame_kind: "turn_terminal", payload: compact({ local_session_ref: sessionRef, local_turn_ref: turnRef, terminal_state: aborted ? "aborted" : "completed", abort_reason: reason, observations: [terminal, timing] }) }];
-}
-function obs(kind, identity, at, value) {
-  return { observation_ref: cealHostObservationRef("claude", cealRequestSha256({ kind, identity, at, value })), observation_kind: kind, observed_at: at, value };
-}
-function safeAlias(value) {
-  return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value) ? value : `prompt:${createHash3("sha256").update(value).digest("hex")}`;
+function sessionObservationValue(input) {
+  return { status: "started", host_kind: "claude", source: input.source, model: input.model ?? "unavailable", decoder_evidence_version: "claude-code-2.1.258" };
+}
+function sourceBoundTranscriptPath(path, transcriptsRoot) {
+  if (!isAbsolute2(path) || !isAbsolute2(transcriptsRoot)) throw new ClaudeHostError("configuration", "Claude transcript registration paths must be absolute.");
+  const transcript = resolve(path);
+  const root = resolve(transcriptsRoot);
+  const child = relative(root, transcript);
+  if (child === "" || child === ".." || child.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute2(child)) {
+    throw new ClaudeHostError("invalid_input", "Claude transcript path is outside the configured transcripts root.");
+  }
+  return transcript;
 }
-function isRecord(value) {
+async function refreshCurrentTurnCursor(store, registration, baseline, promptRef, turnGenerationRef, transcriptTurnRef) {
+  const cursor = await store.readTranscriptCursor(registration);
+  if (cursor?.status !== "active") {
+    await store.writeTranscriptCursor(baseline.cursor);
+    return;
+  }
+  if (baseline.current_line_start === void 0 || baseline.current_user_uuid === void 0 || transcriptTurnRef === void 0 || cursor.offset <= baseline.current_line_start || cursor.open_turn?.user_uuid !== baseline.current_user_uuid) return;
+  await store.attachInvocationTurnGeneration({
+    host_source_ref: registration.host_source_ref,
+    host_session_ref: registration.host_session_ref,
+    host_turn_ref: transcriptTurnRef
+  }, promptRef, turnGenerationRef);
+}
+async function captureClaudeTranscriptBaseline(registration, now, currentPrompt) {
+  let handle;
+  try {
+    handle = await open4(registration.transcript_path, O_RDONLY4 | O_NOFOLLOW3);
+  } catch (error) {
+    if (isNotFound(error)) return { cursor: initialCursor(registration, now) };
+    throw error;
+  }
+  try {
+    const file = await inspectClaudeTranscript(handle);
+    const current = currentPrompt === void 0 ? void 0 : await currentClaudeUserLine(handle, file.size, registration.claude_session_id, currentPrompt);
+    const offset = current?.offset ?? file.size;
+    const cursor = await makeClaudeBaselineCursor(handle, registration, now, file, offset);
+    return {
+      cursor,
+      ...current?.user === void 0 ? {} : {
+        current_turn_ref: claudeLocalTurnRef(registration.claude_session_id, current.user.uuid),
+        current_user_uuid: current.user.uuid,
+        current_line_start: current.offset
+      }
+    };
+  } finally {
+    await handle?.close();
+  }
+}
+async function inspectClaudeTranscript(handle) {
+  const stats = await handle.stat();
+  const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
+  if (!stats.isFile()) throw new ClaudeHostError("storage", "Claude transcript source is not a regular file.");
+  if (stats.uid !== uid) throw new ClaudeHostError("storage", "Claude transcript source is owned by another user.");
+  return { size: stats.size, device: String(stats.dev), inode: String(stats.ino) };
+}
+async function currentClaudeUserLine(handle, size, sessionId, prompt) {
+  const lastLine = await readLastClaudeTranscriptLine(handle, size);
+  if (lastLine === null) return void 0;
+  const user = parseClaudeUserLine(lastLine.bytes.toString("utf8"), sessionId);
+  if (user?.content === prompt) return { offset: lastLine.start, user };
+  return { offset: lastLine.complete ? size : lastLine.start };
+}
+async function makeClaudeBaselineCursor(handle, registration, now, file, offset) {
+  const anchorStart = Math.max(0, offset - CLAUDE_TRANSCRIPT_ANCHOR_BYTES);
+  const anchor = Buffer.alloc(offset - anchorStart);
+  if (anchor.length > 0) await handle.read(anchor, 0, anchor.length, anchorStart);
+  return {
+    schema_version: CLAUDE_TRANSCRIPT_CURSOR_SCHEMA_VERSION,
+    host_source_ref: registration.host_source_ref,
+    host_session_ref: registration.host_session_ref,
+    transcript_path: registration.transcript_path,
+    device: file.device,
+    inode: file.inode,
+    offset,
+    anchor_start: anchorStart,
+    anchor_sha256: createHash4("sha256").update(anchor).digest("hex"),
+    subagents: {},
+    status: "active",
+    updated_at: timestamp4(now)
+  };
+}
+async function readLastClaudeTranscriptLine(handle, size) {
+  if (size === 0) return null;
+  const last = Buffer.alloc(1);
+  await handle.read(last, 0, 1, size - 1);
+  const complete = last[0] === 10;
+  let end = complete ? size - 1 : size;
+  if (end === 0) return null;
+  let position = end;
+  const chunks = [];
+  let total = 0;
+  const maximumBytes = 512 * 1024;
+  while (position > 0 && total <= maximumBytes) {
+    const start = Math.max(0, position - 64 * 1024);
+    const buffer = Buffer.alloc(position - start);
+    const read = await handle.read(buffer, 0, buffer.length, start);
+    const chunk = buffer.subarray(0, read.bytesRead);
+    const newline = chunk.lastIndexOf(10);
+    if (newline >= 0) return { start: start + newline + 1, bytes: Buffer.concat([chunk.subarray(newline + 1), ...chunks]), complete };
+    chunks.unshift(chunk);
+    total += chunk.length;
+    position = start;
+  }
+  if (position === 0) return { start: 0, bytes: Buffer.concat(chunks), complete };
+  return null;
+}
+function parseClaudeUserLine(line, sessionId) {
+  const row = parseClaudeJsonObject(line);
+  if (row === null || row.type !== "user" || row.sessionId !== sessionId || typeof row.uuid !== "string" || row.uuid.length === 0 || !isRecord2(row.message)) return null;
+  return typeof row.message.content === "string" ? { uuid: row.uuid, content: row.message.content } : null;
+}
+function parseClaudeJsonObject(line) {
+  try {
+    const value = JSON.parse(line);
+    return isRecord2(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function compact(value) {
-  return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== void 0));
+function isNotFound(error) {
+  return isRecord2(error) && error.code === "ENOENT";
+}
+function initialCursor(registration, now) {
+  return {
+    schema_version: CLAUDE_TRANSCRIPT_CURSOR_SCHEMA_VERSION,
+    host_source_ref: registration.host_source_ref,
+    host_session_ref: registration.host_session_ref,
+    transcript_path: registration.transcript_path,
+    offset: 0,
+    anchor_start: 0,
+    anchor_sha256: createHash4("sha256").update(Buffer.alloc(0)).digest("hex"),
+    subagents: {},
+    status: "active",
+    updated_at: timestamp4(now)
+  };
 }
 function timestamp4(now) {
   const value = now();
@@ -2422,134 +3813,154 @@ function timestamp4(now) {
 }
 
 // host/claude/src/claude-producer.ts
-import { mkdir as mkdir3, readFile as readFile2, rename as rename2, writeFile } from "node:fs/promises";
-import { join as join3 } from "node:path";
-var STATE_SCHEMA = "ceal.claude_producer_state.v1";
-var SAFE_REF4 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 var ClaudeProducer = class {
+  producer_id = "claude";
+  producer_label = "Claude";
+  outbox_directory;
   store;
-  statePath;
-  installation;
-  epoch;
-  options;
-  tail = Promise.resolve();
+  core;
   constructor(options) {
-    if (!SAFE_REF4.test(options.producer_installation_ref)) throw new ClaudeHostError("configuration", "Claude producer installation identity is invalid.");
-    this.options = options;
-    this.epoch = options.producer_epoch ?? 1;
-    if (!Number.isSafeInteger(this.epoch) || this.epoch <= 0) throw new ClaudeHostError("configuration", "Claude producer epoch is invalid.");
     this.store = new ClaudeOutboxStore(options.outbox_dir);
-    this.statePath = join3(options.outbox_dir, "claude-producer-state.json");
-    this.installation = options.producer_installation_ref;
+    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 retained = 0;
-    for (const batch of read.entries) {
-      const frames = await this.reserve(batch);
-      let complete = true;
-      for (const frame of frames) {
-        const outcome = await this.options.relay.admit(frame);
-        if (outcome.code !== "admitted" && outcome.code !== "already_admitted") {
-          complete = false;
-          break;
-        }
-      }
-      if (!complete) {
-        retained += 1;
-        break;
-      }
-      await this.store.remove(batch);
-      await this.release(batch.batch_ref);
-      admitted += 1;
-    }
-    return { admitted, retained: retained + Math.max(0, read.entries.length - admitted - retained), malformed: read.malformed };
+  fail(code2, message) {
+    return new ClaudeHostError(code2, message);
   }
-  async reserve(batch) {
-    const state = await this.readState();
-    const existing = state.pending[batch.batch_ref];
-    if (existing !== void 0) return existing;
-    const frames = batch.frames.map((draft, offset) => ({ schema_version: "ceal.host_producer_frame.v1", producer_id: "claude", producer_installation_ref: this.installation, producer_epoch: this.epoch, sequence: state.next_sequence + offset, frame_kind: draft.frame_kind, occurred_at: batch.occurred_at, payload: draft.payload }));
-    await this.writeState({ ...state, next_sequence: state.next_sequence + frames.length, pending: { ...state.pending, [batch.batch_ref]: frames } });
-    return frames;
+  listEnvelopes() {
+    return this.store.listEnvelopes();
   }
-  async release(ref) {
-    const state = await this.readState();
-    if (state.pending[ref] === void 0) return;
-    const pending = { ...state.pending };
-    delete pending[ref];
-    await this.writeState({ ...state, pending });
+  removeEnvelope(envelope) {
+    return this.store.removeEnvelope(envelope);
   }
-  async readState() {
-    try {
-      return decodeState(JSON.parse(await readFile2(this.statePath, "utf8")), this.installation, this.epoch);
-    } catch (error) {
-      if (code2(error) !== "ENOENT") throw error;
-      return { schema_version: STATE_SCHEMA, producer_installation_ref: this.installation, producer_epoch: this.epoch, next_sequence: 1, pending: {} };
-    }
+  submissionRefOf(envelope) {
+    return envelope.submission_ref;
   }
-  async writeState(state) {
-    await mkdir3(this.store.directory, { recursive: true, mode: 448 });
-    const temp = `${this.statePath}.${process.pid}.new`;
-    await writeFile(temp, JSON.stringify(state), { mode: 384 });
-    await rename2(temp, this.statePath);
+  expiresAtOf(envelope) {
+    return envelope.expires_at;
+  }
+  createdAtOf(envelope) {
+    return envelope.created_at;
+  }
+  async mapEnvelope(envelope) {
+    const prompt = observation(envelope, "prompt");
+    if (prompt !== void 0) return this.mapInput(envelope, prompt);
+    return [mapTerminal(envelope)];
+  }
+  async mapInput(envelope, prompt) {
+    const drafts = [];
+    const session = observation(envelope, "session");
+    if (session !== void 0) {
+      const registrations = await this.store.listTranscriptRegistrations();
+      const registration = registrations.find((item) => item.host_source_ref === envelope.identity.host_source_ref && item.host_session_ref === envelope.identity.host_session_ref);
+      const directoryIdentity = registration?.cwd ?? envelope.identity.host_session_ref;
+      drafts.push({
+        frame_kind: "session_started",
+        payload: compact({
+          local_session_ref: envelope.identity.host_session_ref,
+          working_directory_ref: claudeWorkspaceRef(directoryIdentity),
+          model: recordText(session.value, "model"),
+          observations: [session]
+        })
+      });
+    }
+    const turn = observation(envelope, "turn");
+    if (turn !== void 0) drafts.push({
+      frame_kind: "turn_started",
+      payload: compact({
+        local_session_ref: envelope.identity.host_session_ref,
+        local_turn_ref: localTurnRef(envelope),
+        observations: [turn]
+      })
+    });
+    if (!isCealHostPromptObservationValue(prompt.value)) throw new ClaudeHostError("storage", "Claude prompt observation is malformed.");
+    drafts.push({
+      frame_kind: "user_input",
+      payload: compact({
+        local_session_ref: envelope.identity.host_session_ref,
+        local_turn_ref: localTurnRef(envelope),
+        local_input_ref: envelope.host_input_ref,
+        input_kind: envelope.input_kind,
+        origin_input: envelope.origin_input,
+        observations: [prompt],
+        context_expires_at: envelope.expires_at
+      })
+    });
+    return drafts;
   }
 };
-function decodeState(value, installation, epoch) {
-  if (!validStateHeader(value, installation)) throw new ClaudeHostError("storage", `Claude producer state header is malformed or belongs to another installation (${refusalFacts([
-    { name: "schema_version", value: record6(value) ? value.schema_version : void 0, expected: STATE_SCHEMA },
-    { name: "producer_installation_ref", value: record6(value) ? value.producer_installation_ref : void 0, expected: installation }
-  ])}).`);
-  if (Number(value.producer_epoch) > epoch) throw new ClaudeHostError("storage", `Claude producer state epoch is ahead of this installation (${refusalFact("producer_epoch", value.producer_epoch, `at most ${epoch}`)}).`);
-  const pending = {};
-  for (const [ref, frames] of Object.entries(value.pending)) {
-    if (!SAFE_REF4.test(ref) || !Array.isArray(frames) || frames.length === 0) throw new ClaudeHostError("storage", "Claude producer reservation is malformed.");
-    pending[ref] = frames.map((frame) => decodeFrame(frame, installation, Number(value.producer_epoch)));
-  }
-  return { schema_version: STATE_SCHEMA, producer_installation_ref: installation, producer_epoch: epoch, next_sequence: Number(value.next_sequence), pending };
-}
-function validStateHeader(value, installation) {
-  return record6(value) && value.schema_version === STATE_SCHEMA && value.producer_installation_ref === installation && positiveInteger(value.producer_epoch) && positiveInteger(value.next_sequence) && record6(value.pending);
-}
-function positiveInteger(value) {
-  return Number.isSafeInteger(value) && Number(value) > 0;
+function mapTerminal(envelope) {
+  const usage = envelope.observations.filter((item) => ["token", "cost"].includes(item.observation_kind));
+  return {
+    frame_kind: "turn_terminal",
+    payload: compact({
+      local_session_ref: envelope.identity.host_session_ref,
+      local_turn_ref: localTurnRef(envelope),
+      terminal_state: "completed",
+      usage: usage.length === 0 ? void 0 : Object.fromEntries(usage.map((item) => [item.observation_kind, item.value])),
+      observations: envelope.observations
+    })
+  };
+}
+function observation(envelope, kind) {
+  return envelope.observations.find((item) => item.observation_kind === kind);
+}
+function localTurnRef(envelope) {
+  return envelope.identity.host_turn_ref;
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== void 0));
 }
-function decodeFrame(value, installation, epoch) {
-  const json = Buffer.from(JSON.stringify(value));
-  const encoded = Buffer.allocUnsafe(json.length + 4);
-  encoded.writeUInt32BE(json.length, 0);
-  json.copy(encoded, 4);
-  const frame = decodeHostProducerFrame(encoded);
-  if (frame.producer_id !== "claude" || frame.producer_installation_ref !== installation || frame.producer_epoch > epoch) throw new ClaudeHostError("storage", `Claude producer frame identity is malformed (${refusalFacts([{ name: "producer_id", value: frame.producer_id, expected: "claude" }, { name: "producer_installation_ref", value: frame.producer_installation_ref, expected: installation }, { name: "producer_epoch", value: frame.producer_epoch, expected: `at most ${epoch}` }])}).`);
-  return frame;
+function asRecord(value) {
+  return isRecord3(value) ? value : void 0;
 }
-function record6(value) {
+function recordText(value, key) {
+  const record6 = asRecord(value);
+  return typeof record6?.[key] === "string" ? record6[key] : void 0;
+}
+function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function code2(error) {
-  return record6(error) && typeof error.code === "string" ? error.code : null;
+
+// host/service-log.ts
+function writeHostServiceDiagnostic(producer_id, event, failure_kind) {
+  try {
+    process.stderr.write(`${JSON.stringify({ schema_version: CEAL_HOST_SERVICE_DIAGNOSTIC_SCHEMA, producer_id, event, ...event === "watcher_scan_failed" && failure_kind !== void 0 ? { failure_kind } : {} })}
+`);
+  } catch {
+  }
 }
+var HOST_SERVICE_LOG_MAX_BYTES = 1024 * 1024;
+var HOST_SERVICE_LOG_TAIL_BYTES = 64 * 1024;
 
 // host/claude/src/claude-producer-runtime.ts
 async function drainClaudeProducerOnce(options) {
-  return new ClaudeProducer({ outbox_dir: options.outbox_dir, producer_installation_ref: options.producer_installation_ref, relay: new HostRelayIpcAdmissionPort(options.relay_endpoint, options.timeout_ms), ...options.producer_epoch === void 0 ? {} : { producer_epoch: options.producer_epoch } }).drainOutbox();
+  const promptPort = new HostRelayCurrentPromptPort(options.relay_endpoint, options.timeout_ms);
+  const scan = await new ClaudeTranscriptWatcher({
+    outbox_dir: options.outbox_dir,
+    producer_installation_ref: options.producer_installation_ref,
+    register_current_prompt: (input) => promptPort.register(input),
+    diagnostic: (event, failure_kind) => writeHostServiceDiagnostic("claude", event, failure_kind)
+  }).scanOnce().catch((error) => {
+    writeHostServiceDiagnostic("claude", "watcher_scan_failed", claudeTranscriptScanFailureKind(error));
+    throw error;
+  });
+  const producer = new ClaudeProducer({ outbox_dir: options.outbox_dir, producer_installation_ref: options.producer_installation_ref, relay: new HostRelayIpcAdmissionPort(options.relay_endpoint, options.timeout_ms), ...options.producer_epoch === void 0 ? {} : { producer_epoch: options.producer_epoch }, ...options.now === void 0 ? {} : { now: options.now } });
+  return { scanned: scan.enqueued, ...await producer.drainOutbox() };
 }
 
 // host/claude/src/claude-hook-runner.ts
-import { homedir } from "node:os";
-import { join as join4 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join6 } from "node:path";
 
 // host/producer-service.ts
 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
@@ -2571,7 +3982,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 };
 }
@@ -2587,19 +3998,24 @@ function assertHostProducerSourcePaths(stateRoot, config, producer, platform = p
 
 // host/producer-service.ts
 import { constants } from "node:fs";
-import { lstat as lstat2, open as open3 } from "node:fs/promises";
-var SAFE_REF5 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+import { lstat as lstat2, open as open5 } from "node:fs/promises";
+var SAFE_REF4 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 var HOST_PRODUCER_CONFIG_FLAG = "--ceal-host-config";
 var HostProducerServiceError = class extends Error {
   code;
-  constructor(code3, message = code3) {
-    super(message === code3 ? code3 : `${code3}: ${message}`);
+  constructor(code2, message = code2) {
+    super(message === code2 ? code2 : `${code2}: ${message}`);
     this.name = "HostProducerServiceError";
-    this.code = code3;
+    this.code = code2;
   }
 };
 var HOST_PRODUCER_CONFIG_KEYS = ["schema_version", "host_source_ref", "producer_installation_ref", "producer_epoch", "outbox_dir", "relay_endpoint"];
 var HOST_PRODUCER_TIMING_DEFAULTS = Object.freeze({ reconcile_interval_ms: 250, retry_backoff_ms: 1e3, ipc_timeout_ms: 5e3 });
+function hostProducerExtraPath(extras, key) {
+  const value = extras[key];
+  if (value === void 0) throw hostProducerError("invalid_config");
+  return value;
+}
 function parseHostProducerConfigFlag(args, platform = process.platform) {
   return parseProducerHostConfigFlag(args, HOST_PRODUCER_CONFIG_FLAG, platform, hostProducerError);
 }
@@ -2620,8 +4036,8 @@ function decodeHostProducerConfigText(descriptor, text, platform = process.platf
   const { extra_paths: extras, ...core } = decoded;
   return Object.freeze(descriptor.config({ schema_version: descriptor.schema, ...core }, extras));
 }
-function hostProducerError(code3, message = code3) {
-  return new HostProducerServiceError(code3, message);
+function hostProducerError(code2, message = code2) {
+  return new HostProducerServiceError(code2, message);
 }
 function parseProducerHostConfigFlag(args, flag, platform, error) {
   const prefix = `${flag}=`;
@@ -2648,10 +4064,10 @@ async function readProducerConfigText(configPath, platform, error) {
 }
 function decodeProducerConfigCore(text, options) {
   const value = parseCanonicalJson(text, options.error);
-  if (!isRecord2(value) || !hasConfigKeys(value, options.keys) || value.schema_version !== options.schema) throw options.error("invalid_config");
+  if (!isRecord4(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 = validateIdentity2(hostSourceRef, installationRef, value.producer_epoch, options.error);
+  const producerEpoch = validateIdentity3(hostSourceRef, installationRef, value.producer_epoch, options.error);
   assertProducerAbsolutePath(value.outbox_dir, options.platform, "runtime", options.error);
   assertProducerRelayEndpoint(value.relay_endpoint, options.platform, options.error);
   const extraPaths = {};
@@ -2693,7 +4109,7 @@ function validateConfigFile(value, platform, error) {
 }
 async function openConfigFile(configPath, flags, error) {
   try {
-    return await open3(configPath, flags);
+    return await open5(configPath, flags);
   } catch {
     throw error("config_unavailable");
   }
@@ -2732,8 +4148,8 @@ function firstDifferenceIndex(left, right) {
   for (let index = 0; index < shared; index += 1) if (left[index] !== right[index]) return index;
   return shared;
 }
-function validateIdentity2(sourceRef, installationRef, epoch, error) {
-  if (!SAFE_REF5.test(sourceRef) || !SAFE_REF5.test(installationRef) || !positive2(epoch, 2147483647)) throw error("invalid_config");
+function validateIdentity3(sourceRef, installationRef, epoch, error) {
+  if (!SAFE_REF4.test(sourceRef) || !SAFE_REF4.test(installationRef) || !positive2(epoch, 2147483647)) throw error("invalid_config");
   return epoch;
 }
 function validateIntervals(reconcile, retry, timeout, error) {
@@ -2743,7 +4159,7 @@ function validateIntervals(reconcile, retry, timeout, error) {
 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 isRecord2(value) {
+function isRecord4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function positive2(value, maximum) {
@@ -2755,10 +4171,12 @@ function boundedMilliseconds(value) {
 
 // host/claude/src/claude-producer-service.ts
 var CLAUDE_PRODUCER_CONFIG_SCHEMA = "ceal.claude_producer_config.v1";
+var CLAUDE_TRANSCRIPTS_ROOT = "claude_transcripts_root";
 var CLAUDE_PRODUCER_DESCRIPTOR = {
   schema: CLAUDE_PRODUCER_CONFIG_SCHEMA,
   producer_id: "claude",
-  config: (shared) => shared,
+  extra_paths: [CLAUDE_TRANSCRIPTS_ROOT],
+  config: (shared, extras) => ({ ...shared, claude_transcripts_root: hostProducerExtraPath(extras, CLAUDE_TRANSCRIPTS_ROOT) }),
   runtime_options: (config) => Object.freeze({
     outbox_dir: config.outbox_dir,
     producer_installation_ref: config.producer_installation_ref,
@@ -2778,39 +4196,38 @@ function claudeHookEventFromArgs(args) {
   const value = args.find((arg) => arg.startsWith("--ceal-hook-event="))?.slice("--ceal-hook-event=".length);
   return isClaudeHookEvent(value) ? value : null;
 }
-async function runClaudeHookProcess(args, stdin, options) {
-  const event = claudeHookEventFromArgs(args);
-  if (event === null) return 0;
+async function runClaudeHook(event, stdin, options) {
   try {
     const result = await runClaudeHookFromStdin(event, stdin, options);
-    if (result.disposition === "rejected") writeClaudeHookDiagnostic(result);
+    if (result.disposition === "rejected") writeHostServiceDiagnostic("claude", "hook_failed");
+    else if (result.reason === "transcript_registered") writeHostServiceDiagnostic("claude", "registration_written");
     return 0;
-  } catch (error) {
-    writeClaudeHookDiagnostic({ event, disposition: "rejected", reason: error instanceof Error ? error.message.slice(0, 128) : "claude_hook_failed" });
+  } catch {
+    writeHostServiceDiagnostic("claude", "hook_failed");
     return 0;
   }
 }
-function writeClaudeHookDiagnostic(result) {
+async function runClaudeHookCli() {
+  const args = process.argv.slice(2);
+  const event = claudeHookEventFromArgs(args);
+  if (event === null) return 0;
+  writeHostServiceDiagnostic("claude", "hook_invoked");
   try {
-    process.stderr.write(`${JSON.stringify({ schema_version: "ceal.claude_sessionstart_diagnostic.v1", event: result.event, disposition: result.disposition, ...result.reason === void 0 ? {} : { reason: result.reason } })}
-`);
+    const options = hasHostConfigArgument(args) ? await installedClaudeHookRunnerOptions(args) : standaloneClaudeHookRunnerOptions();
+    return runClaudeHook(event, process.stdin, options);
   } catch {
+    writeHostServiceDiagnostic("claude", "hook_failed");
+    return 0;
   }
 }
-async function runClaudeHookCli() {
-  const args = process.argv.slice(2);
-  const options = hasHostConfigArgument(args) ? await installedClaudeHookRunnerOptions(args) : standaloneClaudeHookRunnerOptions();
-  return runClaudeHookProcess(args, process.stdin, options);
-}
 async function installedClaudeHookRunnerOptions(args) {
   const config = await readHostProducerConfig(CLAUDE_PRODUCER_DESCRIPTOR, parseHostProducerConfigFlag(args));
-  const port = new HostRelayCurrentPromptPort(config.relay_endpoint, config.ipc_timeout_ms);
-  const options = { outbox_dir: config.outbox_dir, producer_installation_ref: config.producer_installation_ref, register_current_prompt: (input) => port.register(input) };
+  const options = { outbox_dir: config.outbox_dir, claude_transcripts_root: config.claude_transcripts_root };
   Object.defineProperty(options, "host_source_ref", { value: config.host_source_ref, enumerable: false });
   return options;
 }
 function standaloneClaudeHookRunnerOptions() {
-  return { outbox_dir: process.env.CEAL_CLAUDE_OUTBOX_DIR ?? join4(homedir(), ".claude", ".ceal", "claude-observation-outbox") };
+  return { outbox_dir: process.env.CEAL_CLAUDE_OUTBOX_DIR ?? join6(homedir2(), ".claude", ".ceal", "claude-observation-outbox"), claude_transcripts_root: process.env.CLAUDE_CONFIG_DIR !== void 0 ? join6(process.env.CLAUDE_CONFIG_DIR, "projects") : join6(homedir2(), ".claude", "projects") };
 }
 function hasHostConfigArgument(args) {
   return args.some((argument) => argument === HOST_PRODUCER_CONFIG_FLAG || argument.startsWith(`${HOST_PRODUCER_CONFIG_FLAG}=`));
@@ -2842,6 +4259,7 @@ var DOCTOR_FLAGS = Object.freeze({
 var execFileAsync = promisify(execFile);
 
 // host/claude/src/claude-installer.ts
+var ACTIVE_CLAUDE_HOOK_EVENTS = new Set(CLAUDE_HOOK_EVENTS);
 var CLAUDE_LOCAL_CAPABILITY_ACTIVATION = Object.freeze({ environment: "CLAUDE_CODE_ENTRYPOINT", value: "cli" });
 var CLAUDE_CLIENT_ALLOW_RULE = `Bash(${CEAL_SESSION_ENTRY_INVOCATION}:*)`;