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

package/libexec/ceal-host/control.mjs

@@ -2176,6 +2176,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_APPROVAL_DISPOSITIONS = vocabulary([
   "approval_not_required_by_policy",
   "interactive_pending",
@@ -2432,7 +2433,13 @@ var CEAL_OPERATION_JSON_SCHEMA_BUDGET = Object.freeze({
   max_string_length: OPERATION_SCHEMA_LITERAL_MAX_BYTES / 4,
   max_alternatives: 8,
   max_enum_values: 64,
-  max_literal_bytes: OPERATION_SCHEMA_LITERAL_MAX_BYTES
+  max_literal_bytes: OPERATION_SCHEMA_LITERAL_MAX_BYTES,
+  /** @basis our_policy -- bounds explanatory schema prose carried in one catalog. */
+  max_description_characters: 1024,
+  /** @basis our_policy -- bounds regular-expression compilation input from one schema. */
+  max_pattern_characters: 256,
+  /** @basis our_policy -- bounds traversal work inside one already byte-bounded schema literal. */
+  max_literal_nodes: 512
 });
 
 // packages/ceal-client-protocol/src/operation-validation-primitives.ts
@@ -2452,6 +2459,9 @@ function requireIsoTimestamp(value, message) {
   if (typeof value !== "string" || !ISO_TIMESTAMP.test(value) || !Number.isFinite(Date.parse(value))) throw new TypeError(message);
 }
 
+// packages/ceal-client-protocol/src/operation-json-schema.ts
+var JSON_DESCRIPTION_CONTROL_CHARACTER = new RegExp("\\p{Cc}", "u");
+
 // packages/ceal-client-protocol/src/operation-contract-validation.ts
 var CEAL_OPERATION_AUTHORITY_POLICY_KEYS = Object.freeze(["profile", "instance_binding", "target", "admission_recheck"]);
 var MAX_OPERATION_INPUT_RESOLVER_BINDINGS = 96;
@@ -2552,7 +2562,6 @@ var CEAL_BOUNDED_SERIES_CATALOG = Object.freeze({
   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"),
@@ -2561,8 +2570,6 @@ var CEAL_BOUNDED_SERIES_CATALOG = Object.freeze({
   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"),
@@ -2577,6 +2584,11 @@ var CEAL_BOUNDED_SERIES_CATALOG = Object.freeze({
   gateway_admin_access_token: (root) => join(root, "access-tokens.jsonl")
 });
 
+// packages/ceal-client-protocol/src/gateway-installation-activation.ts
+var CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_DATA_CHARACTERS = 32;
+var CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_CHECK_CHARACTERS = 8;
+var CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_COMPACT_CHARACTERS = CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_DATA_CHARACTERS + CEAL_GATEWAY_INSTALLATION_ACTIVATION_CODE_CHECK_CHARACTERS;
+
 // packages/ceal-client-protocol/src/host-registration.ts
 var CEAL_HOST_REGISTRATION_RESULT_KEYS = Object.freeze(["credential_generation", "host_access_token", "host_installation_ref", "host_source_ref", "ok", "registration_attempt_ref", "schema_version", "status"]);
 
@@ -2885,7 +2897,7 @@ var CEAL_REQUEST_RUN_BATCH_JSON_SCHEMA = {
 };
 
 // packages/ceal-client-protocol/src/host-observation.ts
-var CEAL_LOCAL_HOST_CAPABILITIES_SCHEMA_VERSION = "ceal.local_host_capabilities.v6";
+var CEAL_LOCAL_HOST_CAPABILITIES_SCHEMA_VERSION = "ceal.local_host_capabilities.v7";
 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;
@@ -3152,7 +3164,7 @@ 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_AUTOMATIC_FEEDBACK_INTENTS = vocabulary(["initial"]);
 var CEAL_LEASED_MESSAGE_DELIVERY_CAPABILITY_IDS = vocabulary(["message.create", "message.update", "message.delete"]);
 var CEAL_REPOSITORY_VISIBILITIES = vocabulary(["public", "private", "internal"]);
 var CEAL_RESULT_DELIVERY_OFFERS = vocabulary(["pending", "offered", "transport_lost"]);
@@ -3429,6 +3441,7 @@ import { promisify as promisify2 } from "node:util";
 // host/relay/src/producer-frame.ts
 var HOST_PRODUCER_FRAME_SCHEMA = "ceal.host_producer_frame.v1";
 var HOST_PRODUCER_MAX_JSON_BYTES = 262144;
+var HOST_PRODUCER_FRAME_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
 var SAFE_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"]);
@@ -3448,18 +3461,18 @@ 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);
+  const result = Buffer.allocUnsafe(json.byteLength + HOST_PRODUCER_FRAME_LENGTH_BYTES);
   result.writeUInt32BE(json.byteLength, 0);
-  json.copy(result, 4);
+  json.copy(result, HOST_PRODUCER_FRAME_LENGTH_BYTES);
   return result;
 }
 function decodeHostProducerFrame(input) {
-  if (input.byteLength < 4) throw new HostProducerFrameError("frame_truncated", `frame_truncated: ${refusalFact("frame_bytes", input.byteLength, "at least 4")}`);
+  if (input.byteLength < HOST_PRODUCER_FRAME_LENGTH_BYTES) throw new HostProducerFrameError("frame_truncated", `frame_truncated: ${refusalFact("frame_bytes", input.byteLength, `at least ${HOST_PRODUCER_FRAME_LENGTH_BYTES}`)}`);
   const length = input.readUInt32BE(0);
   if (length > HOST_PRODUCER_MAX_JSON_BYTES) throw new HostProducerFrameError("frame_too_large", `frame_too_large: ${refusalFact("declared_bytes", length, `at most ${HOST_PRODUCER_MAX_JSON_BYTES}`)}`);
   if (length === 0) throw new HostProducerFrameError("invalid_frame_length");
-  if (input.byteLength !== length + 4) throw new HostProducerFrameError(input.byteLength < length + 4 ? "frame_truncated" : "invalid_frame_length");
-  const bytes = input.subarray(4);
+  if (input.byteLength !== length + HOST_PRODUCER_FRAME_LENGTH_BYTES) throw new HostProducerFrameError(input.byteLength < length + HOST_PRODUCER_FRAME_LENGTH_BYTES ? "frame_truncated" : "invalid_frame_length");
+  const bytes = input.subarray(HOST_PRODUCER_FRAME_LENGTH_BYTES);
   const text = new TextDecoder("utf-8", { fatal: true });
   let value;
   try {
@@ -3680,6 +3693,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_IPC_LENGTH_BYTES = Uint32Array.BYTES_PER_ELEMENT;
+var HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES = 4096;
 var HostRelayIpcError = class extends Error {
   code;
   constructor(code3, message = code3) {
@@ -3733,12 +3748,12 @@ function exchange(endpoint, encoded, timeoutMs, decode) {
   });
 }
 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")}.`);
+  if (input.length < HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response is truncated: ${refusalFact("response_bytes", input.byteLength, `at least ${HOST_RELAY_IPC_LENGTH_BYTES}`)}.`);
   const length = input.readUInt32BE(0);
-  if (length === 0 || length > 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}` }])}.`);
+  if (length === 0 || length > HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES || input.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response length is invalid: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `between 1 and ${HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES}` }, { name: "received_bytes", value: input.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
   let value;
   try {
-    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(4)));
+    value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(HOST_RELAY_IPC_LENGTH_BYTES)));
   } catch {
     throw new HostRelayIpcError("relay_unavailable", "Host Relay IPC response is invalid.");
   }
@@ -3761,11 +3776,11 @@ function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function decodeResponseBuffer(buffer) {
-  if (buffer.length < 4) return null;
+  if (buffer.length < HOST_RELAY_IPC_LENGTH_BYTES) 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}` }])}.`);
+  if (length === 0 || length > HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC response length is invalid: ${refusalFact("declared_bytes", length, `between 1 and ${HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES}`)}.`);
+  if (buffer.length < length + HOST_RELAY_IPC_LENGTH_BYTES) return null;
+  if (buffer.length !== length + HOST_RELAY_IPC_LENGTH_BYTES) throw new HostRelayIpcError("relay_unavailable", `Host Relay IPC returned trailing bytes: ${refusalFacts([{ name: "declared_bytes", value: length, expected: `the received message length minus ${HOST_RELAY_IPC_LENGTH_BYTES}` }, { name: "received_bytes", value: buffer.byteLength, expected: `exactly ${length + HOST_RELAY_IPC_LENGTH_BYTES}` }])}.`);
   return decodeHostRelayIpcResponse(buffer);
 }
 
