@corca-org/ceal-host-win32-x64 1.0.7 → 1.0.9

package/libexec/ceal-host/control.mjs

@@ -2108,11 +2108,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,
@@ -2139,8 +2156,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
@@ -2176,7 +2200,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",
@@ -2191,6 +2215,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"]);
@@ -2463,8 +2489,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"]);
 
@@ -2538,6 +2566,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",
@@ -2563,17 +2592,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"),
@@ -2624,12 +2652,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",
@@ -2681,8 +2703,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
@@ -2779,12 +2799,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 },
@@ -2917,7 +2937,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.");
@@ -2937,6 +2957,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",
@@ -2952,6 +2980,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",
@@ -3031,6 +3065,14 @@ var CEAL_REQUEST_GRAPH_NODE_PREPARE_READINESS_JSON_SCHEMA = {
 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.`;
+var HOST_HOOK_TIMEOUT_SECONDS = 1;
+
+// 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([
@@ -3247,7 +3289,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",
@@ -3443,7 +3485,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_REF3 = /^[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);
@@ -3484,10 +3525,6 @@ function decodeHostProducerFrame(input) {
   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 opaqueHostSourceRef(value) {
   return typeof value === "string" && SAFE_REF3.test(value) && !value.startsWith("ceal-host-source:");
 }
@@ -3671,12 +3708,19 @@ var RELAY_QUARANTINE_MAX_BYTES = 16 * 1024 * 1024;
 
 // host/relay/src/relay-admission-store.ts
 var DEFAULT_LIMITS = { global_count: 8192, global_bytes: 64 * 1024 * 1024, producer_count: 4096, producer_bytes: 32 * 1024 * 1024 };
+var RETRY_SECONDS = [1, 2, 4, 8, 16, 32, 60];
+var MAX_RETRYABLE_ATTEMPTS = RETRY_SECONDS.length + 10;
 
 // host/relay/src/relay-request-binding-store.ts
 var MAX_STATE_BYTES = 8 * 1024 * 1024;
 
 // host/relay/src/relay-ipc.ts
 import { createConnection, createServer } from "node:net";
+
+// host/relay/src/current-prompt-custody.ts
+var HOST_CURRENT_PROMPT_MAX_BYTES = 256 * 1024;
+
+// host/relay/src/relay-ipc.ts
 var HOST_RELAY_REQUEST_BINDING_KEYS = Object.freeze([
   "schema_version",
   "producer_id",
@@ -3693,6 +3737,8 @@ var HOST_RELAY_REQUEST_BINDING_KEYS = Object.freeze([
   "host_input_ref"
 ]);
 var HOST_RELAY_IPC_RESPONSE_SCHEMA = "ceal.host_relay_admission.v1";
+var HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA = "ceal.host_relay_current_prompt_register.v1";
+var HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA = "ceal.host_relay_current_prompt_result.v1";
 var HOST_RELAY_IPC_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
 var HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES = 4096;
 var HostRelayIpcError = class extends Error {
@@ -3715,22 +3761,42 @@ var HostRelayIpcAdmissionPort = class {
     return { code: response2.code, admitted_through_sequence: response2.admitted_through_sequence, delivered_through_sequence: response2.delivered_through_sequence };
   }
 };
+var HostRelayCurrentPromptPort = class {
+  endpoint;
+  timeout_ms;
+  constructor(endpoint, timeoutMs = 5e3) {
+    this.endpoint = endpoint;
+    this.timeout_ms = timeoutMs;
+  }
+  async register(input) {
+    const request2 = { schema_version: HOST_RELAY_CURRENT_PROMPT_REGISTER_SCHEMA, ...input };
+    const response2 = await exchange(this.endpoint, encodeLengthPrefixed(request2), this.timeout_ms, decodeCurrentPromptResponseBuffer);
+    if (response2.status !== "registered") throw new HostRelayIpcError("relay_unavailable", response2.status);
+  }
+};
 function submitHostProducerFrame(endpoint, frame, timeoutMs = 5e3) {
   return exchange(endpoint, encodeHostProducerFrame(frame), timeoutMs, decodeResponseBuffer);
 }
-function exchange(endpoint, encoded, timeoutMs, decode) {
+function exchange(endpoint, encoded, timeoutMs, decode, signal) {
   return new Promise((resolve, reject2) => {
     const socket = createConnection(endpoint);
     let buffer = Buffer.alloc(0);
     let settled = false;
+    const aborted = () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC was cancelled."));
     const finish = (error, response2) => {
       if (settled) return;
       settled = true;
+      signal?.removeEventListener("abort", aborted);
       socket.destroy();
       if (error !== null) reject2(error);
       else if (response2 !== void 0) resolve(response2);
     };
-    socket.setTimeout(timeoutMs, () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC timed out.")));
+    if (timeoutMs !== void 0) socket.setTimeout(timeoutMs, () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC timed out.")));
+    if (signal?.aborted === true) {
+      aborted();
+      return;
+    }
+    signal?.addEventListener("abort", aborted, { once: true });
     socket.once("error", () => finish(new HostRelayIpcError("relay_unavailable", "Host Relay IPC is unavailable.")));
     socket.once("connect", () => socket.write(encoded));
     socket.on("data", (chunk) => {
@@ -3783,6 +3849,34 @@ function decodeResponseBuffer(buffer) {
   if (buffer.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC returned trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `the received message length minus ${HOST_RELAY_IPC_LENGTH_BYTES}` }, { name: "received_bytes", value: buffer.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
   return decodeHostRelayIpcResponse(buffer);
 }
+function decodeCurrentPromptResponseBuffer(buffer) {
+  const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES);
+  if (value === null) return null;
+  if (!record2(value) || !exactKeys2(value, ["schema_version", "status"]) || value.schema_version !== HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA || value.status !== "registered" && value.status !== "current_prompt_unavailable") throw new HostRelayIpcError("relay_unavailable");
+  return { schema_version: HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA, status: value.status };
+}
+function decodeLengthPrefixedJson(input, maximum) {
+  if (input.length < HOST_RELAY_IPC_LENGTH_BYTES) return null;
+  const length = input.readUInt32BE(0);
+  if (length === 0 || length > maximum) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message length is invalid: ${refusalFact("declared_bytes", length, `between 1 and ${maximum}`)}.`);
+  if (input.length < length + HOST_RELAY_IPC_LENGTH_BYTES) return null;
+  if (input.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC message has trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `the received message length minus ${HOST_RELAY_IPC_LENGTH_BYTES}` }, { name: "received_bytes", value: input.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
+  try {
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(HOST_RELAY_IPC_LENGTH_BYTES)));
+  } catch {
+    throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC message is invalid.");
+  }
+}
+function encodeLengthPrefixed(value) {
+  const body = Buffer.from(JSON.stringify(value), "utf8");
+  const output = Buffer.allocUnsafe(body.length + HOST_RELAY_IPC_LENGTH_BYTES);
+  output.writeUInt32BE(body.length, 0);
+  body.copy(output, HOST_RELAY_IPC_LENGTH_BYTES);
+  return output;
+}
+function exactKeys2(value, keys) {
+  return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
 
 // host/claude/src/claude-producer.ts
 import { mkdir as mkdir3, readFile as readFile2, rename as rename2, writeFile } from "node:fs/promises";
@@ -3817,7 +3911,7 @@ 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);
+  return exactKeys3(value, HOST_INVOCATION_IDENTITY_KEYS);
 }
 function hasHostInvocationContextKeys(value, optional = []) {
   return requiredKeys(value, HOST_INVOCATION_CONTEXT_REQUIRED_KEYS, optional);
@@ -3833,7 +3927,7 @@ function invocationContextFromTurn(identity, promptRef, expiresAt, descriptor2)
   descriptor2.validate(context);
   return Object.freeze(context);
 }
