@corca-org/ceal-host-linux-arm64 1.0.8 → 1.0.10

package/libexec/ceal-host/relay.mjs

@@ -74,11 +74,28 @@ var client_wire_contract_default = {
     ],
     bare_document_fields: [
       "invocation",
-      "next",
+      "required_action_sequence",
+      "entrypoints",
       "common_concepts",
       "operations",
       "catalog_revision"
     ],
+    prompt_field: "prompt",
+    prompt_schema_version: "ceal.prompt.v1",
+    focused_prompt_document_fields: [
+      "catalog_revision",
+      "prompt"
+    ],
+    focused_prompt_continuation_document_fields: [
+      "catalog_revision",
+      "remaining_work",
+      "prompt"
+    ],
+    discovery_command: "discovery",
+    discovery_manifest_schema_version: "ceal.discovery_manifest.v1",
+    discovery_manifest_document_fields: [
+      "discovery_manifest"
+    ],
     exit_code_max: 125,
     bare_document_max_bytes: 65536,
     complete_max_bytes: 66019,
@@ -105,8 +122,15 @@ 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_PROMPT_FIELD = response.prompt_field;
+var CEAL_COMMAND_RESPONSE_PROMPT_SCHEMA_VERSION = response.prompt_schema_version;
+var CEAL_COMMAND_RESPONSE_PROMPT_DOCUMENT_FIELDS = Object.freeze([...response.bare_document_fields, response.prompt_field]);
+var CEAL_COMMAND_RESPONSE_FOCUSED_PROMPT_DOCUMENT_FIELDS = Object.freeze([...response.focused_prompt_document_fields]);
+var CEAL_COMMAND_RESPONSE_FOCUSED_PROMPT_CONTINUATION_DOCUMENT_FIELDS = Object.freeze([...response.focused_prompt_continuation_document_fields]);
+var CEAL_COMMAND_RESPONSE_DISCOVERY_COMMAND = response.discovery_command;
+var CEAL_COMMAND_RESPONSE_DISCOVERY_MANIFEST_SCHEMA_VERSION = response.discovery_manifest_schema_version;
+var CEAL_COMMAND_RESPONSE_DISCOVERY_MANIFEST_DOCUMENT_FIELDS = Object.freeze([...response.discovery_manifest_document_fields]);
 var CEAL_COMMAND_RESPONSE_MAX_BYTES = response.absolute_transport_max_bytes;
 
 // packages/ceal-client-protocol/src/vocabulary.ts
