@corca-org/ceal-host-linux-arm64 1.0.5 → 1.0.6

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

@@ -0,0 +1,2680 @@
+#!/usr/bin/env node
+import { createRequire as __cealCreateRequire } from "node:module";
+const require = __cealCreateRequire(import.meta.url);
+
+// packages/ceal-client-protocol/src/canonical-json.ts
+function cealCanonicalJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("Ceal canonical JSON does not support non-finite numbers.");
+    return JSON.stringify(value);
+  }
+  if (value === void 0) throw new TypeError("Ceal canonical JSON does not support undefined values.");
+  if (Array.isArray(value)) {
+    const entries = [];
+    for (let index = 0; index < value.length; index += 1) {
+      if (!Object.hasOwn(value, index)) throw new TypeError("Ceal canonical JSON does not support sparse arrays.");
+      entries.push(cealCanonicalJson(value[index]));
+    }
+    return `[${entries.join(",")}]`;
+  }
+  if (!isPlainRecord(value)) throw new TypeError("Ceal canonical JSON only supports JSON data.");
+  return `{${Object.keys(value).sort(cealCompareOrdered).map((key) => `${JSON.stringify(key)}:${cealCanonicalJson(value[key])}`).join(",")}}`;
+}
+function cealCompareOrdered(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function isPlainRecord(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// packages/ceal-client-protocol/client-wire-contract.json
+var client_wire_contract_default = {
+  schema_version: "ceal.client_wire_contract.v1",
+  canonical_json: {
+    ordering: "utf16_code_unit_ascending"
+  },
+  artifact_descriptor: {
+    operation_contract_bundle_schema_version: "ceal.operation_contract_bundle.v1",
+    schema_version: "ceal.verified_artifact_descriptor.v1",
+    binding_schema_version: "ceal.verified_artifact_binding.v1",
+    kind: "verified_artifact",
+    binding_kind: "catalog",
+    media_type: "application/json",
+    digest: {
+      algorithm: "sha256",
+      encoding: "lowercase_hex",
+      length: 64,
+      pattern: "^[a-f0-9]{64}$"
+    },
+    catalog_revision: {
+      prefix: "catalog:",
+      digest_length: 64,
+      length: 72,
+      pattern: "^catalog:[a-f0-9]{64}$"
+    },
+    max_bytes: 4194304,
+    envelope_max_bytes: 389
+  },
+  command_request: {
+    schema_version: "ceal.command_request.v1",
+    absolute_transport_max_bytes: 65536
+  },
+  command_response: {
+    schema_version: "ceal.command_response.v1",
+    descriptor_field: "verified_artifact",
+    required_fields: [
+      "schema_version",
+      "exit_code",
+      "document"
+    ],
+    optional_fields: [
+      "verified_artifact"
+    ],
+    bare_document_fields: [
+      "invocation",
+      "next",
+      "common_concepts",
+      "operations",
+      "catalog_revision"
+    ],
+    exit_code_max: 125,
+    bare_document_max_bytes: 65536,
+    complete_max_bytes: 66019,
+    absolute_transport_max_bytes: 4194304
+  }
+};
+
+// packages/ceal-client-protocol/src/client-wire-contract.ts
+var CEAL_CLIENT_WIRE_CONTRACT = Object.freeze(client_wire_contract_default);
+var artifact = CEAL_CLIENT_WIRE_CONTRACT.artifact_descriptor;
+var request = CEAL_CLIENT_WIRE_CONTRACT.command_request;
+var response = CEAL_CLIENT_WIRE_CONTRACT.command_response;
+var CEAL_OPERATION_CONTRACT_BUNDLE_SCHEMA_VERSION = artifact.operation_contract_bundle_schema_version;
+var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_SCHEMA_VERSION = artifact.schema_version;
+var CEAL_VERIFIED_ARTIFACT_BINDING_SCHEMA_VERSION = artifact.binding_schema_version;
+var CEAL_VERIFIED_ARTIFACT_KIND = artifact.kind;
+var CEAL_VERIFIED_ARTIFACT_BINDING_KIND = artifact.binding_kind;
+var CEAL_VERIFIED_ARTIFACT_MEDIA_TYPE = artifact.media_type;
+var CEAL_VERIFIED_ARTIFACT_DIGEST_LENGTH = artifact.digest.length;
+var CEAL_VERIFIED_ARTIFACT_DIGEST_PATTERN = artifact.digest.pattern;
+var CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_LENGTH = artifact.catalog_revision.length;
+var CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_PATTERN = artifact.catalog_revision.pattern;
+var CEAL_VERIFIED_ARTIFACT_MAX_BYTES = artifact.max_bytes;
+var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_MAX_BYTES = artifact.envelope_max_bytes;
+var CEAL_COMMAND_REQUEST_SCHEMA_VERSION = request.schema_version;
+var CEAL_COMMAND_REQUEST_MAX_BYTES = request.absolute_transport_max_bytes;
+var CEAL_COMMAND_RESPONSE_BARE_DOCUMENT_FIELDS = response.bare_document_fields;
+var CEAL_COMMAND_RESPONSE_BARE_DOCUMENT_MAX_BYTES = response.bare_document_max_bytes;
+var CEAL_COMMAND_RESPONSE_MAX_BYTES = response.absolute_transport_max_bytes;
+
+// packages/ceal-client-protocol/src/vocabulary.ts
+function vocabulary(words) {
+  return Object.freeze(words);
+}
+
+// packages/ceal-client-protocol/src/operation-contract-types.ts
+var CEAL_JSON_SCHEMA_2020_12 = "https://json-schema.org/draft/2020-12/schema";
+var CEAL_OPERATION_ERROR_SCHEMA_VERSION = "ceal.operation_error.v1";
+var CEAL_JSON_SCHEMA_TYPES = vocabulary(["object", "array", "string", "integer", "number", "boolean", "null"]);
+var OBSERVATION_POSTURES = vocabulary(["direct_readback", "approved_no_readback", "operator_mediated", "excluded"]);
+var EFFECT_DOMAINS = vocabulary(["none", "gateway_state", "provider", "external_world"]);
+var SAFETY_CLASSES = vocabulary(["routine", "sensitive", "high_impact"]);
+var IDEMPOTENCY_CLASSES = vocabulary(["idempotent", "conditionally_idempotent", "non_idempotent"]);
+var REVERSIBILITY_CLASSES = vocabulary(["none", "reversible", "compensatable", "irreversible"]);
+var COMPENSATION_OWNERS = vocabulary(["none", "connector", "operator"]);
+var CANCELLATION_BOUNDARIES = vocabulary(["before_admission", "before_handoff", "after_handoff_reconcile"]);
+var HANDOFF_CLASSES = vocabulary(["not_applicable", "submission", "effect"]);
+var AUTHORITATIVE_READBACK_CLASSES = vocabulary(["required", "unavailable"]);
+var PROVIDER_READBACK_CLASSES = vocabulary(["required", "not_available", "not_applicable"]);
+var RECONCILIATION_CLASSES = vocabulary(["none", "automatic", "operator"]);
+var NO_READBACK_APPROVAL_CLASSES = vocabulary(["not_applicable", "explicit", "operator"]);
+var REPLAY_PREREQUISITES = vocabulary(["never", "fresh_admission", "reconciled_non_application", "operator_approval"]);
+var UNKNOWN_OUTCOMES = vocabulary(["reconcile", "operator_action", "excluded"]);
+var RECOVERY_OWNERS = vocabulary(["gateway", "connector", "operator"]);
+var CEAL_OPERATION_ADMISSION_STATES = vocabulary(["proposed", "refused", "admitted"]);
+var CEAL_OPERATION_EXECUTION_STATES = vocabulary(["not_started", "started", "completed"]);
+var CEAL_OPERATION_PROVIDER_HANDOFF_STATES = vocabulary(["not_offered", "offered", "accepted", "rejected", "unknown"]);
+var CEAL_OPERATION_EFFECT_STATES = vocabulary(["none", "applied", "failed", "unknown", "compensated"]);
+var CEAL_OPERATION_OBSERVATION_STATES = vocabulary(["not_started", "not_required", "pending", "observed", "unavailable"]);
+var CEAL_OPERATION_RECOVERY_KINDS = vocabulary(["none", "reconcile", "compensate", "operator_action"]);
+var CEAL_OPERATION_RECOVERY_STATUSES = vocabulary(["not_started", "active", "completed"]);
+var CEAL_OPERATION_PROVIDER_READBACK_AVAILABILITY = vocabulary(["not_started", "not_applicable", "not_available", "pending", "available"]);
+var CEAL_OPERATION_OFFERED_HANDOFF_STATES = vocabulary(["accepted", "rejected", "unknown"]);
+var CEAL_OPERATION_RECEIPT_AUTHORITY_KEYS = Object.freeze(["instance_ref", "profile_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]);
+var CEAL_OPERATION_APPROVAL_DISPOSITIONS = vocabulary([
+  "approval_not_required_by_policy",
+  "interactive_pending",
+  "interactive_granted",
+  "interactive_denied",
+  "interactive_expired",
+  "interactive_unavailable"
+]);
+
+// packages/ceal-client-protocol/src/gateway-response-types.ts
+var CEAL_CAPABILITY_READINESS_VALUES = vocabulary(["ready", "degraded", "unavailable", "unknown"]);
+var CEAL_TARGET_REQUIREMENTS = vocabulary(["required", "optional", "none"]);
+var CEAL_AUDIT_OUTCOMES = vocabulary(["succeeded", "denied", "failed"]);
+var CEAL_GATEWAY_PROVIDER_STEP_OUTCOMES = vocabulary(["completed", "rejected", "throttled", "failed"]);
+var CEAL_POLICY_DECISIONS = vocabulary(["allowed", "denied", "not_evaluated"]);
+var CEAL_CONNECTOR_ROUTE_PHASES = vocabulary(["scope_observation", "target_selection", "route_resolution"]);
+var CEAL_CONNECTOR_ROUTE_CAUSES = vocabulary(["provider_throttled", "provider_unavailable", "binding_invalid", "scope_limit_exceeded"]);
+var CEAL_WRITE_SOURCE_KINDS = vocabulary(["authenticated_registered_client", "agent_lease_admission", "provider_authenticated_event"]);
+var CEAL_REFRESH_DELIVERIES = vocabulary(["initial", "recovery", "replay", "terminal_failure", "recovery_unavailable"]);
+var CEAL_CLIENT_OPERATIONS = vocabulary(["handshake", "discover", "call", "readback"]);
+var CEAL_WRITE_IDEMPOTENCY_POSTURES = vocabulary(["required", "optional", "not_required"]);
+var CEAL_WRITE_PROVIDER_READBACK_POSTURES = vocabulary(["required", "best_effort", "not_available"]);
+var CEAL_WRITE_ATTRIBUTIONS = vocabulary(["subject", "requester_event", "connector_integration"]);
+var CEAL_PROTOCOL_VERSION = "1.4.0";
+var CEAL_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["connector_kind", "phase", "schema_version"]);
+var CEAL_CLASSIFIED_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["cause", ...CEAL_CONNECTOR_ROUTE_FAILURE_KEYS]);
+var CEAL_UNCLASSIFIED_CONNECTOR_ROUTE_FAILURE_KEYS = vocabulary(["connector_kind", "error_class", "phase", "schema_version"]);
+
+// packages/ceal-client-protocol/src/gateway-validation-primitives.ts
+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;
+  }
+};
+var SAFE_REF = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var MAX_SAFE_TOKEN_LENGTH = 64;
+var SAFE_CODE = new RegExp(`^[a-z][a-z0-9_]{0,${MAX_SAFE_TOKEN_LENGTH - 1}}$`, "u");
+var SAFE_CONNECTOR_KIND = new RegExp(`^[a-z][a-z0-9-]{0,${MAX_SAFE_TOKEN_LENGTH - 1}}$`, "u");
+var FORBIDDEN_SECRET_KEY = /^(?:[a-z0-9_]*(?:token|secret|password|credential(?:s)?|private_?key)|api_?key|authorization|bearer|raw_?provider_?payload|provider_?payload)$/iu;
+var FORBIDDEN_AUTHORITY_KEY = /^(?:actor_?ref|owner_?ref|registration_?ref|runner_?ref|auth_?decision|policy_?decision|host_?decision)$/iu;
+var TEXT_ENCODER = new TextEncoder();
+var CEAL_WIRE_SAFE_TEXT_MAX_BYTES = 8 * 1024;
+function assertSafeJsonValue(value, options, depth = 0, count = { value: 0 }) {
+  count.value += 1;
+  if (depth > 8 || count.value > (options.maxNodes ?? 512)) invalidByContext(options);
+  if (value === null || typeof value === "boolean") return;
+  if (typeof value === "number") return assertSafeJsonNumber(value, options);
+  if (typeof value === "string") return assertSafeJsonString(value, options);
+  if (Array.isArray(value)) {
+    return assertSafeJsonArray(value, options, depth, count);
+  }
+  assertSafeJsonRecord(requireRecord(value), options, depth, count);
+}
+function assertSafeJsonNumber(value, options) {
+  if (!Number.isFinite(value)) invalidByContext(options);
+}
+function assertSafeJsonString(value, options) {
+  if (byteLength(value) > CEAL_WIRE_SAFE_TEXT_MAX_BYTES || firstDisallowedControl(value, "multi_line") !== null) invalidByContext(options);
+}
+function assertSafeJsonArray(value, options, depth, count) {
+  if (value.length > 128) invalidByContext(options);
+  for (const item of value) assertSafeJsonValue(item, options, depth + 1, count);
+}
+function assertSafeJsonRecord(record6, options, depth, count) {
+  const entries = Object.entries(record6);
+  if (entries.length > 128) invalidByContext(options);
+  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);
+    if (key === "rows" && sourceUrlColumn !== null) {
+      assertSafeJsonCompactRows(child, sourceUrlColumn, options, depth, count);
+      continue;
+    }
+    assertSafeJsonRecordChild(key, child, options, depth, count);
+  }
+}
+function assertSafeJsonRecordChild(key, child, options, depth, count) {
+  if (options.allowResultContent && (key === "text" || key === "text_preview")) {
+    if (!isSafeResultContent(child, key)) invalidByContext(options);
+    return;
+  }
+  if ((key === "url" || key === "source_url") && options.allowHttpsUrl && isSafeExternalHttpsUrl(child)) return;
+  assertSafeJsonValue(child, options, depth + 1, count);
+}
+function compactSourceUrlColumn(fields) {
+  if (!Array.isArray(fields)) return null;
+  const index = fields.indexOf("source_url");
+  return index < 0 ? null : index;
+}
+function assertSafeJsonCompactRows(value, sourceUrlColumn, options, depth, count) {
+  if (!Array.isArray(value) || value.length > 128) invalidByContext(options);
+  for (const row of value) {
+    if (!Array.isArray(row) || row.length > 128) invalidByContext(options);
+    for (const [index, cell] of row.entries()) {
+      if (index === sourceUrlColumn && (cell === null || isSafeExternalHttpsUrl(cell))) continue;
+      assertSafeJsonValue(cell, options, depth + 2, count);
+    }
+  }
+}
+function isSafeNegativeMaterialAssertion(key, value) {
+  return key === "credential_material_included" && value === false;
+}
+function assertSafeJsonKey(key, options) {
+  const invalid2 = !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(key) || FORBIDDEN_SECRET_KEY.test(key) || options.forbidAuthorityKeys && FORBIDDEN_AUTHORITY_KEY.test(key);
+  if (invalid2) invalidByContext(options);
+}
+function isSafeExternalHttpsUrl(value) {
+  if (!isSafeExternalHttpsUrlInput(value)) return false;
+  try {
+    const url = new URL(value);
+    return isSafeExternalHttpsUrlShape(url);
+  } catch {
+    return false;
+  }
+}
+function isSafeExternalHttpsUrlInput(value) {
+  return typeof value === "string" && byteLength(value) <= 2048;
+}
+function isSafeExternalHttpsUrlShape(url) {
+  return url.protocol === "https:" && url.username === "" && url.password === "" && url.hash === "";
+}
+function isSafeResultContent(value, key) {
+  const maximum = key === "text" ? 8192 : 1024;
+  return typeof value === "string" && byteLength(value) <= maximum && firstDisallowedControl(value, "multi_line") === null;
+}
+function normalizeCealSingleLineText(value) {
+  return value.split("").map((character) => hasControlCharacter(character) ? " " : character).join("").trim();
+}
+function byteLength(value) {
+  return TEXT_ENCODER.encode(value).byteLength;
+}
+var LAYOUT_CODE_POINTS = [9, 10, 13];
+function firstDisallowedControl(value, shape) {
+  let index = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    const laysOutALine = shape === "multi_line" && LAYOUT_CODE_POINTS.includes(codePoint);
+    if (!laysOutALine && (codePoint <= 31 || codePoint === 127)) return { codePoint, index };
+    index += character.length;
+  }
+  return null;
+}
+function hasControlCharacter(value) {
+  return firstDisallowedControl(value, "single_line") !== null;
+}
+var AUTHORITY_METADATA_SUFFIX = "(?:_(?:refs?|revisions?|versions?|generations?|ids?))*$";
+var UNDECLARED_AUTHORITY_STATE_KEY = new RegExp(`(?:^|_)(?:decisions?|authority|grants?|policy|policies|scopes?|tokens?|credentials?|secrets?|permissions?|roles?)${AUTHORITY_METADATA_SUFFIX}`, "iu");
+var UNDECLARED_HANDLE_REF_KEY = new RegExp(`(?:^|_)refs?${AUTHORITY_METADATA_SUFFIX}`, "iu");
+function requireRecord(value) {
+  if (!isCealJsonRecord(value)) invalidRequestOrResponse();
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) invalidRequestOrResponse();
+  return value;
+}
+function isCealJsonRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var CEAL_VALIDATION_STATUSES = vocabulary(["not_applicable", "valid", "invalid"]);
+var CEAL_PARSE_STATUSES = vocabulary(["not_applicable", "parsed", "parse_failed"]);
+function invalidByContext(options) {
+  if (options.forbidAuthorityKeys) invalidRequest();
+  invalidResponse();
+}
+var InvalidWireShapeError = class extends Error {
+};
+function invalidRequestOrResponse() {
+  throw new InvalidWireShapeError();
+}
+function invalidRequest() {
+  throw new CealProtocolValidationError("invalid_gateway_request");
+}
+function invalidResponse() {
+  throw new CealProtocolValidationError("invalid_client_response");
+}
+
+// packages/ceal-client-protocol/src/refusal-fact.ts
+var REFUSAL_VALUE_MAX_CHARS = 160;
+function renderText(value) {
+  return normalizeCealSingleLineText(value);
+}
+var REFUSAL_LIST_HEAD = 5;
+var REFUSAL_FACTS_MAX_CHARS = 360;
+var REFUSAL_SENTENCE_MAX_BYTES = 384;
+var REFUSAL_CLOSING_MAX_BYTES = REFUSAL_SENTENCE_MAX_BYTES / 2;
+function refusalFact(name, value, expected) {
+  const rendered = `${JSON.stringify(name)}=${renderRefusalValue(value)}`;
+  return expected === void 0 ? rendered : `${rendered}; expected ${cut(renderText(expected))}`;
+}
+function refusalFacts(facts) {
+  const joined = facts.map((fact) => refusalFact(fact.name, fact.value, fact.expected)).join("; ");
+  return joined.length <= REFUSAL_FACTS_MAX_CHARS ? joined : `${joined.slice(0, REFUSAL_FACTS_MAX_CHARS)}...(+${joined.length - REFUSAL_FACTS_MAX_CHARS} chars, ${facts.length} facts)`;
+}
+function renderRefusalValue(value) {
+  if (typeof value === "object" && value !== null) return renderStructure(value);
+  if (typeof value === "string") return cut(JSON.stringify(renderText(value)));
+  if (typeof value === "function") return `function ${value.name === "" ? "(anonymous)" : value.name} -- a fact must be a value`;
+  if (typeof value === "symbol") return value.toString();
+  if (typeof value === "bigint") return `${value}n`;
+  return String(value);
+}
+function renderStructure(value) {
+  if (Array.isArray(value)) return cut(renderList(value));
+  if (value instanceof Error) return `${value.name}${"code" in value && typeof value.code === "string" ? `(${value.code})` : ""}`;
+  if (value instanceof Date) return value.toISOString();
+  if (ArrayBuffer.isView(value)) return `<${value.byteLength} bytes>`;
+  return renderRecord(value);
+}
+function renderRecord(value) {
+  if (value instanceof Map) return cut(renderList([...value].map(([key, entry]) => `${renderRefusalValue(key)}=${renderRefusalValue(entry)}`), true));
+  if (value instanceof Set) return cut(renderList([...value]));
+  if (isStatRecord(value)) return `{"mode":"0o${Number(value.mode).toString(8)}","size":${Number(value.size)},"kind":"${statKind(value)}"}`;
+  return cut(renderText(JSON.stringify(value, serializable) ?? String(value)));
+}
+function statKind(value) {
+  if (value.isDirectory()) return "directory";
+  return value.isFile() ? "file" : "other";
+}
+function isStatRecord(value) {
+  return "mode" in value && (typeof value.mode === "number" || typeof value.mode === "bigint") && "size" in value && (typeof value.size === "number" || typeof value.size === "bigint") && "isDirectory" in value && typeof value.isDirectory === "function" && "isFile" in value && typeof value.isFile === "function";
+}
+function serializable(_key, entry) {
+  if (typeof entry === "bigint") return `${entry}n`;
+  return ArrayBuffer.isView(entry) ? `<${entry.byteLength} bytes>` : entry;
+}
+function renderList(value, rendered = false) {
+  const head = value.slice(0, REFUSAL_LIST_HEAD).map((item) => rendered ? String(item) : renderRefusalValue(item));
+  const rest = value.length - head.length;
+  return `[${head.join(", ")}${rest > 0 ? `, ...${rest} more` : ""}] (${value.length} items)`;
+}
+function cut(text) {
+  return text.length <= REFUSAL_VALUE_MAX_CHARS ? text : `${text.slice(0, REFUSAL_VALUE_MAX_CHARS)}...(+${text.length - REFUSAL_VALUE_MAX_CHARS} chars)`;
+}
+
+// packages/ceal-client-protocol/src/safe-json-budget.ts
+var SAFE_JSON_MIN_BYTES_PER_NODE = 4;
+function safeJsonNodeBudgetForBytes(maxBytes) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < SAFE_JSON_MIN_BYTES_PER_NODE) {
+    throw new RangeError(`safe-JSON byte cap is invalid: ${refusalFact("maxBytes", maxBytes, `at least ${SAFE_JSON_MIN_BYTES_PER_NODE} bytes`)}`);
+  }
+  return Math.floor(maxBytes / SAFE_JSON_MIN_BYTES_PER_NODE);
+}
+
+// packages/ceal-client-protocol/src/protocol-bounds.ts
+var CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES = 64 * 1024;
+var CEAL_PROTOCOL_RESPONSE_VALUE_MAX_NODES = safeJsonNodeBudgetForBytes(CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES);
+var OPERATION_SCHEMA_LITERAL_MAX_BYTES = CEAL_PROTOCOL_RESPONSE_VALUE_MAX_BYTES / 4;
+var CEAL_OPERATION_JSON_SCHEMA_BUDGET = Object.freeze({
+  max_depth: 8,
+  max_properties: 96,
+  max_string_length: OPERATION_SCHEMA_LITERAL_MAX_BYTES / 4,
+  max_alternatives: 8,
+  max_enum_values: 64,
+  max_literal_bytes: OPERATION_SCHEMA_LITERAL_MAX_BYTES,
+  /** @basis our_policy -- bounds explanatory schema prose carried in one catalog. */
+  max_description_characters: 1024,
+  /** @basis our_policy -- bounds regular-expression compilation input from one schema. */
+  max_pattern_characters: 256,
+  /** @basis our_policy -- bounds traversal work inside one already byte-bounded schema literal. */
+  max_literal_nodes: 512
+});
+
+// packages/ceal-client-protocol/src/operation-validation-primitives.ts
+var ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/u;
+function isOperationRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function requireOperationRecord(value, message) {
+  if (!isOperationRecord(value)) throw new TypeError(message);
+}
+function requireClosedValue(value, members, message) {
+  if (typeof value !== "string" || !members.includes(value)) throw new TypeError(message);
+}
+function requireIsoTimestamp(value, message) {
+  if (typeof value !== "string" || !ISO_TIMESTAMP.test(value) || !Number.isFinite(Date.parse(value))) throw new TypeError(message);
+}
+
+// packages/ceal-client-protocol/src/operation-json-schema.ts
+var JSON_DESCRIPTION_CONTROL_CHARACTER = new RegExp("\\p{Cc}", "u");
+
+// packages/ceal-client-protocol/src/operation-contract-validation.ts
+var CEAL_OPERATION_AUTHORITY_POLICY_KEYS = Object.freeze(["profile", "instance_binding", "target", "admission_recheck"]);
+var MAX_OPERATION_INPUT_RESOLVER_BINDINGS = 96;
+var CEAL_OPERATION_RESULT_KEYS = vocabulary(["ok", "operation_id", "operation_receipt", "schema_version", "value"]);
+var CEAL_OPERATION_COMPACT_RESULT_KEYS = vocabulary(["ok", "operation_evidence", "operation_id", "schema_version", "value"]);
+
+// packages/ceal-client-protocol/src/operation-catalog.ts
+var CEAL_OPERATION_CATALOG_SCHEMA_VERSION = "ceal.catalog.v3";
+var CLIENT_AUDIENCES = Object.freeze(["ceal", "cealctl", "agent"]);
+var CLIENT_AUDIENCE_SET = new Set(CLIENT_AUDIENCES);
+
+// packages/ceal-client-protocol/src/schema-literals.ts
+var CEAL_SCHEMA_LITERALS = [
+  "ceal.activation_transport.v1",
+  "ceal.capability_access.v1",
+  CEAL_OPERATION_CATALOG_SCHEMA_VERSION,
+  "ceal.client_refresh_request.v2",
+  "ceal.client_refresh_result.v2",
+  "ceal.client_revoke_request.v1",
+  "ceal.client_revoke_result.v1",
+  CEAL_COMMAND_REQUEST_SCHEMA_VERSION,
+  "ceal.device_enrollment_challenge.v1",
+  "ceal.device_enrollment_challenge_request.v1",
+  "ceal.device_enrollment_hpke_aad.v1",
+  "ceal.device_enrollment_hpke_info.v1",
+  "ceal.device_enrollment_poll.v1",
+  "ceal.device_enrollment_poll_result.v1",
+  "ceal.device_enrollment_proof.v1",
+  "ceal.device_enrollment_start.v1",
+  "ceal.device_enrollment_start_result.v1",
+  "ceal.effect_approval.v1",
+  "ceal.effect_approval_confirmation.v1",
+  "ceal.enrollment_create.v1",
+  "ceal.enrollment_create_result.v1",
+  "ceal.enrollment_exchange.v1",
+  "ceal.enrollment_result.v1",
+  "ceal.first_activation_causal_join.v1",
+  "ceal.gateway_aggregate_authorization_snapshot.v2",
+  "ceal.gateway_announcement_policy.v1",
+  "ceal.gateway_audit_call_detail.v1",
+  "ceal.gateway_audit_event.v1",
+  "ceal.gateway_audit_readback.v1",
+  "ceal.gateway_authorization_snapshot.v1",
+  "ceal.gateway_cache_origin.v1",
+  "ceal.gateway_call_result.v1",
+  "ceal.gateway_command_resolution.v1",
+  "ceal.gateway_connector_route_failure.v1",
+  "ceal.gateway_discovery.v3",
+  "ceal.gateway_handshake.v1",
+  "ceal.gateway_installation_activation_code_issue_request.v1",
+  "ceal.gateway_installation_activation_code_issue_result.v1",
+  "ceal.gateway_installation_activation_code_list_result.v1",
+  "ceal.gateway_installation_activation_code_revoke_request.v1",
+  "ceal.gateway_installation_activation_code_revoke_result.v1",
+  "ceal.gateway_installation_activation_credential.v1",
+  "ceal.gateway_installation_activation_request.v1",
+  "ceal.gateway_installation_active_state.v1",
+  "ceal.gateway_installation_list_result.v1",
+  "ceal.gateway_installation_revoke_request.v1",
+  "ceal.gateway_installation_revoke_result.v1",
+  "ceal.gateway_policy_denial.v1",
+  "ceal.gateway_rate_limit_policy.v1",
+  "ceal.gateway_refresh_audit_detail.v1",
+  "ceal.gateway_scoped_identity_projection.v1",
+  "ceal.gateway_write_receipt_readback.v1",
+  "ceal.gateway_write_request_receipt.v1",
+  "ceal.host_observation.v1",
+  "ceal.host_registration_request.v1",
+  "ceal.host_registration_result.v1",
+  "ceal.leased-resource-stream.v2",
+  "ceal.leased_consumer_attachment_stream_frame.v2",
+  "ceal.leased_consumer_attachment_stream_request.v2",
+  "ceal.leased_consumer_attachment_stream_transport.v2",
+  "ceal.operation_descriptor.v1",
+  "ceal.operation_error.v1",
+  "ceal.operation_failure.v1",
+  "ceal.operation_receipt.v1",
+  "ceal.operation_result.v1",
+  "ceal.operation_result.compact.v1",
+  "ceal.local_result_materialization.v1",
+  "ceal.local_result_root.v1",
+  "ceal.owner_bootstrap_exchange_request.v1",
+  "ceal.owner_bootstrap_exchange_result.v1",
+  "ceal.protocol_negotiation.v1",
+  "ceal.request.v1",
+  "ceal.request_artifact.v1",
+  "ceal.request_cancellation.v1",
+  "ceal.request_graph_revision.v1",
+  "ceal.request_occurrence_correlation.v1",
+  "ceal.request_projection.v1"
+];
+var CEAL_SCHEMA_LITERAL_SET = new Set(CEAL_SCHEMA_LITERALS);
+
+// packages/ceal-client-protocol/src/bounded-series.ts
+import { join } from "node:path";
+var CEAL_BOUNDED_SERIES_CATALOG = Object.freeze({
+  usage_record: (root) => join(root, "run-usage.jsonl"),
+  control_commit: (root) => join(root, "control-auto-commit.jsonl"),
+  engagement_signal: (root) => join(root, "runtime-state", "slack-feedback.jsonl"),
+  runtime_error: (root) => join(root, "runtime-state", "runtime-errors.jsonl"),
+  turn_bridge_request: (root) => join(root, ".ceal", "turn-bridge", "requests.jsonl"),
+  channel_log: (root) => join(root, "log.jsonl"),
+  thread_run_events: (root) => join(root, "run-events.jsonl"),
+  bounded_store_sidecar: (root) => `${root}.jsonl`,
+  gateway_audit_archive: (root) => `${root}.jsonl`,
+  gateway_capability_audit: (root) => join(root, "capability-audit.jsonl"),
+  gateway_retrieval_waste_partition: (root) => `${root}.jsonl`,
+  gateway_access_policy_publication: (root) => join(root, "access-policy-publications.jsonl"),
+  gateway_profile_connector_control_audit: (root) => `${root}.audit.jsonl`,
+  gateway_profile_connector_scope_audit: (root) => join(root, "profile-connector-scope-audit.jsonl"),
+  gateway_profile_connector_activity_scope_audit: (root) => join(root, "profile-connector-activity-scope-audit.jsonl"),
+  gateway_profile_connector_readiness_audit: (root) => join(root, "profile-connector-readiness.audit.jsonl"),
+  gateway_organization_audit_ledger: (root) => join(root, "organization-ledger.jsonl"),
+  gateway_personal_client_audit: (root) => join(root, "audit.jsonl"),
+  gateway_personal_client_access_audit: (root) => join(root, "access-audit.jsonl"),
+  gateway_admin_enrollment: (root) => join(root, "enrollments.jsonl"),
+  gateway_admin_login: (root) => join(root, "logins.jsonl"),
+  gateway_admin_family: (root) => join(root, "families.jsonl"),
+  gateway_admin_refresh_token: (root) => join(root, "refresh-tokens.jsonl"),
+  gateway_admin_access_token: (root) => join(root, "access-tokens.jsonl")
+});
+
+// packages/ceal-client-protocol/src/gateway-installation-activation.ts
+var CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_DATA_CHARACTERS = 32;
+var CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_CHECK_CHARACTERS = 8;
+var CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_COMPACT_CHARACTERS = CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_DATA_CHARACTERS + CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_CHECK_CHARACTERS;
+
+// packages/ceal-client-protocol/src/host-registration.ts
+var CEAL_HOST_REGISTRATION_RESULT_KEYS = Object.freeze(["credential_generation", "host_access_token", "host_installation_ref", "host_source_ref", "ok", "registration_attempt_ref", "schema_version", "status"]);
+
+// packages/ceal-client-protocol/src/agent-session-handoff.ts
+var CEAL_AGENT_ADMISSION_PHASES = vocabulary([
+  "incumbent_admitted",
+  "incumbent_draining",
+  "drained",
+  "candidate_admitted",
+  "candidate_draining",
+  "rollback_admitted"
+]);
+var CEAL_AGENT_SERVICE_SESSION_RECORD_KEYS = vocabulary([
+  "admission_fence",
+  "admission_state",
+  "admission_state_generation",
+  "bearer",
+  "consumer_ref",
+  "credential_generation",
+  "expires_at",
+  "gateway_instance",
+  "gateway_origin",
+  "gateway_serving_generation",
+  "issued_at",
+  "record_sha256",
+  "renew_after",
+  "renew_by",
+  "schema_version",
+  "session_revision"
+]);
+var CEAL_AGENT_SESSION_COMMIT_KEYS = vocabulary(["attempt_ref", "expected_session_revision", "session_revision"]);
+
+// packages/ceal-client-protocol/src/operation-next-actions.ts
+var CALLER_RECOVERABLE_NEXT_ACTION_VALUES = [
+  "select_did_you_mean",
+  // The graph, not the argument list, is what the caller must change: the
+  // resolver that owns this input has no producing node upstream, and no edit
+  // to the invocation can conjure one. `resolver_dependency_absent` carried no
+  // remedy at all rather than borrow a word that means something else, so the
+  // scorer read a fully-diagnosed, caller-fixable refusal as a failed run.
+  "request.graph.append",
+  "choose_new_output_path",
+  "choose_new_idempotency_key",
+  "restart_search",
+  "repeat_original_arguments",
+  "choose_new_request_identity",
+  // A refusal that names the argument (invalid_argument with `property`) tells the caller exactly what to change.
+  "correct_argument",
+  // A resolver-owned input must move from caller operands into the declared
+  // resolver selection field.
+  "supply_resolver_selections",
+  // The graph names an upstream node whose Operation produces the resolver's
+  // occurrence, and it has not produced one yet. The caller runs that node
+  // first; the refusal used to share a code with a malformed resolver result,
+  // which is not fixable, so neither could carry a remedy.
+  "run_resolver_dependency",
+  // A replay carries the input the occurrence durably admitted, and this one
+  // carries a different one. The caller fixes it by presenting the original
+  // invocation, so it is a remedy; the coordinator minted the word at the
+  // replay guard and never declared it, which read as unguided to the scorer.
+  "use_original_input",
+  // The same mismatch on the Request binding rather than the input: the
+  // occurrence was admitted under one binding and the replay presents another.
+  "use_original_request_binding"
+];
+var CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS = Object.freeze(CALLER_RECOVERABLE_NEXT_ACTION_VALUES);
+var NON_REMEDY_NEXT_ACTION_VALUES = [
+  "await_pending_approval",
+  "check_gateway",
+  "inspect_context_store",
+  "inspect_gateway",
+  "inspect_local_cache",
+  // The thin client prints these on its own behalf, before or after the wire.
+  // They were declared only as `CealClientLocalRemedy` keys and, for two of
+  // them, only as Go string literals -- a second and third vocabulary for one
+  // thing. `CealClientLocalRemedy` derives from this list now, so the client's
+  // remedies cannot drift from the words the protocol knows.
+  "inspect_local_client",
+  "inspect_local_command",
+  "inspect_local_output",
+  "inspect_local_route",
+  "inspect_receipt",
+  "inspect_request",
+  "none",
+  "recover",
+  "reconcile",
+  // Reconciliation of one named occurrence, not of the deployment: a legacy
+  // occurrence with no admitted input commitment cannot be replayed safely and
+  // no edit to the call changes that. `reconcile` is the deployment-wide word.
+  "reconcile_occurrence",
+  "reduce_request_size",
+  "repair_or_adopt_session",
+  "request.effect_approval.read",
+  "request.run",
+  "retry",
+  // The owner -- a correlation hook, an approval hook -- is not serving right
+  // now. The caller changes nothing and the same call succeeds once the owner
+  // is back, so this is not a remedy the scorer may count as guidance.
+  "retry_after_owner_recovery",
+  "retry_same_receipt_read",
+  "run_file_search_again",
+  "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 RECOVERABLE = new Set(CEAL_CALLER_RECOVERABLE_NEXT_ACTIONS);
+
+// packages/ceal-client-protocol/src/operation-contract-artifact.ts
+var CATALOG_REVISION = new RegExp(CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_PATTERN, "u");
+var SHA256 = new RegExp(CEAL_VERIFIED_ARTIFACT_DIGEST_PATTERN, "u");
+var CEAL_OPERATION_CONTRACT_REQUIRED_FIELDS = Object.freeze(["input_schema", "result_schema"]);
+var CEAL_OPERATION_CONTRACT_OPTIONAL_FIELDS = Object.freeze(["summary", "input_resolution"]);
+var CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_JSON_SCHEMA = Object.freeze({
+  $schema: CEAL_JSON_SCHEMA_2020_12,
+  $id: "https://ceal.dev/schemas/verified-artifact-descriptor.v1.schema.json",
+  title: "Ceal verified artifact descriptor",
+  type: "object",
+  additionalProperties: false,
+  required: ["schema_version", "kind", "media_type", "byte_count", "sha256", "binding"],
+  properties: {
+    schema_version: { const: CEAL_VERIFIED_ARTIFACT_DESCRIPTOR_SCHEMA_VERSION },
+    kind: { const: CEAL_VERIFIED_ARTIFACT_KIND },
+    media_type: { const: CEAL_VERIFIED_ARTIFACT_MEDIA_TYPE },
+    byte_count: { type: "integer", minimum: 1, maximum: CEAL_VERIFIED_ARTIFACT_MAX_BYTES },
+    sha256: { type: "string", minLength: CEAL_VERIFIED_ARTIFACT_DIGEST_LENGTH, maxLength: CEAL_VERIFIED_ARTIFACT_DIGEST_LENGTH, pattern: CEAL_VERIFIED_ARTIFACT_DIGEST_PATTERN },
+    binding: {
+      type: "object",
+      additionalProperties: false,
+      required: ["schema_version", "kind", "catalog_revision"],
+      properties: {
+        schema_version: { const: CEAL_VERIFIED_ARTIFACT_BINDING_SCHEMA_VERSION },
+        kind: { const: CEAL_VERIFIED_ARTIFACT_BINDING_KIND },
+        catalog_revision: { type: "string", minLength: CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_LENGTH, maxLength: CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_LENGTH, pattern: CEAL_VERIFIED_ARTIFACT_CATALOG_REVISION_PATTERN }
+      }
+    }
+  }
+});
+
+// packages/ceal-client-protocol/src/operation-occurrence.ts
+var MAX_RECEIPT_REVISION = Number.MAX_SAFE_INTEGER - 1;
+
+// packages/ceal-client-protocol/src/leased-resource-stream.ts
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_MAGIC = new Uint8Array([67, 69, 65, 76, 82, 83, 50, 0]);
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_RECORD_PREFIX_BYTES = 8;
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_MAX_HEADER_BYTES = 16 * 1024;
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_CHUNK_BYTES = 64 * 1024;
+var CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_MAX_RECORD_BYTES = CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_RECORD_PREFIX_BYTES + CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_MAX_HEADER_BYTES + CEAL_LEASED_CONSUMER_ATTACHMENT_STREAM_CHUNK_BYTES;
+var CEAL_ATTACHMENT_UNREAD_REASONS = vocabulary(["blocked", "unavailable", "too_large", "unsupported", "download_failed", "digest_mismatch"]);
+
+// packages/ceal-client-protocol/src/request-validation-primitives.ts
+import { createHash } from "node:crypto";
+var DIGEST = /^[a-f0-9]{64}$/u;
+function isCealDigest(value) {
+  return typeof value === "string" && DIGEST.test(value);
+}
+function cealRequestSha256(value) {
+  return createHash("sha256").update(cealCanonicalJson(value), "utf8").digest("hex");
+}
+function operationRecord(value, message) {
+  requireOperationRecord(value, message);
+  return value;
+}
+function invalid(message) {
+  throw new TypeError(message);
+}
+function requirePrefixedRef(value, prefix, message) {
+  if (typeof value !== "string" || !SAFE_REF.test(value) || !value.startsWith(prefix)) invalid(message);
+}
+
+// packages/ceal-client-protocol/src/request-authority.ts
+var CEAL_REQUEST_SCHEMA_VERSION = "ceal.request.v1";
+var CEAL_REQUEST_ARTIFACT_OWNERS = vocabulary(["gateway", "host", "connector"]);
+var CEAL_REQUEST_HOST_BINDING_KEYS = vocabulary(["prompt_ref", "host_session_ref", "host_turn_ref", "host_source_ref"]);
+var CEAL_REQUEST_ARTIFACT_RETENTION_CLASSES = vocabulary(["request", "source", "result"]);
+var CANCELLATION_STATES = vocabulary(["requested", "cancelled"]);
+var CEAL_REQUEST_KEYS = Object.freeze(["schema_version", "ceal_request_ref", "created_at", "authority", "prompt_ref", "host_session_ref", "host_turn_ref", "host_source_ref"]);
+var CEAL_REQUEST_JSON_SCHEMA = {
+  type: "object",
+  maxProperties: 9,
+  additionalProperties: false,
+  properties: {
+    schema_version: { type: "string", const: CEAL_REQUEST_SCHEMA_VERSION, maxLength: 32 },
+    ceal_request_ref: { type: "string", minLength: 1, maxLength: 128, pattern: "^ceal-request:[A-Za-z0-9][A-Za-z0-9._:-]{0,114}$" },
+    created_at: { type: "string", minLength: 1, maxLength: 64 },
+    authority: {
+      type: "object",
+      maxProperties: 5,
+      additionalProperties: false,
+      properties: {
+        instance_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+        profile_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+        principal_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+        execution_subject_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+        authority_revision_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source }
+      },
+      required: ["instance_ref", "profile_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]
+    },
+    prompt_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+    host_session_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+    host_turn_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+    host_input_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
+    host_source_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source }
+  },
+  required: CEAL_REQUEST_KEYS
+};
+
+// packages/ceal-client-protocol/src/request-operands.ts
+var CEAL_REQUEST_MAX_RESOLVER_SELECTIONS = 128;
+var CEAL_REQUEST_MAX_SELECTOR_PROPERTIES = 16;
+var CEAL_REQUEST_MAX_SELECTOR_VALUE_LENGTH = 1024;
+var CEAL_REQUEST_RESOLVER_SELECTION_JSON_SCHEMA = {
+  type: "object",
+  maxProperties: 2,
+  additionalProperties: false,
+  properties: {
+    property: { type: "string", minLength: 1, maxLength: 128 },
+    selectors: {
+      type: "object",
+      maxProperties: CEAL_REQUEST_MAX_SELECTOR_PROPERTIES,
+      properties: {},
+      additionalProperties: { type: "string", minLength: 1, maxLength: CEAL_REQUEST_MAX_SELECTOR_VALUE_LENGTH }
+    }
+  },
+  required: ["property", "selectors"]
+};
+
+// packages/ceal-client-protocol/src/request-graph.ts
+var CEAL_REQUEST_MAX_GRAPH_NODES = 128;
+
+// packages/ceal-client-protocol/src/request-run.ts
+var CEAL_REQUEST_NODE_STANDING_OCCURRENCE_SCHEMA_VERSION = "ceal.request_node_standing_occurrence.v1";
+var CEAL_REQUEST_RUN_BATCH_SCHEMA_VERSION = "ceal.request_run_batch.v3";
+var REQUEST_ACTION_SAFE_REF_SCHEMA = { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source };
+var REQUEST_ACTION_DIGEST_SCHEMA = { type: "string", minLength: 64, maxLength: 64, pattern: "^[a-f0-9]{64}$" };
+var REQUEST_NODE_STANDING_OCCURRENCE_SCHEMA = {
+  type: "object",
+  maxProperties: 9,
+  additionalProperties: false,
+  properties: {
+    schema_version: { type: "string", const: CEAL_REQUEST_NODE_STANDING_OCCURRENCE_SCHEMA_VERSION, maxLength: 64 },
+    node_ref: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    operation_id: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    correlation_ref: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    occurrence_ref: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    graph_revision: { type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER },
+    graph_revision_digest: REQUEST_ACTION_DIGEST_SCHEMA,
+    admitted_input_sha256: REQUEST_ACTION_DIGEST_SCHEMA,
+    reason: { type: "string", minLength: 1, maxLength: 1024 }
+  },
+  required: ["schema_version", "node_ref", "operation_id", "correlation_ref", "occurrence_ref", "graph_revision", "graph_revision_digest", "admitted_input_sha256", "reason"]
+};
+var REQUEST_EXECUTION_PREPARE_REFUSAL_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  maxProperties: 9,
+  properties: {
+    schema_version: { type: "string", const: CEAL_OPERATION_ERROR_SCHEMA_VERSION, maxLength: 64 },
+    code: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    message: { type: "string", minLength: 1, maxLength: 2048 },
+    property: { type: "string", minLength: 1, maxLength: 256 },
+    next_action: REQUEST_ACTION_SAFE_REF_SCHEMA,
+    retryable: { type: "boolean" },
+    repaired_input: {},
+    unrepaired_pointers: { type: "array", maxItems: 128, items: { type: "string", minLength: 1, maxLength: 256 } },
+    provider_handoff: { type: "string", const: "not_offered", maxLength: 32 }
+  },
+  required: ["schema_version", "code", "message", "next_action", "retryable"]
+};
+var CEAL_REQUEST_EXECUTION_ORDERS = vocabulary(["graph_dependency", "caller"]);
+var CEAL_REQUEST_CALL_BUDGET_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  maxProperties: 2,
+  properties: {
+    gateway_calls_so_far: { type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER },
+    floor_for_this_graph: { type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER }
+  },
+  required: ["gateway_calls_so_far", "floor_for_this_graph"]
+};
+var CEAL_REQUEST_RUN_BATCH_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  maxProperties: 5,
+  properties: {
+    schema_version: { type: "string", const: CEAL_REQUEST_RUN_BATCH_SCHEMA_VERSION, maxLength: 64 },
+    order: { enum: [...CEAL_REQUEST_EXECUTION_ORDERS] },
+    nodes: {
+      type: "array",
+      minItems: 1,
+      maxItems: CEAL_REQUEST_MAX_GRAPH_NODES,
+      items: {
+        // The runtime validator owns "exactly one of a result, a refusal
+        // and a standing run". The result envelope already names the
+        // Operation that ran.
+        type: "object",
+        additionalProperties: false,
+        maxProperties: 4,
+        properties: { node_ref: REQUEST_ACTION_SAFE_REF_SCHEMA, result: {}, refusal: REQUEST_EXECUTION_PREPARE_REFUSAL_SCHEMA, standing: REQUEST_ACTION_SAFE_REF_SCHEMA },
+        required: ["node_ref"]
+      }
+    },
+    standing_reading: { type: "string", minLength: 1, maxLength: 512 },
+    call_budget: CEAL_REQUEST_CALL_BUDGET_JSON_SCHEMA
+  },
+  required: ["schema_version", "order", "nodes", "call_budget"]
+};
+
+// packages/ceal-client-protocol/src/host-observation.ts
+var CEAL_HOST_OBSERVATION_REF_PREFIX = "host-observation:";
+function validateCealHostObservationDraft(value) {
+  const record6 = operationRecord(value, "Ceal Host observation draft is invalid.");
+  requirePrefixedRef(record6.observation_ref, CEAL_HOST_OBSERVATION_REF_PREFIX, "Ceal Host observation reference is invalid.");
+  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"]);
+function isCealHostPromptObservationValue(value) {
+  return isOperationRecord(value) && Object.keys(value).length === 1 && isCealDigest(value.body_sha256);
+}
+var HOST_RESERVED_KEY = /^(?:admission|approval|audit|authorization|cancellation|capability|effect|grant|occurrence|operation|policy|profile|provider_readback|receipt|reconciliation|replay|target|write_request)(?:_|$)/iu;
+function assertHostObservationValue(value, kind) {
+  if (value === void 0) invalid("Ceal Host observation value is invalid.");
+  if (kind === "prompt" && !isCealHostPromptObservationValue(value)) invalid("Ceal Host prompt observation must contain only its body digest.");
+  assertSafeJsonValue(value, { forbidAuthorityKeys: true, maxNodes: 512 });
+  if (byteLength(JSON.stringify(value) ?? "") > CEAL_REQUEST_MAX_OBSERVATION_VALUE_BYTES) invalid("Ceal Host observation value is oversized.");
+  inspectHostKeys(value);
+}
+function inspectHostKeys(value) {
+  if (Array.isArray(value)) {
+    for (const entry of value) inspectHostKeys(entry);
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  for (const [key, child] of Object.entries(value)) {
+    if (HOST_RESERVED_KEY.test(key)) invalid("Ceal Host observation cannot restate Gateway-owned facts.");
+    inspectHostKeys(child);
+  }
+}
+
+// packages/ceal-client-protocol/src/request-effect-approval.ts
+var CEAL_EFFECT_APPROVAL_DECISION_CHECK_PHRASES = Object.freeze([
+  "observed after this approval was raised and before it expires",
+  "from this same Host session and Host source",
+  "not the Host input that opened the Request",
+  "an input that has decided no other approval"
+]);
+var CEAL_EFFECT_APPROVAL_DECISION_INSTRUCTION = `Submit exactly one phrase below in a Host input ${CEAL_EFFECT_APPROVAL_DECISION_CHECK_PHRASES.join(", ")}.`;
+
+// packages/ceal-client-protocol/src/request-projection.ts
+var CEAL_REQUEST_STATUSES = vocabulary(["pending", "partial", "completed", "cancelled", "failed", "unknown_effect", "reconciled", "incomplete", "contradiction"]);
+var OWNER_WRITE_STATES = Object.freeze(["attempt_started", "provider_acknowledged", "verified", "outcome_unknown", "reconciled"]);
+var OWNER_EFFECT_STATES = Object.freeze(["none", "applied", "failed", "unknown", "reconciled"]);
+var OWNER_RECEIPT_STATES = Object.freeze(["pending", "available", "failed", "unknown", "reconciled"]);
+
+// packages/ceal-client-protocol/src/request-graph-readiness.ts
+var REQUEST_GRAPH_PRODUCER_TO_APPEND_SCHEMA = {
+  type: "object",
+  maxProperties: 4,
+  additionalProperties: false,
+  properties: {
+    operation_id: { type: "string", minLength: 1, maxLength: 128 },
+    edge_to_node_ref: { type: "string", minLength: 1, maxLength: 128 },
+    edge_from_node_refs: { type: "array", minItems: 1, maxItems: CEAL_REQUEST_MAX_GRAPH_NODES, items: { type: "string", minLength: 1, maxLength: 128 } },
+    remedy: { type: "string", minLength: 1, maxLength: 512 }
+  },
+  required: ["operation_id", "edge_to_node_ref", "remedy"]
+};
+var REQUEST_GRAPH_RESOLVER_CONSUMERS_SCHEMA = {
+  type: "object",
+  maxProperties: 2,
+  additionalProperties: false,
+  properties: {
+    consumer_node_refs: { type: "array", minItems: 1, maxItems: CEAL_REQUEST_MAX_GRAPH_NODES, items: { type: "string", minLength: 1, maxLength: 128 } },
+    remedy: { type: "string", minLength: 1, maxLength: 512 }
+  },
+  required: ["consumer_node_refs", "remedy"]
+};
+var REQUEST_GRAPH_RESOLVER_REUSE_SCHEMA = {
+  type: "object",
+  maxProperties: 3,
+  additionalProperties: false,
+  properties: {
+    reuse_node_ref: { type: "string", minLength: 1, maxLength: 128 },
+    consumer_node_refs: { type: "array", maxItems: CEAL_REQUEST_MAX_GRAPH_NODES, items: { type: "string", minLength: 1, maxLength: 128 } },
+    remedy: { type: "string", minLength: 1, maxLength: 512 }
+  },
+  required: ["reuse_node_ref", "consumer_node_refs", "remedy"]
+};
+var RESOLVER_OWNED_INPUT_SCHEMA = {
+  type: "object",
+  maxProperties: 5,
+  additionalProperties: false,
+  properties: {
+    property: { type: "string", minLength: 1, maxLength: 128 },
+    resolver_operation_id: { type: "string", minLength: 1, maxLength: 128 },
+    resolver_selection_template: CEAL_REQUEST_RESOLVER_SELECTION_JSON_SCHEMA,
+    producing_node_refs: { type: "array", maxItems: CEAL_REQUEST_MAX_RESOLVER_SELECTIONS, items: { type: "string", minLength: 1, maxLength: 128 } },
+    append_producer: REQUEST_GRAPH_PRODUCER_TO_APPEND_SCHEMA
+  },
+  required: ["property", "resolver_operation_id", "producing_node_refs"]
+};
+var USER_OPERANDS_TEMPLATE_SCHEMA = {
+  type: "object",
+  maxProperties: 2,
+  additionalProperties: false,
+  properties: {
+    required_properties: { type: "array", maxItems: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, items: { type: "string", minLength: 1, maxLength: 128 } },
+    operands: { type: "object", properties: {}, maxProperties: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, additionalProperties: {} }
+  },
+  required: ["required_properties", "operands"]
+};
+var CEAL_REQUEST_GRAPH_NODE_PREPARE_READINESS_JSON_SCHEMA = {
+  type: "object",
+  maxProperties: 9,
+  additionalProperties: false,
+  properties: {
+    node_ref: { type: "string", minLength: 1, maxLength: 128 },
+    operation_id: { type: "string", minLength: 1, maxLength: 128 },
+    resolver_owned: { type: "array", maxItems: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, items: RESOLVER_OWNED_INPUT_SCHEMA },
+    gateway_derived: { type: "array", maxItems: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, items: { type: "string", minLength: 1, maxLength: 128 } },
+    result_bound: { type: "array", maxItems: MAX_OPERATION_INPUT_RESOLVER_BINDINGS, items: { type: "string", minLength: 1, maxLength: 128 } },
+    user_operands_template: { type: "array", maxItems: CEAL_OPERATION_JSON_SCHEMA_BUDGET.max_alternatives, items: USER_OPERANDS_TEMPLATE_SCHEMA },
+    unfed_resolver: REQUEST_GRAPH_RESOLVER_CONSUMERS_SCHEMA,
+    redundant_resolver: REQUEST_GRAPH_RESOLVER_REUSE_SCHEMA,
+    standing_occurrence: REQUEST_NODE_STANDING_OCCURRENCE_SCHEMA
+  },
+  required: ["node_ref", "operation_id", "resolver_owned", "gateway_derived"]
+};
+
+// packages/ceal-client-protocol/src/host-invocation-authentication.ts
+var CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA = "ceal.host_invocation_authentication_request.v1";
+var CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA = "ceal.host_invocation_authentication_result.v1";
+var CEAL_HOST_CLIENT_NONCE_PATTERN = /^[A-Za-z0-9_-]{43}$/u;
+var CEAL_HOST_CONTEXT_TOKEN_PATTERN = /^ceal_context_[A-Za-z0-9_-]{43}$/u;
+function decodeCealHostInvocationAuthenticationRequest(value) {
+  if (!isCealJsonRecord(value) || !exactKeys(value, ["schema_version", "client_nonce"]) || value.schema_version !== CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA || typeof value.client_nonce !== "string" || !CEAL_HOST_CLIENT_NONCE_PATTERN.test(value.client_nonce)) {
+    throw new TypeError("The Host invocation authentication request is invalid.");
+  }
+  return Object.freeze({ schema_version: CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA, client_nonce: value.client_nonce });
+}
+function decodeCealHostInvocationAuthenticationResult(value, now = /* @__PURE__ */ new Date()) {
+  if (!isCealJsonRecord(value) || !exactKeys(value, ["schema_version", "context_token", "expires_at"]) || value.schema_version !== CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA || typeof value.context_token !== "string" || !CEAL_HOST_CONTEXT_TOKEN_PATTERN.test(value.context_token) || typeof value.expires_at !== "string" || !validFutureTimestamp(value.expires_at, now)) {
+    throw new TypeError("The Host invocation authentication result is invalid.");
+  }
+  return Object.freeze({ schema_version: CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA, context_token: value.context_token, expires_at: value.expires_at });
+}
+function validFutureTimestamp(value, now) {
+  const timestamp4 = Date.parse(value);
+  return Number.isFinite(timestamp4) && new Date(timestamp4).toISOString() === value && timestamp4 > now.getTime();
+}
+function exactKeys(value, expected) {
+  const keys = Object.keys(value);
+  return keys.length === expected.length && expected.every((key) => Object.hasOwn(value, key));
+}
+
+// packages/ceal-client-protocol/src/client-result-materialization.ts
+var REQUIRED_FIELDS = Object.freeze(["schema_version", "operation_id", "local_path", "content_json_pointer", "size_bytes", "sha256", "read_argv"]);
+var FIELDS = /* @__PURE__ */ new Set([...REQUIRED_FIELDS, "local_result_root", "model_disclosure"]);
+
+// packages/ceal-client-protocol/src/profile-readback.ts
+function cealAuthenticatedProfileReadback(value) {
+  if (!isProfileReadResult(value)) return null;
+  const receipt = value.operation_receipt;
+  if (!isUnaffectingAvailableReceipt(receipt)) return null;
+  const authority = receipt.authority;
+  if (!isCealJsonRecord(authority) || typeof authority.instance_ref !== "string" || typeof authority.profile_ref !== "string") return null;
+  return Object.freeze({ instance_ref: authority.instance_ref, profile_ref: authority.profile_ref });
+}
+function isProfileReadResult(value) {
+  return isCealJsonRecord(value) && value.schema_version === "ceal.operation_result.v1" && value.ok === true && value.operation_id === "profile.read";
+}
+function isUnaffectingAvailableReceipt(value) {
+  return isCealJsonRecord(value) && value.effect === "none" && value.provider_handoff === "not_offered" && isCealJsonRecord(value.terminal) && value.terminal.availability === "available";
+}
+
+// packages/ceal-client-protocol/src/conversation-contracts.ts
+var CEAL_APPROVAL_POLICY_KINDS = vocabulary(["requester_only", "named_users", "role_based"]);
+var CEAL_APPROVAL_TARGET_KINDS = vocabulary([
+  "repo_change",
+  "investigation",
+  "skill_creation",
+  "command_creation",
+  "connector_creation",
+  "generic"
+]);
+var CEAL_PROGRESS_PHASES = vocabulary(["request_review", "information_gathering", "work_execution", "result_check"]);
+
+// packages/ceal-client-protocol/src/gateway-cache-origin-validation.ts
+var CEAL_MAX_CACHE_ORIGIN_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+
+// packages/ceal-client-protocol/src/gateway-write-contract.ts
+var CEAL_GATEWAY_WRITE_CONTRACT_CLOSED_VOCABULARIES = Object.freeze({
+  idempotency: CEAL_WRITE_IDEMPOTENCY_POSTURES,
+  provider_readback: CEAL_WRITE_PROVIDER_READBACK_POSTURES,
+  dry_run: Object.freeze(["supported", "unsupported"]),
+  attribution: CEAL_WRITE_ATTRIBUTIONS,
+  provenance_binding: Object.freeze(["gateway_attested_requester_event_v1"])
+});
+var REQUIRED_KEYS = Object.freeze(["side_effect_class", "idempotency", "provider_readback"]);
+
+// packages/ceal-client-protocol/src/gateway-proof-claims.ts
+var CEAL_GATEWAY_PROOF_AXES = Object.freeze(["host_decision", "provider_execution", "production_audit"]);
+var CEAL_GATEWAY_PROOF_AXIS_NON_CLAIMS = Object.freeze({
+  host_decision: null,
+  provider_execution: "provider_execution_not_reached",
+  production_audit: "production_audit_not_reached"
+});
+var CEAL_PROOF_LEVELS = vocabulary(["surface", "readiness", "worker_queued", "host_decision", "provider_roundtrip"]);
+var CEAL_GATEWAY_HOST_NON_CLAIM_ORDER = Object.freeze(["provider_execution_not_reached", "target_authorization_not_observed", "production_audit_not_reached"]);
+var CEAL_GATEWAY_ANNOUNCEMENT_POLICY_NON_CLAIMS = vocabulary([
+  "policy_projection_does_not_authorize",
+  "provider_roundtrip_not_established_by_discovery",
+  "target_specific_scope_not_declared"
+]);
+
+// packages/ceal-client-protocol/src/gateway-discovery-response-validation.ts
+var ANNOUNCEMENT_POLICY_CAPABILITY_BINDINGS = Object.freeze({
+  "github.repository.get": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "collection.search": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "github.issue.get": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "github.pull_request.get": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "github.workflow_run.get": [{ effect: "read", scopeStatementKind: "github_app_installation_repositories", providerAuthorityKind: "github_app" }],
+  "message.search": [{ effect: "read", scopeStatementKind: "slack_public_app_member_channels_only", providerAuthorityKind: "slack_app" }],
+  "message.get": [{ effect: "read", scopeStatementKind: "slack_public_app_member_channels_only", providerAuthorityKind: "slack_app" }],
+  "resource.resolve": [
+    { effect: "read", scopeStatementKind: "slack_public_app_member_channels_only", providerAuthorityKind: "slack_app" },
+    { effect: "read", scopeStatementKind: "notion_connected_logical_area", providerAuthorityKind: "notion_integration" }
+  ],
+  "conversation.thread.get": [{ effect: "read", scopeStatementKind: "slack_public_app_member_channels_only", providerAuthorityKind: "slack_app" }],
+  "notion.search": [{ effect: "read", scopeStatementKind: "notion_connected_logical_area", providerAuthorityKind: "notion_integration" }],
+  "notion.page.get": [{ effect: "read", scopeStatementKind: "notion_connected_logical_area", providerAuthorityKind: "notion_integration" }],
+  "calendar.availability": [{ effect: "read", scopeStatementKind: "google_workspace_calendar_read_only", providerAuthorityKind: "google_service_account" }],
+  "calendar.event.search": [{ effect: "read", scopeStatementKind: "google_workspace_calendar_read_only", providerAuthorityKind: "google_service_account" }],
+  "calendar.event.get": [{ effect: "read", scopeStatementKind: "google_workspace_calendar_read_only", providerAuthorityKind: "google_service_account" }],
+  "file.search": [{ effect: "read", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_metadata", providerAuthorityKind: "google_service_account" }],
+  "sheets.values.read": [{ effect: "read", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_sheet_ranges", providerAuthorityKind: "google_service_account" }],
+  "sheets.tabs.list": [{ effect: "read", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_sheet_tabs", providerAuthorityKind: "google_service_account" }],
+  "sheets.values.update": [{ effect: "write", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_editable_sheet_ranges", providerAuthorityKind: "google_service_account" }],
+  "sheets.values.clear": [{ effect: "write", scopeStatementKind: "google_workspace_ceal_drive_or_direct_share_editable_sheet_clear_ranges", providerAuthorityKind: "google_service_account" }]
+});
+var ANNOUNCEMENT_SCOPE_STATEMENTS = Object.freeze({
+  github_app_installation_repositories: "Repositories in the installed GitHub App installation.",
+  slack_public_app_member_channels_only: "Public channels where the installed Slack app is a member; private channels, direct messages, multi-person direct messages, and requester membership are not declared by this connector.",
+  notion_connected_logical_area: "Connected Notion logical area under provider-enforced sharing; descendant inventory is not declared.",
+  google_workspace_calendar_read_only: "Approved Calendar availability and event reads only; Calendar mutation is not declared.",
+  google_workspace_ceal_drive_or_direct_share_metadata: "Metadata search for files in the organization shared drive named Ceal Drive and files directly shared with the provider application; file-content read and mutation are not declared.",
+  google_workspace_ceal_drive_or_direct_share_sheet_ranges: "Bounded values reads from governed Google Sheets in the organization shared drive named Ceal Drive and directly shared files; file mutation is not declared.",
+  google_workspace_ceal_drive_or_direct_share_editable_sheet_ranges: "Bounded values updates in governed editable Google Sheets in the organization shared drive named Ceal Drive and directly shared files; Docs, Slides, and other Drive file mutation are not declared.",
+  google_workspace_ceal_drive_or_direct_share_editable_sheet_clear_ranges: "Bounded values clears in governed editable Google Sheets in the organization shared drive named Ceal Drive and directly shared files; Docs, Slides, and other Drive file mutation are 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"]);
+
+// packages/ceal-client-protocol/src/protocol-negotiation.ts
+var CEAL_SUPPORTED_GATEWAY_PROTOCOL_RANGE = Object.freeze({
+  minimum: CEAL_PROTOCOL_VERSION,
+  maximum: CEAL_PROTOCOL_VERSION
+});
+
+// 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_GAP_KINDS = vocabulary(["unknown", "unavailable", "partial"]);
+var ADMIN_UNAVAILABLE_REASONS = vocabulary([
+  "not_recorded",
+  "legacy",
+  "invalid_observation",
+  "redacted",
+  "owner_unavailable",
+  "unit_unknown",
+  "retention_gap",
+  "source_owner_limit"
+]);
+var ADMIN_SOURCE_OWNERS = vocabulary([
+  "request",
+  "operation",
+  "authority",
+  "occurrence",
+  "approval",
+  "audit",
+  "provider_readback",
+  "host_observation",
+  "person",
+  "resource",
+  "prompt",
+  "usage"
+]);
+var ADMIN_COMPLETENESS_STATES = vocabulary(["complete", "partial", "unknown"]);
+var ADMIN_OPERATION_OUTCOMES = vocabulary(["completed", "failed", "denied", "cancelled", "unknown"]);
+var ADMIN_APPROVAL_DISPOSITIONS = CEAL_OPERATION_APPROVAL_DISPOSITIONS;
+var ADMIN_APPROVAL_POSTURES = vocabulary([...ADMIN_APPROVAL_DISPOSITIONS, "not_applicable"]);
+var ADMIN_LINEAGE_NODE_KINDS = vocabulary(["source_read", "synthesis_preview", "approval", "effect", "readback"]);
+
+// packages/ceal-client-protocol/src/actor-kind.ts
+var CEAL_ACTOR_KINDS = vocabulary(["human", "bot", "app", "unknown"]);
+
+// packages/ceal-client-protocol/src/leased-consumer-vocabulary.ts
+var CEAL_TERMINAL_DISPOSITIONS = vocabulary(["completed", "failed", "cancelled"]);
+var CEAL_LEASE_DISPOSITIONS = vocabulary([...CEAL_TERMINAL_DISPOSITIONS, "deferred"]);
+var CEAL_AUTOMATIC_FEEDBACK_INTENTS = vocabulary(["initial"]);
+var CEAL_LEASED_MESSAGE_DELIVERY_CAPABILITY_IDS = vocabulary(["message.create", "message.update", "message.delete"]);
+var CEAL_REPOSITORY_VISIBILITIES = vocabulary(["public", "private", "internal"]);
+var CEAL_RESULT_DELIVERY_OFFERS = vocabulary(["pending", "offered", "transport_lost"]);
+var CEAL_RESULT_DELIVERY_STATES = vocabulary(["unavailable", ...CEAL_RESULT_DELIVERY_OFFERS]);
+var CEAL_PROVIDER_OUTCOMES = vocabulary(["not_attempted", "outcome_unknown", "verified"]);
+var CEAL_ACTIVITY_GAP_CODES = vocabulary([
+  "provider_page_budget",
+  "related_item_budget",
+  "provider_cursor_unavailable",
+  "malformed_provider_page",
+  "visibility_incomplete",
+  "unsupported_event_kind"
+]);
+var CEAL_ACTIVITY_COVERAGE_STATUSES = vocabulary(["complete_for_target", "continuation_required", "blocked"]);
+var CEAL_ACTIVITY_EVENT_KINDS = vocabulary([
+  "slack.message",
+  "slack.reply",
+  "github.commit.authored",
+  "github.issue.opened",
+  "github.pull_request.opened",
+  "github.review.submitted",
+  "github.issue_comment.created",
+  "github.review_comment.created",
+  "calendar.organized",
+  "calendar.accepted_invite",
+  "calendar.recorded"
+]);
+var CEAL_ACTIVITY_TIMESTAMP_BASES = vocabulary([
+  "message_created",
+  "commit_authored",
+  "resource_created",
+  "review_submitted",
+  "comment_created",
+  "event_start",
+  "all_day_start"
+]);
+var CEAL_ARTIFACT_STAGE_TERMINALS = vocabulary(["chunk_accepted", "artifact_ready", "idempotency_replayed"]);
+var CEAL_READ_ITEM_KINDS = vocabulary(["conversation", "identity", "usergroup", "message", "file", "document"]);
+var CEAL_RESOURCE_RESOLVE_KINDS = vocabulary(["conversation", "identity", "usergroup", "permalink"]);
+var CEAL_OPAQUE_HANDLE_KINDS = vocabulary(["target", "message", "thread", "artifact", "document", "object"]);
+var CEAL_WRITE_OBJECT_KINDS = vocabulary(["document", "comment", "cell_range"]);
+var CEAL_CONVERSATION_KINDS = vocabulary(["channel", "dm", "group"]);
+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"]);
+var CEAL_UNREAD_REASONS = vocabulary(["blocked", "unavailable", "too_large", "unsupported", "download_failed", "permission_denied"]);
+var CEAL_PLAN_ITEM_STATUSES = vocabulary(["pending", "active", "completed"]);
+var CEAL_FINAL_PRESENTATION_INTENTS = vocabulary(["final", "stop", "transient_notice"]);
+var CEAL_PRESENTATION_INTENTS = vocabulary(["progress", ...CEAL_FINAL_PRESENTATION_INTENTS]);
+
+// packages/ceal-client-protocol/src/personal-client-vocabulary.ts
+var CEAL_PERSONAL_CLIENT_BINDING_KEYS = vocabulary([
+  "profile_ref",
+  "membership_ref",
+  "registration_ref",
+  "client_ref",
+  "subject_ref",
+  "instance_ref"
+]);
+var CEAL_ENROLLMENT_FAILURE_CODES = vocabulary(["enrollment_invalid", "enrollment_expired", "enrollment_used"]);
+var CEAL_REFRESH_FAILURE_CODES = vocabulary([
+  "refresh_invalid",
+  "refresh_expired",
+  "refresh_inactive",
+  "refresh_replayed",
+  "refresh_revoked",
+  "authority_replaced",
+  "refresh_recovery_unavailable"
+]);
+
+// packages/ceal-client-protocol/src/device-enrollment.ts
+var CEAL_DEVICE_ENROLLMENT_POLL_FAILURE_CODES = Object.freeze(["unsupported_feature", "recovery_required", "expired"]);
+var POLL_RESULT_KEYS = Object.freeze(["retry_after_ms", "schema_version", "status"]);
+
+// packages/ceal-client-protocol/src/personal-client-session.ts
+var REFRESH_FAILURE_CODES = new Set(CEAL_REFRESH_FAILURE_CODES);
+
+// packages/ceal-client-protocol/src/index.ts
+var MAX_REQUEST_BYTES = 32 * 1024;
+var MAX_ARGUMENT_BYTES = 16 * 1024;
+var HANDSHAKE_IDENTITY_KEYS = Object.freeze(["membership_ref", "registration_ref", "client_ref", "subject_ref", "instance_ref"]);
+var AUDIT_IDENTITY_KEYS = Object.freeze(["event_ref", "membership_ref", "registration_ref", "client_ref", "subject_ref", "instance_ref"]);
+var FAILURE_RESPONSE_KEYS = Object.freeze(["error", "ok", "proof_ref_or_unavailable", "protocol_version", "request_id"]);
+var MAX_RECOVERY_RETRY_AFTER_MS = 60 * 60 * 1e3;
+
+// host/invocation-authentication-client-command.ts
+var MAX_DETAIL_CHARACTERS = 240;
+var HOST_OWNED_CODE = /^[a-z][a-z0-9]*(?:_[a-z0-9]+){0,7}$/u;
+function hostTerminalFailure(error, component) {
+  const code3 = errorCode(error);
+  const detail = failureDetail(error);
+  if (code3 === "ENOENT") return { code: "host_dependency_unavailable", message: `A command or file the ${component} Host needs is unavailable: ${detail}`, next_action: "Install the missing dependency or restore the missing file, then rerun this command." };
+  if (code3 === "EACCES" || code3 === "EPERM") return { code: "host_permission_denied", message: `The ${component} Host was refused access to a local path: ${detail}`, next_action: "Repair the ownership or mode of the named path, then rerun this command." };
+  if (code3 === "ENOSPC") return { code: "host_storage_unavailable", message: `The ${component} Host could not write local state: ${detail}`, next_action: "Free local disk space, then rerun this command." };
+  if (code3 !== null && HOST_OWNED_CODE.test(code3)) return { code: code3, message: `The ${component} Host command failed: ${detail}`, next_action: `Resolve the named failure above; run \`ceal-host doctor --json\` only if it reports installed ${component} Host drift.` };
+  return { code: "host_failure_unclassified", message: `The ${component} Host command failed for a cause it cannot classify: ${detail}`, next_action: `Run \`ceal-host doctor --json\`; if it reports no drift then the ${component} Host configuration is not the cause, and the message above is the only evidence of what is.` };
+}
+var DOCTOR_FLAGS = Object.freeze({
+  "--expected-sha256": "expected_sha256",
+  "--expected-source-commit": "expected_source_commit",
+  "--expected-instance-ref": "expected_instance_ref"
+});
+function parseHostClientDoctorOptions(args) {
+  if (args.length % 2 !== 0) return null;
+  const result = {};
+  for (let index = 0; index < args.length; index += 2) {
+    const field = DOCTOR_FLAGS[args[index] ?? ""];
+    const value = args[index + 1];
+    if (field === void 0 || value === void 0 || value.startsWith("-") || result[field] !== void 0) return null;
+    result[field] = value;
+  }
+  return result;
+}
+async function runHostInvocationAuthenticationClientCommand(command, argv, write = writeStdout) {
+  const doctor = argv[0] === "doctor";
+  const schemaVersion = doctor ? command.doctorSchemaVersion : command.authenticationSchemaVersion;
+  try {
+    if (!doctor) return await command.runAuthentication(argv);
+    return await runHostClientDoctor(command, argv.slice(1), write);
+  } catch (error) {
+    write(hostClientFailureLine(schemaVersion, hostTerminalFailure(error, command.component)));
+    return 2;
+  }
+}
+async function runHostClientDoctor(command, args, write) {
+  const options = parseHostClientDoctorOptions(args);
+  if (options === null) {
+    write(hostClientFailureLine(command.doctorSchemaVersion, {
+      code: "invalid_command",
+      message: `The ${command.component} client doctor arguments are invalid.`,
+      next_action: `Run \`${command.executable} doctor\` with optional exact candidate expectations.`
+    }));
+    return 2;
+  }
+  const result = await command.runDoctor(options);
+  write(`${JSON.stringify(result)}
+`);
+  return result.ok ? 0 : 1;
+}
+function hostClientFailureLine(schemaVersion, error) {
+  return `${JSON.stringify({ schema_version: schemaVersion, ok: false, status: "failure", error })}
+`;
+}
+function writeStdout(line) {
+  process.stdout.write(line);
+}
+function failureDetail(error) {
+  const text = error instanceof Error ? `${error.name}: ${error.message}` : typeof error === "string" ? error : "";
+  const safe = normalizeCealSingleLineText(text).slice(0, MAX_DETAIL_CHARACTERS);
+  return safe === "" ? "the command threw no readable error text" : safe;
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
+}
+function hostClientProbe(result, read) {
+  if (result === null) return { kind: "unreachable" };
+  if (result.exit_code !== 0) return { kind: "refused", exit_code: result.exit_code };
+  const value = read(result);
+  return value === null ? { kind: "unreadable" } : { kind: "value", value };
+}
+function hostClientProbeRefusal(probe, subject) {
+  const invocation = `\`ceal ${subject.command}\``;
+  if (probe.kind === "unreachable") return { code: "ceal_execution_failed", message: `The ${invocation} command did not run to completion from the ${subject.component} Host.`, next_action: `Run ${invocation} from that Host and resolve the local execution failure; the installed client bytes were already ${subject.executable_identity}.` };
+  if (probe.kind === "refused") return { code: "ceal_command_refused", message: `The ${invocation} command exited ${probe.exit_code} from the ${subject.component} Host.`, next_action: `Run ${invocation} from that Host and read its own structured failure.` };
+  return { code: "ceal_output_unreadable", message: `The ${invocation} command returned output the ${subject.component} Host cannot read.`, next_action: `Verify the installed Ceal client matches the protocol this ${subject.component} Host expects, then run this doctor again.` };
+}
+
+// host/relay/src/producer-frame.ts
+var HOST_PRODUCER_FRAME_SCHEMA = "ceal.host_producer_frame.v1";
+var HOST_PRODUCER_MAX_JSON_BYTES = 262144;
+var HOST_PRODUCER_FRAME_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
+var SAFE_REF2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var PRODUCERS = /* @__PURE__ */ new Set(["codex", "claude"]);
+var HOST_PRODUCER_FRAME_KINDS = ["session_started", "turn_started", "user_input", "turn_terminal", "producer_status"];
+var FRAME_KINDS = new Set(HOST_PRODUCER_FRAME_KINDS);
+function isHostProducerFrameKind(value) {
+  return typeof value === "string" && FRAME_KINDS.has(value);
+}
+var HostProducerFrameError = class extends Error {
+  code;
+  constructor(code3, message = code3) {
+    super(message);
+    this.code = code3;
+  }
+};
+function encodeHostProducerFrame(frame) {
+  validateFrame(frame);
+  const json = Buffer.from(JSON.stringify(frame), "utf8");
+  if (json.byteLength > HOST_PRODUCER_MAX_JSON_BYTES) throw new HostProducerFrameError("frame_too_large", `frame_too_large: ${refusalFact("frame_bytes", json.byteLength, `at most ${HOST_PRODUCER_MAX_JSON_BYTES}`)}`);
+  const result = Buffer.allocUnsafe(json.byteLength + HOST_PRODUCER_FRAME_LENGTH_BYTES);
+  result.writeUInt32BE(json.byteLength, 0);
+  json.copy(result, HOST_PRODUCER_FRAME_LENGTH_BYTES);
+  return result;
+}
+function decodeHostProducerFrame(input) {
+  if (input.byteLength < HOST_PRODUCER_FRAME_LENGTH_BYTES) throw new HostProducerFrameError("frame_truncated", `frame_truncated: ${refusalFact("frame_bytes", input.byteLength, `at least ${HOST_PRODUCER_FRAME_LENGTH_BYTES}`)}`);
+  const length = input.readUInt32BE(0);
+  if (length > HOST_PRODUCER_MAX_JSON_BYTES) throw new HostProducerFrameError("frame_too_large", `frame_too_large: ${refusalFact("declared_bytes", length, `at most ${HOST_PRODUCER_MAX_JSON_BYTES}`)}`);
+  if (length === 0) throw new HostProducerFrameError("invalid_frame_length");
+  if (input.byteLength !== length + HOST_PRODUCER_FRAME_LENGTH_BYTES) throw new HostProducerFrameError(input.byteLength < length + HOST_PRODUCER_FRAME_LENGTH_BYTES ? "frame_truncated" : "invalid_frame_length");
+  const bytes = input.subarray(HOST_PRODUCER_FRAME_LENGTH_BYTES);
+  const text = new TextDecoder("utf-8", { fatal: true });
+  let value;
+  try {
+    value = JSON.parse(text.decode(bytes));
+  } catch (error) {
+    if (error instanceof TypeError) throw new HostProducerFrameError("invalid_frame_encoding");
+    throw new HostProducerFrameError("frame_truncated");
+  }
+  validateFrame(value);
+  return value;
+}
+function validateFrame(value) {
+  if (!record(value)) throw new HostProducerFrameError("invalid_frame_shape");
+  if (value.schema_version !== HOST_PRODUCER_FRAME_SCHEMA) throw new HostProducerFrameError("unsupported_frame_schema", `unsupported_frame_schema: ${refusalFact("schema_version", value.schema_version, HOST_PRODUCER_FRAME_SCHEMA)}`);
+  if (!exactKeys2(value, ["schema_version", "producer_id", "producer_installation_ref", "producer_epoch", "sequence", "frame_kind", "occurred_at", "payload"])) throw new HostProducerFrameError("invalid_frame_shape");
+  if (!PRODUCERS.has(String(value.producer_id)) || !safeRef(value.producer_installation_ref)) throw new HostProducerFrameError("invalid_producer_identity");
+  if (!positive(value.producer_epoch) || !positive(value.sequence) || !hostProducerFrameKind(value.frame_kind) || !timestamp(value.occurred_at) || !record(value.payload)) throw new HostProducerFrameError("invalid_frame_shape");
+  validatePayload(value.frame_kind, value.payload);
+}
+function validatePayload(kind, value) {
+  const valid = kind === "session_started" ? validSession(value) : kind === "turn_started" ? validTurn(value) : kind === "user_input" ? validInput(value) : kind === "turn_terminal" ? validTerminal(value) : validStatus(value);
+  if (!valid) throw new HostProducerFrameError("invalid_frame_shape");
+}
+function validSession(value) {
+  return exactOptional(value, ["local_session_ref", "working_directory_ref"], ["model", "host_version", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.working_directory_ref) && optionalText(value.model, 256) && optionalText(value.host_version, 256) && validObservations(value.observations);
+}
+function validTurn(value) {
+  return exactOptional(value, ["local_session_ref", "local_turn_ref"], ["model", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && optionalText(value.model, 256) && validObservations(value.observations);
+}
+function validInput(value) {
+  return exactOptional(value, ["local_session_ref", "local_turn_ref", "local_input_ref", "origin_input", "observations"], ["decision", "local_turn_aliases", "context_expires_at"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && safeRef(value.local_input_ref) && validInputObservations(value.observations) && typeof value.origin_input === "boolean" && validInputOptionals(value);
+}
+function validInputObservations(value) {
+  return validObservations(value) && Array.isArray(value) && value.filter((item) => record(item) && item.observation_kind === "prompt").length === 1;
+}
+function validInputOptionals(value) {
+  return validDecision(value.decision) && 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);
+}
+function validTerminalDisposition(state, reason) {
+  return (state === "completed" || state === "aborted") && (reason === void 0 || state === "aborted" && safeRef(reason));
+}
+function validStatus(value) {
+  return exactOptional(value, ["status", "reason_code"], ["detail"]) && ["ready", "degraded", "stopping"].includes(String(value.status)) && safeRef(value.reason_code) && optionalText(value.detail, 4096);
+}
+function validDecision(value) {
+  return value === void 0 || record(value) && exactKeys2(value, ["decision", "approval_ref"]) && (value.decision === "approved" || value.decision === "denied") && safeRef(value.approval_ref);
+}
+function optionalText(value, maxLength) {
+  return value === void 0 || typeof value === "string" && value.length > 0 && value.length <= maxLength;
+}
+function optionalNonNegative(value) {
+  return value === void 0 || typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function optionalRefs(value) {
+  return value === void 0 || Array.isArray(value) && value.length <= 16 && value.every(safeRef);
+}
+function validObservations(value) {
+  if (value === void 0) return true;
+  if (!Array.isArray(value) || value.length > 32) return false;
+  return value.every((item) => {
+    try {
+      validateCealHostObservationDraft(item);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+function jsonValue(value, depth = 0) {
+  if (depth > 16) return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.length <= 256 && value.every((item) => jsonValue(item, depth + 1));
+  return record(value) && Object.keys(value).length <= 256 && Object.entries(value).every(([key, item]) => key.length > 0 && key.length <= 128 && jsonValue(item, depth + 1));
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function safeRef(value) {
+  return typeof value === "string" && SAFE_REF2.test(value);
+}
+function positive(value) {
+  return Number.isSafeInteger(value) && Number(value) > 0;
+}
+function timestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function hostProducerFrameKind(value) {
+  return isHostProducerFrameKind(value);
+}
+function exactKeys2(value, keys) {
+  return JSON.stringify(Object.keys(value).sort()) === JSON.stringify([...keys].sort());
+}
+function exactOptional(value, required, optional) {
+  const keys = Object.keys(value);
+  return required.every((key) => keys.includes(key)) && keys.every((key) => required.includes(key) || optional.includes(key));
+}
+
+// host/relay/src/durable-atomic-replacement.ts
+import { O_RDONLY } from "node:constants";
+import { lstat, mkdir, open, rename, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+var DEFAULT_PORT = {
+  platform: process.platform,
+  mkdir: (path, options) => mkdir(path, options),
+  lstat: (path) => lstat(path),
+  open_file: (path) => open(path, "wx", 384),
+  rename,
+  unlink,
+  open_directory: (path) => open(path, O_RDONLY),
+  unique_ref: () => `${process.pid}.${crypto.randomUUID()}`
+};
+async function durableAtomicReplace(target, data, port = DEFAULT_PORT) {
+  const parent = dirname(target);
+  await port.mkdir(parent, { recursive: true, mode: 448 });
+  const parentStats = await port.lstat(parent);
+  if (!parentStats.isDirectory() || parentStats.isSymbolicLink() || !ownerPrivate(parentStats, port.platform)) throw new TypeError(`Host Relay durable-state directory is unsafe: ${refusalFacts([{ name: "parent_stats", value: parentStats, expected: "an owner-private directory" }, { name: "platform", value: port.platform }])}.`);
+  const temporary = `${target}.${port.unique_ref()}.new`;
+  let staged;
+  const failures = [];
+  try {
+    staged = await port.open_file(temporary);
+    await staged.writeFile(data, typeof data === "string" ? { encoding: "utf8" } : void 0);
+    await staged.sync();
+    const closing = staged;
+    staged = void 0;
+    await closing.close();
+    await port.rename(temporary, target);
+    await syncParentDirectory(parent, port);
+  } catch (error) {
+    failures.push(error);
+  }
+  await closeStaged(staged, failures);
+  await removeTemporary(temporary, port, failures);
+  throwFailures(failures);
+}
+async function syncParentDirectory(path, port) {
+  if (port.platform === "win32") return;
+  const handle = await port.open_directory(path);
+  let failure2;
+  try {
+    await handle.sync();
+  } catch (error) {
+    if (!directorySyncUnsupported(error)) failure2 = error;
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    if (failure2 === void 0) failure2 = error;
+    else failure2 = new AggregateError([failure2, error], "Host Relay directory sync and close failed.");
+  }
+  if (failure2 !== void 0) throw failure2;
+}
+function ownerPrivate(stats, platform) {
+  if (platform === "win32") return true;
+  const uid = typeof process.geteuid === "function" ? process.geteuid() : stats.uid;
+  return stats.uid === uid && (stats.mode & 63) === 0;
+}
+async function closeStaged(staged, failures) {
+  if (staged !== void 0) try {
+    await staged.close();
+  } catch (error) {
+    failures.push(error);
+  }
+}
+async function removeTemporary(path, port, failures) {
+  try {
+    await port.unlink(path);
+  } catch (error) {
+    if (errorCode2(error) !== "ENOENT") failures.push(error);
+  }
+}
+function throwFailures(failures) {
+  if (failures.length === 1) throw failures[0];
+  if (failures.length > 1) throw new AggregateError(failures, "Host Relay durable replacement and cleanup failed.");
+}
+function directorySyncUnsupported(error) {
+  return ["EINVAL", "ENOSYS", "ENOTSUP"].includes(errorCode2(error) ?? "");
+}
+function errorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : null;
+}
+
+// host/relay/src/relay-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 };
+
+// host/relay/src/relay-request-binding-store.ts
+var MAX_STATE_BYTES = 8 * 1024 * 1024;
+
+// host/relay/src/relay-ipc.ts
+import { createConnection, createServer } from "node:net";
+var HOST_RELAY_REQUEST_BINDING_KEYS = Object.freeze([
+  "schema_version",
+  "producer_id",
+  "producer_installation_ref",
+  "local_session_ref",
+  "local_turn_ref",
+  "local_turn_aliases",
+  "prompt_ref",
+  "request_ref",
+  "bound_at",
+  "host_source_ref",
+  "host_session_ref",
+  "host_turn_ref",
+  "host_input_ref"
+]);
+var HOST_RELAY_IPC_RESPONSE_SCHEMA = "ceal.host_relay_admission.v1";
+var HOST_RELAY_BINDING_QUERY_SCHEMA = "ceal.host_relay_binding_query.v1";
+var HOST_RELAY_BINDING_RESULT_SCHEMA = "ceal.host_relay_binding_result.v1";
+var HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA = "ceal.host_relay_invocation_context_query.v1";
+var HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA = "ceal.host_relay_invocation_context_result.v1";
+var HOST_RELAY_IPC_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
+var HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES = 4096;
+var HOST_RELAY_QUERY_RESPONSE_MAX_BYTES = 8192;
+var HostRelayIpcError = class extends Error {
+  code;
+  constructor(code3, message = code3) {
+    super(message);
+    this.code = code3;
+  }
+};
+var HostRelayRequestBindingPort = class {
+  endpoint;
+  timeout_ms;
+  constructor(endpoint, timeoutMs = 5e3) {
+    this.endpoint = endpoint;
+    this.timeout_ms = timeoutMs;
+  }
+  query(input) {
+    return queryHostRelayRequestBinding(this.endpoint, input, this.timeout_ms);
+  }
+  mintInvocationContext(input) {
+    return queryHostRelayInvocationContext(this.endpoint, input, this.timeout_ms);
+  }
+};
+var HostRelayIpcAdmissionPort = class {
+  endpoint;
+  timeout_ms;
+  constructor(endpoint, timeoutMs = 5e3) {
+    this.endpoint = endpoint;
+    this.timeout_ms = timeoutMs;
+  }
+  async admit(frame) {
+    const response2 = await submitHostProducerFrame(this.endpoint, frame, this.timeout_ms);
+    if (!relayAdmissionCode(response2.code)) throw new HostRelayIpcError(response2.code);
+    return { code: response2.code, admitted_through_sequence: response2.admitted_through_sequence, delivered_through_sequence: response2.delivered_through_sequence };
+  }
+};
+function submitHostProducerFrame(endpoint, frame, timeoutMs = 5e3) {
+  return exchange(endpoint, encodeHostProducerFrame(frame), timeoutMs, decodeResponseBuffer);
+}
+async function queryHostRelayRequestBinding(endpoint, query, timeoutMs = 5e3) {
+  const request2 = encodeBindingQuery(query);
+  const response2 = await exchange(endpoint, request2, timeoutMs, decodeBindingResponseBuffer);
+  if (response2.status === "no_binding") return { status: "no_binding" };
+  return { status: "ready", binding: response2.binding };
+}
+function decodeHostRelayBindingQueryResult(value) {
+  if (!validBindingResponse(value)) throw new HostRelayIpcError("relay_unavailable", "Host Relay binding response is invalid.");
+  return value.status === "no_binding" ? { status: "no_binding" } : { status: "ready", binding: value.binding };
+}
+function queryHostRelayInvocationContext(endpoint, query, timeoutMs = 5e3) {
+  return exchange(endpoint, encodeInvocationContextQuery(query), timeoutMs, decodeInvocationContextResponseBuffer);
+}
+function exchange(endpoint, encoded, timeoutMs, decode) {
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(endpoint);
+    let buffer = Buffer.alloc(0);
+    let settled = false;
+    const finish = (error, response2) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      if (error !== null) reject(error);
+      else if (response2 !== void 0) resolve(response2);
+    };
+    socket.setTimeout(timeoutMs, () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC timed out.")));
+    socket.once("error", () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC is unavailable.")));
+    socket.once("connect", () => socket.write(encoded));
+    socket.on("data", (chunk) => {
+      try {
+        buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+        const decoded = decode(buffer);
+        if (decoded !== null) finish(null, decoded);
+      } catch (error) {
+        finish(error instanceof Error ? error : new HostRelayIpcError("relay_unavailable"));
+      }
+    });
+    socket.once("end", () => {
+      if (!settled) finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC closed without a response."));
+    });
+  });
+}
+function decodeHostRelayIpcResponse(input) {
+  if (input.length < HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response is truncated: ${refusalFact("response_bytes", input.byteLength, `at least ${HOST_RELAY_IPC_LENGTH_BYTES}`)}.`);
+  const length = input.readUInt32BE(0);
+  if (length === 0 || length > HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES || input.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response length is invalid: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `between 1 and ${HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES}` }, { name: "received_bytes", value: input.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(HOST_RELAY_IPC_LENGTH_BYTES)));
+  } catch {
+    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC response is invalid.");
+  }
+  if (!validResponse(value)) throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC response shape is invalid.");
+  return value;
+}
+function relayAdmissionCode(value) {
+  return value === "admitted" || value === "already_admitted" || value === "producer_epoch_stale" || value === "sequence_gap" || value === "frame_identity_conflict" || value === "producer_queue_full" || value === "relay_queue_full" || value === "producer_already_connected" || value === "invalid_producer_identity";
+}
+function validResponse(value) {
+  return record2(value) && value.schema_version === HOST_RELAY_IPC_RESPONSE_SCHEMA && hostRelayIpcCode(value.code) && nonnegative(value.admitted_through_sequence) && nonnegative(value.delivered_through_sequence) && Object.keys(value).length === 4;
+}
+function hostRelayIpcCode(value) {
+  return typeof value === "string" && ["admitted", "already_admitted", "producer_epoch_stale", "sequence_gap", "frame_identity_conflict", "producer_queue_full", "relay_queue_full", "invalid_frame_encoding", "invalid_frame_length", "frame_truncated", "unsupported_frame_schema", "invalid_frame_shape", "invalid_producer_identity", "frame_too_large", "producer_already_connected", "relay_unavailable"].includes(value);
+}
+function nonnegative(value) {
+  return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function decodeResponseBuffer(buffer) {
+  if (buffer.length < HOST_RELAY_IPC_LENGTH_BYTES) return null;
+  const length = buffer.readUInt32BE(0);
+  if (length === 0 || length > HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response length is invalid: ${refusalFact("declared_bytes", length, `between 1 and ${HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES}`)}.`);
+  if (buffer.length < length + HOST_RELAY_IPC_LENGTH_BYTES) return null;
+  if (buffer.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC returned trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `the received message length minus ${HOST_RELAY_IPC_LENGTH_BYTES}` }, { name: "received_bytes", value: buffer.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
+  return decodeHostRelayIpcResponse(buffer);
+}
+function decodeBindingResponseBuffer(buffer) {
+  const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_QUERY_RESPONSE_MAX_BYTES);
+  if (value === null) return null;
+  const decoded = decodeHostRelayBindingQueryResult(value);
+  return decoded.status === "no_binding" ? { schema_version: HOST_RELAY_BINDING_RESULT_SCHEMA, status: "no_binding" } : { schema_version: HOST_RELAY_BINDING_RESULT_SCHEMA, status: "ready", binding: decoded.binding };
+}
+function decodeInvocationContextResponseBuffer(buffer) {
+  const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_QUERY_RESPONSE_MAX_BYTES);
+  if (value === null) return null;
+  if (!validInvocationContextResponse(value)) throw new HostRelayIpcError("relay_unavailable", "Host Relay invocation context response is invalid.");
+  return value;
+}
+function encodeBindingQuery(query) {
+  const value = { schema_version: HOST_RELAY_BINDING_QUERY_SCHEMA, ...query };
+  if (!validBindingQueryRequest(value)) throw new HostRelayIpcError("invalid_frame_shape", "Host Relay binding query is invalid.");
+  return encodeLengthPrefixed(value);
+}
+function encodeInvocationContextQuery(query) {
+  const value = { schema_version: HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA, ...query };
+  if (!validInvocationContextQueryRequest(value)) throw new HostRelayIpcError("invalid_frame_shape");
+  return encodeLengthPrefixed(value);
+}
+function validBindingQueryRequest(value) {
+  return validQueryIdentity(value, HOST_RELAY_BINDING_QUERY_SCHEMA) && exactKeys3(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref"]);
+}
+function validInvocationContextQueryRequest(value) {
+  return validQueryIdentity(value, HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) && exactKeys3(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref", "client_nonce"]) && typeof value.client_nonce === "string" && CEAL_HOST_CLIENT_NONCE_PATTERN.test(value.client_nonce);
+}
+function validQueryIdentity(value, schema) {
+  return record2(value) && value.schema_version === schema && (value.producer_id === "codex" || value.producer_id === "claude") && safeRef2(value.producer_installation_ref) && safeRef2(value.local_session_ref) && safeRef2(value.local_turn_ref);
+}
+function validBindingResponse(value) {
+  if (!record2(value) || value.schema_version !== HOST_RELAY_BINDING_RESULT_SCHEMA) return false;
+  if (value.status === "no_binding") return Object.keys(value).length === 2;
+  return value.status === "ready" && Object.keys(value).length === 3 && validWireBinding(value.binding);
+}
+function validInvocationContextResponse(value) {
+  if (!record2(value) || value.schema_version !== HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA) return false;
+  if (value.status === "no_binding") return Object.keys(value).length === 2;
+  if (value.status !== "ready" || Object.keys(value).length !== 3) return false;
+  try {
+    decodeCealHostInvocationAuthenticationResult(value.result);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validWireBinding(value) {
+  if (!record2(value) || value.schema_version !== "ceal.host_relay_request_binding.v1" || value.producer_id !== "codex" && value.producer_id !== "claude") return false;
+  const required = HOST_RELAY_REQUEST_BINDING_KEYS;
+  const keys = Object.keys(value);
+  return required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => required.includes(key) || key === "context_expires_at") && validWireBindingRefs(value) && validWireBindingTimes(value);
+}
+function validWireBindingRefs(value) {
+  const tuple = [value.host_source_ref, value.host_session_ref, value.host_turn_ref, value.host_input_ref];
+  return [value.producer_installation_ref, value.local_session_ref, value.local_turn_ref, value.prompt_ref, value.request_ref].every(safeRef2) && Array.isArray(value.local_turn_aliases) && value.local_turn_aliases.length <= 16 && value.local_turn_aliases.every(safeRef2) && tuple.every(safeRef2);
+}
+function validWireBindingTimes(value) {
+  return validTimestamp(value.bound_at) && (value.context_expires_at === void 0 || validTimestamp(value.context_expires_at));
+}
+function decodeLengthPrefixedJson(input, maximum) {
+  if (input.length < HOST_RELAY_IPC_LENGTH_BYTES) return null;
+  const length = input.readUInt32BE(0);
+  if (length === 0 || length > maximum) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message length is invalid: ${refusalFact("declared_bytes", length, `between 1 and ${maximum}`)}.`);
+  if (input.length < length + HOST_RELAY_IPC_LENGTH_BYTES) return null;
+  if (input.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message has trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `the received message length minus ${HOST_RELAY_IPC_LENGTH_BYTES}` }, { name: "received_bytes", value: input.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(HOST_RELAY_IPC_LENGTH_BYTES)));
+  } catch {
+    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC message is invalid.");
+  }
+}
+function encodeLengthPrefixed(value) {
+  const body = Buffer.from(JSON.stringify(value), "utf8");
+  const output = Buffer.allocUnsafe(body.length + HOST_RELAY_IPC_LENGTH_BYTES);
+  output.writeUInt32BE(body.length, 0);
+  body.copy(output, HOST_RELAY_IPC_LENGTH_BYTES);
+  return output;
+}
+function exactKeys3(value, keys) {
+  return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function safeRef2(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+}
+function validTimestamp(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+
+// host/invocation-authentication-command.ts
+var HOST_INVOCATION_AUTHENTICATION_COMMAND_PREFIX = ["authenticate", "--client-nonce"];
+function installedHostInvocationAuthenticationCommandOptions(config) {
+  const port = new HostRelayRequestBindingPort(config.relay_endpoint, config.ipc_timeout_ms);
+  return {
+    host_source_ref: config.host_source_ref,
+    outbox_dir: config.outbox_dir,
+    producer_installation_ref: config.producer_installation_ref,
+    mint_invocation_context: (input) => port.mintInvocationContext({ ...input, producer_id: input.producer_id })
+  };
+}
+async function runHostInvocationAuthenticationCommand(descriptor, args, options) {
+  let sink = options?.output_sink;
+  try {
+    const resolved = await resolveOptions(descriptor, args, options);
+    sink = resolved.options.output_sink;
+    writeResult(await authenticateHostInvocation(descriptor, resolved.input, resolved.options), sink);
+    return 0;
+  } catch {
+    writeResult({ ok: false, code: "invocation_authentication_unavailable" }, sink);
+    return 2;
+  }
+}
+async function authenticateHostInvocation(descriptor, input, options) {
+  if (input.length !== HOST_INVOCATION_AUTHENTICATION_COMMAND_PREFIX.length + 1 || input[0] !== HOST_INVOCATION_AUTHENTICATION_COMMAND_PREFIX[0] || input[1] !== HOST_INVOCATION_AUTHENTICATION_COMMAND_PREFIX[1]) throw new TypeError("invalid arguments");
+  const request2 = decodeCealHostInvocationAuthenticationRequest({ schema_version: CEAL_HOST_INVOCATION_AUTHENTICATION_REQUEST_SCHEMA, client_nonce: input[2] });
+  const config = validateOptions(options, descriptor.command_name);
+  const now = (config.now ?? (() => /* @__PURE__ */ new Date()))();
+  const { store, current } = await currentInvocation(descriptor, config, now);
+  if (config.mint_invocation_context === void 0) throw new TypeError("mint unavailable");
+  const query = {
+    producer_id: descriptor.producer_id,
+    producer_installation_ref: config.producer_installation_ref,
+    local_session_ref: current.identity.host_session_ref,
+    local_turn_ref: current.identity.host_turn_ref,
+    client_nonce: request2.client_nonce
+  };
+  const response2 = await config.mint_invocation_context(query);
+  if (response2.status !== "ready") throw new TypeError(response2.status);
+  const rechecked = await store.readInvocationContext(current.identity.host_source_ref, current.identity.host_session_ref, (config.now ?? (() => /* @__PURE__ */ new Date()))());
+  if (rechecked === null || !sameTurn(current, rechecked)) throw new TypeError("context replaced");
+  return decodeCealHostInvocationAuthenticationResult(response2.result, now);
+}
+async function currentInvocation(descriptor, config, now) {
+  const store = descriptor.create_store(config.outbox_dir);
+  const identity = resolveIdentity(descriptor, config);
+  if (identity.status !== "ready") throw new TypeError(identity.status);
+  const current = await store.readInvocationContext(identity.identity.host_source_ref, identity.identity.host_session_ref, now);
+  if (current === null || Date.parse(current.expires_at) <= now.getTime()) throw new TypeError("context unavailable");
+  return { store, current };
+}
+function resolveIdentity(descriptor, options) {
+  const sessionId = options.session_id === null ? void 0 : options.session_id ?? process.env[descriptor.session_id_env];
+  if (isHostSessionId(sessionId)) return { status: "ready", identity: { host_source_ref: options.host_source_ref, host_session_ref: descriptor.session_ref(options.host_source_ref, sessionId) } };
+  return { status: "unavailable" };
+}
+async function resolveOptions(descriptor, args, options) {
+  if (options !== void 0) return { input: [...args], options };
+  const configPath = descriptor.parse_config_flag(args);
+  return {
+    input: args.filter((argument) => !argument.startsWith(`${descriptor.config_flag}=`)),
+    options: installedHostInvocationAuthenticationCommandOptions(await descriptor.read_producer_config(configPath))
+  };
+}
+function validateOptions(options, commandName) {
+  if (typeof options.outbox_dir !== "string" || options.outbox_dir.length === 0 || typeof options.host_source_ref !== "string" || !SAFE_REF.test(options.host_source_ref) || typeof options.producer_installation_ref !== "string" || !SAFE_REF.test(options.producer_installation_ref) || !validOptionalSession(options.session_id)) {
+    throw new TypeError(`${commandName} invocation authentication command options are invalid.`);
+  }
+  return options;
+}
+function isHostSessionId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 256 && !value.includes("\0");
+}
+function validOptionalSession(value) {
+  return value === void 0 || value === null || typeof value === "string";
+}
+function sameTurn(left, right) {
+  return left.identity.host_turn_ref === right.identity.host_turn_ref;
+}
+function writeResult(value, sink) {
+  (sink ?? ((document) => process.stdout.write(`${JSON.stringify(document)}
+`)))(value);
+}
+
+// host/producer-service.ts
+import { constants } from "node:fs";
+import { lstat as lstat2, open as open2 } from "node:fs/promises";
+
+// host/absolute-path.ts
+import { posix, win32 } from "node:path";
+function isAbsoluteNormalizedNonRootPath(value, flavor = process.platform, allowRoot = false) {
+  const pathApi = flavor === "win32" || flavor === "windows" ? win32 : posix;
+  return typeof value === "string" && value.length <= 4096 && !value.includes("\0") && pathApi.isAbsolute(value) && pathApi.normalize(value) === value && (allowRoot || pathApi.parse(value).root !== value);
+}
+
+// host/producer-service.ts
+var MAX_CONFIG_BYTES = 32 * 1024;
+var SAFE_REF3 = /^[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}`);
+    this.name = "HostProducerServiceError";
+    this.code = code3;
+  }
+};
+var HOST_PRODUCER_CONFIG_KEYS = ["schema_version", "host_source_ref", "producer_installation_ref", "producer_epoch", "outbox_dir", "relay_endpoint", "reconcile_interval_ms", "retry_backoff_ms", "ipc_timeout_ms"];
+function parseHostProducerConfigFlag(args, platform = process.platform) {
+  return parseProducerHostConfigFlag(args, HOST_PRODUCER_CONFIG_FLAG, platform, hostProducerError);
+}
+async function readHostProducerConfig(descriptor, configPath, platform = process.platform) {
+  return decodeHostProducerConfigText(descriptor, await readProducerConfigText(configPath, platform, hostProducerError), platform);
+}
+function decodeHostProducerConfigText(descriptor, text, platform = process.platform) {
+  const extraPaths = descriptor.extra_paths ?? [];
+  const decoded = decodeProducerConfigCore(text, { schema: descriptor.schema, keys: [...HOST_PRODUCER_CONFIG_KEYS, ...extraPaths], platform, extraPaths, error: hostProducerError });
+  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 parseProducerHostConfigFlag(args, flag, platform, error) {
+  const prefix = `${flag}=`;
+  const values = args.filter((argument) => argument.startsWith(prefix));
+  if (values.length !== 1) throw error("invalid_arguments", refusalFact("config_flags", values, "exactly one"));
+  const value = values[0]?.slice(prefix.length);
+  assertProducerAbsolutePath(value, platform, "config", error);
+  return value;
+}
+async function readProducerConfigText(configPath, platform, error) {
+  assertProducerAbsolutePath(configPath, platform, "config", error);
+  const pathStat = await configPathStat(configPath, error);
+  validateConfigFile(pathStat, platform, error);
+  const noFollow = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+  const handle = await openConfigFile(configPath, constants.O_RDONLY | noFollow, error);
+  try {
+    validateOpenedFile(await handle.stat(), pathStat, platform, error);
+    return await readBoundedConfig(handle, error);
+  } finally {
+    await handle.close();
+  }
+}
+function decodeProducerConfigCore(text, options) {
+  const value = parseCanonicalJson(text, options.error);
+  if (!isRecord(value) || !hasExactKeys2(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 = validateIdentity(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 = {};
+  for (const key of options.extraPaths ?? []) {
+    assertProducerAbsolutePath(value[key], options.platform, "runtime", options.error);
+    extraPaths[key] = value[key];
+  }
+  const intervals = validateIntervals(value.reconcile_interval_ms, value.retry_backoff_ms, value.ipc_timeout_ms, options.error);
+  return {
+    extra_paths: Object.freeze(extraPaths),
+    host_source_ref: hostSourceRef,
+    producer_installation_ref: installationRef,
+    producer_epoch: producerEpoch,
+    outbox_dir: value.outbox_dir,
+    relay_endpoint: value.relay_endpoint,
+    reconcile_interval_ms: intervals[0],
+    retry_backoff_ms: intervals[1],
+    ipc_timeout_ms: intervals[2]
+  };
+}
+function assertProducerRelayEndpoint(value, platform, error) {
+  if (platform === "win32" && typeof value === "string" && /^\\\\\.\\pipe\\[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value)) return;
+  assertProducerAbsolutePath(value, platform, "runtime", error);
+}
+function assertProducerAbsolutePath(value, platform, kind, error) {
+  if (!isAbsoluteNormalizedNonRootPath(value, platform) || /[\r\n]/u.test(value)) throw error(kind === "config" ? "invalid_config_path" : "invalid_config", refusalFact("path", value, "absolute, normalized, non-root, and without line breaks"));
+}
+async function configPathStat(configPath, error) {
+  try {
+    return await lstat2(configPath);
+  } catch {
+    throw error("config_unavailable");
+  }
+}
+function validateConfigFile(value, platform, error) {
+  if (!value.isFile() || value.isSymbolicLink()) throw error("invalid_config", refusalFacts([{ name: "config_is_file", value: value.isFile(), expected: "true" }, { name: "config_is_symlink", value: value.isSymbolicLink(), expected: "false" }]));
+  if (value.size <= 0 || value.size > MAX_CONFIG_BYTES) throw error("invalid_config", refusalFact("config_bytes", value.size, `between 1 and ${MAX_CONFIG_BYTES}`));
+  if (platform !== "win32" && (value.uid !== process.getuid?.() || (value.mode & 63) !== 0)) throw error("config_not_private", refusalFacts([{ name: "platform", value: platform, expected: "win32 or owner-private" }, { name: "config_uid", value: value.uid, expected: "the current user" }, { name: "config_mode", value: value.mode, expected: "owner-private" }]));
+}
+async function openConfigFile(configPath, flags, error) {
+  try {
+    return await open2(configPath, flags);
+  } catch {
+    throw error("config_unavailable");
+  }
+}
+function validateOpenedFile(opened, pathStat, platform, error) {
+  if (!opened.isFile()) throw error("config_unavailable", refusalFacts([{ name: "opened_is_file", value: opened.isFile(), expected: "true" }, { name: "opened_mode", value: opened.mode.toString(8), expected: "a regular file mode" }]));
+  if (platform !== "win32" && (opened.dev !== pathStat.dev || opened.ino !== pathStat.ino)) throw error("config_unavailable", refusalFacts([{ name: "platform", value: platform, expected: "win32, or the same file the path named" }, { name: "opened_device", value: opened.dev, expected: String(pathStat.dev) }, { name: "opened_inode", value: opened.ino, expected: String(pathStat.ino) }]));
+}
+async function readBoundedConfig(handle, error) {
+  const buffer = Buffer.allocUnsafe(MAX_CONFIG_BYTES + 1);
+  const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, 0);
+  if (bytesRead === 0 || bytesRead > MAX_CONFIG_BYTES) throw error("invalid_config", refusalFact("bytes_read", bytesRead, `between 1 and ${MAX_CONFIG_BYTES}`));
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, bytesRead));
+  } catch {
+    throw error("invalid_config");
+  }
+}
+function parseCanonicalJson(text, error) {
+  try {
+    const value = JSON.parse(text);
+    const canonical = JSON.stringify(value);
+    if (canonical !== text.trim()) throw new Error(`noncanonical: ${refusalFacts([{ name: "config_bytes", value: Buffer.byteLength(text.trim(), "utf8"), expected: `the ${Buffer.byteLength(canonical, "utf8")} bytes of its canonical form` }, { name: "first_difference_index", value: firstDifferenceIndex(text.trim(), canonical) }])}`);
+    return value;
+  } catch (parseError) {
+    throw error("invalid_config", refusalFacts([{ name: "parse_error", value: parseError }, { name: "config_bytes", value: Buffer.byteLength(text, "utf8"), expected: "canonical JSON" }]));
+  }
+}
+function firstDifferenceIndex(left, right) {
+  const shared = Math.min(left.length, right.length);
+  for (let index = 0; index < shared; index += 1) if (left[index] !== right[index]) return index;
+  return shared;
+}
+function validateIdentity(sourceRef, installationRef, epoch, error) {
+  if (!SAFE_REF3.test(sourceRef) || !SAFE_REF3.test(installationRef) || !positive2(epoch, 2147483647)) throw error("invalid_config");
+  return epoch;
+}
+function validateIntervals(reconcile, retry, timeout, error) {
+  if (!boundedMilliseconds(reconcile) || !boundedMilliseconds(retry) || !boundedMilliseconds(timeout)) throw error("invalid_config");
+  return [reconcile, retry, timeout];
+}
+function hasExactKeys2(value, keys) {
+  const observed = Object.keys(value);
+  return observed.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function positive2(value, maximum) {
+  return Number.isSafeInteger(value) && Number(value) > 0 && Number(value) <= maximum;
+}
+function boundedMilliseconds(value) {
+  return positive2(value, 6e4) && Number(value) >= 25;
+}
+
+// host/claude/src/claude-decoder.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// host/claude/src/claude-types.ts
+var CLAUDE_HOST_ERROR_CODES = ["invalid_input", "storage", "configuration"];
+function isClaudeHostErrorCode(value) {
+  return typeof value === "string" && CLAUDE_HOST_ERROR_CODES.some((code3) => code3 === value);
+}
+var CLAUDE_OUTBOX_SCHEMA = "ceal.claude_hook_outbox.v1";
+var CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION = "ceal.claude_invocation_context.v1";
+var ClaudeHostError = class extends Error {
+  name = "ClaudeHostError";
+  code;
+  constructor(code3, message) {
+    super(message);
+    if (!isClaudeHostErrorCode(code3)) throw new TypeError("Claude Host error code is invalid.");
+    this.code = code3;
+  }
+};
+
+// host/claude/src/claude-decoder.ts
+var MAX_HOOK_BYTES = 256 * 1024;
+var MAX_TEXT = 128 * 1024;
+function claudeLocalSessionRef(sessionId) {
+  return `claude-session:${digest(sessionId)}`;
+}
+function digest(value) {
+  return createHash2("sha256").update(value, "utf8").digest("hex");
+}
+
+// host/claude/src/claude-outbox.ts
+import { open as open3, mkdir as mkdir2, readdir, readFile, unlink as unlink2 } from "node:fs/promises";
+import { join as join2 } 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 exactKeys4(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 exactKeys4(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.");
+  validateIdentity2(value.identity);
+  validateContextReferences(value);
+  validateContextTimes(value);
+}
+function contextShape(value) {
+  return record3(value) && value.schema_version === CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION && hasHostInvocationContextKeys(value, ["request_ref", "bound_at", "working_directory"]);
+}
+function validateIdentity2(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)) 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 record3(value) && hasHostInvocationIdentityKeys(value) && [value.host_session_ref, value.host_turn_ref, value.host_source_ref].every(safeRef3);
+}
+function optionalSafeRef(value) {
+  return value === void 0 || 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 record3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// host/claude/src/claude-outbox.ts
+var SAFE_REF4 = /^[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");
+  }
+  async prepare() {
+    await mkdir2(this.entries, { recursive: true, mode: 448 });
+    await mkdir2(this.activeContexts, { recursive: true, mode: 448 });
+  }
+  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 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 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"));
+        validateClaudeHostInvocationContext(value);
+        if (Date.parse(value.expires_at) > now.getTime()) contexts.push(value);
+      } catch {
+      }
+    }
+    return contexts;
+  }
+  async put(batch) {
+    validateBatch(batch);
+    await this.prepare();
+    const path = this.path(batch.batch_ref);
+    try {
+      const handle = await open3(path, "wx", 384);
+      try {
+        await handle.writeFile(JSON.stringify(batch));
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+    } 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.");
+    }
+  }
+  async list() {
+    await this.prepare();
+    const batches = [];
+    let malformed = 0;
+    for (const name of await readdir(this.entries)) {
+      if (!name.endsWith(".json")) continue;
+      try {
+        const value = JSON.parse(await readFile(join2(this.entries, name), "utf8"));
+        validateBatch(value);
+        batches.push(value);
+      } catch {
+        malformed += 1;
+      }
+    }
+    batches.sort(compareBatch);
+    return { entries: batches, malformed };
+  }
+  async remove(batch) {
+    try {
+      await unlink2(this.path(batch.batch_ref));
+    } catch (error) {
+      if (code(error) !== "ENOENT") throw error;
+    }
+  }
+  path(ref) {
+    return join2(this.entries, `${cealRequestSha256(ref)}.json`);
+  }
+  activeContextPath(identity) {
+    return join2(this.activeContexts, `${invocationContextKey(identity)}.json`);
+  }
+};
+function validateInvocationContextReadArguments(hostSourceRef, hostSessionRef, now) {
+  if (!SAFE_REF4.test(hostSourceRef) || !SAFE_REF4.test(hostSessionRef) || !(now instanceof Date) || !Number.isFinite(now.getTime())) throw new ClaudeHostError("invalid_input", "Claude Host context identity or clock is invalid.");
+}
+async function readInvocationContextFile(file, hostSourceRef, hostSessionRef, now) {
+  try {
+    const context = JSON.parse(await readFile(file, "utf8"));
+    validateClaudeHostInvocationContext(context);
+    return contextMatches(context, hostSourceRef, hostSessionRef) && Date.parse(context.expires_at) > now.getTime() ? context : null;
+  } 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 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 rank(event) {
+  return event === "SessionStart" ? 0 : event === "UserPromptSubmit" ? 1 : 2;
+}
+function validateBatch(value) {
+  if (!validBatchHeader(value)) throw new ClaudeHostError("storage", "Claude hook batch is malformed.");
+  for (const [index, draft] of value.frames.entries()) {
+    if (!record4(draft) || !hostFrameKind(draft.frame_kind) || !record4(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 validBatchHeader(value) {
+  return record4(value) && value.schema_version === CLAUDE_OUTBOX_SCHEMA && safeRef4(value.batch_ref) && claudeEvent(value.hook_event) && safeRef4(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 claudeEvent(value) {
+  return typeof value === "string" && ["SessionStart", "UserPromptSubmit", "Stop", "StopFailure"].includes(value);
+}
+function hostFrameKind(value) {
+  return isHostProducerFrameKind(value);
+}
+function safeRef4(value) {
+  return typeof value === "string" && SAFE_REF4.test(value);
+}
+function optionalRef(value) {
+  return value === void 0 || typeof value === "string" && SAFE_REF4.test(value);
+}
+function timestamp3(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function record4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function code(error) {
+  return record4(error) && typeof error.code === "string" ? error.code : null;
+}
+
+// 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_REF5 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var ClaudeProducer = class {
+  store;
+  statePath;
+  installation;
+  epoch;
+  options;
+  tail = Promise.resolve();
+  constructor(options) {
+    if (!SAFE_REF5.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;
+  }
+  drainOutbox() {
+    const run = this.tail.then(() => this.drainLocked());
+    this.tail = run.then(() => void 0, () => void 0);
+    return run;
+  }
+  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 };
+  }
+  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;
+  }
+  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 });
+  }
+  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: {} };
+    }
+  }
+  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);
+  }
+};
+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: record5(value) ? value.schema_version : void 0, expected: STATE_SCHEMA },
+    { name: "producer_installation_ref", value: record5(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_REF5.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 record5(value) && value.schema_version === STATE_SCHEMA && value.producer_installation_ref === installation && positiveInteger(value.producer_epoch) && positiveInteger(value.next_sequence) && record5(value.pending);
+}
+function positiveInteger(value) {
+  return Number.isSafeInteger(value) && Number(value) > 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 record5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function code2(error) {
+  return record5(error) && typeof error.code === "string" ? error.code : null;
+}
+
+// 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();
+}
+
+// host/claude/src/claude-producer-service.ts
+var CLAUDE_PRODUCER_CONFIG_SCHEMA = "ceal.claude_producer_config.v1";
+var CLAUDE_PRODUCER_DESCRIPTOR = {
+  schema: CLAUDE_PRODUCER_CONFIG_SCHEMA,
+  config: (shared) => shared,
+  runtime_options: (config) => Object.freeze({
+    outbox_dir: config.outbox_dir,
+    producer_installation_ref: config.producer_installation_ref,
+    producer_epoch: config.producer_epoch,
+    relay_endpoint: config.relay_endpoint,
+    timeout_ms: config.ipc_timeout_ms
+  }),
+  drain: drainClaudeProducerOnce
+};
+
+// host/claude/src/claude-invocation-authentication-command.ts
+var CLAUDE_INVOCATION_AUTHENTICATION_DESCRIPTOR = {
+  command_name: "ceal-claude-invocation-authentication",
+  producer_id: "claude",
+  create_store: (directory) => new ClaudeOutboxStore(directory),
+  session_id_env: "CLAUDE_SESSION_ID",
+  session_ref: (_hostSourceRef, sessionId) => claudeLocalSessionRef(sessionId),
+  config_flag: HOST_PRODUCER_CONFIG_FLAG,
+  parse_config_flag: parseHostProducerConfigFlag,
+  read_producer_config: (configPath) => readHostProducerConfig(CLAUDE_PRODUCER_DESCRIPTOR, configPath)
+};
+function runClaudeInvocationAuthenticationCommand(args, options) {
+  return runHostInvocationAuthenticationCommand(CLAUDE_INVOCATION_AUTHENTICATION_DESCRIPTOR, args, options);
+}
+
+// host/client-doctor.ts
+import { createHash as createHash3 } from "node:crypto";
+import { execFile } from "node:child_process";
+import { access, open as open4, readFile as readFile3, realpath, stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join as join4 } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var GIT_OID = /^[a-f0-9]{40}$/u;
+var SHA2562 = /^[a-f0-9]{64}$/u;
+var SAFE_REF6 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
+var CEAL_ENVIRONMENT_OVERRIDES = ["CEAL_GATEWAY_ORIGIN", "CEAL_GATEWAY_TRANSPORT_ORIGIN", "CEAL_ACCESS_TOKEN", "CEAL_CONTEXT_STORE_PATH"];
+async function doctorClient(options = {}, component) {
+  const environment = canonicalClientEnvironment(options.environment ?? process.env);
+  const run = options.run ?? executeCealCommand;
+  const executableInspection = await inspectExecutable(options, environment, component);
+  if (!executableInspection.ok) return executableInspection.failure;
+  const executable = executableInspection.value;
+  const versionInspection = await inspectVersion(options, executable, environment, run, component);
+  if (!versionInspection.ok) return versionInspection.failure;
+  const version = versionInspection.value;
+  const contextInspection = await inspectCanonicalContext(options, executable, environment, run, component);
+  if (!contextInspection.ok) return contextInspection.failure;
+  const selected = contextInspection.value;
+  const readbackFailure = await inspectAuthenticatedReadback(executable, selected, environment, run, component);
+  if (readbackFailure !== null) return readbackFailure;
+  return {
+    ok: true,
+    status: "ready",
+    executable_path: executable.path,
+    executable_sha256: executable.sha256,
+    version: version.version,
+    source_commit: version.source_commit,
+    source_tree: version.source_tree,
+    context_source: "canonical_user_config",
+    context_name: selected.name,
+    instance_ref: selected.instance_ref,
+    profile_ref: selected.profile_ref,
+    authenticated_readback: "profile.read"
+  };
+}
+async function inspectExecutable(options, environment, component) {
+  let executable;
+  try {
+    executable = await (options.resolve_executable ?? resolveCealExecutable)(options.executable ?? "ceal", environment);
+  } catch (error) {
+    return inspectedFailure("ceal_unavailable", `The ${component} Host cannot resolve an executable Ceal client from its current environment (${refusalFact("error", error)}).`, `Install the intended Ceal client in the Host PATH, restart ${component}, and run this doctor again.`);
+  }
+  if (!validExpectations(options) || options.expected_sha256 !== void 0 && executable.sha256 !== options.expected_sha256) return inspectedFailure("ceal_identity_mismatch", `The Ceal executable visible to the ${component} Host does not match the intended candidate.`, `Install the exact candidate bytes, restart ${component}, and run this doctor with the expected identity.`);
+  return { ok: true, value: executable };
+}
+async function inspectVersion(options, executable, environment, run, component) {
+  const probe = hostClientProbe(await safeRun(run, executable.path, ["version"], environment), (result) => versionIdentity(commandDocument(result)));
+  if (probe.kind !== "value") return probeFailure(probe, "version", component, options);
+  if (options.expected_source_commit !== void 0 && probe.value.source_commit !== options.expected_source_commit) return inspectedFailure("ceal_identity_mismatch", `The Ceal executable visible to the ${component} Host did not return the expected source identity (${refusalFact("source_commit", probe.value.source_commit, `expected ${options.expected_source_commit}`)}).`, `Install the exact candidate, restart ${component}, and verify \`ceal version\` from that Host.`);
+  return { ok: true, value: probe.value };
+}
+function executableIdentity(options) {
+  return options.expected_sha256 === void 0 ? "resolved" : "verified";
+}
+function probeFailure(probe, command, component, options) {
+  const refusal = hostClientProbeRefusal(probe, { component, command, executable_identity: executableIdentity(options) });
+  return inspectedFailure(probeCode(refusal.code), refusal.message, refusal.next_action);
+}
+function probeCode(code3) {
+  if (code3 === "ceal_execution_failed" || code3 === "ceal_command_refused") return code3;
+  return "ceal_output_unreadable";
+}
+async function inspectCanonicalContext(options, executable, environment, run, component) {
+  const probe = hostClientProbe(await safeRun(run, executable.path, ["profile", "list"], environment), (result) => selectedContext(commandDocument(result)));
+  if (probe.kind === "unreachable") return probeFailure(probe, "profile list", component, options);
+  if (probe.kind !== "value" || options.expected_instance_ref !== void 0 && probe.value.instance_ref !== options.expected_instance_ref) return inspectedFailure("canonical_context_unavailable", `The ${component} Host cannot select the intended authenticated context from Ceal's canonical user configuration (${refusalFacts([{ name: "probe_kind", value: probe.kind, expected: "value" }, { name: "instance_ref", value: probe.kind === "value" ? probe.value.instance_ref : "unavailable", expected: options.expected_instance_ref ?? "a selected context" }])}).`, `Run \`ceal session adopt --email <email>\` without CEAL context overrides, then restart ${component}.`);
+  return { ok: true, value: probe.value };
+}
+async function inspectAuthenticatedReadback(executable, selected, environment, run, component) {
+  const result = await safeRun(run, executable.path, ["profile", "show"], environment);
+  if (result !== null && result.exit_code === 0 && readbackProvesSelectedContext(commandDocument(result), selected)) return null;
+  return failure("gateway_context_unavailable", "The canonical Ceal context could not complete an authenticated Gateway readback.", `Inspect the structured \`ceal profile show\` failure, repair or re-adopt the context, then restart ${component} if its environment changed.`);
+}
+function inspectedFailure(code3, message, nextAction) {
+  return { ok: false, failure: failure(code3, message, nextAction) };
+}
+function canonicalClientEnvironment(input) {
+  const environment = { ...input };
+  for (const name of CEAL_ENVIRONMENT_OVERRIDES) delete environment[name];
+  return environment;
+}
+async function resolveCealExecutable(command, environment) {
+  const candidates = isAbsolute(command) ? [command] : (environment.PATH ?? "").split(delimiter).filter((entry) => entry.length > 0).map((entry) => join4(entry, command));
+  for (const candidate of candidates) {
+    try {
+      await access(candidate);
+      const path = await realpath(candidate);
+      const metadata = await stat(path);
+      if (!metadata.isFile()) continue;
+      if (await isLauncher(path)) return resolveLauncherBinary(path, environment);
+      return { path, sha256: createHash3("sha256").update(await readFile3(path)).digest("hex") };
+    } catch {
+    }
+  }
+  throw new Error("ceal executable unavailable");
+}
+async function isLauncher(path) {
+  if (/\.(?:bat|cjs|cmd|js|mjs|ps1)$/u.test(path)) return true;
+  const handle = await open4(path, "r");
+  try {
+    const buffer = Buffer.alloc(128);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, 0);
+    const prefix = buffer.subarray(0, bytesRead).toString("utf8");
+    return prefix.startsWith("#!") && /\bnode\b/u.test(prefix.split("\n", 1)[0] ?? "");
+  } finally {
+    await handle.close();
+  }
+}
+async function resolveLauncherBinary(launcherPath, environment) {
+  const result = await execFileAsync(launcherPath, ["doctor"], { env: environment, timeout: 15e3, encoding: "utf8", windowsHide: false });
+  let parsed;
+  try {
+    parsed = JSON.parse(result.stdout);
+  } catch {
+    throw new Error("launcher doctor returned unreadable output");
+  }
+  if (!isRecord2(parsed) || parsed.schema_version !== "ceal.doctor.v1" || parsed.ok !== true || typeof parsed.binary_path !== "string" || parsed.binary_path.length === 0) throw new Error("launcher doctor did not report a binary path");
+  const binaryPath = await realpath(parsed.binary_path);
+  const metadata = await stat(binaryPath);
+  if (!metadata.isFile()) throw new Error("launcher doctor reported a non-file binary path");
+  return { path: binaryPath, sha256: createHash3("sha256").update(await readFile3(binaryPath)).digest("hex") };
+}
+async function executeCealCommand(executable, args, environment) {
+  try {
+    const result = await execFileAsync(executable, [...args], { env: environment, timeout: 15e3, encoding: "utf8" });
+    return { exit_code: 0, stdout: result.stdout, stderr: result.stderr };
+  } catch (error) {
+    if (isRecord2(error)) return { exit_code: typeof error.code === "number" ? error.code : 1, stdout: typeof error.stdout === "string" ? error.stdout : "", stderr: typeof error.stderr === "string" ? error.stderr : "" };
+    throw error;
+  }
+}
+function safeRun(run, executable, args, environment) {
+  return run(executable, args, environment).catch(() => null);
+}
+function commandDocument(result) {
+  if (result === null) return null;
+  try {
+    const value = JSON.parse(result.stdout);
+    return isRecord2(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function selectedContext(value) {
+  if (value?.schema_version !== "ceal.profile.v1" || value.ok !== true || !Array.isArray(value.contexts)) return null;
+  const selected = value.contexts.filter((item) => isRecord2(item) && item.selected === true);
+  if (selected.length !== 1) return null;
+  return selectedContextRecord(selected[0]);
+}
+function selectedContextRecord(item) {
+  if (!isRecord2(item) || typeof item.name !== "string" || typeof item.instance_ref !== "string" || typeof item.profile_ref !== "string") return null;
+  if (!SAFE_REF6.test(item.instance_ref) || !SAFE_REF6.test(item.profile_ref)) return null;
+  return { name: item.name, instance_ref: item.instance_ref, profile_ref: item.profile_ref };
+}
+function versionIdentity(value) {
+  if (value?.schema_version !== "ceal.version.v1" || value.ok !== true || typeof value.version !== "string" || typeof value.source_commit !== "string" || typeof value.source_tree !== "string") return null;
+  if (value.version.length === 0 || !GIT_OID.test(value.source_commit) || !GIT_OID.test(value.source_tree)) return null;
+  return { version: value.version, source_commit: value.source_commit, source_tree: value.source_tree };
+}
+function readbackProvesSelectedContext(value, selected) {
+  const authority = cealAuthenticatedProfileReadback(value);
+  return authority?.instance_ref === selected.instance_ref && authority.profile_ref === selected.profile_ref;
+}
+function validExpectations(options) {
+  return (options.expected_sha256 === void 0 || SHA2562.test(options.expected_sha256)) && (options.expected_source_commit === void 0 || GIT_OID.test(options.expected_source_commit)) && (options.expected_instance_ref === void 0 || SAFE_REF6.test(options.expected_instance_ref));
+}
+function failure(code3, message, next_action) {
+  return { ok: false, status: "failure", error: { code: code3, message, next_action } };
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// host/claude/src/claude-client-doctor.ts
+var CLAUDE_CLIENT_DOCTOR_SCHEMA_VERSION = "ceal.claude_client_doctor.v1";
+async function doctorClaudeClient(options = {}) {
+  return { schema_version: CLAUDE_CLIENT_DOCTOR_SCHEMA_VERSION, ...await doctorClient(options, "Claude") };
+}
+
+// host/claude/bin/ceal-claude-invocation-authentication.ts
+var CLAUDE_INVOCATION_AUTHENTICATION_CLIENT_COMMAND = {
+  component: "Claude",
+  executable: "ceal-claude-invocation-authentication",
+  authenticationSchemaVersion: CEAL_HOST_INVOCATION_AUTHENTICATION_RESULT_SCHEMA,
+  doctorSchemaVersion: CLAUDE_CLIENT_DOCTOR_SCHEMA_VERSION,
+  runAuthentication: runClaudeInvocationAuthenticationCommand,
+  runDoctor: doctorClaudeClient
+};
+async function main() {
+  return runHostInvocationAuthenticationClientCommand(CLAUDE_INVOCATION_AUTHENTICATION_CLIENT_COMMAND, process.argv.slice(2));
+}
+void main().then((exitCode) => {
+  process.exitCode = exitCode;
+});
+export {
+  CLAUDE_INVOCATION_AUTHENTICATION_CLIENT_COMMAND,
+  main
+};