@@ -4166,7 +4181,8 @@ var CODEX_CLI_VERSION = "0.152.0";
 var CODEX_HOOK_FEATURE = "hooks";
 var CODEX_HOOKS_CONFIG_FILE = "hooks.json";
 var CODEX_HOOK_OWNER = "ceal-codex-host-observation-v1";
-var CODEX_SESSION_ID_ENVIRONMENT = "CODEX_THREAD_ID";
+var CODEX_THREAD_ID_ENVIRONMENT = "CODEX_THREAD_ID";
+var CODEX_SESSION_ID_ENVIRONMENT = "CODEX_SESSION_ID";
 var CODEX_OUTBOX_SCHEMA_VERSION = "ceal.codex_observation_outbox.v1";
 var CODEX_TURN_BINDING_SCHEMA_VERSION = "ceal.codex_turn_binding.v1";
 var CODEX_SESSION_SCHEMA_VERSION = "ceal.codex_session.v1";
@@ -4251,6 +4267,7 @@ function isRecord2(value) {
 
 // host/codex/src/codex-outbox.ts
 var SAFE_REF6 = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+var CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS = 4096;
 var CodexOutboxStore = class {
   directory;
   entriesDirectory;
@@ -4617,13 +4634,13 @@ function validateRegistration(value) {
 }
 function validateRegistrationFields(value) {
   if (![value.host_source_ref, value.host_session_ref, value.codex_session_id].every((candidate) => typeof candidate === "string" && SAFE_REF6.test(candidate))) throw storageError(`Codex transcript registration references are malformed (${refusalFacts([{ name: "host_source_ref", value: value.host_source_ref }, { name: "host_session_ref", value: value.host_session_ref }, { name: "codex_session_id", value: value.codex_session_id }])}).`);
-  if (!validRegistrationCwd(value.cwd)) throw storageError(`Codex transcript registration working directory is malformed (${refusalFact("cwd_characters", typeof value.cwd === "string" ? value.cwd.length : 0, "an absolute path of at most 4096 characters")}).`);
+  if (!validRegistrationCwd(value.cwd)) throw storageError(`Codex transcript registration working directory is malformed (${refusalFact("cwd_characters", typeof value.cwd === "string" ? value.cwd.length : 0, `an absolute path of at most ${CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS} characters`)}).`);
   if (typeof value.transcript_path !== "string") throw storageError(`Codex transcript registration path is malformed (${refusalFact("kind", typeof value.transcript_path, "string")}).`);
-  if (value.transcript_path.length === 0 || value.transcript_path.length > 4096) throw storageError(`Codex transcript registration path is malformed (${refusalFact("characters", value.transcript_path.length, "from 1 through 4096")}).`);
+  if (value.transcript_path.length === 0 || value.transcript_path.length > CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS) throw storageError(`Codex transcript registration path is malformed (${refusalFact("characters", value.transcript_path.length, `from 1 through ${CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS}`)}).`);
   if (!isTimestamp(value.registered_at) || !isTimestamp(value.expires_at)) throw storageError(`Codex transcript registration timestamps are malformed (${refusalFacts([{ name: "registered_at", value: value.registered_at }, { name: "expires_at", value: value.expires_at }])}).`);
 }
 function validRegistrationCwd(value) {
-  return value === void 0 || typeof value === "string" && isAbsolute(value) && value.length <= 4096 && !value.includes("\0");
+  return value === void 0 || typeof value === "string" && isAbsolute(value) && value.length <= CODEX_TRANSCRIPT_PATH_MAX_CHARACTERS && !value.includes("\0");
 }
 function validateCursor(value) {
   if (!isRecord3(value)) throw storageError("Codex transcript cursor is malformed.");
@@ -5978,6 +5995,8 @@ var HOST_REGISTRATION_STATE_KEYS = Object.freeze([
 
 // host/relay/src/host-relay-runtime.ts
 var HOST_RELAY_CONFIG_SCHEMA = "ceal.host_relay_config.v1";
+var HOST_RELAY_CONFIG_MIN_BYTES = Buffer.byteLength("{}", "utf8");
+var HOST_RELAY_CONFIG_MAX_BYTES = 65536;
 var HostRelayConfigError = class extends Error {
   name = "HostRelayConfigError";
   code;
@@ -5994,7 +6013,7 @@ async function readHostRelayConfig(path) {
     handle = await open6(path, O_RDONLY4 | O_NOFOLLOW3);
     const stats = await handle.stat();
     if (!stats.isFile() || !ownerPrivate2(stats)) throw new HostRelayConfigError("config_not_private", "Host Relay config file is not owner-private.");
-    if (stats.size < 2 || stats.size > 65536) throw new HostRelayConfigError("invalid_config", `invalid_config: Host Relay config size is invalid: ${refusalFact("config_bytes", stats.size, "between 2 and 65536")}.`);
+    if (stats.size < HOST_RELAY_CONFIG_MIN_BYTES || stats.size > HOST_RELAY_CONFIG_MAX_BYTES) throw new HostRelayConfigError("invalid_config", `invalid_config: Host Relay config size is invalid: ${refusalFact("config_bytes", stats.size, `between ${HOST_RELAY_CONFIG_MIN_BYTES} and ${HOST_RELAY_CONFIG_MAX_BYTES}`)}.`);
     const text = await handle.readFile("utf8");
     assertNoDuplicateJsonKeys(text);
     let value;
@@ -6067,7 +6086,7 @@ function exactOptionalKeys(value, required, optional) {
 // host/lifecycle/src/host-runtime-hooks.ts
 import { lstat as lstat8 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname7, join as join11 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join11 } from "node:path";
 
 // host/hook-drift-policy.ts
 var REINSTALL_REPAIRS_PREFIX = ["owned_hook_drifted:"];
@@ -6238,7 +6257,7 @@ function hostLocalCapabilityDescriptor(input) {
   return {
     schema_version: CEAL_LOCAL_HOST_CAPABILITIES_SCHEMA_VERSION,
     owner: input.owner,
-    ...input.activationEnvironment === void 0 ? {} : { activation_environment: input.activationEnvironment },
+    ...input.activation === void 0 ? {} : { activation: input.activation },
     authentication: { mode: "nonce", execution: { mode: "verbatim", argv: [...argv, "authenticate", "--client-nonce"] } },
     capabilities: []
   };
@@ -6246,7 +6265,7 @@ function hostLocalCapabilityDescriptor(input) {
 
 // host/claude/src/claude-installer.ts
 var OWNER = "ceal-claude-host-observation-v1";
-var CLAUDE_LOCAL_CAPABILITY_ACTIVATION_ENVIRONMENT = "CLAUDE_CODE_ENTRYPOINT";
+var CLAUDE_LOCAL_CAPABILITY_ACTIVATION = Object.freeze({ environment: "CLAUDE_CODE_ENTRYPOINT", value: "cli" });
 function resolveClaudeSettingsPath(claudeHome, environment = process.env) {
   return join8(claudeHome ?? environment.CLAUDE_CONFIG_DIR ?? join8(homedir2(), ".claude"), "settings.json");
 }
@@ -6303,7 +6322,7 @@ async function doctorClaudeHooks(options) {
   return { status, settings_path: settingsPath, configured_events: configured, missing_events: missing, ...executableSha256 === void 0 ? {} : { executable_sha256: executableSha256 }, drift_reasons: reasons };
 }
 function claudeLocalCapabilityDescriptor(authenticationCommand) {
-  return hostLocalCapabilityDescriptor({ owner: OWNER, authenticationCommand, activationEnvironment: CLAUDE_LOCAL_CAPABILITY_ACTIVATION_ENVIRONMENT });
+  return hostLocalCapabilityDescriptor({ owner: OWNER, authenticationCommand, activation: CLAUDE_LOCAL_CAPABILITY_ACTIVATION });
 }
 async function installClaudeLocalCapability(path, authenticationCommand) {
   if (!isAbsolute3(path)) throw new ClaudeHostError("configuration", "Claude local capability path must be absolute.");
@@ -6452,6 +6471,7 @@ import { copyFile as copyFile2, lstat as lstat7, mkdir as mkdir8, open as open8,
 import { homedir as homedir3 } from "node:os";
 import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute4, join as join9 } from "node:path";
 import { fileURLToPath } from "node:url";
+var CODEX_HOOK_COMMAND_MAX_CHARACTERS = 4096;
 function codexHooksInstalled(doctor) {
   return doctor.status === "ready" || doctor.status === "installed";
 }
@@ -6588,7 +6608,7 @@ async function validateAuthenticationCommand(command) {
   }
 }
 function codexLocalCapabilityDescriptor(authenticationCommand) {
-  return hostLocalCapabilityDescriptor({ owner: CODEX_LOCAL_CAPABILITY_OWNER, authenticationCommand, activationEnvironment: CODEX_SESSION_ID_ENVIRONMENT });
+  return hostLocalCapabilityDescriptor({ owner: CODEX_LOCAL_CAPABILITY_OWNER, authenticationCommand, activation: { environment: CODEX_THREAD_ID_ENVIRONMENT, value: { environment: CODEX_SESSION_ID_ENVIRONMENT } } });
 }
 async function installCodexLocalCapability(path, authenticationCommand) {
   const current = await readOptionalText(path);
@@ -6704,7 +6724,7 @@ function validateHookHandler(entry) {
 }
 function validateCommandHookHandler(entry) {
   if (typeof entry.command !== "string") throw configurationError(`Codex hook command is malformed (${refusalFact("kind", typeof entry.command, "string")}).`);
-  if (entry.command.length === 0 || entry.command.length > 4096) throw configurationError(`Codex hook command is malformed (${refusalFact("characters", entry.command.length, "from 1 through 4096")}).`);
+  if (entry.command.length === 0 || entry.command.length > CODEX_HOOK_COMMAND_MAX_CHARACTERS) throw configurationError(`Codex hook command is malformed (${refusalFact("characters", entry.command.length, `from 1 through ${CODEX_HOOK_COMMAND_MAX_CHARACTERS}`)}).`);
   validateOptionalString(entry.commandWindows, "Codex hook commandWindows is malformed.");
   validateOptionalInteger(entry.timeout, 1, "Codex hook timeout is malformed.");
   validateOptionalBoolean(entry.async, "Codex hook async flag is malformed.");
@@ -6942,6 +6962,9 @@ function isHostBundleComponent(value) {
 function isHostBundleProducer(value) {
   return HOST_BUNDLE_PRODUCERS.some((producer) => producer === value);
 }
+function hostPrivateRuntimeModule(entry) {
+  return `${entry}.mjs`;
+}
 function hostBundleComponentsForProducers(producers) {
   const selected = /* @__PURE__ */ new Set(["lifecycle", "relay", ...producers]);
   return HOST_BUNDLE_COMPONENTS.filter((component) => selected.has(component));
@@ -6981,14 +7004,14 @@ function resolveInstalledHostRuntimePaths(prefix, platform = process.platform) {
   return {
     private_root: privateRoot,
     node_executable: join10(privateRoot, "node", "bin", platform === "win32" ? "node.exe" : "node"),
-    control_module: join10(privateRoot, "control.mjs"),
-    codex_hook_module: join10(privateRoot, "codex-hook.mjs"),
-    codex_invocation_authentication_module: join10(privateRoot, "codex-invocation-authentication.mjs"),
-    claude_hook_module: join10(privateRoot, "claude-hook.mjs"),
-    claude_invocation_authentication_module: join10(privateRoot, "claude-invocation-authentication.mjs"),
-    relay_module: join10(privateRoot, "relay.mjs"),
-    codex_producer_module: join10(privateRoot, "codex-producer.mjs"),
-    claude_producer_module: join10(privateRoot, "claude-producer.mjs")
+    control_module: join10(privateRoot, hostPrivateRuntimeModule("control")),
+    codex_hook_module: join10(privateRoot, hostPrivateRuntimeModule("codex-hook")),
+    codex_invocation_authentication_module: join10(privateRoot, hostPrivateRuntimeModule("codex-invocation-authentication")),
+    claude_hook_module: join10(privateRoot, hostPrivateRuntimeModule("claude-hook")),
+    claude_invocation_authentication_module: join10(privateRoot, hostPrivateRuntimeModule("claude-invocation-authentication")),
+    relay_module: join10(privateRoot, hostPrivateRuntimeModule("relay")),
+    codex_producer_module: join10(privateRoot, hostPrivateRuntimeModule("codex-producer")),
+    claude_producer_module: join10(privateRoot, hostPrivateRuntimeModule("claude-producer"))
   };
 }
 function parseHostRuntimeControlRequest(value) {
@@ -7229,13 +7252,13 @@ var InstalledHostRuntimeHookAdapter = class {
     const targets = { runtime: paths.private_root, services: servicesRoot };
     if (producer === "codex") {
       const entryRoot2 = resolveHostEntryRoot(this.homes.codex_home, ".codex");
-      const hook2 = hostEntryCommand({ entryRoot: entryRoot2, module: "codex-hook.mjs", configFlag: HOST_PRODUCER_CONFIG_FLAG, configFile: "codex.json" });
-      const authentication2 = hostEntryCommand({ entryRoot: entryRoot2, module: "codex-invocation-authentication.mjs", configFlag: HOST_PRODUCER_CONFIG_FLAG, configFile: "codex.json" });
+      const hook2 = hostEntryCommand({ entryRoot: entryRoot2, module: hostPrivateRuntimeModule("codex-hook"), configFlag: HOST_PRODUCER_CONFIG_FLAG, configFile: "codex.json" });
+      const authentication2 = hostEntryCommand({ entryRoot: entryRoot2, module: hostPrivateRuntimeModule("codex-invocation-authentication"), configFlag: HOST_PRODUCER_CONFIG_FLAG, configFile: "codex.json" });
       return { entryRoot: entryRoot2, targets, hook: hook2, authentication: authentication2, configPath: this.configPaths.codex };
     }
     const entryRoot = resolveHostEntryRoot(this.homes.claude_home, ".claude");
-    const hook = hostEntryCommand({ entryRoot, module: "claude-hook.mjs", configFlag: HOST_PRODUCER_CONFIG_FLAG, configFile: "claude.json" });
-    const authentication = hostEntryCommand({ entryRoot, module: "claude-invocation-authentication.mjs", configFlag: HOST_PRODUCER_CONFIG_FLAG, configFile: "claude.json" });
+    const hook = hostEntryCommand({ entryRoot, module: hostPrivateRuntimeModule("claude-hook"), configFlag: HOST_PRODUCER_CONFIG_FLAG, configFile: "claude.json" });
+    const authentication = hostEntryCommand({ entryRoot, module: hostPrivateRuntimeModule("claude-invocation-authentication"), configFlag: HOST_PRODUCER_CONFIG_FLAG, configFile: "claude.json" });
     return { entryRoot, targets, hook, authentication, configPath: this.configPaths.claude };
   }
 };
@@ -7306,13 +7329,17 @@ function claudeLocalCapabilityPath(claudeHome) {
 async function assertRegularRuntimeFile(path, executable) {
   let info;
   const platform = process.platform;
+  const module2 = basename3(path);
   try {
     info = await lstat8(path);
-  } catch (error) {
-    throw new Error(`The installed Host private runtime is unavailable (${refusalFact("error", error)}).`);
+  } catch {
+    throw runtimeUnavailable(`missing_module:${module2}`);
   }
-  if (!info.isFile() || info.isSymbolicLink()) throw new Error(`The installed Host private runtime is unavailable (${refusalFact("mode", `0o${info.mode.toString(8)}`, "a regular-file mode (0o100xxx)")}).`);
-  if (executable && platform !== "win32" && (info.mode & 73) === 0) throw new Error(`The installed Host private runtime is unavailable (${refusalFacts([{ name: "mode", value: `0o${info.mode.toString(8)}`, expected: "at least one execute bit" }, { name: "platform", value: platform, expected: "win32, where the execute bit is not required" }])}).`);
+  if (!info.isFile() || info.isSymbolicLink()) throw runtimeUnavailable(`irregular_module:${module2}`);
+  if (executable && platform !== "win32" && (info.mode & 73) === 0) throw runtimeUnavailable(`non_executable_module:${module2}`);
+}
+function runtimeUnavailable(reason) {
+  return new HostRuntimeReasonedError("private_runtime_unavailable", [reason]);
 }
 function selectedProducers(selection) {
   return selection.components.filter(isHostBundleProducer);
@@ -7323,7 +7350,7 @@ import { execFile } from "node:child_process";
 import { constants as constants3 } from "node:fs";
 import { chmod as chmod2, lstat as lstat9, mkdir as mkdir9, open as open9, rename as rename8, unlink as unlink5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { basename as basename3, dirname as dirname8, join as join12 } from "node:path";
+import { basename as basename4, dirname as dirname8, join as join12 } from "node:path";
 import { promisify } from "node:util";
 import { createHash as createHash7 } from "node:crypto";
 
@@ -7338,11 +7365,6 @@ function equalStringLists(left, right) {
 // host/lifecycle/src/host-runtime-services.ts
 var HOST_RUNTIME_SERVICE_COMPONENTS = Object.freeze(hostBundleComponentsForProducers(HOST_BUNDLE_PRODUCERS).filter((component) => component !== "lifecycle"));
 var HOST_RUNTIME_SERVICE_COMMAND_TIMEOUT_MS = 2e4;
-var ENTRYPOINTS = Object.freeze({
-  relay: "relay.mjs",
-  codex: "codex-producer.mjs",
-  claude: "claude-producer.mjs"
-});
 var HOST_RUNTIME_SERVICE_STATES = ["absent", "stopped", "running", "unknown"];
 var HostRuntimeServiceContractError = class extends Error {
   code;
@@ -7361,7 +7383,7 @@ function createHostRuntimeServiceSet(input) {
   const node = path.join(prefix, HOST_BUNDLE_PRIVATE_RUNTIME_ROOT, "node", "bin", flavor === "windows" ? "node.exe" : "node");
   const services = selected.map((component) => {
     const config = absoluteNormalizedPath(input.config_paths[component], `${component} service config`, path);
-    const entrypoint = path.join(prefix, HOST_BUNDLE_PRIVATE_RUNTIME_ROOT, ENTRYPOINTS[component]);
+    const entrypoint = path.join(prefix, HOST_BUNDLE_PRIVATE_RUNTIME_ROOT, hostPrivateRuntimeModule(component === "relay" ? component : `${component}-producer`));
     const command = { executable: node, args: [entrypoint, "serve", "--config", config] };
     validateHostCommandVector(command);
     return { component, command };
@@ -7601,7 +7623,7 @@ async function readManagedPlist(path, marker, uid) {
 async function writeManagedPlist(path, marker, text, uid) {
   const current = await readManagedPlist(path, marker, uid);
   if (current === text) return;
-  const temporary = join12(dirname8(path), `.${basename3(path)}.${process.pid}.${createHash7("sha256").update(`${Date.now()}:${Math.random()}`).digest("hex").slice(0, 12)}.tmp`);
+  const temporary = join12(dirname8(path), `.${basename4(path)}.${process.pid}.${createHash7("sha256").update(`${Date.now()}:${Math.random()}`).digest("hex").slice(0, 12)}.tmp`);
   try {
     const handle = await open9(temporary, "wx", 384);
     try {
@@ -7920,7 +7942,7 @@ var WINDOWS_TASK_SCHEDULER_PROGRAM = Buffer.from(TASK_SCHEDULER_SOURCE, "utf16le
 
 // host/lifecycle/src/host-runtime-systemd.ts
 import { createHash as createHash8, randomUUID } from "node:crypto";
-import { chmod as chmod3, lstat as lstat10, mkdir as mkdir10, open as open10, readFile as readFile6, rename as rename9, unlink as unlink6 } from "node:fs/promises";
+import { chmod as chmod3, lstat as lstat10, mkdir as mkdir10, open as open10, readFile as readFile6, readdir as readdir3, rename as rename9, unlink as unlink6 } from "node:fs/promises";
 import { join as join13 } from "node:path";
 
 // host/lifecycle/src/systemd-unit-show.ts
@@ -8000,12 +8022,12 @@ function createLinuxUserSystemdAdapter(options) {
       const previousByComponent = serviceMap(previous);
       const targetByComponent = serviceMap(target);
       await ensurePrivateUnitDirectory(unitDirectory);
-      const ownedUnits = await ownedUnitComponents(unitDirectory, identity, previousByComponent, targetByComponent);
+      const ownedUnits = await ownedHostUnits(unitDirectory);
       for (const service of target.services) await replaceOwnedUnit(unitDirectory, identity, service);
-      for (const service of previous.services) {
-        if (targetByComponent.has(service.component)) continue;
-        if (ownedUnits.has(service.component)) await invokeSystemctl(run, systemctl, ["--user", "disable", "--now", unitName(identity, service.component)]);
-        await removeOwnedUnit(unitDirectory, identity, service.component);
+      for (const unit of ownedUnits) {
+        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);
       }
       await invokeSystemctl(run, systemctl, ["--user", "daemon-reload"]);
       for (const service of target.services) {
@@ -8014,9 +8036,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 service of previous.services) {
-        if (!targetByComponent.has(service.component)) await requireAbsentReadback(run, systemctl, unitDirectory, identity, service.component);
-      }
+      for (const unit of ownedUnits) 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);
@@ -8054,12 +8074,20 @@ function unitPath(directory, identity, component) {
 function serviceMap(set) {
   return new Map(set.services.map((service) => [service.component, service]));
 }
-async function ownedUnitComponents(directory, identity, previous, target) {
-  const owned = /* @__PURE__ */ new Set();
-  for (const component of HOST_RUNTIME_SERVICE_COMPONENTS) {
-    if ((previous.has(component) || target.has(component)) && await ownedUnitPresent(unitPath(directory, identity, component), identity, component)) owned.add(component);
+async function ownedHostUnits(directory) {
+  const owned = [];
+  for (const name of await readdir3(directory)) {
+    const match = /^ceal-host-([a-f0-9]{64})-(lifecycle|relay|codex|claude)\.service$/u.exec(name);
+    if (match === null) continue;
+    const identity = match[1];
+    const component = match[2];
+    if (identity === void 0 || !UNIT_ID_PATTERN.test(identity) || !isHostRuntimeServiceComponent(component)) continue;
+    if (await ownedUnitPresent(unitPath(directory, identity, component), identity, component)) owned.push({ identity, component });
   }
-  return owned;
+  return owned.sort((left, right) => unitName(left.identity, left.component).localeCompare(unitName(right.identity, right.component)));
+}
+function isHostRuntimeServiceComponent(value) {
+  return value !== void 0 && HOST_RUNTIME_SERVICE_COMPONENTS.some((component) => component === value);
 }
 async function ensurePrivateUnitDirectory(directory) {
   try {
@@ -8227,6 +8255,7 @@ function projectionError(detail) {
 // host/lifecycle/src/host-runtime-composition.ts
 var execFileAsync2 = promisify2(execFile2);
 var STATE_ROOT_ENVIRONMENT = "CEAL_HOST_STATE_ROOT";
+var HOST_STATE_ROOT_MAX_CHARACTERS = 4096;
 var InstalledHostRuntimeCompositionError = class extends Error {
   code;
   constructor(code3, message) {
@@ -8407,7 +8436,7 @@ function processFailure(error) {
 function resolveStateRoot(environment, platform) {
   const value = environment[STATE_ROOT_ENVIRONMENT];
   const path = platform === "win32" ? win324 : posix3;
-  if (value === void 0 || value.length === 0 || value.length > 4096 || value.includes("\0") || !path.isAbsolute(value) || path.normalize(value) !== value || path.parse(value).root === value) throw new InstalledHostRuntimeCompositionError("state_root_unavailable", `The Go-owned Host state root is unavailable (${refusalFact("state_root", value, "a normalized absolute non-root path of at most 4096 characters")}).`);
+  if (value === void 0 || value.length === 0 || value.length > HOST_STATE_ROOT_MAX_CHARACTERS || value.includes("\0") || !path.isAbsolute(value) || path.normalize(value) !== value || path.parse(value).root === value) throw new InstalledHostRuntimeCompositionError("state_root_unavailable", `The Go-owned Host state root is unavailable (${refusalFact("state_root", value, `a normalized absolute non-root path of at most ${HOST_STATE_ROOT_MAX_CHARACTERS} characters`)}).`);
   return value;
 }
 function prefixFromPaths(paths, platform) {