@corca-org/ceal-host-win32-x64 1.0.19 → 1.0.20

package/libexec/ceal-host/control.mjs

@@ -3093,6 +3093,7 @@ var OPTIONAL_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_o
 var CEAL_SYSTEMCTL_EXECUTABLE_PATH = "/usr/bin/systemctl";
 
 // packages/ceal-client-protocol/src/resource-row.ts
+var CEAL_RESOURCE_ROW_TITLE_MATCH_DISPOSITIONS = vocabulary(["exact", "not_exact", "unknown"]);
 var CEAL_RESOURCE_SEARCH_ORDERS = vocabulary(["relevance", "modified", "viewed", "created"]);
 var CEAL_RESOURCE_SEARCH_DIRECTIONS = vocabulary(["ascending", "descending"]);
 var CEAL_RESOURCE_SEARCH_FILTERS = vocabulary(["query", "modified_since", "since", "until", "authored_by_me", "authored_by", "include_replies", "kinds", "container_ref", "container_refs", "container_names", "addressed_to_me", "unread"]);
@@ -3176,6 +3177,7 @@ var RESOURCE_ROW_KEY_RULES = Object.freeze({
   next: { required: true, timestamp: false },
   kind: { required: true, timestamp: false },
   matched_kinds: { required: false, timestamp: false },
+  title_match: { required: false, timestamp: false },
   title: { required: true, timestamp: false },
   container_label: { required: true, timestamp: false },
   container_ref: { required: false, timestamp: false },
@@ -3663,7 +3665,7 @@ var CEAL_HOST_AUTHENTICATION_POLICY = Object.freeze({
   invalid_arguments: Object.freeze({ classification: "host_arguments_invalid", next_action: "answer_with_gap" }),
   options_invalid: Object.freeze({ classification: "host_configuration_invalid", next_action: "answer_with_gap" }),
   session_unavailable: Object.freeze({ classification: "host_session_unavailable", next_action: "answer_with_gap" }),
-  context_unavailable: Object.freeze({ classification: "host_context_unavailable", next_action: "refresh_host_invocation_context", remedy: "the Host has no invocation context from the current transcript turn; run `ceal-host install` to repair the Host hook registration, then retry this command on a fresh Host turn" }),
+  context_unavailable: Object.freeze({ classification: "host_context_unavailable", next_action: "refresh_host_invocation_context", remedy: "the Host has no invocation context from the current transcript turn; send a new message to start a fresh Host turn, then retry this command on that turn (run `ceal-host install` only if the Host hook registration is missing or drifted)" }),
   context_replaced: Object.freeze({ classification: "host_invocation_context_stale", next_action: "refresh_host_invocation_context" }),
   no_binding: Object.freeze({ classification: "host_binding_unavailable", next_action: "refresh_host_invocation_context" }),
   context_stale: Object.freeze({ classification: "host_invocation_context_stale", next_action: "refresh_host_invocation_context" }),
@@ -3693,6 +3695,7 @@ var CEAL_HOST_SERVICE_DIAGNOSTIC_EVENTS = vocabulary([
   "watcher_turn_observed",
   "current_prompt_registered",
   "current_prompt_registration_failed",
+  "current_prompt_capacity_exhausted",
   "activation_recorded",
   "activation_failed",
   "watcher_scan_failed",
@@ -4357,7 +4360,7 @@ import { promisify as promisify2 } from "node:util";
 // host/relay/src/host-producer-core.ts
 import { createHash as createHash3 } from "node:crypto";
 import { O_NOFOLLOW as O_NOFOLLOW2, O_RDONLY as O_RDONLY3 } from "node:constants";
-import { mkdir as mkdir2, open as open4, readFile, rename as rename2, writeFile } from "node:fs/promises";
+import { mkdir as mkdir2, open as open5, readFile, rename as rename2, writeFile } from "node:fs/promises";
 import { join as join2 } from "node:path";
 
 // host/relay/src/relay-ipc.ts
@@ -4366,6 +4369,60 @@ import { createConnection, createServer } from "node:net";
 // host/relay/src/current-prompt-custody.ts
 var HOST_CURRENT_PROMPT_MAX_BYTES = 256 * 1024;
 
+// host/service-log.ts
+import { constants as constants2 } from "node:fs";
+import { copyFile, open as open4, stat, truncate } from "node:fs/promises";
+var HOST_SERVICE_LOG_ENVIRONMENT = "CEAL_HOST_SERVICE_LOG";
+function writeHostServiceDiagnostic(producer_id, event, failure_kind, cause, sink) {
+  const line = `${JSON.stringify({ schema_version: CEAL_HOST_SERVICE_DIAGNOSTIC_SCHEMA, producer_id, event, ...event === "watcher_scan_failed" && failure_kind !== void 0 ? { failure_kind } : {}, ...event === "watcher_scan_failed" && cause !== void 0 ? { cause } : {} })}
+`;
+  try {
+    (sink ?? defaultHostServiceDiagnosticSink)(line);
+  } catch {
+  }
+}
+function defaultHostServiceDiagnosticSink(line) {
+  process.stderr.write(line);
+}
+var HOST_SERVICE_LOG_MAX_BYTES = 1024 * 1024;
+function hostServiceLogPreviousPath(path) {
+  return `${path}.1`;
+}
+var HOST_SERVICE_LOG_TAIL_BYTES = 64 * 1024;
+async function readHostServiceLogTail(path, lines) {
+  const current = await readTail(path);
+  if (current.length >= lines) return current.slice(-lines);
+  return [...await readTail(hostServiceLogPreviousPath(path)), ...current].slice(-lines);
+}
+async function readTail(path) {
+  let handle;
+  try {
+    handle = await open4(path, constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
+  } catch (error) {
+    if (isNotFound(error) || errorCode2(error) === "ELOOP") return [];
+    throw error;
+  }
+  try {
+    const info = await handle.stat();
+    if (!info.isFile()) return [];
+    const length = Math.min(info.size, HOST_SERVICE_LOG_TAIL_BYTES);
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, info.size - length);
+    const all = buffer.subarray(0, bytesRead).toString("utf8").split("\n");
+    if (length < info.size) all.shift();
+    all.pop();
+    return all;
+  } finally {
+    await handle.close();
+  }
+}
+function isNotFound(error) {
+  return errorCode2(error) === "ENOENT";
+}
+function errorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "unknown";
+}
+
 // host/relay/src/relay-ipc.ts
 var HOST_RELAY_REQUEST_BINDING_KEYS = Object.freeze([
   "schema_version",
@@ -4384,6 +4441,7 @@ var HOST_RELAY_REQUEST_BINDING_KEYS = Object.freeze([
 ]);
 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_RELEASE_SCHEMA = "ceal.host_relay_current_prompt_release.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;
@@ -4442,11 +4500,17 @@ var HostRelayIpcError = class extends Error {
     this.failure = failure;
   }
 };
+var HostRelayCurrentPromptCapacityRefusal = class extends Error {
+  constructor() {
+    super("current_prompt_capacity_exhausted");
+    this.name = "HostRelayCurrentPromptCapacityRefusal";
+  }
+};
 function hostRelayExchangeFailure(error) {
   return error instanceof HostRelayIpcError ? error.failure : void 0;
 }
 function socketErrorFailure(error) {
-  switch (errorCode2(error)) {
+  switch (errorCode3(error)) {
     case "EACCES":
     case "EPERM":
       return "permission_denied";
@@ -4481,8 +4545,14 @@ var HostRelayCurrentPromptPort = class {
   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 === "capacity_exhausted") throw new HostRelayCurrentPromptCapacityRefusal();
     if (response2.status !== "registered") throw new HostRelayIpcError("relay_unavailable", response2.status);
   }
+  async release(identity) {
+    const request2 = { schema_version: HOST_RELAY_CURRENT_PROMPT_RELEASE_SCHEMA, ...identity };
+    const response2 = await exchange(this.endpoint, encodeLengthPrefixed(request2), this.timeout_ms, decodeCurrentPromptResponseBuffer);
+    if (response2.status !== "released") throw new HostRelayIpcError("relay_unavailable", response2.status, "response_invalid");
+  }
 };
 function submitHostProducerFrame(endpoint, frame, timeoutMs = 5e3) {
   return exchange(endpoint, encodeHostProducerFrame(frame), timeoutMs, decodeResponseBuffer);
@@ -4565,7 +4635,7 @@ function decodeResponseBuffer(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");
+  if (!record2(value) || !exactKeys2(value, ["schema_version", "status"]) || value.schema_version !== HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA || value.status !== "registered" && value.status !== "capacity_exhausted" && value.status !== "current_prompt_unavailable" && value.status !== "released") throw new HostRelayIpcError("relay_unavailable", "Host Relay current-prompt response is invalid.", "response_invalid");
   return { schema_version: HOST_RELAY_CURRENT_PROMPT_RESULT_SCHEMA, status: value.status };
 }
 function decodeLengthPrefixedJson(input, maximum) {
@@ -4591,7 +4661,7 @@ function exactKeys2(value, required, optional = []) {
   const keys = Object.keys(value);
   return required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => required.includes(key) || optional.includes(key));
 }
-function errorCode2(error) {
+function errorCode3(error) {
   return record2(error) && typeof error.code === "string" ? error.code : null;
 }
 
@@ -4601,6 +4671,29 @@ function isHostTranscriptCursorReason(value) {
   return typeof value === "string" && HOST_TRANSCRIPT_CURSOR_REASONS.some((reason) => reason === value);
 }
 var TRANSCRIPT_MISSING_REASON = "transcript_missing";
+var TRANSCRIPT_SCAN_READ_ERROR_ERRNOS = ["EBADF", "EACCES", "EIO", "EMFILE", "ENFILE", "ENOENT", "ENOTDIR", "EPERM"];
+function transcriptScanFailureKind(error, adapterFailureKind) {
+  if (transcriptErrorCode(error) === "ELOOP") return "symlink";
+  const adapter = adapterFailureKind(error);
+  if (adapter !== void 0) return adapter;
+  const code2 = transcriptErrorCode(error);
+  if (code2 === "EFBIG") return "size_budget";
+  if (code2 !== null && TRANSCRIPT_SCAN_READ_ERROR_ERRNOS.includes(code2)) return "read_error";
+  return "other";
+}
+async function registerHostCurrentPromptDiagnosed(register, diagnostic) {
+  try {
+    await register();
+    diagnostic("current_prompt_registered");
+    return true;
+  } catch (error) {
+    if (!(error instanceof HostRelayCurrentPromptCapacityRefusal)) diagnostic("current_prompt_registration_failed");
+    throw error;
+  }
+}
+function transcriptErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
+}
 var HOST_TRANSCRIPT_READ_CHUNK_BYTES = 256 * 1024;
 async function readTranscriptCompleteChunk(handle, offset, size) {
   const available = Math.max(0, size - offset);
@@ -4709,19 +4802,24 @@ var HostTranscriptWatcher = class {
     return scanTranscriptRegistrations(await this.listRegistrations(), (registration) => this.scanRegistration(registration));
   }
   async scanRegistration(registration) {
-    return this.openTranscript(registration, (handle) => this.scanOpened(handle, registration), {
-      missing: () => this.retireMissing(registration),
-      failed: (handle, error) => this.scanFailed(handle, registration, error)
-    });
+    try {
+      return await this.openTranscript(registration, (handle) => this.scanOpened(handle, registration), {
+        missing: () => this.retireMissing(registration),
+        failed: (handle, error) => this.scanFailed(handle, registration, error)
+      });
+    } catch (error) {
+      if (error instanceof HostRelayCurrentPromptCapacityRefusal) return { records: 0, enqueued: 0, quarantined: false };
+      throw error;
+    }
   }
   async openTranscript(registration, scan, handlers) {
     let handle;
     try {
-      handle = await open4(this.transcriptPathOf(registration), O_RDONLY3 | O_NOFOLLOW2);
+      handle = await open5(this.transcriptPathOf(registration), O_RDONLY3 | O_NOFOLLOW2);
       return await scan(handle);
     } catch (error) {
       if (handle === void 0 && isMissingTranscriptError(error)) return handlers.missing();
-      if (hostRelayExchangeFailure(error) !== void 0) throw error;
+      if (hostRelayExchangeFailure(error) !== void 0 || error instanceof HostRelayCurrentPromptCapacityRefusal) throw error;
       return handlers.failed(handle, error);
     } finally {
       await handle?.close();
@@ -4862,7 +4960,7 @@ var HostProducerDrainCore = class {
       const value = JSON.parse(await readFile(this.statePath, "utf8"));
       return this.decodeState(value);
     } catch (error) {
-      if (errorCode3(error) !== "ENOENT") throw error;
+      if (errorCode4(error) !== "ENOENT") throw error;
       return { schema_version: this.stateSchema, producer_installation_ref: this.installationRef, producer_epoch: this.epoch, next_sequence: 1, pending: {} };
     }
   }
@@ -4908,7 +5006,7 @@ var HostProducerDrainCore = class {
 function isDrainStateHeader(value, schema, installationRef) {
   return isTranscriptRecord(value) && value.schema_version === schema && value.producer_installation_ref === installationRef && Number.isSafeInteger(value.producer_epoch) && Number(value.producer_epoch) > 0 && Number.isSafeInteger(value.next_sequence) && Number(value.next_sequence) > 0 && isTranscriptRecord(value.pending);
 }
-function errorCode3(error) {
+function errorCode4(error) {
   return typeof error === "object" && error !== null && "code" in error ? String(error.code) : null;
 }
 
@@ -4922,56 +5020,6 @@ var DEFAULT_LIMITS = { global_count: 8192, global_bytes: 64 * 1024 * 1024, produ
 var RETRY_SECONDS = [1, 2, 4, 8, 16, 32, 60];
 var MAX_RETRYABLE_ATTEMPTS = RETRY_SECONDS.length + 10;
 
-// host/service-log.ts
-import { constants as constants2 } from "node:fs";
-import { copyFile, open as open5, stat, truncate } from "node:fs/promises";
-var HOST_SERVICE_LOG_ENVIRONMENT = "CEAL_HOST_SERVICE_LOG";
-function writeHostServiceDiagnostic(producer_id, event, failure_kind) {
-  try {
-    process.stderr.write(`${JSON.stringify({ schema_version: CEAL_HOST_SERVICE_DIAGNOSTIC_SCHEMA, producer_id, event, ...event === "watcher_scan_failed" && failure_kind !== void 0 ? { failure_kind } : {} })}
-`);
-  } catch {
-  }
-}
-var HOST_SERVICE_LOG_MAX_BYTES = 1024 * 1024;
-function hostServiceLogPreviousPath(path) {
-  return `${path}.1`;
-}
-var HOST_SERVICE_LOG_TAIL_BYTES = 64 * 1024;
-async function readHostServiceLogTail(path, lines) {
-  const current = await readTail(path);
-  if (current.length >= lines) return current.slice(-lines);
-  return [...await readTail(hostServiceLogPreviousPath(path)), ...current].slice(-lines);
-}
-async function readTail(path) {
-  let handle;
-  try {
-    handle = await open5(path, constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
-  } catch (error) {
-    if (isNotFound(error) || errorCode4(error) === "ELOOP") return [];
-    throw error;
-  }
-  try {
-    const info = await handle.stat();
-    if (!info.isFile()) return [];
-    const length = Math.min(info.size, HOST_SERVICE_LOG_TAIL_BYTES);
-    const buffer = Buffer.alloc(length);
-    const { bytesRead } = await handle.read(buffer, 0, length, info.size - length);
-    const all = buffer.subarray(0, bytesRead).toString("utf8").split("\n");
-    if (length < info.size) all.shift();
-    all.pop();
-    return all;
-  } finally {
-    await handle.close();
-  }
-}
-function isNotFound(error) {
-  return errorCode4(error) === "ENOENT";
-}
-function errorCode4(error) {
-  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "unknown";
-}
-
 // host/claude/src/claude-decoder.ts
 import { createHash as createHash4 } from "node:crypto";
 
@@ -5628,6 +5676,7 @@ var TOKEN_OBSERVATION_SOURCE = "claude_transcript.message.usage";
 var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
   store;
   registerCurrentPrompt;
+  releaseCurrentPrompt;
   diagnostic;
   constructor(options) {
     super(options, {
@@ -5637,6 +5686,7 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
     });
     this.store = new ClaudeOutboxStore(options.outbox_dir);
     this.registerCurrentPrompt = options.register_current_prompt;
+    this.releaseCurrentPrompt = options.release_current_prompt;
     this.diagnostic = options.diagnostic ?? (() => void 0);
   }
   transcriptPathOf(registration) {
@@ -5649,19 +5699,23 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
     const { size, device, inode } = await ownedClaudeTranscriptFile(handle);
     const cursor = await this.preflight(registration, handle, size, device, inode);
     if (cursor === null) return { records: 0, enqueued: 0, quarantined: true };
-    if (cursor.status === "quarantined") return { records: 0, enqueued: 0, quarantined: true };
+    if (cursor.status === "quarantined") {
+      if (cursor.reason !== "transcript_malformed") await this.releaseStoredPromptBestEffort(registration.host_session_ref, cursor);
+      return { records: 0, enqueued: 0, quarantined: true };
+    }
     const draft = mutableCursor(cursor);
     await this.scanOpenedTranscript(registration, handle, draft, size, device, inode);
     return { records: draft.consumed, enqueued: draft.enqueued, quarantined: false };
   }
   async scanFailed(handle, registration, error) {
-    this.diagnostic("watcher_scan_failed", claudeTranscriptScanFailureKind(error));
+    this.diagnostic("watcher_scan_failed", claudeTranscriptScanFailureKind(error), claudeTranscriptScanCause(handle, error));
     if (handle === void 0 && isSymlinkTranscript(error)) return await this.quarantineUnopened(registration, "transcript_malformed");
     if (error instanceof ClaudeHostError && error.code === "payload_rejected") return await this.quarantineDraft(await this.preservedCursor(registration));
     await this.quarantineFailure(registration, handle);
     return { records: 0, enqueued: 0, quarantined: true };
   }
   async retireMissing(registration) {
+    await this.releaseStoredPromptBestEffort(registration.host_session_ref, await this.store.readTranscriptCursor(registration).catch(() => null));
     return this.retireMissingTranscript(registration.transcript_path, "Claude", () => this.store.retireTranscriptRegistration(registration));
   }
   initialCursor(registration) {
@@ -5708,10 +5762,10 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       if (isUserTurnLine(record7)) await this.openTurn(registration, draft, record7);
       else if (isAssistantUsageLine(record7)) this.accumulateUsage(draft, toUsage(record7.uuid, record7.timestamp, record7.message.usage));
       else if (isAssistantLine(record7) && record7.message.usage !== void 0) throw new ClaudeHostError("payload_rejected", "Claude transcript usage is malformed.");
+      if (isAssistantTerminalLine(record7)) await this.releaseOpenTurn(registration, draft);
     }
   }
   async openTurn(registration, draft, record7) {
-    this.diagnostic("watcher_turn_observed");
     await this.closeTurn(registration, draft, record7.timestamp);
     const sessionRef = registration.host_session_ref;
     const turnRef = claudeLocalTurnRef(registration.claude_session_id, record7.uuid);
@@ -5727,23 +5781,40 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       if (session !== null) observations.push({ observation_ref: observationRef("transcript_session", sessionRef, session.value), observation_kind: "session", observed_at: record7.timestamp, value: session.value });
       draft.session_observed = true;
     }
-    await this.store.putEnvelope({
-      schema_version: "ceal.claude_observation_outbox.v1",
-      identity,
-      host_input_ref: inputRef,
-      input_kind: "human",
-      prompt_ref: promptRef,
-      observations,
-      origin_input: true,
-      submission_ref: submissionRef("input", turnRef, inputRef, promptRef),
-      created_at: record7.timestamp,
-      expires_at: this.expire(this.outboxRetentionMs)
-    });
-    draft.enqueued += 1;
-    await this.registerPrompt(sessionRef, turnRef, promptRef, record7.message.content);
+    await this.persistOpenedTurnContext(registration, draft, record7, inputRef, turnRef, promptRef, identity, observations);
+  }
+  async persistOpenedTurnContext(registration, draft, record7, inputRef, turnRef, promptRef, identity, observations) {
+    const sessionRef = registration.host_session_ref;
+    const expiresAt = this.expire(this.outboxRetentionMs);
+    const custodyRegistered = await this.registerPrompt(sessionRef, turnRef, promptRef, record7.message.content, expiresAt);
+    if (custodyRegistered) this.diagnostic("watcher_turn_observed");
+    try {
+      await this.store.putEnvelope({
+        schema_version: "ceal.claude_observation_outbox.v1",
+        identity,
+        host_input_ref: inputRef,
+        input_kind: "human",
+        prompt_ref: promptRef,
+        observations,
+        origin_input: true,
+        submission_ref: submissionRef("input", turnRef, inputRef, promptRef),
+        created_at: record7.timestamp,
+        expires_at: expiresAt
+      });
+      draft.enqueued += 1;
+      await this.activateOpenedTurnContext(identity, promptRef, expiresAt);
+      this.setOpenedTurn(draft, record7, inputRef, turnRef, promptRef);
+    } catch (error) {
+      if (custodyRegistered) await this.releasePrompt(sessionRef, { turn_key: turnRef, prompt_ref: promptRef }).catch(() => void 0);
+      throw error;
+    }
+  }
+  async activateOpenedTurnContext(identity, promptRef, expiresAt) {
     const selection = await this.store.readInvocationTurnSelection(identity.host_source_ref, identity.host_session_ref);
     const turnGenerationRef = selection?.prompt_ref === promptRef ? selection.turn_generation_ref : void 0;
-    await this.activateContext(identity, promptRef, turnGenerationRef);
+    await this.activateContext(identity, promptRef, turnGenerationRef, expiresAt);
+  }
+  setOpenedTurn(draft, record7, inputRef, turnRef, promptRef) {
     const folded = foldUnattributed(draft.unattributed);
     draft.open_turn = {
       turn_key: turnRef,
@@ -5762,9 +5833,18 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
     draft.open_turn = void 0;
     if (turn === void 0) return;
     const digest3 = terminalDigest(turn);
-    if (digest3 === turn.last_terminal_digest) return;
-    await this.putTerminalEnvelope(registration, turn, digest3, turn.message_ids.length === 0 ? at : void 0);
-    draft.enqueued += 1;
+    if (digest3 !== turn.last_terminal_digest) {
+      await this.putTerminalEnvelope(registration, turn, digest3, turn.message_ids.length === 0 ? at : void 0);
+      draft.enqueued += 1;
+    }
+    await this.releasePrompt(registration.host_session_ref, turn);
+  }
+  async releaseOpenTurn(registration, draft) {
+    if (draft.open_turn !== void 0) await this.releasePrompt(registration.host_session_ref, draft.open_turn);
+  }
+  async releasePrompt(sessionRef, turn) {
+    if (this.producerInstallationRef === void 0 || this.releaseCurrentPrompt === void 0) return;
+    await this.releaseCurrentPrompt({ producer_id: "claude", producer_installation_ref: this.producerInstallationRef, local_session_ref: sessionRef, local_turn_ref: turn.turn_key, prompt_ref: turn.prompt_ref });
   }
   accumulateUsage(draft, usage) {
     const turn = draft.open_turn;
@@ -5798,6 +5878,8 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       if (isMissingTranscriptError(error) || isNotDirectory(error)) return 0;
       throw new ClaudeHostError("payload_rejected", "Claude subagent transcript directory is unavailable.");
     }
+    const listed = new Set(names);
+    for (const name of Object.keys(draft.subagents)) if (!listed.has(name)) delete draft.subagents[name];
     if (names.length > CLAUDE_TRANSCRIPT_MAX_SUBAGENT_FILES) {
       this.log(`Claude ignored subagent transcripts past its file bound: transcript_path=${JSON.stringify(registration.transcript_path)}, files=${names.length}.`);
       names = names.slice(0, CLAUDE_TRANSCRIPT_MAX_SUBAGENT_FILES);
@@ -5912,27 +5994,33 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       updated_at: this.stamp()
     });
   }
-  async registerPrompt(sessionRef, turnRef, promptRef, prompt) {
-    if (this.producerInstallationRef === void 0 || this.registerCurrentPrompt === void 0) return;
-    try {
-      await this.registerCurrentPrompt({
+  async registerPrompt(sessionRef, turnRef, promptRef, prompt, expiresAt) {
+    if (this.producerInstallationRef === void 0 || this.registerCurrentPrompt === void 0) return false;
+    const register = this.registerCurrentPrompt;
+    const installationRef = this.producerInstallationRef;
+    return registerHostCurrentPromptDiagnosed(
+      () => register({
         producer_id: "claude",
-        producer_installation_ref: this.producerInstallationRef,
+        producer_installation_ref: installationRef,
         local_session_ref: sessionRef,
         local_turn_ref: turnRef,
         prompt_ref: promptRef,
         current_prompt: prompt,
-        context_expires_at: this.expire(this.outboxRetentionMs)
-      });
-      this.diagnostic("current_prompt_registered");
-    } catch (error) {
-      this.diagnostic("current_prompt_registration_failed");
-      throw error;
-    }
+        context_expires_at: expiresAt
+      }),
+      (event) => this.diagnostic(event)
+    );
   }
-  async activateContext(identity, promptRef, turnGenerationRef) {
+  async releaseStoredPromptBestEffort(sessionRef, cursor) {
+    await this.releaseOpenTurnBestEffort(sessionRef, cursor?.open_turn);
+  }
+  async releaseOpenTurnBestEffort(sessionRef, turn) {
+    if (turn === void 0) return;
+    await this.releasePrompt(sessionRef, turn).catch(() => void 0);
+  }
+  async activateContext(identity, promptRef, turnGenerationRef, expiresAt) {
     try {
-      await this.store.activateInvocationContext(identity, promptRef, this.expire(this.outboxRetentionMs), void 0, turnGenerationRef);
+      await this.store.activateInvocationContext(identity, promptRef, expiresAt, void 0, turnGenerationRef);
       this.diagnostic("activation_recorded");
     } catch (error) {
       this.diagnostic("activation_failed");
@@ -5940,6 +6028,7 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
     }
   }
   async quarantineStored(cursor, device, inode, reason) {
+    await this.releaseStoredPromptBestEffort(cursor.host_session_ref, cursor);
     await this.store.writeTranscriptCursor({ ...cursor, device, inode, status: "quarantined", reason, updated_at: this.stamp() });
     return null;
   }
@@ -6056,21 +6145,12 @@ function isUserTurnLine(record7) {
   if (identity === null) throw new ClaudeHostError("payload_rejected", "Claude transcript user line is malformed.");
   return true;
 }
-function claudeTranscriptScanFailureKind(error) {
-  if (isSymlinkTranscript(error)) return "symlink";
-  if (error instanceof ClaudeHostError) {
-    if (error.diagnostic_kind !== void 0) return error.diagnostic_kind;
-    if (error.code === "payload_rejected") return "payload_rejected";
-    if (error.code === "storage") return "read_error";
-  }
-  const code2 = transcriptErrorCode(error);
-  if (code2 === "EFBIG") return "size_budget";
-  if (["EBADF", "EACCES", "EIO", "EMFILE", "ENFILE", "ENOENT", "ENOTDIR", "EPERM"].includes(code2 ?? "")) return "read_error";
-  return "other";
-}
 function isAssistantLine(record7) {
   return isTranscriptRecord(record7) && record7.type === "assistant" && isTranscriptRecord(record7.message);
 }
+function isAssistantTerminalLine(record7) {
+  return isAssistantLine(record7) && (record7.message.stop_reason === "end_turn" || record7.message.stop_reason === "stop_sequence");
+}
 function isAssistantUsageLine(record7) {
   if (!isTranscriptRecord(record7)) return false;
   if (!isAssistantLine(record7) || record7.message.usage === void 0) return false;
@@ -6098,12 +6178,24 @@ async function ownedClaudeTranscriptFile(handle) {
 function isNotDirectory(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOTDIR";
 }
+function claudeTranscriptScanCause(handle, error) {
+  if (error instanceof ClaudeHostError) return error.diagnostic_kind ?? error.code;
+  const code2 = transcriptErrorCode(error);
+  if (code2 !== null) return `${handle === void 0 ? "open" : "scan"}:${code2}`;
+  return `${handle === void 0 ? "open" : "scan"}:unknown`;
+}
+function claudeTranscriptScanFailureKind(error) {
+  return transcriptScanFailureKind(error, (candidate) => {
+    if (!(candidate instanceof ClaudeHostError)) return void 0;
+    if (candidate.diagnostic_kind !== void 0) return candidate.diagnostic_kind;
+    if (candidate.code === "payload_rejected") return "payload_rejected";
+    if (candidate.code === "storage") return "read_error";
+    return void 0;
+  });
+}
 function isSymlinkTranscript(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ELOOP";
 }
-function transcriptErrorCode(error) {
-  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
-}
 
 // host/claude/src/claude-producer-runtime.ts
 async function drainClaudeProducerOnce(options) {
@@ -6112,9 +6204,10 @@ async function drainClaudeProducerOnce(options) {
     outbox_dir: options.outbox_dir,
     producer_installation_ref: options.producer_installation_ref,
     register_current_prompt: (input) => promptPort.register(input),
-    diagnostic: (event, failure_kind) => writeHostServiceDiagnostic("claude", event, failure_kind)
+    release_current_prompt: (identity) => promptPort.release(identity),
+    diagnostic: (event, failure_kind, cause) => writeHostServiceDiagnostic("claude", event, failure_kind, cause)
   }).scanOnce().catch((error) => {
-    writeHostServiceDiagnostic("claude", "watcher_scan_failed", claudeTranscriptScanFailureKind(error));
+    writeHostServiceDiagnostic("claude", "watcher_scan_failed", claudeTranscriptScanFailureKind(error), claudeTranscriptScanCause(void 0, error));
     throw error;
   });
   const producer = new ClaudeProducer({ outbox_dir: options.outbox_dir, producer_installation_ref: options.producer_installation_ref, relay: new HostRelayIpcAdmissionPort(options.relay_endpoint, options.timeout_ms), ...options.producer_epoch === void 0 ? {} : { producer_epoch: options.producer_epoch }, ...options.now === void 0 ? {} : { now: options.now } });
@@ -7118,6 +7211,8 @@ function codexSubmissionReference(hostInputRef, event, ordinal) {
 var CodexTranscriptWatcher = class extends HostTranscriptWatcher {
   store;
   registerCurrentPrompt;
+  releaseCurrentPrompt;
+  diagnostic;
   constructor(options) {
     super(options, {
       default_retention_ms: CODEX_DEFAULT_RETENTION_MS,
@@ -7126,6 +7221,8 @@ var CodexTranscriptWatcher = class extends HostTranscriptWatcher {
     });
     this.store = new CodexOutboxStore(options.outbox_dir);
     this.registerCurrentPrompt = options.register_current_prompt;
+    this.releaseCurrentPrompt = options.release_current_prompt;
+    this.diagnostic = options.diagnostic ?? (() => void 0);
   }
   transcriptPathOf(registration) {
     return registration.transcript_path;
@@ -7141,17 +7238,22 @@ var CodexTranscriptWatcher = class extends HostTranscriptWatcher {
     if (complete === "empty" || complete === "partial") return { records: 0, enqueued: 0, quarantined: false };
     return await this.consumeCompleteChunk(registration, handle, preflight.cursor, complete, device, inode);
   }
-  async scanFailed(handle, registration, _error) {
+  async scanFailed(handle, registration, error) {
+    this.diagnostic("watcher_scan_failed", codexTranscriptScanFailureKind(error));
     await this.quarantineFailure(registration, handle);
     return { records: 0, enqueued: 0, quarantined: true };
   }
   async retireMissing(registration) {
+    await this.releaseStoredPromptBestEffort(registration.host_session_ref, await this.store.readTranscriptCursor(registration).catch(() => null));
     return this.retireMissingTranscript(registration.transcript_path, "Codex", () => this.store.retireTranscriptRegistration(registration));
   }
   async preflight(registration, handle, size, device, inode) {
     const existing = await this.store.readTranscriptCursor(registration);
     let cursor = existing ?? codexTranscriptInitialCursor(registration, device, inode, this.now);
-    if (cursor.status === "quarantined") return { cursor: null, result: { records: 0, enqueued: 0, quarantined: true } };
+    if (cursor.status === "quarantined") {
+      if (cursor.reason !== "transcript_malformed") await this.releaseStoredPromptBestEffort(registration.host_session_ref, cursor);
+      return { cursor: null, result: { records: 0, enqueued: 0, quarantined: true } };
+    }
     const reason = this.cursorIdentityReason(cursor, registration.transcript_path, device, inode) ?? await this.cursorBoundsReason(handle, cursor, size);
     if (reason === null) return { cursor, result: { records: 0, enqueued: 0, quarantined: false } };
     await this.quarantine(registration, cursor, device, inode, reason);
@@ -7190,25 +7292,41 @@ var CodexTranscriptWatcher = class extends HostTranscriptWatcher {
     const stats = await handle.stat().catch(() => null);
     if (stats === null) return;
     const existing = await this.store.readTranscriptCursor(registration).catch(() => null);
-    await this.quarantine(registration, existing ?? codexTranscriptInitialCursor(registration, String(stats.dev), String(stats.ino), this.now), String(stats.dev), String(stats.ino), "transcript_malformed");
+    const quarantined = {
+      ...existing ?? codexTranscriptInitialCursor(registration, String(stats.dev), String(stats.ino), this.now),
+      transcript_path: registration.transcript_path,
+      device: String(stats.dev),
+      inode: String(stats.ino),
+      status: "quarantined",
+      reason: "transcript_malformed",
+      updated_at: this.stamp()
+    };
+    await this.store.writeTranscriptCursor(quarantined);
   }
   async processRecord(registration, activeTask, record7) {
-    if (record7.kind === "task_started") {
-      return { activeTask: { codex_turn_id: record7.turn_id, host_turn_ref: hostTurnReference(registration.host_source_ref, registration.host_session_ref, record7.turn_id), started_at: record7.timestamp }, enqueued: 0 };
-    }
+    if (record7.kind === "task_started") return this.processTaskStarted(registration, activeTask, record7);
     if (record7.kind === "turn_context") return { ...activeTask === void 0 ? {} : { activeTask: record7.turn_id === activeTask.codex_turn_id ? { ...activeTask, model: record7.model } : activeTask }, enqueued: 0 };
     if (record7.kind === "token_count") return { ...activeTask === void 0 ? {} : { activeTask: accumulateTokenCount(activeTask, record7) }, enqueued: 0 };
     if (record7.kind === "user_text") return this.processUserInput(registration, activeTask, record7);
     if (record7.kind === "task_complete" || record7.kind === "turn_aborted") return this.processTerminal(registration, activeTask, record7);
     return { ...activeTask === void 0 ? {} : { activeTask }, enqueued: 0 };
   }
+  async processTaskStarted(registration, activeTask, record7) {
+    if (activeTask !== void 0 && activeTask.codex_turn_id !== record7.turn_id && activeTask.prompt_ref !== void 0) await this.releasePrompt(registration.host_session_ref, activeTask, activeTask.prompt_ref);
+    return { activeTask: { codex_turn_id: record7.turn_id, host_turn_ref: hostTurnReference(registration.host_source_ref, registration.host_session_ref, record7.turn_id), started_at: record7.timestamp }, enqueued: 0 };
+  }
   async processUserInput(registration, activeTask, record7) {
-    if (activeTask === void 0 || activeTask.codex_turn_id !== record7.turn_id) return { ...activeTask === void 0 ? {} : { activeTask }, enqueued: 0 };
+    if (activeTask === void 0 || activeTask.codex_turn_id !== record7.turn_id) {
+      const adopted = await this.adoptHookCorrelatedTurn(registration, activeTask, record7);
+      if (adopted === void 0) return { ...activeTask === void 0 ? {} : { activeTask }, enqueued: 0 };
+      activeTask = adopted;
+    }
     const hostInputRef = hostInputReference(registration.host_source_ref, registration.host_session_ref, record7.turn_id, record7.message_id, record7.ordinal, record7.prompt);
     const origin = activeTask.origin_host_input_ref === void 0;
     const promptValue = promptObservationValue(record7.prompt);
     const currentPromptRef = hostProducerPromptRef(promptValue.body_sha256);
     const promptRef = activeTask.prompt_ref ?? currentPromptRef;
+    const steeredPromptRef = await this.steeredPromptRef(registration, activeTask, origin, currentPromptRef);
     const identity = { host_source_ref: registration.host_source_ref, host_session_ref: registration.host_session_ref, host_turn_ref: activeTask.host_turn_ref };
     const observations = [{
       observation_ref: observationRef2("transcript_user_text", hostInputRef, record7.prompt),
@@ -7234,14 +7352,88 @@ var CodexTranscriptWatcher = class extends HostTranscriptWatcher {
       created_at: record7.timestamp,
       expires_at: this.expire(this.outboxRetentionMs)
     };
-    await this.registerPrompt(origin, registration, activeTask, currentPromptRef, record7.prompt, envelope.expires_at);
-    await this.store.put(envelope);
-    if (origin) await activateTranscriptTurnContext(this.store, identity, promptRef, envelope.expires_at);
+    const persisted = await this.persistUserInputTurn(registration, activeTask, record7, hostInputRef, origin, currentPromptRef, promptRef, identity, envelope);
+    if (steeredPromptRef !== null) await this.activateTranscriptTurnContext(identity, steeredPromptRef, envelope.expires_at);
+    return persisted;
+  }
+  /**
+   * The steered prompt to re-activate under the running task, or null when
+   * there is nothing to repair. A steered message joins the running turn
+   * with new prompt bytes but no task_started. When the steer hook already
+   * replaced the turn selection (a turn id the hook did not recognize as
+   * the running one, or a hook that ran before any context was live), the
+   * running task's context no longer matches and the next invocation would
+   * wait for a boundary that never comes. When the hook kept the live
+   * selection, the context still matches and this stays null.
+   */
+  async steeredPromptRef(registration, activeTask, origin, currentPromptRef) {
+    if (origin || activeTask.prompt_ref === void 0 || activeTask.prompt_ref === currentPromptRef) return null;
+    const selection = await this.store.readInvocationTurnSelection(registration.host_source_ref, registration.host_session_ref).catch(() => null);
+    return selection?.prompt_ref === currentPromptRef ? currentPromptRef : null;
+  }
+  /**
+   * Adopt the live hooked turn when its transcript message arrives before
+   * (or without) its task_started, as an interrupted turn's follow-up can.
+   * The UserPromptSubmit hook names the exact hooked prompt, so only a
+   * message carrying those bytes adopts; inherited history and other turns
+   * stay ignored. A stale active task for another turn releases first, the
+   * same as a task_started supersession.
+   */
+  async adoptHookCorrelatedTurn(registration, activeTask, record7) {
+    const currentPromptRef = hostProducerPromptRef(promptObservationValue(record7.prompt).body_sha256);
+    const selection = await this.store.readInvocationTurnSelection(registration.host_source_ref, registration.host_session_ref);
+    if (selection?.prompt_ref !== currentPromptRef) return void 0;
+    if (activeTask !== void 0 && activeTask.codex_turn_id !== record7.turn_id && activeTask.prompt_ref !== void 0) {
+      await this.releasePrompt(registration.host_session_ref, activeTask, activeTask.prompt_ref);
+    }
+    return {
+      codex_turn_id: record7.turn_id,
+      host_turn_ref: hostTurnReference(registration.host_source_ref, registration.host_session_ref, record7.turn_id),
+      started_at: record7.timestamp
+    };
+  }
+  async persistUserInputTurn(registration, activeTask, record7, hostInputRef, origin, currentPromptRef, promptRef, identity, envelope) {
+    const custodyRegistered = await this.registerPrompt(origin, registration, activeTask, currentPromptRef, record7.prompt, envelope.expires_at);
+    if (custodyRegistered) this.diagnostic("watcher_turn_observed");
+    try {
+      await this.store.put(envelope);
+      if (origin) await this.activateTranscriptTurnContext(identity, promptRef, envelope.expires_at);
+    } catch (error) {
+      if (custodyRegistered) await this.releasePrompt(registration.host_session_ref, activeTask, currentPromptRef).catch(() => void 0);
+      throw error;
+    }
     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 });
+    if (!origin || this.producerInstallationRef === void 0 || this.registerCurrentPrompt === void 0) return false;
+    const register = this.registerCurrentPrompt;
+    const installationRef = this.producerInstallationRef;
+    return registerHostCurrentPromptDiagnosed(
+      () => register({ producer_id: "codex", producer_installation_ref: installationRef, local_session_ref: registration.host_session_ref, local_turn_ref: activeTask.host_turn_ref, prompt_ref: promptRef, current_prompt: prompt, context_expires_at: expiresAt }),
+      (event) => this.diagnostic(event)
+    );
+  }
+  async activateTranscriptTurnContext(identity, promptRef, expiresAt) {
+    try {
+      const selection = await this.store.readInvocationTurnSelection(identity.host_source_ref, identity.host_session_ref);
+      const turnGenerationRef = selection?.prompt_ref === promptRef ? selection.turn_generation_ref : void 0;
+      await this.store.activateInvocationContext(identity, promptRef, expiresAt, turnGenerationRef);
+      this.diagnostic("activation_recorded");
+    } catch (error) {
+      this.diagnostic("activation_failed");
+      throw error;
+    }
+  }
+  async releasePrompt(sessionRef, activeTask, promptRef) {
+    if (this.producerInstallationRef === void 0 || this.releaseCurrentPrompt === void 0) return;
+    await this.releaseCurrentPrompt({ producer_id: "codex", producer_installation_ref: this.producerInstallationRef, local_session_ref: sessionRef, local_turn_ref: activeTask.host_turn_ref, prompt_ref: promptRef });
+  }
+  async releaseStoredPromptBestEffort(sessionRef, cursor) {
+    await this.releaseActiveTaskBestEffort(sessionRef, cursor?.active_task);
+  }
+  async releaseActiveTaskBestEffort(sessionRef, activeTask) {
+    if (activeTask?.prompt_ref === void 0) return;
+    await this.releasePrompt(sessionRef, activeTask, activeTask.prompt_ref).catch(() => void 0);
   }
   async processTerminal(registration, activeTask, record7) {
     if (activeTask === void 0 || activeTask.codex_turn_id !== record7.turn_id || activeTask.origin_host_input_ref === void 0 || activeTask.prompt_ref === void 0) return { ...activeTask === void 0 ? {} : { activeTask }, enqueued: 0 };
@@ -7261,18 +7453,23 @@ var CodexTranscriptWatcher = class extends HostTranscriptWatcher {
       created_at: record7.timestamp,
       expires_at: this.expire(this.outboxRetentionMs)
     });
+    await this.releasePrompt(registration.host_session_ref, activeTask, activeTask.prompt_ref);
     await this.store.clearInvocationContext(identity, this.now());
     return { enqueued: 1 };
   }
   async quarantine(registration, cursor, device, inode, reason) {
+    await this.releaseStoredPromptBestEffort(registration.host_session_ref, cursor);
     const quarantined = { ...cursor, transcript_path: registration.transcript_path, device, inode, status: "quarantined", reason, updated_at: this.stamp() };
     await this.store.writeTranscriptCursor(quarantined);
   }
 };
-async function activateTranscriptTurnContext(store, identity, promptRef, expiresAt) {
-  const selection = await store.readInvocationTurnSelection(identity.host_source_ref, identity.host_session_ref);
-  const turnGenerationRef = selection?.prompt_ref === promptRef ? selection.turn_generation_ref : void 0;
-  await store.activateInvocationContext(identity, promptRef, expiresAt, turnGenerationRef);
+function codexTranscriptScanFailureKind(error) {
+  return transcriptScanFailureKind(error, (candidate) => {
+    if (!(candidate instanceof CodexHostAdapterError)) return void 0;
+    if (candidate.code === "payload_rejected") return "payload_rejected";
+    if (candidate.code === "storage") return "read_error";
+    return void 0;
+  });
 }
 function accumulateTokenCount(activeTask, record7) {
   if (record7.usage_gap_reason !== void 0) return { ...activeTask, token_usage_gap_reason: record7.usage_gap_reason };
@@ -7360,7 +7557,16 @@ function assertRecordSequence(registration, cursor, records, lastOrdinal, record
 // host/codex/src/codex-producer-runtime.ts
 async function drainCodexProducerOnce(options) {
   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 scan = await new CodexTranscriptWatcher({
+    outbox_dir: options.outbox_dir,
+    producer_installation_ref: options.producer_installation_ref,
+    register_current_prompt: (input) => promptPort.register(input),
+    release_current_prompt: (identity) => promptPort.release(identity),
+    diagnostic: (event, failure_kind) => writeHostServiceDiagnostic("codex", event, failure_kind)
+  }).scanOnce().catch((error) => {
+    writeHostServiceDiagnostic("codex", "watcher_scan_failed", codexTranscriptScanFailureKind(error));
+    throw error;
+  });
   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() };
 }
@@ -7972,7 +8178,12 @@ async function readSettingsForMutation(path) {
 async function readSettings(path) {
   const info = await lstat8(path);
   if (!info.isFile() || info.isSymbolicLink()) throw new ClaudeHostError("configuration", "Claude settings path is not a regular file.");
-  const value = JSON.parse(await readFile3(path, "utf8"));
+  let value;
+  try {
+    value = JSON.parse(await readFile3(path, "utf8"));
+  } catch {
+    throw new ClaudeHostError("configuration", "Claude settings file is not JSON.");
+  }
   if (!record6(value)) throw new ClaudeHostError("configuration", "Claude settings must be a JSON object.");
   hooksRecord(value);
   allowEntries(value);
@@ -8653,7 +8864,8 @@ function parseHostRuntimeControlRequest(value) {
   if (value.schema_version !== HOST_RUNTIME_CONTROL_REQUEST_SCHEMA) throw invalid2("invalid_request_schema", [`expected:${HOST_RUNTIME_CONTROL_REQUEST_SCHEMA}`]);
   if (!isOperation2(value.operation)) throw invalid2("invalid_request_schema");
   assertPrefix(value.prefix);
-  const control = parseSelection(value.control_candidate_ref, value.control_components, false);
+  const scan = value.operation === "installations_scan";
+  const control = parseSelection(value.control_candidate_ref, value.control_components, scan);
   const previous = parseSelection(value.previous_candidate_ref, value.previous_components, true);
   const target = parseSelection(value.candidate_ref, value.components, true);
   if (typeof value.transaction_ref !== "string") throw invalid2("invalid_transaction_ref");
@@ -8682,32 +8894,37 @@ async function runHostRuntimeControl(value, dependencies) {
   try {
     request2 = parseHostRuntimeControlRequest(value);
   } catch (error) {
-    return invalidResult(errorCode6(error));
+    return invalidResult(errorCode6(error), errorReasons(error));
   }
-  const paths = resolveInstalledHostRuntimePaths(request2.prefix, dependencies.platform);
-  const transition = requestTransition(request2);
   try {
-    switch (request2.operation) {
-      case "hooks_reconcile":
-        await dependencies.hooks.reconcile(transition, paths);
-        return successResult(request2, "hooks_reconciled");
-      case "services_reconcile":
-        await dependencies.services.reconcile(transition, paths);
-        return successResult(request2, "services_reconciled");
-      case "service_restart":
-        await dependencies.services.restart(request2, paths);
-        return successResult(request2, "restarted");
-      case "readiness_check":
-        await dependencies.readiness.check(transition.target, paths);
-        return successResult(request2, request2.candidate_ref === "" ? "absent" : "ready");
-      case "readiness_observe": {
-        const observation3 = await dependencies.readiness.observe(transition.target, paths);
-        const result = successResult(request2, request2.candidate_ref === "" ? "absent" : "ready");
-        return observation3.recent_invocation_mints.length === 0 ? result : { ...result, recent_invocation_mints: observation3.recent_invocation_mints };
-      }
-    }
+    return await dispatchControlOperation(request2, dependencies);
   } catch (error) {
-    return failureResult(request2, errorCode6(error), errorReasons(error));
+    return failureResult(request2, errorCode6(error), errorReasons(error, request2.operation));
+  }
+}
+async function dispatchControlOperation(request2, dependencies) {
+  const paths = resolveInstalledHostRuntimePaths(request2.prefix, dependencies.platform);
+  const transition = requestTransition(request2);
+  switch (request2.operation) {
+    case "hooks_reconcile":
+      await dependencies.hooks.reconcile(transition, paths);
+      return successResult(request2, "hooks_reconciled");
+    case "services_reconcile":
+      await dependencies.services.reconcile(transition, paths);
+      return successResult(request2, "services_reconciled");
+    case "service_restart":
+      await dependencies.services.restart(request2, paths);
+      return successResult(request2, "restarted");
+    case "readiness_check":
+      await dependencies.readiness.check(transition.target, paths);
+      return successResult(request2, request2.candidate_ref === "" ? "absent" : "ready");
+    case "readiness_observe": {
+      const observation3 = await dependencies.readiness.observe(transition.target, paths);
+      const result = successResult(request2, request2.candidate_ref === "" ? "absent" : "ready");
+      return observation3.recent_invocation_mints.length === 0 ? result : { ...result, recent_invocation_mints: observation3.recent_invocation_mints };
+    }
+    case "installations_scan":
+      return scanInstallations(request2, dependencies);
   }
 }
 async function runHostRuntimeControlText(text, dependencies) {
@@ -8722,7 +8939,7 @@ async function runHostRuntimeControlText(text, dependencies) {
   try {
     rejectDuplicateJsonKeys2(decoded);
   } catch (error) {
-    return invalidResult(errorCode6(error));
+    return invalidResult(errorCode6(error), errorReasons(error));
   }
   let value;
   try {
@@ -8757,8 +8974,8 @@ async function runHostRuntimeControlCli(input, output, args, dependencies) {
         chunks.push(bytes);
       }
       result = await runHostRuntimeControlText(Buffer2.concat(chunks), dependencies);
-    } catch {
-      result = invalidResult("input_unavailable");
+    } catch (error) {
+      result = invalidResult("input_unavailable", unknownErrorReasons(error));
     }
   }
   output.write(serializeHostRuntimeControlResult(result));
@@ -8779,6 +8996,7 @@ function parseSelection(candidate, componentsValue, allowAbsent) {
 }
 function parseOperationFields(value, target) {
   const component = value.component;
+  if (value.operation === "installations_scan") return parseScanFields(value.transaction_ref, component, target);
   if (value.operation === "readiness_observe") return parseObserveFields(value.transaction_ref, component, target);
   if (typeof value.transaction_ref !== "string" || !HOST_RUNTIME_TRANSACTION_REF_PATTERN.test(value.transaction_ref)) throw invalid2("invalid_transaction_ref");
   if (value.operation === "service_restart") return parseRestartComponent(component, target);
@@ -8812,7 +9030,12 @@ function hasExactKeys3(value, required, optional) {
   return required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => allowed.has(key));
 }
 function isOperation2(value) {
-  return value === "hooks_reconcile" || value === "services_reconcile" || value === "service_restart" || value === "readiness_check" || value === "readiness_observe";
+  return value === "hooks_reconcile" || value === "services_reconcile" || value === "service_restart" || value === "readiness_check" || value === "readiness_observe" || value === "installations_scan";
+}
+function parseScanFields(transactionRef, component, target) {
+  if (transactionRef !== "") throw invalid2("invalid_operation_fields", [`transaction_ref_chars:${String(transactionRef).length}`]);
+  if (component !== void 0 || target.candidate_ref !== "" || target.components.length !== 0) throw invalid2("invalid_operation_fields");
+  return void 0;
 }
 function isRestartComponent(value) {
   return isHostBundleComponent(value) && value !== "lifecycle";
@@ -8829,8 +9052,54 @@ function inputSizeReasons(observed) {
 function errorCode6(error) {
   return error instanceof HostRuntimeControlError && SAFE_CODE2.test(error.code) ? error.code : "control_failed";
 }
-function errorReasons(error) {
-  return error instanceof HostRuntimeReasonedError ? error.reasons : [];
+function errorReasons(error, operation) {
+  if (error instanceof HostRuntimeReasonedError) return error.reasons;
+  const reasons = [...unknownErrorReasons(error)];
+  if (operation !== void 0) reasons.unshift(`operation:${operation}`);
+  return reasons.filter((reason) => SAFE_REASON.test(reason)).slice(0, MAX_UNKNOWN_REASONS);
+}
+var UNKNOWN_REASON_CODE_WORD = /^[A-Za-z0-9_.-]{1,64}$/u;
+var MAX_UNKNOWN_REASONS = 5;
+function unknownErrorReasons(error) {
+  if (error instanceof HostRuntimeReasonedError) return error.reasons;
+  const reasons = [...recordErrorReasons(error), ...factNameReasons(error)];
+  if (error instanceof Error && error.name !== "Error" && UNKNOWN_REASON_CODE_WORD.test(error.name)) reasons.push(`error:${error.name}`);
+  return reasons.filter((reason) => SAFE_REASON.test(reason)).slice(0, MAX_UNKNOWN_REASONS);
+}
+function recordErrorReasons(error) {
+  if (!isCealJsonRecord(error)) return [];
+  return [...wordReason(error.code, "code"), ...wordReason(error.syscall, "syscall"), ...pathReason(error.path), ...fieldReasons(error.reasons)];
+}
+function fieldReasons(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((reason) => typeof reason === "string" && SAFE_REASON.test(reason));
+}
+function wordReason(value, head) {
+  return typeof value === "string" && UNKNOWN_REASON_CODE_WORD.test(value) ? [`${head}:${value}`] : [];
+}
+function pathReason(value) {
+  if (typeof value !== "string") return [];
+  const leaf = value.split(/[/\\]/u).pop() ?? "";
+  return wordReason(leaf === "" ? void 0 : leaf, "file");
+}
+var REFUSAL_FACT_NAME_PATTERN = /"([a-z][a-z0-9_]*)"=/gu;
+var MAX_FACT_REASONS = 2;
+function factNameReasons(error) {
+  if (!isCealJsonRecord(error)) return [];
+  if (typeof error.code !== "string" || typeof error.message !== "string") return [];
+  const names = [];
+  for (const match of error.message.matchAll(REFUSAL_FACT_NAME_PATTERN)) {
+    const name = match[1];
+    if (name === void 0) continue;
+    const reason = `fact:${name}`;
+    if (!names.includes(reason)) names.push(reason);
+    if (names.length >= MAX_FACT_REASONS) break;
+  }
+  return names.filter((reason) => SAFE_REASON.test(reason));
+}
+async function scanInstallations(request2, dependencies) {
+  const installations = await dependencies.services.listInstallations();
+  return { ...successResult(request2, "scanned"), installations };
 }
 function successResult(request2, status) {
   return { schema_version: HOST_RUNTIME_CONTROL_RESULT_SCHEMA, ok: true, code: "ok", status, candidate_ref: request2.candidate_ref, components: request2.components };
@@ -8978,14 +9247,14 @@ async function assertRegularRuntimeFile(path, executable) {
   const module2 = basename3(path);
   try {
     info = await lstat10(path);
-  } catch {
-    throw runtimeUnavailable(`missing_module:${module2}`);
+  } catch (error) {
+    throw runtimeUnavailable(`missing_module:${module2}`, ...unknownErrorReasons(error));
   }
   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 runtimeUnavailable(...reasons) {
+  return new HostRuntimeReasonedError("private_runtime_unavailable", reasons);
 }
 function selectedProducers(selection) {
   return selection.components.filter(isHostBundleProducer);
@@ -8994,7 +9263,7 @@ function selectedProducers(selection) {
 // host/lifecycle/src/host-runtime-services-macos.ts
 import { execFile } from "node:child_process";
 import { constants as constants4 } from "node:fs";
-import { chmod as chmod2, lstat as lstat11, mkdir as mkdir8, open as open11, rename as rename7, unlink as unlink6 } from "node:fs/promises";
+import { chmod as chmod2, lstat as lstat11, mkdir as mkdir8, open as open11, readdir as readdir4, rename as rename7, unlink as unlink6 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { basename as basename4, dirname as dirname9, join as join13 } from "node:path";
 import { promisify } from "node:util";
@@ -9012,6 +9281,13 @@ function equalStringLists(left, right) {
 var HOST_RUNTIME_SERVICE_COMPONENTS = Object.freeze(hostBundleComponentsForProducers(HOST_BUNDLE_PRODUCERS).filter((component) => component !== "lifecycle"));
 var HOST_RUNTIME_SERVICE_COMMAND_TIMEOUT_MS = 2e4;
 var HOST_RUNTIME_SERVICE_STATES = ["absent", "stopped", "running", "unknown"];
+function assembleHostRuntimeInstallations(groups) {
+  return [...groups.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([installation_id, group]) => ({
+    installation_id,
+    ...group.prefix === void 0 ? {} : { prefix: group.prefix },
+    services: [...group.services].sort((left, right) => HOST_RUNTIME_SERVICE_COMPONENTS.indexOf(left.component) - HOST_RUNTIME_SERVICE_COMPONENTS.indexOf(right.component))
+  }));
+}
 var HostRuntimeServiceContractError = class extends Error {
   code;
   constructor(code2, message) {
@@ -9056,6 +9332,13 @@ function serviceReadinessReasons(component, wanted, found) {
   if (found.command === void 0 || !sameCommand(found.command, wanted.command)) reasons.push(`${component}_service_command_drifted`);
   return reasons;
 }
+var HOST_PRIVATE_NODE_POSIX_SUFFIX = `/${HOST_BUNDLE_PRIVATE_RUNTIME_ROOT}/node/bin/node`;
+function hostPrefixFromPosixNodeExecutable(executable) {
+  if (!executable.endsWith(HOST_PRIVATE_NODE_POSIX_SUFFIX)) return void 0;
+  const prefix = executable.slice(0, -HOST_PRIVATE_NODE_POSIX_SUFFIX.length);
+  if (!isAbsoluteNormalizedNonRootPath(prefix, "posix")) return void 0;
+  return prefix;
+}
 function exactSelection(value) {
   if (!Array.isArray(value) || new Set(value).size !== value.length || value.some((component) => !HOST_BUNDLE_COMPONENTS.includes(component))) throw invalidComponents();
   if (value.length === 0) return [];
@@ -9104,25 +9387,54 @@ var LAUNCHCTL = "/bin/launchctl";
 var OWNER_MARKER = "ceal-host-runtime-service-v1";
 var MacosHostRuntimeServiceError = class extends Error {
   code;
-  constructor(code2, message) {
+  /**
+   * Bounded code-shaped words naming what the refusal held, so the control
+   * boundary can repeat them without quoting private paths or file bodies.
+   * The message keeps the rendered facts for local reading; only these
+   * words travel in the control result.
+   */
+  reasons;
+  constructor(code2, message, reasons = []) {
     super(message);
     this.name = "MacosHostRuntimeServiceError";
     this.code = code2;
+    this.reasons = reasons.filter((reason) => typeof reason === "string");
   }
 };
 function createMacosHostRuntimeServiceAdapter(options) {
   const platform = options.platform ?? process.platform;
-  if (platform !== "darwin") throw new MacosHostRuntimeServiceError("unsupported", `The launchd Host service adapter requires macOS (${refusalFact("platform", platform, "darwin")}).`);
+  if (platform !== "darwin") throw new MacosHostRuntimeServiceError("unsupported", `The launchd Host service adapter requires macOS (${refusalFact("platform", platform, "darwin")}).`, ["fact:platform"]);
   const uid = options.uid ?? (typeof process.geteuid === "function" ? process.geteuid() : -1);
-  if (!Number.isSafeInteger(uid) || uid < 0) throw new MacosHostRuntimeServiceError("invalid_owner", "The launchd user identity is unavailable.");
+  if (!Number.isSafeInteger(uid) || uid < 0) throw new MacosHostRuntimeServiceError("invalid_owner", "The launchd user identity is unavailable.", ["fact:uid"]);
   const directory = absoluteNormalized(options.launch_agents_directory ?? join13(homedir5(), "Library", "LaunchAgents"));
   return new MacosHostRuntimeServiceAdapter(directory, absoluteNormalized(options.log_directory), uid, options.run_launchctl ?? runMacosLaunchctl, options.progress ?? (() => void 0));
 }
 function macosHostRuntimeServiceLabel(prefix, component) {
-  const normalizedPrefix = absoluteNormalized(prefix);
-  if (!HOST_RUNTIME_SERVICE_COMPONENTS.includes(component)) throw new MacosHostRuntimeServiceError("invalid_owner", "The launchd service component is invalid.");
-  const installation = createHash10("sha256").update(normalizedPrefix).digest("hex").slice(0, 24);
-  return `ai.corca.ceal.host.${installation}.${component}`;
+  if (!HOST_RUNTIME_SERVICE_COMPONENTS.includes(component)) throw new MacosHostRuntimeServiceError("invalid_owner", "The launchd service component is invalid.", ["fact:component"]);
+  return `ai.corca.ceal.host.${macosHostRuntimeServiceInstallation(prefix)}.${component}`;
+}
+function macosHostRuntimeServiceInstallation(prefix) {
+  return createHash10("sha256").update(absoluteNormalized(prefix)).digest("hex").slice(0, 24);
+}
+var CEAL_LAUNCHD_LABEL_PATTERN = new RegExp(`^ai[.]corca[.]ceal[.]host[.]([0-9a-f]{24})[.](${HOST_RUNTIME_SERVICE_COMPONENTS.join("|")})$`, "u");
+function parseCealLaunchdLabel(label) {
+  const match = CEAL_LAUNCHD_LABEL_PATTERN.exec(label);
+  const installation = match?.[1];
+  const component = match?.[2];
+  if (installation === void 0 || !isServiceComponent(component)) return void 0;
+  return { installation, component };
+}
+function isServiceComponent(value) {
+  return value !== void 0 && HOST_RUNTIME_SERVICE_COMPONENTS.some((component) => component === value);
+}
+function launchctlListLabels(stdout) {
+  const labels = [];
+  for (const line of stdout.split("\n")) {
+    const fields = line.split(/\s+/u).filter((field) => field !== "");
+    const label = fields[fields.length - 1];
+    if (label !== void 0) labels.push(label);
+  }
+  return labels;
 }
 async function runMacosLaunchctl(args) {
   try {
@@ -9150,6 +9462,7 @@ var MacosHostRuntimeServiceAdapter = class {
     assertSamePrefix(input.previous, input.target);
     await ensureLaunchAgentsDirectory(this.directory, this.uid);
     if (input.target.services.length > 0) await mkdir8(this.logDirectory, { recursive: true, mode: 448 });
+    if (input.target.services.length > 0) await this.refuseForeignCealOrphans(input.target.prefix);
     const targetComponents = new Set(input.target.services.map((service) => service.component));
     for (const previous of [...input.previous.services].reverse()) {
       if (!targetComponents.has(previous.component)) await this.remove(input.target.prefix, previous.component);
@@ -9163,17 +9476,17 @@ var MacosHostRuntimeServiceAdapter = class {
   }
   async restart(input) {
     const directoryAvailable = await inspectLaunchAgentsDirectory(this.directory, this.uid);
-    if (!directoryAvailable) throw new MacosHostRuntimeServiceError("service_not_installed", `The LaunchAgents directory is unavailable (${refusalFact("directory", this.directory, "an existing LaunchAgents directory")}).`);
+    if (!directoryAvailable) throw new MacosHostRuntimeServiceError("service_not_installed", `The LaunchAgents directory is unavailable (${refusalFact("directory", this.directory, "an existing LaunchAgents directory")}).`, [`service:${input.service.component}`, "fact:directory"]);
     const owner = this.owner(input.target.prefix, input.service.component);
     const current = await readManagedPlist(owner.path, owner.marker, this.uid);
     const expected = launchAgentPlist(owner, input.service);
     if (current !== expected) throw new MacosHostRuntimeServiceError("service_not_installed", `The selected launchd service definition is not installed exactly (${refusalFacts([
       { name: "installed_bytes", value: current === null ? -1 : Buffer.byteLength(current, "utf8"), expected: `${Buffer.byteLength(expected, "utf8")} bytes` },
       { name: "installed_digest", value: current === null ? "absent" : plistDigest(current), expected: plistDigest(expected) }
-    ])}).`);
+    ])}).`, [`service:${input.service.component}`, "fact:installed_bytes", "fact:installed_digest"]);
     const loaded = await this.launchctl(["print", owner.target]);
-    if (loaded.exit_code !== 0) throw new MacosHostRuntimeServiceError("service_not_installed", "The selected launchd service is not loaded.");
-    await this.requireLaunchctl(["kickstart", "-k", owner.target], "Unable to restart the selected launchd service.");
+    if (loaded.exit_code !== 0) throw new MacosHostRuntimeServiceError("service_not_installed", "The selected launchd service is not loaded.", [`service:${input.service.component}`, "fact:loaded"]);
+    await this.requireLaunchctl(["kickstart", "-k", owner.target], "Unable to restart the selected launchd service.", [`service:${input.service.component}`, "launchctl:kickstart"]);
   }
   async inspect(input) {
     const directoryAvailable = await inspectLaunchAgentsDirectory(this.directory, this.uid);
@@ -9194,6 +9507,62 @@ var MacosHostRuntimeServiceAdapter = class {
   async recentOutput(input) {
     return readHostServiceLogTail(this.owner(input.target.prefix, input.component).log, input.lines).catch(() => []);
   }
+  async listInstallations() {
+    const groups = /* @__PURE__ */ new Map();
+    for (const label of await this.cealLabels()) {
+      const record7 = await this.describeLabel(label);
+      if (record7 === void 0) continue;
+      let group = groups.get(record7.installation);
+      if (group === void 0) {
+        group = { services: [] };
+        groups.set(record7.installation, group);
+      }
+      if (record7.prefix !== void 0 && group.prefix === void 0) group.prefix = record7.prefix;
+      group.services.push(record7.service);
+    }
+    return assembleHostRuntimeInstallations(groups);
+  }
+  async cealLabels() {
+    const labels = /* @__PURE__ */ new Set();
+    let files;
+    try {
+      files = (await readdir4(this.directory)).sort();
+    } catch {
+      files = [];
+    }
+    for (const file of files) {
+      if (!file.endsWith(".plist")) continue;
+      const label = file.slice(0, -".plist".length);
+      if (parseCealLaunchdLabel(label) !== void 0) labels.add(label);
+    }
+    const listed = await this.launchctl(["list"]);
+    if (listed.exit_code === 0) for (const label of launchctlListLabels(listed.stdout)) {
+      if (parseCealLaunchdLabel(label) !== void 0) labels.add(label);
+    }
+    return [...labels].sort();
+  }
+  async describeLabel(label) {
+    const parsed = parseCealLaunchdLabel(label);
+    if (parsed === void 0) return void 0;
+    const owned = await this.ownedLabelPrefix(label);
+    const loaded = await this.launchctl(["print", `gui/${this.uid}/${label}`]);
+    if (owned.prefix === void 0 && loaded.exit_code !== 0) return void 0;
+    return { installation: parsed.installation, ...owned.prefix === void 0 ? {} : { prefix: owned.prefix }, service: { component: parsed.component, state: loaded.exit_code !== 0 ? "stopped" : launchctlState(loaded.stdout), name: label } };
+  }
+  /**
+   * The owning prefix an owned plist's program arguments prove. Anything
+   * unowned, unreadable, or unparseable reads as absent, never as a guess.
+   */
+  async ownedLabelPrefix(label) {
+    let text;
+    try {
+      text = await readManagedPlist(join13(this.directory, `${label}.plist`), `<!-- ${OWNER_MARKER}:${label} -->`, this.uid);
+    } catch {
+      return {};
+    }
+    if (text === null) return {};
+    return { prefix: ownedPlistPrefix(text) };
+  }
   async ensureReported(prefix, service) {
     const started = Date.now();
     this.progress(`service ${service.component}: starting`);
@@ -9205,30 +9574,51 @@ var MacosHostRuntimeServiceAdapter = class {
       throw error;
     }
   }
+  async refuseForeignCealOrphans(prefix) {
+    const installation = macosHostRuntimeServiceInstallation(prefix);
+    const listed = await this.launchctl(["list"]);
+    if (listed.exit_code !== 0) return;
+    for (const label of launchctlListLabels(listed.stdout)) {
+      const parsed = parseCealLaunchdLabel(label);
+      if (parsed === void 0 || parsed.installation === installation) continue;
+      if (await this.hasOwnedDefinition(label)) continue;
+      throw new MacosHostRuntimeServiceError("unsafe_plist", `A loaded launchd service "${label}" from another Host installation has no Ceal-owned definition. Remove the orphan with \`launchctl bootout gui/${this.uid}/${label}\`, then rerun the operation.`, [`service:${parsed.component}`, `label:${label}`, "launchctl:bootout"]);
+    }
+  }
+  async hasOwnedDefinition(label) {
+    try {
+      return await readManagedPlist(join13(this.directory, `${label}.plist`), `<!-- ${OWNER_MARKER}:${label} -->`, this.uid) !== null;
+    } catch (error) {
+      if (error instanceof MacosHostRuntimeServiceError) return false;
+      throw error;
+    }
+  }
   async ensure(prefix, service) {
     const owner = this.owner(prefix, service.component);
     const expected = launchAgentPlist(owner, service);
     const current = await readManagedPlist(owner.path, owner.marker, this.uid);
-    const loaded = await this.launchctl(["print", owner.target]);
-    if (current === null && loaded.exit_code === 0) throw new MacosHostRuntimeServiceError("unsafe_plist", "A loaded launchd service has no Ceal-owned definition.");
+    let loaded = await this.launchctl(["print", owner.target]);
+    if (current === null && loaded.exit_code === 0) {
+      await this.requireLaunchctl(["bootout", owner.target], "Unable to stop the orphaned launchd service.", [`service:${service.component}`, "launchctl:bootout"]);
+      loaded = { exit_code: 1, stdout: "", stderr: "" };
+    }
     if (current === expected && loaded.exit_code === 0) {
       if (launchctlState(loaded.stdout) === "running") return "already running";
-      await this.requireLaunchctl(["kickstart", owner.target], "Unable to start the launchd service.");
+      await this.requireLaunchctl(["kickstart", owner.target], "Unable to start the launchd service.", [`service:${service.component}`, "launchctl:kickstart"]);
       return "started in place";
     }
-    if (loaded.exit_code === 0) await this.requireLaunchctl(["bootout", owner.target], "Unable to stop the existing launchd service.");
+    if (loaded.exit_code === 0) await this.requireLaunchctl(["bootout", owner.target], "Unable to stop the existing launchd service.", [`service:${service.component}`, "launchctl:bootout"]);
     if (current !== expected) await writeManagedPlist(owner.path, owner.marker, expected, this.uid);
-    await this.requireLaunchctl(["enable", owner.target], "Unable to enable the launchd service.");
-    await this.requireLaunchctl(["bootstrap", `gui/${this.uid}`, owner.path], "Unable to load the launchd service definition.");
-    await this.requireLaunchctl(["kickstart", owner.target], "Unable to start the launchd service.");
+    await this.requireLaunchctl(["enable", owner.target], "Unable to enable the launchd service.", [`service:${service.component}`, "launchctl:enable"]);
+    await this.requireLaunchctl(["bootstrap", `gui/${this.uid}`, owner.path], "Unable to load the launchd service definition.", [`service:${service.component}`, "launchctl:bootstrap"]);
+    await this.requireLaunchctl(["kickstart", owner.target], "Unable to start the launchd service.", [`service:${service.component}`, "launchctl:kickstart"]);
     return "loaded and started";
   }
   async remove(prefix, component) {
     const owner = this.owner(prefix, component);
     const current = await readManagedPlist(owner.path, owner.marker, this.uid);
     const loaded = await this.launchctl(["print", owner.target]);
-    if (current === null && loaded.exit_code === 0) throw new MacosHostRuntimeServiceError("unsafe_plist", "A loaded launchd service has no Ceal-owned definition.");
-    if (loaded.exit_code === 0) await this.requireLaunchctl(["bootout", owner.target], "Unable to stop the launchd service.");
+    if (loaded.exit_code === 0) await this.requireLaunchctl(["bootout", owner.target], current === null ? "Unable to stop the orphaned launchd service." : "Unable to stop the launchd service.", [`service:${component}`, "launchctl:bootout"]);
     if (current !== null) await unlink6(owner.path);
   }
   owner(prefix, component) {
@@ -9238,8 +9628,8 @@ var MacosHostRuntimeServiceAdapter = class {
   async launchctl(args) {
     return boundedLaunchctlResult(await this.runner(args));
   }
-  async requireLaunchctl(args, message) {
-    if ((await this.launchctl(args)).exit_code !== 0) throw new MacosHostRuntimeServiceError("launchctl_failed", message);
+  async requireLaunchctl(args, message, reasons = []) {
+    if ((await this.launchctl(args)).exit_code !== 0) throw new MacosHostRuntimeServiceError("launchctl_failed", message, reasons);
   }
 };
 function macosHostRuntimeServiceLogPath(logDirectory, component) {
@@ -9270,7 +9660,7 @@ function launchAgentPlist(owner, service) {
 async function ensureLaunchAgentsDirectory(path, uid) {
   await mkdir8(path, { recursive: true, mode: 448 });
   const directoryAvailable = await inspectLaunchAgentsDirectory(path, uid);
-  if (!directoryAvailable) throw new MacosHostRuntimeServiceError("invalid_owner", `The LaunchAgents directory is unavailable (${refusalFact("directory", path, "an existing LaunchAgents directory")}).`);
+  if (!directoryAvailable) throw new MacosHostRuntimeServiceError("invalid_owner", `The LaunchAgents directory is unavailable (${refusalFact("directory", path, "an existing LaunchAgents directory")}).`, ["fact:directory"]);
 }
 async function inspectLaunchAgentsDirectory(path, uid) {
   let info;
@@ -9280,9 +9670,9 @@ async function inspectLaunchAgentsDirectory(path, uid) {
     if (isNotFound5(error)) return false;
     throw error;
   }
-  if (!info.isDirectory() || info.isSymbolicLink()) throw new MacosHostRuntimeServiceError("invalid_owner", `The LaunchAgents path is not a directory (${refusalFact("mode", `0o${info.mode.toString(8)}`, "a directory mode (0o40xxx)")}).`);
-  if (info.uid !== uid) throw new MacosHostRuntimeServiceError("invalid_owner", `The LaunchAgents directory is owned by another user (${refusalFact("uid", info.uid, `expected ${uid}`)}).`);
-  if ((info.mode & 18) !== 0) throw new MacosHostRuntimeServiceError("invalid_owner", `The LaunchAgents directory is group- or world-writable (${refusalFact("permission_bits", `0o${(info.mode & 511).toString(8)}`, "no group or other write bit")}).`);
+  if (!info.isDirectory() || info.isSymbolicLink()) throw new MacosHostRuntimeServiceError("invalid_owner", `The LaunchAgents path is not a directory (${refusalFact("mode", `0o${info.mode.toString(8)}`, "a directory mode (0o40xxx)")}).`, ["fact:mode"]);
+  if (info.uid !== uid) throw new MacosHostRuntimeServiceError("invalid_owner", `The LaunchAgents directory is owned by another user (${refusalFact("uid", info.uid, `expected ${uid}`)}).`, ["fact:uid"]);
+  if ((info.mode & 18) !== 0) throw new MacosHostRuntimeServiceError("invalid_owner", `The LaunchAgents directory is group- or world-writable (${refusalFact("permission_bits", `0o${(info.mode & 511).toString(8)}`, "no group or other write bit")}).`, ["fact:permission_bits"]);
   return true;
 }
 async function readManagedPlist(path, marker, uid) {
@@ -9290,12 +9680,12 @@ async function readManagedPlist(path, marker, uid) {
   try {
     handle = await open11(path, constants4.O_RDONLY | (constants4.O_NOFOLLOW ?? 0));
     const info = await handle.stat();
-    if (!info.isFile()) throw unsafePlist(refusalFact("mode", `0o${info.mode.toString(8)}`, "a regular-file mode (0o100xxx)"));
-    if (info.uid !== uid) throw unsafePlist(refusalFact("uid", info.uid, `expected ${uid}`));
-    if ((info.mode & 63) !== 0) throw unsafePlist(refusalFact("permission_bits", `0o${(info.mode & 511).toString(8)}`, "no group or other bits"));
-    if (info.size > MAX_PLIST_BYTES) throw unsafePlist(refusalFact("size", info.size, `at most ${MAX_PLIST_BYTES} bytes`));
+    if (!info.isFile()) throw unsafePlist(refusalFact("mode", `0o${info.mode.toString(8)}`, "a regular-file mode (0o100xxx)"), ["fact:mode"]);
+    if (info.uid !== uid) throw unsafePlist(refusalFact("uid", info.uid, `expected ${uid}`), ["fact:uid"]);
+    if ((info.mode & 63) !== 0) throw unsafePlist(refusalFact("permission_bits", `0o${(info.mode & 511).toString(8)}`, "no group or other bits"), ["fact:permission_bits"]);
+    if (info.size > MAX_PLIST_BYTES) throw unsafePlist(refusalFact("size", info.size, `at most ${MAX_PLIST_BYTES} bytes`), ["fact:size"]);
     const text = await handle.readFile("utf8");
-    if (!text.includes(marker)) throw unsafePlist(refusalFact("owner_marker_present", false, "the managed owner marker"));
+    if (!text.includes(marker)) throw unsafePlist(refusalFact("owner_marker_present", false, "the managed owner marker"), ["fact:owner_marker_present"]);
     return text;
   } catch (error) {
     if (isNotFound5(error)) return null;
@@ -9330,9 +9720,9 @@ async function writeManagedPlist(path, marker, text, uid) {
   }
 }
 function boundedLaunchctlResult(value) {
-  if (!Number.isSafeInteger(value.exit_code) || value.exit_code < 0) throw new MacosHostRuntimeServiceError("launchctl_failed", `The launchctl exit status is invalid (${refusalFact("exit_code", value.exit_code, "a non-negative safe integer")}).`);
-  if (typeof value.stdout !== "string" || typeof value.stderr !== "string") throw new MacosHostRuntimeServiceError("launchctl_failed", `The launchctl result streams are invalid (${refusalFacts([{ name: "stdout_kind", value: typeof value.stdout, expected: "string" }, { name: "stderr_kind", value: typeof value.stderr, expected: "string" }])}).`);
-  if (Buffer.byteLength(value.stdout) > MAX_LAUNCHCTL_OUTPUT_BYTES || Buffer.byteLength(value.stderr) > MAX_LAUNCHCTL_OUTPUT_BYTES) throw new MacosHostRuntimeServiceError("launchctl_failed", `The launchctl result exceeds its bound (${refusalFacts([{ name: "stdout_bytes", value: Buffer.byteLength(value.stdout), expected: `at most ${MAX_LAUNCHCTL_OUTPUT_BYTES}` }, { name: "stderr_bytes", value: Buffer.byteLength(value.stderr), expected: `at most ${MAX_LAUNCHCTL_OUTPUT_BYTES}` }])}).`);
+  if (!Number.isSafeInteger(value.exit_code) || value.exit_code < 0) throw new MacosHostRuntimeServiceError("launchctl_failed", `The launchctl exit status is invalid (${refusalFact("exit_code", value.exit_code, "a non-negative safe integer")}).`, ["fact:exit_code"]);
+  if (typeof value.stdout !== "string" || typeof value.stderr !== "string") throw new MacosHostRuntimeServiceError("launchctl_failed", `The launchctl result streams are invalid (${refusalFacts([{ name: "stdout_kind", value: typeof value.stdout, expected: "string" }, { name: "stderr_kind", value: typeof value.stderr, expected: "string" }])}).`, ["fact:stdout_kind", "fact:stderr_kind"]);
+  if (Buffer.byteLength(value.stdout) > MAX_LAUNCHCTL_OUTPUT_BYTES || Buffer.byteLength(value.stderr) > MAX_LAUNCHCTL_OUTPUT_BYTES) throw new MacosHostRuntimeServiceError("launchctl_failed", `The launchctl result exceeds its bound (${refusalFacts([{ name: "stdout_bytes", value: Buffer.byteLength(value.stdout), expected: `at most ${MAX_LAUNCHCTL_OUTPUT_BYTES}` }, { name: "stderr_bytes", value: Buffer.byteLength(value.stderr), expected: `at most ${MAX_LAUNCHCTL_OUTPUT_BYTES}` }])}).`, ["fact:stdout_bytes", "fact:stderr_bytes"]);
   return value;
 }
 function launchctlState(stdout) {
@@ -9340,12 +9730,25 @@ function launchctlState(stdout) {
   if (HOST_RUNTIME_LAUNCHCTL_STOPPED_STATE_PATTERN.test(stdout)) return "stopped";
   return "unknown";
 }
+function ownedPlistPrefix(text) {
+  const anchor = "<key>ProgramArguments</key><array>";
+  const start = text.indexOf(anchor);
+  if (start < 0) return void 0;
+  const open13 = text.indexOf("<string>", start);
+  if (open13 < 0) return void 0;
+  const close = text.indexOf("</string>", open13);
+  if (close < 0) return void 0;
+  return hostPrefixFromPosixNodeExecutable(xmlUnescape(text.slice(open13 + "<string>".length, close)));
+}
+function xmlUnescape(value) {
+  return value.replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&amp;", "&");
+}
 function absoluteNormalized(value) {
-  if (!isAbsoluteNormalizedNonRootPath(value, "posix")) throw new MacosHostRuntimeServiceError("invalid_owner", "The launchd owner path must be absolute, normalized, and non-root.");
+  if (!isAbsoluteNormalizedNonRootPath(value, "posix")) throw new MacosHostRuntimeServiceError("invalid_owner", "The launchd owner path must be absolute, normalized, and non-root.", ["fact:path"]);
   return value;
 }
 function assertSamePrefix(previous, target) {
-  if (previous.prefix !== target.prefix) throw new MacosHostRuntimeServiceError("invalid_owner", `Launchd reconciliation cannot cross Host prefixes (${refusalFacts([{ name: "previous_prefix", value: previous.prefix }, { name: "target_prefix", value: target.prefix }])}).`);
+  if (previous.prefix !== target.prefix) throw new MacosHostRuntimeServiceError("invalid_owner", `Launchd reconciliation cannot cross Host prefixes (${refusalFacts([{ name: "previous_prefix", value: previous.prefix }, { name: "target_prefix", value: target.prefix }])}).`, ["fact:previous_prefix", "fact:target_prefix"]);
 }
 function executionFailure(error) {
   if (!isCealJsonRecord(error)) return { stdout: "", stderr: "" };
@@ -9363,8 +9766,8 @@ function xml(value) {
 function isNotFound5(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function unsafePlist(detail) {
-  return new MacosHostRuntimeServiceError("unsafe_plist", detail === void 0 ? "The LaunchAgent plist is unsafe or belongs to another owner." : `The LaunchAgent plist is unsafe or belongs to another owner (${detail}).`);
+function unsafePlist(detail, reasons = []) {
+  return new MacosHostRuntimeServiceError("unsafe_plist", detail === void 0 ? "The LaunchAgent plist is unsafe or belongs to another owner." : `The LaunchAgent plist is unsafe or belongs to another owner (${detail}).`, reasons);
 }
 
 // host/lifecycle/src/host-runtime-services-windows.ts
@@ -9420,6 +9823,13 @@ function createWindowsHostRuntimeServiceAdapter(input) {
     // Task Scheduler keeps no service output, and the Windows Host has no live acceptance to design a log destination against.
     async recentOutput() {
       return [];
+    },
+    // Enumerating every Ceal task in the Scheduler folder would need a new
+    // PowerShell wire operation, and that program cannot be verified without
+    // a Windows runner: the scan honestly reports nothing here instead of
+    // shipping unverified manager behavior.
+    async listInstallations() {
+      return [];
     }
   };
 }
@@ -9502,9 +9912,9 @@ function isWireResult(value) {
   return isRecord9(value) && value.schema_version === WINDOWS_SERVICE_RESULT_SCHEMA && value.ok === true && (value.observations === void 0 || Array.isArray(value.observations));
 }
 function isWireObservation(value) {
-  return isRecord9(value) && isServiceComponent(value.component) && isServiceState(value.state) && typeof value.definition_matches === "boolean";
+  return isRecord9(value) && isServiceComponent2(value.component) && isServiceState(value.state) && typeof value.definition_matches === "boolean";
 }
-function isServiceComponent(value) {
+function isServiceComponent2(value) {
   return HOST_RUNTIME_SERVICE_COMPONENTS.some((component) => component === value);
 }
 function isServiceState(value) {
@@ -9633,7 +10043,7 @@ var WINDOWS_TASK_SCHEDULER_PROGRAM = Buffer.from(TASK_SCHEDULER_SOURCE, "utf16le
 
 // host/lifecycle/src/host-runtime-systemd.ts
 import { createHash as createHash11, randomUUID } from "node:crypto";
-import { chmod as chmod3, lstat as lstat12, mkdir as mkdir9, open as open12, readFile as readFile5, readdir as readdir4, rename as rename8, unlink as unlink7 } from "node:fs/promises";
+import { chmod as chmod3, lstat as lstat12, mkdir as mkdir9, open as open12, readFile as readFile5, readdir as readdir5, rename as rename8, unlink as unlink7 } from "node:fs/promises";
 import { join as join14 } from "node:path";
 
 // host/lifecycle/src/systemd-unit-show.ts
@@ -9694,13 +10104,22 @@ function validSystemdUnitShow(shown) {
 var DEFAULT_JOURNALCTL_PATH = "/usr/bin/journalctl";
 var MAX_COMMAND_OUTPUT_BYTES = SYSTEMD_SHOW_MAX_OUTPUT_BYTES;
 var UNIT_ID_PATTERN = /^[a-f0-9]{64}$/u;
+var CEAL_HOST_UNIT_PATTERN = /^ceal-host-([a-f0-9]{64})-(lifecycle|relay|codex|claude)\.service$/u;
 var OWNER_HEADER = "# Managed by ceal-host. Do not edit.";
 var LinuxUserSystemdAdapterError = class extends Error {
   code;
-  constructor(code2, message) {
+  /**
+   * Bounded code-shaped words naming what the refusal held, so the control
+   * boundary can repeat them without quoting unit bodies. The message keeps
+   * the exact removal command for local reading; only these words travel in
+   * the control result.
+   */
+  reasons;
+  constructor(code2, message, reasons = []) {
     super(message);
     this.name = "LinuxUserSystemdAdapterError";
     this.code = code2;
+    this.reasons = reasons.filter((reason) => typeof reason === "string");
   }
 };
 function createLinuxUserSystemdAdapter(options) {
@@ -9714,6 +10133,7 @@ function createLinuxUserSystemdAdapter(options) {
       const previousByComponent = serviceMap(previous);
       const targetByComponent = serviceMap(target);
       await ensurePrivateUnitDirectory(unitDirectory);
+      if (target.services.length > 0) await refuseForeignCealUnits(unitDirectory, run, systemctl, identity);
       const removableUnits = await ownedHostUnits(unitDirectory, identity);
       for (const service of target.services) await replaceOwnedUnit(unitDirectory, identity, service);
       for (const unit of removableUnits) {
@@ -9735,6 +10155,9 @@ function createLinuxUserSystemdAdapter(options) {
       await invokeSystemctl(run, systemctl, ["--user", "restart", unitName(identity, service.component)]);
       await requireExpectedReadback(run, systemctl, unitDirectory, identity, service, "running");
     },
+    async listInstallations() {
+      return listSystemdInstallations(unitDirectory, run, systemctl);
+    },
     async inspect({ target }) {
       const identity = prefixIdentity(target.prefix);
       const expected = serviceMap(target);
@@ -9780,8 +10203,8 @@ function serviceMap(set) {
 }
 async function ownedHostUnits(directory, identity) {
   const owned = [];
-  for (const name of await readdir4(directory)) {
-    const match = /^ceal-host-([a-f0-9]{64})-(lifecycle|relay|codex|claude)\.service$/u.exec(name);
+  for (const name of await readdir5(directory)) {
+    const match = CEAL_HOST_UNIT_PATTERN.exec(name);
     if (match === null) continue;
     const unitIdentity = match[1];
     const component = match[2];
@@ -9790,6 +10213,132 @@ async function ownedHostUnits(directory, identity) {
   }
   return owned.sort((left, right) => unitName(left.identity, left.component).localeCompare(unitName(right.identity, right.component)));
 }
+async function refuseForeignCealUnits(directory, run, systemctl, identity) {
+  const names = (await readdir5(directory)).sort();
+  for (const name of names) {
+    const parsed = parseCealHostUnit(name);
+    if (parsed === void 0 || parsed.identity === identity) continue;
+    if (await provenOwnedUnitPresent(directory, parsed.identity, parsed.component)) refuseForeignCealUnit(name, parsed.identity, parsed.component);
+  }
+  for (const name of await listedCealUnitNames(run, systemctl)) {
+    const parsed = parseCealHostUnit(name);
+    if (parsed === void 0 || parsed.identity === identity) continue;
+    refuseForeignCealUnit(name, parsed.identity, parsed.component);
+  }
+}
+function parseCealHostUnit(name) {
+  const match = CEAL_HOST_UNIT_PATTERN.exec(name);
+  const identity = match?.[1];
+  const component = match?.[2];
+  if (identity === void 0 || !isHostRuntimeServiceComponent(component)) return void 0;
+  return { identity, component };
+}
+async function provenOwnedUnitPresent(directory, identity, component) {
+  try {
+    return await ownedUnitPresent(unitPath(directory, identity, component), identity, component);
+  } catch {
+    return false;
+  }
+}
+async function listSystemdInstallations(directory, run, systemctl) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const name of await collectCealUnitNames(directory, run, systemctl)) {
+    const record7 = await describeCealUnit(directory, run, systemctl, name);
+    if (record7 === void 0) continue;
+    let group = groups.get(record7.identity);
+    if (group === void 0) {
+      group = { services: [] };
+      groups.set(record7.identity, group);
+    }
+    if (record7.prefix !== void 0 && group.prefix === void 0) group.prefix = record7.prefix;
+    group.services.push(record7.service);
+  }
+  return assembleHostRuntimeInstallations(groups);
+}
+async function collectCealUnitNames(directory, run, systemctl) {
+  let files;
+  try {
+    files = (await readdir5(directory)).sort();
+  } catch {
+    return [];
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const file of files) if (parseCealHostUnit(file) !== void 0) names.add(file);
+  for (const name of await listedCealUnitNames(run, systemctl)) names.add(name);
+  return [...names].sort();
+}
+async function describeCealUnit(directory, run, systemctl, name) {
+  const parsed = parseCealHostUnit(name);
+  if (parsed === void 0) return void 0;
+  const owned = await provenOwnedUnitPresent(directory, parsed.identity, parsed.component);
+  const shown = await shownUnitState(run, systemctl, name);
+  if (!owned && shown === void 0) return void 0;
+  const state = unitReportState(owned, shown);
+  if (state === void 0) return void 0;
+  const prefix = owned ? await ownedUnitPrefix(directory, parsed.identity, parsed.component) : void 0;
+  return { identity: parsed.identity, ...prefix === void 0 ? {} : { prefix }, service: { component: parsed.component, state, name } };
+}
+function unitReportState(owned, shown) {
+  if (shown !== void 0) {
+    if (shown.loadState === "not-found") return owned ? "stopped" : void 0;
+    return shown.activeState === "active" ? "running" : "stopped";
+  }
+  return owned ? "stopped" : void 0;
+}
+async function shownUnitState(run, systemctl, name) {
+  let result;
+  try {
+    result = await run(systemctl, ["--user", ...systemdShowArguments(name)], { timeout_ms: HOST_RUNTIME_SERVICE_COMMAND_TIMEOUT_MS, max_output_bytes: MAX_COMMAND_OUTPUT_BYTES });
+  } catch {
+    return void 0;
+  }
+  if (!validCommandResult(result) || result.exit_code !== 0) {
+    const shown = systemdUnitShow(result.stdout);
+    return shown !== null && shown.loadState === "not-found" ? shown : void 0;
+  }
+  return systemdUnitShow(result.stdout) ?? void 0;
+}
+async function ownedUnitPrefix(directory, identity, component) {
+  let text;
+  try {
+    text = await readFile5(unitPath(directory, identity, component), "utf8");
+  } catch {
+    return void 0;
+  }
+  for (const line of text.split("\n")) {
+    if (!line.startsWith("ExecStart=")) continue;
+    const executable = firstExecToken(line.slice("ExecStart=".length));
+    return executable === void 0 ? void 0 : hostPrefixFromPosixNodeExecutable(executable);
+  }
+  return void 0;
+}
+function firstExecToken(value) {
+  const text = value.trimStart();
+  if (text.startsWith('"')) {
+    const body = /^"((?:[^"\\]|\\.)*)"/u.exec(text)?.[1];
+    return body === void 0 ? void 0 : body.replaceAll(/\\(.)/gu, "$1");
+  }
+  const token = text.split(/\s+/u)[0];
+  return token === void 0 || token === "" ? void 0 : token;
+}
+async function listedCealUnitNames(run, systemctl) {
+  let result;
+  try {
+    result = await run(systemctl, ["--user", "list-units", "--all", "--no-legend", "--plain", "ceal-host-*"], { timeout_ms: HOST_RUNTIME_SERVICE_COMMAND_TIMEOUT_MS, max_output_bytes: MAX_COMMAND_OUTPUT_BYTES });
+  } catch {
+    return [];
+  }
+  if (!validCommandResult(result) || result.exit_code !== 0) return [];
+  const names = [];
+  for (const line of result.stdout.split("\n")) {
+    const name = line.split(/\s+/u).filter((field) => field !== "")[0];
+    if (name !== void 0 && CEAL_HOST_UNIT_PATTERN.test(name)) names.push(name);
+  }
+  return names;
+}
+function refuseForeignCealUnit(name, identity, component) {
+  throw new LinuxUserSystemdAdapterError("foreign_unit", `A systemd user unit "${name}" belongs to another Host installation (installation ${identity}). This installation cannot retire another installation's units: remove each stale Ceal unit with \`systemctl --user disable --now ${name}\` (list them with \`systemctl --user list-units 'ceal-host-*' --all\`), then rerun the operation.`, [`service:${component}`, `installation:${identity}`, "systemctl:disable"]);
+}
 function isHostRuntimeServiceComponent(value) {
   return value !== void 0 && HOST_RUNTIME_SERVICE_COMPONENTS.some((component) => component === value);
 }
@@ -10064,6 +10613,9 @@ var InstalledHostRuntimeServiceComposition = class {
     if (service === void 0) throw configInvalid();
     await this.platform.restart({ target, service });
   }
+  async listInstallations() {
+    return this.platform.listInstallations();
+  }
 };
 var InstalledHostRuntimeReadinessComposition = class {
   owner;