@corca-org/ceal-host-linux-arm64 1.0.0

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

@@ -0,0 +1,2413 @@
+#!/usr/bin/env node
+
+// host/direct-invocation.ts
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+function isDirectInvocation(importMetaUrl, argv1 = process.argv[1]) {
+  if (!argv1) return false;
+  try {
+    return realpathSync(fileURLToPath(importMetaUrl)) === realpathSync(argv1);
+  } catch {
+    return false;
+  }
+}
+
+// host/claude/src/claude-types.ts
+var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "Stop", "StopFailure"];
+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;
+  }
+};
+function isClaudeHookEvent(value) {
+  return typeof value === "string" && CLAUDE_HOOK_EVENTS.some((event) => event === value);
+}
+
+// host/claude/src/claude-decoder.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// 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_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(record7, options, depth, count) {
+  const entries = Object.entries(record7);
+  if (entries.length > 128) invalidByContext(options);
+  const sourceUrlColumn = options.allowHttpsUrl ? compactSourceUrlColumn(record7.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 invalid3 = !/^[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 (invalid3) 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
+});
+
+// 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-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"),
+  provider_retry: (root) => join(root, "observability", "provider-retry-queue", "queue.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_event_lease_journal: (root) => `${root}.journal.jsonl`,
+  gateway_control_audit: (root) => `${root}.control-audits.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/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:";
+var HOST_OBSERVATION_PRODUCER = /^[a-z][a-z0-9]{0,31}$/u;
+var HOST_OBSERVATION_DIGEST = /^[a-f0-9]{8,64}$/u;
+function cealHostObservationRef(producer, digest2) {
+  if (!HOST_OBSERVATION_PRODUCER.test(producer) || !HOST_OBSERVATION_DIGEST.test(digest2)) invalid("Ceal Host observation reference parts are invalid.");
+  return `${CEAL_HOST_OBSERVATION_REF_PREFIX}${producer}-${digest2}`;
+}
+function validateCealHostObservationDraft(value) {
+  const record7 = operationRecord(value, "Ceal Host observation draft is invalid.");
+  requirePrefixedRef(record7.observation_ref, CEAL_HOST_OBSERVATION_REF_PREFIX, "Ceal Host observation reference is invalid.");
+  requireClosedValue(record7.observation_kind, CEAL_HOST_OBSERVATION_KINDS, "Ceal Host observation kind is invalid.");
+  requireIsoTimestamp(record7.observed_at, "Ceal Host observation time is invalid.");
+  assertHostObservationValue(record7.value, record7.observation_kind);
+}
+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/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/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(["reaction", "progress_start", "progress_finish"]);
+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/claude/src/claude-decoder.ts
+var MAX_HOOK_BYTES = 256 * 1024;
+var MAX_TEXT = 128 * 1024;
+var SESSION_SOURCES = ["startup", "resume", "clear", "compact", "fork"];
+var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+var STOP_FAILURES = ["rate_limit", "overloaded", "authentication_failed", "oauth_org_not_allowed", "account_on_hold", "billing_error", "invalid_request", "model_not_found", "server_error", "max_output_tokens", "unknown"];
+function decodeClaudeHookInput(event, raw) {
+  const rawBytes = Buffer.byteLength(raw, "utf8");
+  if (rawBytes > MAX_HOOK_BYTES) throw invalid2(`Claude hook input is too large (${refusalFact("bytes", rawBytes, `at most ${MAX_HOOK_BYTES} UTF-8 bytes`)}).`);
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw invalid2("Claude hook input is not valid JSON.");
+  }
+  if (!record(value) || value.hook_event_name !== event) throw invalid2(`Claude hook event identity does not match the configured event (${refusalFact("hook_event_name", record(value) ? value.hook_event_name : value, `expected ${event}`)}).`);
+  const common = decodeCommon(value, event);
+  if (event === "SessionStart") return decodeSessionStart(value, common);
+  const promptId = requiredText(value.prompt_id, 256, "Claude turn hook is missing prompt_id.");
+  if (event === "UserPromptSubmit") return decodeUserPrompt(value, common, promptId);
+  return event === "Stop" ? decodeStop(value, common, promptId) : decodeStopFailure(value, common, promptId);
+}
+function decodeSessionStart(value, common) {
+  if (!isSessionSource(value.source)) throw invalid2("Claude SessionStart source is invalid.");
+  const model = optionalText(value.model, 256);
+  return { ...common, hook_event_name: "SessionStart", source: value.source, ...model === void 0 ? {} : { model } };
+}
+function decodeUserPrompt(value, common, promptId) {
+  return { ...common, hook_event_name: "UserPromptSubmit", prompt_id: promptId, prompt: requiredText(value.prompt, MAX_TEXT, "Claude prompt is invalid.") };
+}
+function decodeStop(value, common, promptId) {
+  if (typeof value.stop_hook_active !== "boolean") throw invalid2("Claude Stop state is invalid.");
+  return { ...common, hook_event_name: "Stop", prompt_id: promptId, stop_hook_active: value.stop_hook_active, last_assistant_message: requiredText(value.last_assistant_message, MAX_TEXT, "Claude Stop response is invalid.") };
+}
+function decodeStopFailure(value, common, promptId) {
+  if (!isStopFailure(value.error)) throw invalid2("Claude StopFailure error is invalid.");
+  const errorDetails = optionalText(value.error_details, 4096);
+  const lastMessage = optionalText(value.last_assistant_message, MAX_TEXT);
+  return { ...common, hook_event_name: "StopFailure", prompt_id: promptId, error: value.error, ...errorDetails === void 0 ? {} : { error_details: errorDetails }, ...lastMessage === void 0 ? {} : { last_assistant_message: lastMessage } };
+}
+function claudeLocalSessionRef(sessionId) {
+  return `claude-session:${digest(sessionId)}`;
+}
+function claudeLocalTurnRef(sessionId, promptId) {
+  return `claude-turn:${cealRequestSha256({ session_id: sessionId, prompt_id: promptId })}`;
+}
+function claudeLocalInputRef(sessionId, promptId) {
+  return `claude-input:${cealRequestSha256({ session_id: sessionId, prompt_id: promptId })}`;
+}
+function claudeWorkspaceRef(cwd) {
+  return `workspace:${digest(cwd)}`;
+}
+function decodeCommon(value, event) {
+  const effort = decodeEffort(value.effort);
+  const promptId = optionalText(value.prompt_id, 256);
+  const permissionMode = optionalText(value.permission_mode, 64);
+  return {
+    session_id: requiredText(value.session_id, 256, "Claude session identity is invalid."),
+    ...promptId === void 0 ? {} : { prompt_id: promptId },
+    transcript_path: requiredAbsolutePath(value.transcript_path, "Claude transcript path is invalid."),
+    cwd: requiredAbsolutePath(value.cwd, "Claude working directory is invalid."),
+    ...permissionMode === void 0 ? {} : { permission_mode: permissionMode },
+    ...effort === void 0 ? {} : { effort },
+    hook_event_name: event
+  };
+}
+function decodeEffort(value) {
+  if (value === void 0) return void 0;
+  if (!record(value) || !isEffortLevel(value.level)) throw invalid2("Claude effort is invalid.");
+  return { level: value.level };
+}
+function isSessionSource(value) {
+  return typeof value === "string" && SESSION_SOURCES.some((source) => source === value);
+}
+function isEffortLevel(value) {
+  return typeof value === "string" && EFFORT_LEVELS.some((effort) => effort === value);
+}
+function isStopFailure(value) {
+  return typeof value === "string" && STOP_FAILURES.some((failure) => failure === value);
+}
+function requiredAbsolutePath(value, message) {
+  const text = requiredText(value, 4096, message);
+  if (!text.startsWith("/") || text.includes("\0")) throw invalid2(message);
+  return text;
+}
+function requiredText(value, max, message) {
+  if (typeof value !== "string") throw invalid2(`${message} (${refusalFact("kind", typeof value, "string")})`);
+  if (value.length === 0 || value.length > max) throw invalid2(`${message} (${refusalFact("characters", value.length, `from 1 through ${max}`)})`);
+  const nul = value.indexOf("\0");
+  if (nul >= 0) throw invalid2(`${message} (${refusalFact("nul_index", nul, "no NUL code point")})`);
+  return value;
+}
+function optionalText(value, max) {
+  if (value === void 0) return void 0;
+  return requiredText(value, max, "Claude optional hook field is invalid.");
+}
+function digest(value) {
+  return createHash2("sha256").update(value, "utf8").digest("hex");
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function invalid2(message) {
+  return new ClaudeHostError("invalid_input", message);
+}
+
+// host/claude/src/claude-outbox.ts
+import { open as open2, mkdir as mkdir2, readdir, readFile, unlink as unlink2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// host/relay/src/producer-frame.ts
+var HOST_PRODUCER_FRAME_SCHEMA = "ceal.host_producer_frame.v1";
+var HOST_PRODUCER_MAX_JSON_BYTES = 262144;
+var SAFE_REF2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var DIGEST2 = /^[a-f0-9]{64}$/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 + 4);
+  result.writeUInt32BE(json.byteLength, 0);
+  json.copy(result, 4);
+  return result;
+}
+function decodeHostProducerFrame(input) {
+  if (input.byteLength < 4) throw new HostProducerFrameError("frame_truncated", `frame_truncated: ${refusalFact("frame_bytes", input.byteLength, "at least 4")}`);
+  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 + 4) throw new HostProducerFrameError(input.byteLength < length + 4 ? "frame_truncated" : "invalid_frame_length");
+  const bytes = input.subarray(4);
+  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 hostProducerPromptRef(promptSha256) {
+  if (!DIGEST2.test(promptSha256)) throw new TypeError("Canonical Host prompt digest is invalid.");
+  return `ceal-host-prompt:${promptSha256}`;
+}
+function validateFrame(value) {
+  if (!record2(value)) throw new HostProducerFrameError("invalid_frame_shape");
+  if (value.schema_version !== HOST_PRODUCER_FRAME_SCHEMA) throw new HostProducerFrameError("unsupported_frame_schema", `unsupported_frame_schema: ${refusalFact("schema_version", value.schema_version, HOST_PRODUCER_FRAME_SCHEMA)}`);
+  if (!exactKeys(value, ["schema_version", "producer_id", "producer_installation_ref", "producer_epoch", "sequence", "frame_kind", "occurred_at", "payload"])) throw new HostProducerFrameError("invalid_frame_shape");
+  if (!PRODUCERS.has(String(value.producer_id)) || !safeRef(value.producer_installation_ref)) throw new HostProducerFrameError("invalid_producer_identity");
+  if (!positive(value.producer_epoch) || !positive(value.sequence) || !hostProducerFrameKind(value.frame_kind) || !timestamp(value.occurred_at) || !record2(value.payload)) throw new HostProducerFrameError("invalid_frame_shape");
+  validatePayload(value.frame_kind, value.payload);
+}
+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) && optionalText2(value.model, 256) && optionalText2(value.host_version, 256) && validObservations(value.observations);
+}
+function validTurn(value) {
+  return exactOptional(value, ["local_session_ref", "local_turn_ref"], ["model", "observations"]) && safeRef(value.local_session_ref) && safeRef(value.local_turn_ref) && optionalText2(value.model, 256) && validObservations(value.observations);
+}
+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) => record2(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) && optionalText2(value.detail, 4096);
+}
+function validDecision(value) {
+  return value === void 0 || record2(value) && exactKeys(value, ["decision", "approval_ref"]) && (value.decision === "approved" || value.decision === "denied") && safeRef(value.approval_ref);
+}
+function optionalText2(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 record2(value) && Object.keys(value).length <= 256 && Object.entries(value).every(([key, item]) => key.length > 0 && key.length <= 128 && jsonValue(item, depth + 1));
+}
+function record2(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 exactKeys(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 failure;
+  try {
+    await handle.sync();
+  } catch (error) {
+    if (!directorySyncUnsupported(error)) failure = error;
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    if (failure === void 0) failure = error;
+    else failure = new AggregateError([failure, error], "Host Relay directory sync and close failed.");
+  }
+  if (failure !== void 0) throw failure;
+}
+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 (errorCode(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(errorCode(error) ?? "");
+}
+function errorCode(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 HostRelayIpcError = class extends Error {
+  code;
+  constructor(code3, message = code3) {
+    super(message);
+    this.code = code3;
+  }
+};
+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);
+}
+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 < 4) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response is truncated: ${refusalFact("response_bytes", input.byteLength, "at least 4")}.`);
+  const length = input.readUInt32BE(0);
+  if (length === 0 || length > 4096 || input.length !== length + 4) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response length is invalid: ${refusalFacts([{ name: "declared_bytes", value: length, expected: "between 1 and 4096" }, { name: "received_bytes", value: input.byteLength, expected: `exactly ${length + 4}` }])}.`);
+  let value;
+  try {
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(4)));
+  } 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 record3(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 record3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function decodeResponseBuffer(buffer) {
+  if (buffer.length < 4) return null;
+  const length = buffer.readUInt32BE(0);
+  if (length === 0 || length > 4096) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response length is invalid: ${refusalFact("declared_bytes", length, "between 1 and 4096")}.`);
+  if (buffer.length < length + 4) return null;
+  if (buffer.length !== length + 4) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC returned trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: "the received message length minus 4" }, { name: "received_bytes", value: buffer.byteLength, expected: `exactly ${length + 4}` }])}.`);
+  return decodeHostRelayIpcResponse(buffer);
+}
+
+// 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 exactKeys2(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 exactKeys2(value, keys) {
+  const actual = Object.keys(value);
+  return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key)) && actual.every((key) => keys.includes(key));
+}
+function requiredKeys(value, required, optional) {
+  const actual = Object.keys(value);
+  const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
+  return actual.length >= required.length && actual.length <= allowed.size && required.every((key) => Object.hasOwn(value, key)) && actual.every((key) => allowed.has(key));
+}
+
+// host/claude/src/claude-invocation-context.ts
+function claudeInvocationContextFromTurn(identity, promptRef, expiresAt, workingDirectory) {
+  return invocationContextFromTurn(identity, promptRef, expiresAt, { schema_version: CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION, validate: validateClaudeHostInvocationContext, working_directory: workingDirectory });
+}
+function validateClaudeHostInvocationContext(value) {
+  if (!contextShape(value)) throw new ClaudeHostError("storage", "Claude Host invocation context is malformed.");
+  validateIdentity(value.identity);
+  validateContextReferences(value);
+  validateContextTimes(value);
+}
+function validateClaudeIdentity(value) {
+  if (!validIdentity(value)) throw new ClaudeHostError("invalid_input", "Claude Host session identity is invalid.");
+}
+function contextShape(value) {
+  return record4(value) && value.schema_version === CLAUDE_INVOCATION_CONTEXT_SCHEMA_VERSION && hasHostInvocationContextKeys(value, ["request_ref", "bound_at", "working_directory"]);
+}
+function validateIdentity(value) {
+  if (!validIdentity(value)) throw new ClaudeHostError("storage", "Claude Host invocation identity is malformed.");
+}
+function validateContextReferences(value) {
+  if (!safeRef2(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 record4(value) && hasHostInvocationIdentityKeys(value) && [value.host_session_ref, value.host_turn_ref, value.host_source_ref].every(safeRef2);
+}
+function optionalSafeRef(value) {
+  return value === void 0 || safeRef2(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 safeRef2(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
+}
+function timestamp2(value) {
+  return typeof value === "string" && value.length <= 64 && Number.isFinite(Date.parse(value));
+}
+function record4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// host/claude/src/claude-outbox.ts
+var SAFE_REF3 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var 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 open2(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_REF3.test(hostSourceRef) || !SAFE_REF3.test(hostSessionRef) || !(now instanceof Date) || !Number.isFinite(now.getTime())) throw new ClaudeHostError("invalid_input", "Claude Host context identity or clock is invalid.");
+}
+async function readInvocationContextFile(file, hostSourceRef, hostSessionRef, now) {
+  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 (!record5(draft) || !hostFrameKind(draft.frame_kind) || !record5(draft.payload)) throw new ClaudeHostError("storage", "Claude frame draft is malformed.");
+    encodeHostProducerFrame({ schema_version: "ceal.host_producer_frame.v1", producer_id: "claude", producer_installation_ref: "validation", producer_epoch: 1, sequence: index + 1, frame_kind: draft.frame_kind, occurred_at: value.occurred_at, payload: draft.payload });
+  }
+}
+function validBatchHeader(value) {
+  return record5(value) && value.schema_version === CLAUDE_OUTBOX_SCHEMA && safeRef3(value.batch_ref) && claudeEvent(value.hook_event) && safeRef3(value.local_session_ref) && optionalRef(value.local_turn_ref) && timestamp3(value.occurred_at) && Array.isArray(value.frames) && value.frames.length > 0 && value.frames.length <= 3;
+}
+function claudeEvent(value) {
+  return typeof value === "string" && ["SessionStart", "UserPromptSubmit", "Stop", "StopFailure"].includes(value);
+}
+function hostFrameKind(value) {
+  return isHostProducerFrameKind(value);
+}
+function safeRef3(value) {
+  return typeof value === "string" && SAFE_REF3.test(value);
+}
+function optionalRef(value) {
+  return value === void 0 || typeof value === "string" && SAFE_REF3.test(value);
+}
+function timestamp3(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function record5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function code(error) {
+  return record5(error) && typeof error.code === "string" ? error.code : null;
+}
+
+// host/claude/src/claude-adapter.ts
+import { createHash as createHash3 } from "node:crypto";
+var ClaudeHookAdapter = class {
+  store;
+  now;
+  constructor(options) {
+    this.store = new ClaudeOutboxStore(options.outbox_dir);
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.optionsSourceRef = options.host_source_ref ?? "claude-host:local";
+  }
+  async handle(event, raw) {
+    let input;
+    try {
+      input = decodeClaudeHookInput(event, raw);
+    } catch (error) {
+      return { event, disposition: "rejected", reason: error instanceof Error ? refusalFact("error", error) : "invalid_claude_hook_input" };
+    }
+    const occurredAt = timestamp4(this.now);
+    const sessionRef = claudeLocalSessionRef(input.session_id);
+    const turnRef = input.prompt_id === void 0 ? void 0 : claudeLocalTurnRef(input.session_id, input.prompt_id);
+    const frames = mapFrames(input, occurredAt);
+    const batchRef = `claude-batch:${cealRequestSha256({ event, session_ref: sessionRef, turn_ref: turnRef ?? null, occurred_at: occurredAt, frames })}`;
+    const batch = { schema_version: CLAUDE_OUTBOX_SCHEMA, batch_ref: batchRef, hook_event: event, local_session_ref: sessionRef, ...turnRef === void 0 ? {} : { local_turn_ref: turnRef }, occurred_at: occurredAt, frames };
+    await this.store.put(batch);
+    await this.activatePromptContext(input, frames, sessionRef, turnRef);
+    return { event, disposition: "queued", batch_ref: batchRef, local_session_ref: sessionRef, ...turnRef === void 0 ? {} : { local_turn_ref: turnRef } };
+  }
+  async activatePromptContext(input, frames, sessionRef, turnRef) {
+    if (input.hook_event_name !== "UserPromptSubmit" || turnRef === void 0) return;
+    const identity = { host_source_ref: this.optionsSourceRef, host_session_ref: sessionRef, host_turn_ref: turnRef };
+    validateClaudeIdentity(identity);
+    const inputFrame = frames.find((frame) => frame.frame_kind === "user_input");
+    const expiresAt = inputFrame?.payload.context_expires_at;
+    if (typeof expiresAt !== "string") throw new ClaudeHostError("storage", "Claude prompt context expiry is unavailable.");
+    const observations = inputFrame?.payload.observations;
+    const prompt = Array.isArray(observations) ? observations.find((observation) => isRecord(observation) && observation.observation_kind === "prompt") : void 0;
+    const promptValue = isRecord(prompt) ? prompt.value : void 0;
+    if (!isCealHostPromptObservationValue(promptValue)) throw new ClaudeHostError("storage", "Claude prompt observation is unavailable.");
+    await this.store.activateInvocationContext(identity, hostProducerPromptRef(promptValue.body_sha256), expiresAt, input.cwd);
+  }
+  optionsSourceRef;
+};
+function mapFrames(input, at) {
+  if (input.hook_event_name === "SessionStart") return sessionFrames(input, at);
+  if (input.hook_event_name === "UserPromptSubmit") return inputFrames(input, at);
+  return terminalFrames(input, at);
+}
+function sessionFrames(input, at) {
+  const sessionRef = claudeLocalSessionRef(input.session_id);
+  const observation = obs("session", sessionRef, at, { status: "started", host_kind: "claude", source: input.source, model: input.model ?? "unavailable", decoder_evidence_version: "claude-code-2.1.258" });
+  return [{ frame_kind: "session_started", payload: compact({ local_session_ref: sessionRef, working_directory_ref: claudeWorkspaceRef(input.cwd), model: input.model, observations: [observation] }) }];
+}
+function inputFrames(input, at) {
+  const sessionRef = claudeLocalSessionRef(input.session_id);
+  const turnRef = claudeLocalTurnRef(input.session_id, input.prompt_id);
+  const promptDigest = createHash3("sha256").update(input.prompt, "utf8").digest("hex");
+  const turn = obs("turn", turnRef, at, { status: "started", prompt_id_sha256: createHash3("sha256").update(input.prompt_id, "utf8").digest("hex"), effort: input.effort?.level ?? "unavailable" });
+  const prompt = obs("prompt", claudeLocalInputRef(input.session_id, input.prompt_id), at, { body_sha256: promptDigest });
+  return [{ frame_kind: "turn_started", payload: { local_session_ref: sessionRef, local_turn_ref: turnRef, observations: [turn] } }, { frame_kind: "user_input", payload: compact({ local_session_ref: sessionRef, local_turn_ref: turnRef, local_input_ref: claudeLocalInputRef(input.session_id, input.prompt_id), origin_input: true, local_turn_aliases: [safeAlias(input.prompt_id)], context_expires_at: new Date(Date.parse(at) + 24 * 60 * 60 * 1e3).toISOString(), observations: [prompt] }) }];
+}
+function terminalFrames(input, at) {
+  const sessionRef = claudeLocalSessionRef(input.session_id);
+  const turnRef = claudeLocalTurnRef(input.session_id, input.prompt_id);
+  const aborted = input.hook_event_name === "StopFailure";
+  const reason = aborted ? `api_${input.error}` : void 0;
+  const terminal = obs("turn", `${turnRef}:${aborted ? "failed" : "stopped"}`, at, compact({ status: aborted ? "aborted" : "completed", reason }));
+  const timing = obs("timing", `${turnRef}:timing`, at, { status: "unavailable", reason: "claude_hook_does_not_expose_timing_or_usage" });
+  return [{ frame_kind: "turn_terminal", payload: compact({ local_session_ref: sessionRef, local_turn_ref: turnRef, terminal_state: aborted ? "aborted" : "completed", abort_reason: reason, observations: [terminal, timing] }) }];
+}
+function obs(kind, identity, at, value) {
+  return { observation_ref: cealHostObservationRef("claude", cealRequestSha256({ kind, identity, at, value })), observation_kind: kind, observed_at: at, value };
+}
+function safeAlias(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value) ? value : `prompt:${createHash3("sha256").update(value).digest("hex")}`;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== void 0));
+}
+function timestamp4(now) {
+  const value = now();
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) throw new TypeError("Claude Host clock is invalid.");
+  return value.toISOString();
+}
+
+// host/claude/src/claude-producer.ts
+import { mkdir as mkdir3, readFile as readFile2, rename as rename2, writeFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var STATE_SCHEMA = "ceal.claude_producer_state.v1";
+var SAFE_REF4 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var ClaudeProducer = class {
+  store;
+  statePath;
+  installation;
+  epoch;
+  options;
+  tail = Promise.resolve();
+  constructor(options) {
+    if (!SAFE_REF4.test(options.producer_installation_ref)) throw new ClaudeHostError("configuration", "Claude producer installation identity is invalid.");
+    this.options = options;
+    this.epoch = options.producer_epoch ?? 1;
+    if (!Number.isSafeInteger(this.epoch) || this.epoch <= 0) throw new ClaudeHostError("configuration", "Claude producer epoch is invalid.");
+    this.store = new ClaudeOutboxStore(options.outbox_dir);
+    this.statePath = join3(options.outbox_dir, "claude-producer-state.json");
+    this.installation = options.producer_installation_ref;
+  }
+  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: record6(value) ? value.schema_version : void 0, expected: STATE_SCHEMA },
+    { name: "producer_installation_ref", value: record6(value) ? value.producer_installation_ref : void 0, expected: installation }
+  ])}).`);
+  if (Number(value.producer_epoch) > epoch) throw new ClaudeHostError("storage", `Claude producer state epoch is ahead of this installation (${refusalFact("producer_epoch", value.producer_epoch, `at most ${epoch}`)}).`);
+  const pending = {};
+  for (const [ref, frames] of Object.entries(value.pending)) {
+    if (!SAFE_REF4.test(ref) || !Array.isArray(frames) || frames.length === 0) throw new ClaudeHostError("storage", "Claude producer reservation is malformed.");
+    pending[ref] = frames.map((frame) => decodeFrame(frame, installation, Number(value.producer_epoch)));
+  }
+  return { schema_version: STATE_SCHEMA, producer_installation_ref: installation, producer_epoch: epoch, next_sequence: Number(value.next_sequence), pending };
+}
+function validStateHeader(value, installation) {
+  return record6(value) && value.schema_version === STATE_SCHEMA && value.producer_installation_ref === installation && positiveInteger(value.producer_epoch) && positiveInteger(value.next_sequence) && record6(value.pending);
+}
+function positiveInteger(value) {
+  return Number.isSafeInteger(value) && Number(value) > 0;
+}
+function 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 record6(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function code2(error) {
+  return record6(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-hook-runner.ts
+import { homedir } from "node:os";
+import { join as join4 } from "node:path";
+
+// host/session-start-affordance.ts
+var HOST_ENTRY_AFFORDANCE = "When the user asks to use Ceal or provides a link to information that may be available through installed organizational capabilities, first run the bare `ceal` shell command with no arguments; treat that link as a candidate Ceal resource rather than a public web-search target, and let the current Profile capability result supply the exact next steps.";
+function hostSessionStartEntryAffordance(hostName) {
+  return `${HOST_ENTRY_AFFORDANCE} This text is the Ceal ${hostName} Host's own SessionStart hook running in this ${hostName} session. The Host owns this session's Request identity, and the generic client authenticates each call automatically; follow the required_action_sequence returned by bare \`ceal\`. Never run \`ceal request create\`, and never type, guess, or reuse --host-session-ref, --host-turn-ref, --prompt-ref, or any other session or turn reference.`;
+}
+
+// host/producer-service.ts
+import { constants } from "node:fs";
+import { lstat as lstat2, open as open3 } 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_REF5 = /^[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 (!isRecord2(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 = validateIdentity2(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 open3(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 validateIdentity2(sourceRef, installationRef, epoch, error) {
+  if (!SAFE_REF5.test(sourceRef) || !SAFE_REF5.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 isRecord2(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-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-hook-runner.ts
+var MAX_STDIN_BYTES = 256 * 1024;
+var CLAUDE_SESSION_START_ENTRY_AFFORDANCE = hostSessionStartEntryAffordance("Claude");
+function claudeSessionStartHookOutput() {
+  return { suppressOutput: true, hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: CLAUDE_SESSION_START_ENTRY_AFFORDANCE } };
+}
+async function runClaudeHookFromStdin(event, stdin, options) {
+  return new ClaudeHookAdapter(options).handle(event, await readStdin(stdin));
+}
+function claudeHookEventFromArgs(args) {
+  const value = args.find((arg) => arg.startsWith("--ceal-hook-event="))?.slice("--ceal-hook-event=".length);
+  return isClaudeHookEvent(value) ? value : null;
+}
+async function runClaudeHookProcess(args, stdin, options) {
+  const event = claudeHookEventFromArgs(args);
+  if (event === null) return 0;
+  const result = await runClaudeHookFromStdin(event, stdin, options);
+  if (event === "SessionStart") process.stdout.write(`${JSON.stringify(claudeSessionStartHookOutput())}
+`);
+  if (result.disposition === "rejected") return 0;
+  return 0;
+}
+async function runClaudeHookCli() {
+  const args = process.argv.slice(2);
+  const options = hasHostConfigArgument(args) ? await installedClaudeHookRunnerOptions(args) : standaloneClaudeHookRunnerOptions();
+  return runClaudeHookProcess(args, process.stdin, options);
+}
+async function installedClaudeHookRunnerOptions(args) {
+  const config = await readHostProducerConfig(CLAUDE_PRODUCER_DESCRIPTOR, parseHostProducerConfigFlag(args));
+  const options = { outbox_dir: config.outbox_dir };
+  Object.defineProperty(options, "host_source_ref", { value: config.host_source_ref, enumerable: false });
+  return options;
+}
+function standaloneClaudeHookRunnerOptions() {
+  return { outbox_dir: process.env.CEAL_CLAUDE_OUTBOX_DIR ?? join4(homedir(), ".claude", ".ceal", "claude-observation-outbox") };
+}
+function hasHostConfigArgument(args) {
+  return args.some((argument) => argument === HOST_PRODUCER_CONFIG_FLAG || argument.startsWith(`${HOST_PRODUCER_CONFIG_FLAG}=`));
+}
+async function readStdin(stdin) {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of stdin) {
+    const value = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    chunks.push(value);
+    bytes += value.byteLength;
+    if (bytes > MAX_STDIN_BYTES) return " ".repeat(MAX_STDIN_BYTES + 1);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// host/client-doctor.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// host/invocation-authentication-client-command.ts
+var DOCTOR_FLAGS = Object.freeze({
+  "--expected-sha256": "expected_sha256",
+  "--expected-source-commit": "expected_source_commit",
+  "--expected-instance-ref": "expected_instance_ref"
+});
+
+// host/client-doctor.ts
+var execFileAsync = promisify(execFile);
+
+// host/claude/bin/ceal-claude-hook.ts
+async function main() {
+  return runClaudeHookCli();
+}
+if (isDirectInvocation(import.meta.url)) process.exitCode = await main();
+export {
+  main
+};