-function exactKeys2(value, keys) {
+function exactKeys3(value, keys) {
   const actual = Object.keys(value);
   return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key)) && actual.every((key) => keys.includes(key));
 }
@@ -5517,6 +5611,8 @@ var CodexTranscriptWatcher = class {
   now;
   log;
   retriedMalformedQuarantines = /* @__PURE__ */ new Set();
+  producerInstallationRef;
+  registerCurrentPrompt;
   constructor(options) {
     if (typeof options.outbox_dir !== "string" || options.outbox_dir.length === 0) throw new CodexHostAdapterError("configuration", "Codex transcript watcher outbox is invalid.");
     this.store = new CodexOutboxStore(options.outbox_dir);
@@ -5526,6 +5622,8 @@ var CodexTranscriptWatcher = class {
       process.stderr.write(`${line}
 `);
     });
+    this.producerInstallationRef = options.producer_installation_ref;
+    this.registerCurrentPrompt = options.register_current_prompt;
   }
   async scanOnce() {
     const registrations = await this.store.listTranscriptRegistrations();
@@ -5670,10 +5768,15 @@ var CodexTranscriptWatcher = class {
       created_at: record8.timestamp,
       expires_at: expiration(this.now, this.outboxRetentionMs)
     };
+    await this.registerPrompt(origin, registration, activeTask, currentPromptRef, record8.prompt, envelope.expires_at);
     await this.store.put(envelope);
     if (origin) await this.store.activateInvocationContext(identity, promptRef, envelope.expires_at);
     return { activeTask: { ...activeTask, origin_host_input_ref: activeTask.origin_host_input_ref ?? hostInputRef, prompt_ref: activeTask.prompt_ref ?? currentPromptRef }, enqueued: 1 };
   }