@@ -142,7 +166,7 @@ var CEAL_OPERATION_RECOVERY_KINDS = vocabulary(["none", "reconcile", "compensate
 var CEAL_OPERATION_RECOVERY_STATUSES = vocabulary(["not_started", "active", "completed"]);
 var CEAL_OPERATION_PROVIDER_READBACK_AVAILABILITY = vocabulary(["not_started", "not_applicable", "not_available", "pending", "available"]);
 var CEAL_OPERATION_OFFERED_HANDOFF_STATES = vocabulary(["accepted", "rejected", "unknown"]);
-var CEAL_OPERATION_RECEIPT_AUTHORITY_KEYS = Object.freeze(["instance_ref", "profile_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]);
+var CEAL_OPERATION_RECEIPT_AUTHORITY_KEYS = Object.freeze(["instance_ref", "access_group_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]);
 var CEAL_OPERATION_APPROVAL_DISPOSITIONS = vocabulary([
   "approval_not_required_by_policy",
   "interactive_pending",
@@ -157,6 +181,8 @@ var CEAL_CAPABILITY_READINESS_VALUES = vocabulary(["ready", "degraded", "unavail
 var CEAL_TARGET_REQUIREMENTS = vocabulary(["required", "optional", "none"]);
 var CEAL_AUDIT_OUTCOMES = vocabulary(["succeeded", "denied", "failed"]);
 var CEAL_GATEWAY_PROVIDER_STEP_OUTCOMES = vocabulary(["completed", "rejected", "throttled", "failed"]);
+var CEAL_GATEWAY_READ_REUSE_DISPOSITIONS = vocabulary(["response_cache_hit", "corpus_hit", "corpus_hit_after_revalidation", "corpus_partial_provider_supplement", "provider_direct", "provider_continuation", "reuse_unavailable"]);
+var CEAL_GATEWAY_READ_REUSE_UNAVAILABLE_REASONS = vocabulary(["not_reported", "storage_unavailable", "coverage_incomplete", "freshness_refresh_required", "not_reusable", "bypassed"]);
 var CEAL_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"]);
@@ -429,8 +455,10 @@ function requireIsoTimestamp(value, message) {
 var JSON_DESCRIPTION_CONTROL_CHARACTER = new RegExp("\\p{Cc}", "u");
 
 // packages/ceal-client-protocol/src/operation-contract-validation.ts
-var CEAL_OPERATION_AUTHORITY_POLICY_KEYS = Object.freeze(["profile", "instance_binding", "target", "admission_recheck"]);
+var CEAL_OPERATION_AUTHORITY_POLICY_KEYS = Object.freeze(["access_group", "instance_binding", "target", "admission_recheck"]);
 var MAX_OPERATION_INPUT_RESOLVER_BINDINGS = 96;
+var CEAL_OPERATION_DESCRIPTOR_REQUIRED_ENVELOPE_KEYS = Object.freeze(["schema_version", "id", "input_contract", "result_contract", "policy"]);
+var CEAL_OPERATION_DESCRIPTOR_OPTIONAL_ENVELOPE_KEYS = Object.freeze(["input_resolution", "summary"]);
 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"]);
 
@@ -504,6 +532,7 @@ var CEAL_SCHEMA_LITERALS = [
   "ceal.operation_descriptor.v1",
   "ceal.operation_error.v1",
   "ceal.operation_failure.v1",
+  "ceal.operation_failure.compact.v1",
   "ceal.operation_receipt.v1",
   "ceal.operation_result.v1",
   "ceal.operation_result.compact.v1",
@@ -529,17 +558,16 @@ var CEAL_BOUNDED_SERIES_CATALOG = Object.freeze({
   engagement_signal: (root) => join(root, "runtime-state", "slack-feedback.jsonl"),
   runtime_error: (root) => join(root, "runtime-state", "runtime-errors.jsonl"),
   turn_bridge_request: (root) => join(root, ".ceal", "turn-bridge", "requests.jsonl"),
-  channel_log: (root) => join(root, "log.jsonl"),
   thread_run_events: (root) => join(root, "run-events.jsonl"),
   bounded_store_sidecar: (root) => `${root}.jsonl`,
   gateway_audit_archive: (root) => `${root}.jsonl`,
   gateway_capability_audit: (root) => join(root, "capability-audit.jsonl"),
   gateway_retrieval_waste_partition: (root) => `${root}.jsonl`,
   gateway_access_policy_publication: (root) => join(root, "access-policy-publications.jsonl"),
-  gateway_profile_connector_control_audit: (root) => `${root}.audit.jsonl`,
-  gateway_profile_connector_scope_audit: (root) => join(root, "profile-connector-scope-audit.jsonl"),
-  gateway_profile_connector_activity_scope_audit: (root) => join(root, "profile-connector-activity-scope-audit.jsonl"),
-  gateway_profile_connector_readiness_audit: (root) => join(root, "profile-connector-readiness.audit.jsonl"),
+  gateway_access_group_connector_control_audit: (root) => `${root}.audit.jsonl`,
+  gateway_access_group_connector_scope_audit: (root) => join(root, "profile-connector-scope-audit.jsonl"),
+  gateway_access_group_connector_activity_scope_audit: (root) => join(root, "profile-connector-activity-scope-audit.jsonl"),
+  gateway_access_group_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"),
@@ -590,12 +618,6 @@ var CEAL_AGENT_SESSION_COMMIT_KEYS = vocabulary(["attempt_ref", "expected_sessio
 // 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",
@@ -647,8 +669,6 @@ var NON_REMEDY_NEXT_ACTION_VALUES = [
   "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
@@ -745,12 +765,12 @@ var CEAL_REQUEST_JSON_SCHEMA = {
       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 },
+        access_group_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
         principal_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
         execution_subject_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source },
         authority_revision_ref: { type: "string", minLength: 1, maxLength: 128, pattern: SAFE_REF.source }
       },
-      required: ["instance_ref", "profile_ref", "principal_ref", "execution_subject_ref", "authority_revision_ref"]
+      required: ["instance_ref", "access_group_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 },
@@ -876,7 +896,7 @@ var CEAL_HOST_OBSERVATION_KINDS = vocabulary(["prompt", "session", "turn", "mode
 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;
+var HOST_RESERVED_KEY = /^(?:access_group|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.");
@@ -896,6 +916,14 @@ function inspectHostKeys(value) {
   }
 }
 
+// packages/ceal-client-protocol/src/host-prompt-ref.ts
+var CEAL_HOST_PROMPT_DIGEST_PATTERN = "^[a-f0-9]{64}$";
+var PROMPT_DIGEST = new RegExp(CEAL_HOST_PROMPT_DIGEST_PATTERN, "u");
+function hostProducerPromptRef(promptSha256) {
+  if (!PROMPT_DIGEST.test(promptSha256)) throw new TypeError("Canonical Host prompt digest is invalid.");
+  return `ceal-host-prompt:${promptSha256}`;
+}
+
 // 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",
@@ -911,6 +939,12 @@ var OWNER_WRITE_STATES = Object.freeze(["attempt_started", "provider_acknowledge
 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/thread-excerpt.ts
+var CEAL_THREAD_RECENT_WINDOW = 6;
+var CEAL_THREAD_LAST_APP_MESSAGES_WINDOW = 3;
+var CEAL_THREAD_OLDER_SUMMARY_WINDOW = 4;
+var CEAL_FED_THREAD_MESSAGE_LIMIT = CEAL_THREAD_RECENT_WINDOW + CEAL_THREAD_OLDER_SUMMARY_WINDOW + CEAL_THREAD_LAST_APP_MESSAGES_WINDOW;
+
 // packages/ceal-client-protocol/src/request-graph-readiness.ts
 var REQUEST_GRAPH_PRODUCER_TO_APPEND_SCHEMA = {
   type: "object",
@@ -1010,6 +1044,13 @@ function exactKeys(value, expected) {
 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/session-start-affordance.ts
+var CEAL_SESSION_ENTRY_INVOCATION = "ceal";
+var CEAL_LINK_RESOURCE_PRECEDENCE = `When the user asks to use Ceal or provides a link to information that may be available through installed organizational capabilities, run bare \`${CEAL_SESSION_ENTRY_INVOCATION}\`. The Host supplies the current user prompt without exposing it to the client command, and the Gateway returns the applicable entry in that one response. Treat a supplied link as a candidate Ceal resource rather than a public web-search target. Reach for a generic web fetch or web search only when the Gateway offered nothing.`;
+
+// packages/ceal-client-protocol/src/discovery-manifest.ts
+var CEAL_DISCOVERY_MANIFEST_CONNECTOR_KINDS = vocabulary(["github", "google-workspace", "notion", "slack"]);
+
 // 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([
@@ -1226,7 +1267,7 @@ var CEAL_PRESENTATION_INTENTS = vocabulary(["progress", ...CEAL_FINAL_PRESENTATI
 
 // packages/ceal-client-protocol/src/personal-client-vocabulary.ts
 var CEAL_PERSONAL_CLIENT_BINDING_KEYS = vocabulary([
-  "profile_ref",
+  "access_group_ref",
   "membership_ref",
   "registration_ref",
   "client_ref",
@@ -1241,7 +1282,8 @@ var CEAL_REFRESH_FAILURE_CODES = vocabulary([
   "refresh_replayed",
   "refresh_revoked",
   "authority_replaced",
-  "refresh_recovery_unavailable"
+  "refresh_recovery_unavailable",
+  "refresh_recovery_expired"
 ]);
 
 // packages/ceal-client-protocol/src/device-enrollment.ts
@@ -1268,8 +1310,8 @@ function hostTerminalFailure(error, component) {
   if (code === "ENOENT") return { code: "host_dependency_unavailable", message: `A command or file the ${component} Host needs is unavailable: ${detail}`, next_action: "Install the missing dependency or restore the missing file, then rerun this command." };
   if (code === "EACCES" || code === "EPERM") return { code: "host_permission_denied", message: `The ${component} Host was refused access to a local path: ${detail}`, next_action: "Repair the ownership or mode of the named path, then rerun this command." };
   if (code === "ENOSPC") return { code: "host_storage_unavailable", message: `The ${component} Host could not write local state: ${detail}`, next_action: "Free local disk space, then rerun this command." };
-  if (code !== null && HOST_OWNED_CODE.test(code)) return { code, message: `The ${component} Host command failed: ${detail}`, next_action: `Resolve the named failure above; run \`ceal-host doctor --json\` only if it reports installed ${component} Host drift.` };
-  return { code: "host_failure_unclassified", message: `The ${component} Host command failed for a cause it cannot classify: ${detail}`, next_action: `Run \`ceal-host doctor --json\`; if it reports no drift then the ${component} Host configuration is not the cause, and the message above is the only evidence of what is.` };
+  if (code !== null && HOST_OWNED_CODE.test(code)) return { code, message: `The ${component} Host command failed: ${detail}`, next_action: `Resolve the named failure above; run \`ceal-host doctor\` only if it reports installed ${component} Host drift.` };
+  return { code: "host_failure_unclassified", message: `The ${component} Host command failed for a cause it cannot classify: ${detail}`, next_action: `Run \`ceal-host doctor\`; if it reports no drift then the ${component} Host configuration is not the cause, and the message above is the only evidence of what is.` };
 }
 var DOCTOR_FLAGS = Object.freeze({
   "--expected-sha256": "expected_sha256",
@@ -1386,7 +1428,6 @@ var HOST_PRODUCER_FRAME_SCHEMA = "ceal.host_producer_frame.v1";
 var HOST_PRODUCER_MAX_JSON_BYTES = 262144;
 var HOST_PRODUCER_FRAME_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
 var SAFE_REF2 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-var 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);
@@ -1450,10 +1491,6 @@ function hostProducerInputRef(hostSourceRef, frame, localSessionRef, localTurnRe
 function hostProducerSubmissionRef(hostSourceRef, frame) {
   return requiredIdentity(hostProducerIdentityRefs(hostSourceRef, frame).submission_ref);
 }
-function hostProducerPromptRef(promptSha256) {
-  if (!DIGEST2.test(promptSha256)) throw new TypeError("Canonical Host prompt digest is invalid.");
-  return `ceal-host-prompt:${promptSha256}`;
-}
 function opaqueHostSourceRef(value) {
   return typeof value === "string" && SAFE_REF2.test(value) && !value.startsWith("ceal-host-source:");
 }
@@ -1752,6 +1789,7 @@ function errorCode3(error) {
 var DEFAULT_LIMITS = { global_count: 8192, global_bytes: 64 * 1024 * 1024, producer_count: 4096, producer_bytes: 32 * 1024 * 1024 };
 var PRODUCER_ORDER = ["codex", "claude"];
 var RETRY_SECONDS = [1, 2, 4, 8, 16, 32, 60];
+var MAX_RETRYABLE_ATTEMPTS = RETRY_SECONDS.length + 10;
 var RelayAdmissionStore = class {
   tail = Promise.resolve();
   root;
@@ -1822,7 +1860,8 @@ var RelayAdmissionStore = class {
       if (!head || head.retry_at_ms > options.now_ms) continue;
       const input = { frame: structuredClone(head.frame), host_source_ref: options.host_source_ref, submission_ref: hostProducerSubmissionRef(options.host_source_ref, head.frame) };
       const outcome = await deliver(input);
-      if (outcome.status === "retryable") {
+      const exhausted = retryExhausted(outcome, head);
+      if (outcome.status === "retryable" && !exhausted) {
         scheduleRetry(head, options.now_ms, outcome.reason);
         retained.push(input.submission_ref);
         await this.write(state);
@@ -1830,9 +1869,9 @@ var RelayAdmissionStore = class {
       }
       const installation2 = state.installations[installationKey(head.frame)];
       if (!installation2) throw new TypeError("Host Relay delivery installation is unavailable.");
-      if (outcome.status === "refused") {
+      if (outcome.status === "refused" || exhausted) {
         await this.quarantine.retainFrame(head.frame, "gateway_refused");
-        installation2.last_refusal = { sequence: head.sequence, submission_ref: input.submission_ref, code: outcome.code, message: outcome.message, refused_at_ms: options.now_ms };
+        installation2.last_refusal = { sequence: head.sequence, submission_ref: input.submission_ref, ...refusalCause(outcome, head), refused_at_ms: options.now_ms };
         refused.push(input.submission_ref);
       } else {
         await options.after_gateway_accept_before_delivery_fsync?.({ fault_point: "after_gateway_accept_before_delivery_fsync", delivery: structuredClone(input) });
@@ -1866,6 +1905,14 @@ function replayCode(existing, hash, sequence, installation2) {
 function bytes(entries) {
   return entries.reduce((total, entry2) => total + entry2.charged_bytes, 0);
 }
+function retryExhausted(outcome, entry2) {
+  return outcome.status === "retryable" && entry2.retry_attempts >= MAX_RETRYABLE_ATTEMPTS;
+}
+function refusalCause(outcome, entry2) {
+  if (outcome.status === "refused") return { code: outcome.code, message: outcome.message };
+  const reason = outcome.status === "retryable" ? outcome.reason ?? "no reason reported" : "no reason reported";
+  return { code: "retry_exhausted", message: `Gateway delivery stayed retryable through ${entry2.retry_attempts} attempts: ${reason}` };
+}
 function scheduleRetry(entry2, nowMs, reason) {
   if (reason === void 0) delete entry2.retry_reason;
   else entry2.retry_reason = reason;
@@ -2622,6 +2669,52 @@ function acknowledgement(value) {
 // host/relay/src/relay-ipc.ts
 import { chmod, lstat as lstat3, unlink as unlink2 } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
+
+// host/relay/src/current-prompt-custody.ts
+import { createHash as createHash4 } from "node:crypto";
+var HOST_CURRENT_PROMPT_MAX_BYTES = 256 * 1024;
+var MAX_CURRENT_PROMPTS = 1024;
+var HostCurrentPromptCustody = class {
+  #records = /* @__PURE__ */ new Map();
+  #consumed = /* @__PURE__ */ new Map();
+  #now;
+  constructor(now = Date.now) {
+    this.#now = now;
+  }
+  register(identity, prompt, expiresAt) {
+    const bytes2 = Buffer.byteLength(prompt, "utf8");
+    const expiry = Date.parse(expiresAt);
+    if (bytes2 === 0 || bytes2 > HOST_CURRENT_PROMPT_MAX_BYTES || !Number.isFinite(expiry) || expiry <= this.#now()) throw new TypeError("current_prompt_unavailable");
+    if (hostProducerPromptRef(createHash4("sha256").update(prompt, "utf8").digest("hex")) !== identity.prompt_ref) throw new TypeError("current_prompt_unavailable");
+    this.#purge();
+    const key = promptKey(identity);
+    if (this.#consumed.has(key)) return;
+    if (!this.#records.has(key) && this.#records.size + this.#consumed.size >= MAX_CURRENT_PROMPTS) throw new TypeError("current_prompt_unavailable");
+    this.#records.set(key, { prompt, expires_at_ms: expiry });
+  }
+  /** Transfer this turn's prompt into at most one authenticated invocation. */
+  take(identity) {
+    this.#purge();
+    const key = promptKey(identity);
+    const prompt = this.#records.get(key)?.prompt;
+    if (prompt !== void 0) {
+      const expiresAt = this.#records.get(key)?.expires_at_ms;
+      this.#records.delete(key);
+      if (expiresAt !== void 0) this.#consumed.set(key, expiresAt);
+    }
+    return prompt;
+  }
+  #purge() {
+    const now = this.#now();
+    for (const [key, value] of this.#records) if (value.expires_at_ms <= now) this.#records.delete(key);
+    for (const [key, expiresAt] of this.#consumed) if (expiresAt <= now) this.#consumed.delete(key);
+  }
+};
+function promptKey(value) {
+  return [value.producer_id, value.producer_installation_ref, value.local_session_ref, value.local_turn_ref, value.prompt_ref].join("\0");
+}
+
+// host/relay/src/relay-ipc.ts
 var HOST_RELAY_REQUEST_BINDING_KEYS = Object.freeze([
   "schema_version",
   "producer_id",
@@ -2642,6 +2735,8 @@ var HOST_RELAY_BINDING_QUERY_SCHEMA = "ceal.host_relay_binding_query.v1";
 var HOST_RELAY_BINDING_RESULT_SCHEMA = "ceal.host_relay_binding_result.v1";
 var HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA = "ceal.host_relay_invocation_context_query.v1";
 var HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA = "ceal.host_relay_invocation_context_result.v1";
+var HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA = "ceal.host_relay_current_prompt_register.v1";
+var HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA = "ceal.host_relay_current_prompt_result.v1";
 var HOST_RELAY_IPC_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
 var HostRelayIpcError = class extends Error {
   code;
@@ -2655,7 +2750,8 @@ async function startHostRelayIpcServer(options) {
   const active = /* @__PURE__ */ new Map();
   const sockets = /* @__PURE__ */ new Set();
   const quarantine = options.quarantine ?? options.admission.quarantine;
-  const server = createServer((socket) => serveSocket(socket, options.admission, options.bindings, options.mintInvocationContext, quarantine, active, sockets));
+  const currentPrompts = options.currentPrompts ?? new HostCurrentPromptCustody();
+  const server = createServer((socket) => serveSocket(socket, options.admission, options.bindings, currentPrompts, options.mintInvocationContext, quarantine, active, sockets));
   await listen(server, options.endpoint);
   if (process.platform !== "win32") await chmod(options.endpoint, 384);
   return { endpoint: options.endpoint, close: () => closeServer(server, sockets, options.endpoint) };
@@ -2667,12 +2763,12 @@ function encodeHostRelayIpcResponse(response2) {
   body.copy(result2, HOST_RELAY_IPC_LENGTH_BYTES);
   return result2;
 }
-function serveSocket(socket, admission, bindings, mintInvocationContext, quarantine, active, sockets) {
-  const state = { buffer: Buffer.alloc(0), closed: false, tail: Promise.resolve() };
+function serveSocket(socket, admission, bindings, currentPrompts, mintInvocationContext2, quarantine, active, sockets) {
+  const state = { buffer: Buffer.alloc(0), closed: false, tail: Promise.resolve(), abort: new AbortController() };
   sockets.add(socket);
   socket.on("data", (chunk) => {
     state.buffer = Buffer.concat([state.buffer, Buffer.from(chunk)]);
-    state.tail = state.tail.then(() => drainFrames(socket, state, admission, bindings, mintInvocationContext, quarantine, active)).catch(() => {
+    state.tail = state.tail.then(() => drainFrames(socket, state, admission, bindings, currentPrompts, mintInvocationContext2, quarantine, active)).catch(() => {
       writeResponse(socket, errorResponse("relay_unavailable"));
       socket.end();
     });
@@ -2680,24 +2776,26 @@ function serveSocket(socket, admission, bindings, mintInvocationContext, quarant
   socket.once("error", () => closeConnection(socket, state, active, sockets));
   socket.once("close", () => closeConnection(socket, state, active, sockets));
   socket.once("end", () => {
-    if (state.buffer.length > 0) void quarantine.retainMalformed(state.buffer, "frame_truncated").finally(() => {
+    if (state.buffer.length > 0 && currentPromptWire(state.buffer)) {
+      writeCurrentPromptResponse(socket, "current_prompt_unavailable");
+      socket.end();
+    } else if (state.buffer.length > 0) void quarantine.retainMalformed(state.buffer, "frame_truncated").finally(() => {
       writeResponse(socket, errorResponse("frame_truncated"));
       socket.end();
     });
     else socket.end();
   });
 }
-async function drainFrames(socket, state, admission, bindings, mintInvocationContext, quarantine, active) {
-  while (!state.closed && state.buffer.length >= HOST_RELAY_IPC_LENGTH_BYTES && await processBufferedRequest(socket, state, admission, bindings, mintInvocationContext, quarantine, active)) {
+async function drainFrames(socket, state, admission, bindings, currentPrompts, mintInvocationContext2, quarantine, active) {
+  while (!state.closed && state.buffer.length >= HOST_RELAY_IPC_LENGTH_BYTES && await processBufferedRequest(socket, state, admission, bindings, currentPrompts, mintInvocationContext2, quarantine, active)) {
   }
 }
-async function processBufferedRequest(socket, state, admission, bindings, mintInvocationContext, quarantine, active) {
+async function processBufferedRequest(socket, state, admission, bindings, currentPrompts, mintInvocationContext2, quarantine, active) {
   const length = state.buffer.readUInt32BE(0);
-  if (length === 0 || length > HOST_PRODUCER_MAX_JSON_BYTES) {
-    const code = length === 0 ? "invalid_frame_length" : "frame_too_large";
-    const raw = state.buffer.subarray(0, Math.min(state.buffer.length, length + HOST_RELAY_IPC_LENGTH_BYTES));
-    await quarantine.retainMalformed(raw, code);
-    writeResponse(socket, errorResponse(code));
+  const promptWire = currentPromptWire(state.buffer);
+  const maximum = promptWire ? HOST_CURRENT_PROMPT_MAX_BYTES + 4096 : HOST_PRODUCER_MAX_JSON_BYTES;
+  if (length === 0 || length > maximum) {
+    await refuseInvalidBufferedRequest(socket, state.buffer, length, promptWire, quarantine);
     state.buffer = Buffer.alloc(0);
     socket.end();
     return false;
@@ -2709,15 +2807,40 @@ async function processBufferedRequest(socket, state, admission, bindings, mintIn
   try {
     request2 = decodeIpcRequest(encoded);
   } catch (error) {
-    const code = error instanceof HostProducerFrameError ? error.code : "invalid_frame_shape";
-    await quarantine.retainMalformed(encoded, code);
-    writeResponse(socket, errorResponse(code));
+    await refuseMalformedRequest(socket, encoded, promptWire, error, quarantine);
+    return true;
+  }
+  if (request2.schema_version === HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA) {
+    try {
+      currentPrompts.register(request2, request2.current_prompt, request2.context_expires_at);
+      writeCurrentPromptResponse(socket, "registered");
+    } catch {
+      writeCurrentPromptResponse(socket, "current_prompt_unavailable");
+    }
     return true;
   }
-  if (await processHostQuery(socket, request2, bindings, mintInvocationContext)) return true;
+  if (await processHostQuery(socket, request2, bindings, currentPrompts, mintInvocationContext2, state.abort.signal)) return true;
   await processProducerRequest(socket, state, request2, encoded, admission, quarantine, active);
   return true;
 }
+async function refuseInvalidBufferedRequest(socket, rawBuffer, length, promptWire, quarantine) {
+  if (promptWire) {
+    writeCurrentPromptResponse(socket, "current_prompt_unavailable");
+    return;
+  }
+  const code = length === 0 ? "invalid_frame_length" : "frame_too_large";
+  await quarantine.retainMalformed(rawBuffer.subarray(0, Math.min(rawBuffer.length, length + HOST_RELAY_IPC_LENGTH_BYTES)), code);
+  writeResponse(socket, errorResponse(code));
+}
+async function refuseMalformedRequest(socket, encoded, promptWire, error, quarantine) {
+  if (promptWire) {
+    writeCurrentPromptResponse(socket, "current_prompt_unavailable");
+    return;
+  }
+  const code = error instanceof HostProducerFrameError ? error.code : "invalid_frame_shape";
+  await quarantine.retainMalformed(encoded, code);
+  writeResponse(socket, errorResponse(code));
+}
 async function processProducerRequest(socket, state, request2, encoded, admission, quarantine, active) {
   if (!("producer_epoch" in request2)) throw new HostRelayIpcError("relay_unavailable");
   const ownership = claimProducer(socket, state, request2, active);
@@ -2729,13 +2852,13 @@ async function processProducerRequest(socket, state, request2, encoded, admissio
   }
   writeResponse(socket, admissionResponse(await admission.admit(request2)));
 }
-async function processHostQuery(socket, request2, bindings, mint) {
+async function processHostQuery(socket, request2, bindings, currentPrompts, mint, signal) {
   if (request2.schema_version === HOST_RELAY_BINDING_QUERY_SCHEMA) {
     writeBindingResponse(socket, await bindings.query(bindingQueryFromRequest(request2)));
     return true;
   }
   if (request2.schema_version === HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) {
-    writeInvocationContextResponse(socket, await resolveInvocationContext(request2, bindings, mint));
+    writeInvocationContextResponse(socket, await resolveInvocationContext(request2, bindings, currentPrompts, mint, signal));
     return true;
   }
   return false;
@@ -2755,6 +2878,7 @@ function claimProducer(socket, state, frame, active) {
 }
 function closeConnection(socket, state, active, sockets) {
   state.closed = true;
+  state.abort.abort();
   sockets.delete(socket);
   if (state.producer_key !== void 0 && active.get(state.producer_key)?.socket === socket) active.delete(state.producer_key);
 }
@@ -2768,11 +2892,15 @@ function writeBindingResponse(socket, result2) {
 function writeInvocationContextResponse(socket, response2) {
   if (!socket.destroyed) socket.write(encodeLengthPrefixed(response2));
 }
-async function resolveInvocationContext(request2, bindings, mint) {
+function writeCurrentPromptResponse(socket, status) {
+  if (!socket.destroyed) socket.write(encodeLengthPrefixed({ schema_version: HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA, status }));
+}
+async function resolveInvocationContext(request2, bindings, currentPrompts, mint, signal) {
   if (mint === void 0) throw new HostRelayIpcError("relay_unavailable");
   const binding = await bindings.query(bindingQueryFromRequest(request2));
   if (binding.status !== "ready") return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, ...binding };
-  const result2 = await mint({ client_nonce: request2.client_nonce, context_expires_at: binding.binding.context_expires_at ?? binding.binding.bound_at, request_work_context: relayRequestWorkContextFromBinding(binding.binding) }, new AbortController().signal);
+  const currentPrompt = currentPrompts.take({ producer_id: request2.producer_id, producer_installation_ref: request2.producer_installation_ref, local_session_ref: request2.local_session_ref, local_turn_ref: request2.local_turn_ref, prompt_ref: binding.binding.prompt_ref });
+  const result2 = await mint({ client_nonce: request2.client_nonce, context_expires_at: binding.binding.context_expires_at ?? binding.binding.bound_at, request_work_context: relayRequestWorkContextFromBinding(binding.binding), ...currentPrompt === void 0 ? {} : { current_prompt: currentPrompt } }, signal);
   return { schema_version: HOST_RELAY_INVOCATION_CONTEXT_RESULT_SCHEMA, status: "ready", result: result2 };
 }
 function admissionResponse(result2) {
@@ -2788,16 +2916,29 @@ function record4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function decodeIpcRequest(input) {
-  const value = decodeLengthPrefixedJson(input, HOST_PRODUCER_MAX_JSON_BYTES);
-  if (value !== null && record4(value) && value.schema_version === HOST_RELAY_BINDING_QUERY_SCHEMA) {
+  const value = decodeLengthPrefixedJson(input, Math.max(HOST_PRODUCER_MAX_JSON_BYTES, HOST_CURRENT_PROMPT_MAX_BYTES + 4096));
+  const local = decodeLocalRequest(value);
+  if (local !== void 0) return local;
+  return decodeHostProducerFrame(input);
+}
+function decodeLocalRequest(value) {
+  if (!record4(value)) return void 0;
+  if (value.schema_version === HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA) {
+    if (!validCurrentPromptRegisterRequest(value)) throw new HostProducerFrameError("invalid_frame_shape");
+    return value;
+  }
+  if (value.schema_version === HOST_RELAY_BINDING_QUERY_SCHEMA) {
     if (!validBindingQueryRequest(value)) throw new HostProducerFrameError("invalid_frame_shape");
     return value;
   }
-  if (value !== null && record4(value) && value.schema_version === HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) {
+  if (value.schema_version === HOST_RELAY_INVOCATION_CONTEXT_QUERY_SCHEMA) {
     if (!validInvocationContextQueryRequest(value)) throw new HostProducerFrameError("invalid_frame_shape");
     return value;
   }
-  return decodeHostProducerFrame(input);
+  return void 0;
+}
+function validCurrentPromptRegisterRequest(value) {
+  return validQueryIdentity(value, HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA) && exactKeys4(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref", "prompt_ref", "current_prompt", "context_expires_at"]) && safeRef3(value.prompt_ref) && typeof value.current_prompt === "string" && Buffer.byteLength(value.current_prompt, "utf8") > 0 && Buffer.byteLength(value.current_prompt, "utf8") <= HOST_CURRENT_PROMPT_MAX_BYTES && validTimestamp2(value.context_expires_at);
 }
 function validBindingQueryRequest(value) {
   return validQueryIdentity(value, HOST_RELAY_BINDING_QUERY_SCHEMA) && exactKeys4(value, ["schema_version", "producer_id", "producer_installation_ref", "local_session_ref", "local_turn_ref"]);
@@ -2830,12 +2971,18 @@ function encodeLengthPrefixed(value) {
   body.copy(output, HOST_RELAY_IPC_LENGTH_BYTES);
   return output;
 }
+function currentPromptWire(value) {
+  return value.subarray(HOST_RELAY_IPC_LENGTH_BYTES, Math.min(value.length, HOST_RELAY_IPC_LENGTH_BYTES + 128)).includes(Buffer.from(`"schema_version":"${HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA}"`, "utf8"));
+}
 function exactKeys4(value, keys) {
   return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
 }
 function safeRef3(value) {
   return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value);
 }
+function validTimestamp2(value) {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
 async function assertEndpointVacant(endpoint) {
   try {
     await lstat3(endpoint);
@@ -2931,7 +3078,7 @@ async function serveHostRelay(config, signal, dependencies = {}) {
   } });
   let server;
   try {
-    server = await (dependencies.startIpc ?? startHostRelayIpcServer)({ endpoint: config.ipc_endpoint, admission, bindings, mintInvocationContext: (input, invocationSignal) => gateway.mintInvocationContext(input, invocationSignal) });
+    server = await (dependencies.startIpc ?? startHostRelayIpcServer)({ endpoint: config.ipc_endpoint, admission, bindings, mintInvocationContext: (input, invocationSignal) => mintInvocationContext(gateway, input, invocationSignal, config.gateway_timeout_ms, dependencies.observeInvocationMint ?? reportInvocationMint, dependencies.scheduleInvocationMintDeadline ?? scheduleInvocationMintDeadline) });
     while (!signal.aborted) {
       const round = await admission.drainRound((input) => bridge.deliver(input), { now_ms: (dependencies.now ?? Date.now)(), host_source_ref: config.host_source_ref });
       if (round.delivered.length === 0 && round.refused.length === 0) await (dependencies.wait ?? ((milliseconds, waitSignal) => waitForAbort(waitSignal, milliseconds)))(config.drain_interval_ms, signal);
@@ -2940,6 +3087,41 @@ async function serveHostRelay(config, signal, dependencies = {}) {
     await server?.close();
   }
 }
+async function mintInvocationContext(gateway, input, callerSignal, timeoutMs, observe, scheduleDeadline) {
+  const controller2 = new AbortController();
+  const started = process.hrtime.bigint();
+  let cancellation = null;
+  let outcome = "failed";
+  const cancel = (cause) => {
+    if (cancellation === null) cancellation = cause;
+    controller2.abort();
+  };
+  const callerCancelled = () => cancel("caller_cancelled");
+  const clearDeadline = scheduleDeadline(() => cancel("deadline"), timeoutMs);
+  if (callerSignal.aborted) callerCancelled();
+  else callerSignal.addEventListener("abort", callerCancelled, { once: true });
+  const cancelled = new Promise((_resolve, reject) => controller2.signal.addEventListener("abort", () => reject(new Error("invocation mint cancelled")), { once: true }));
+  try {
+    const result2 = await Promise.race([gateway.mintInvocationContext(input, controller2.signal), cancelled]);
+    outcome = "completed";
+    return result2;
+  } catch (error) {
+    outcome = cancellation ?? "failed";
+    throw error;
+  } finally {
+    clearDeadline();
+    callerSignal.removeEventListener("abort", callerCancelled);
+    observe({ outcome, elapsed_ms: Number((process.hrtime.bigint() - started) / 1000000n) });
+  }
+}
+function scheduleInvocationMintDeadline(expire, milliseconds) {
+  const timeout = setTimeout(expire, milliseconds);
+  return () => clearTimeout(timeout);
+}
+function reportInvocationMint(observation) {
+  process.stderr.write(`[host-relay-invocation-mint] outcome=${observation.outcome} elapsed_ms=${observation.elapsed_ms}
+`);
+}
 async function runHostRelayCli(args, signal, dependencies = {}) {
   try {
     const configPath = parseServeArgs(args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corca-org/ceal-host-linux-arm64",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "license": "MIT",
   "repository": {
     "type": "git",