+  async registerPrompt(origin, registration, activeTask, promptRef, prompt, expiresAt) {
+    if (!origin || this.producerInstallationRef === void 0 || this.registerCurrentPrompt === void 0) return;
+    await this.registerCurrentPrompt({ producer_id: "codex", producer_installation_ref: this.producerInstallationRef, local_session_ref: registration.host_session_ref, local_turn_ref: activeTask.host_turn_ref, prompt_ref: promptRef, current_prompt: prompt, context_expires_at: expiresAt });
+  }
   async processTerminal(registration, activeTask, record8) {
     if (activeTask === void 0 || activeTask.codex_turn_id !== record8.turn_id || activeTask.origin_host_input_ref === void 0 || activeTask.prompt_ref === void 0) return { ...activeTask === void 0 ? {} : { activeTask }, enqueued: 0 };
     const identity = { host_source_ref: registration.host_source_ref, host_session_ref: registration.host_session_ref, host_turn_ref: activeTask.host_turn_ref };
@@ -5878,7 +5981,8 @@ function expiration(now, retentionMs) {
 
 // host/codex/src/codex-producer-runtime.ts
 async function drainCodexProducerOnce(options) {
-  const scan = await new CodexTranscriptWatcher({ outbox_dir: options.outbox_dir }).scanOnce();
+  const promptPort = new HostRelayCurrentPromptPort(options.relay_endpoint, options.timeout_ms);
+  const scan = await new CodexTranscriptWatcher({ outbox_dir: options.outbox_dir, producer_installation_ref: options.producer_installation_ref, register_current_prompt: (input) => promptPort.register(input) }).scanOnce();
   const producer = new CodexProducer({ outbox_dir: options.outbox_dir, producer_installation_ref: options.producer_installation_ref, relay: new HostRelayIpcAdmissionPort(options.relay_endpoint, options.timeout_ms), ...options.producer_epoch === void 0 ? {} : { producer_epoch: options.producer_epoch }, ...options.now === void 0 ? {} : { now: options.now } });
   return { scanned: scan.enqueued, ...await producer.drainOutbox() };
 }
@@ -6221,7 +6325,6 @@ import { homedir as homedir2 } from "node:os";
 import { dirname as dirname5, isAbsolute as isAbsolute3, join as join8 } from "node:path";
 
 // host/command-vector.ts
-var HOST_HOOK_TIMEOUT_SECONDS = 1;
 var MAX_ARGUMENTS = 64;
 var MAX_COMMAND_BYTES = 4096;
 function validateHostCommandVector(vector) {
@@ -6755,12 +6858,15 @@ function normalizeHookGroups(entries) {
   }
   return groups;
 }
+function ownedHookEntry(command, event) {
+  return { type: "command", command: hookCommand(command, event, "posix"), commandWindows: hookCommand(command, event, "windows"), timeout: HOST_HOOK_TIMEOUT_SECONDS, async: false };
+}
 function mergeOwnedHooks2(config, command) {
   const hooks = isRecord7(config.hooks) ? { ...config.hooks } : {};
   for (const event of CODEX_HOOK_EVENTS) {
     const groups = Array.isArray(hooks[event]) ? normalizeHookGroups(hooks[event]) : [];
     const retained = groups.map((group) => ({ ...group, hooks: group.hooks.filter((entry) => !ownedHookHandler(entry)) })).filter((group) => group.hooks.length > 0);
-    retained.push({ hooks: [{ type: "command", command: hookCommand(command, event, "posix"), commandWindows: hookCommand(command, event, "windows"), timeout: HOST_HOOK_TIMEOUT_SECONDS, async: false }] });
+    retained.push({ hooks: [ownedHookEntry(command, event)] });
     hooks[event] = retained;
   }
   return { ...config, hooks };
@@ -6853,9 +6959,15 @@ function inspectHookCommands(config, command) {
     const locations = ownedHookLocations(config, event);
     if (locations.length !== 1) return [];
     const handler = locations[0]?.handler;
-    return handler?.command === hookCommand(command, event, "posix") && handler.commandWindows === hookCommand(command, event, "windows") ? [] : [`owned_hook_drifted:${event}`];
+    return ownedHookEntryMatches(handler, ownedHookEntry(command, event)) ? [] : [`owned_hook_drifted:${event}`];
   });
 }
+function ownedHookEntryMatches(actual, expected) {
+  if (actual === void 0) return false;
+  const actualKeys = Object.keys(actual).sort();
+  const expectedKeys = Object.keys(expected).sort();
+  return actualKeys.length === expectedKeys.length && expectedKeys.every((key, index) => actualKeys[index] === key && actual[key] === expected[key]);
+}
 async function readTrustConfig(configPath) {
   try {
     return await readCodexConfig(codexConfigPath(configPath));
@@ -7232,8 +7344,11 @@ var InstalledHostRuntimeHookAdapter = class {
       const isInstalled = transition.target.components.includes(producer);
       const entry = this.entry(producer, paths);
       if (wasInstalled && !isInstalled) {
-        await uninstallProducerHooks(producer, this.homes);
-        if (!remaining.has(entry.entryRoot)) await removeHostEntryLinks(entry.entryRoot);
+        const entryState = await inspectHostEntryLinks(entry.entryRoot, entry.targets);
+        if (entryState !== "drifted") {
+          await uninstallProducerHooks(producer, this.homes);
+          if (!remaining.has(entry.entryRoot)) await removeHostEntryLinks(entry.entryRoot);
+        }
       }
       if (isInstalled) {
         await installHostEntryLinks(entry.entryRoot, entry.targets);
@@ -8024,7 +8139,8 @@ function createLinuxUserSystemdAdapter(options) {
       await ensurePrivateUnitDirectory(unitDirectory);
       const ownedUnits = await ownedHostUnits(unitDirectory);
       for (const service of target.services) await replaceOwnedUnit(unitDirectory, identity, service);
-      for (const unit of ownedUnits) {
+      const removableUnits = target.services.length === 0 ? ownedUnits.filter((unit) => unit.identity === identity) : ownedUnits;
+      for (const unit of removableUnits) {
         if (unit.identity === identity && targetByComponent.has(unit.component)) continue;
         await invokeSystemctl(run, systemctl, ["--user", "disable", "--now", unitName(unit.identity, unit.component)]);
         await removeOwnedUnit(unitDirectory, unit.identity, unit.component);
@@ -8036,7 +8152,7 @@ function createLinuxUserSystemdAdapter(options) {
         if (previousByComponent.has(service.component)) await invokeSystemctl(run, systemctl, ["--user", "restart", name]);
         await requireExpectedReadback(run, systemctl, unitDirectory, identity, service, "running");
       }
-      for (const unit of ownedUnits) if (unit.identity !== identity || !targetByComponent.has(unit.component)) await requireAbsentReadback(run, systemctl, unitDirectory, unit.identity, unit.component);
+      for (const unit of removableUnits) if (unit.identity !== identity || !targetByComponent.has(unit.component)) await requireAbsentReadback(run, systemctl, unitDirectory, unit.identity, unit.component);
     },
     async restart({ target, service }) {
       const identity = prefixIdentity(target.prefix);