@corca-org/ceal-host-linux-arm64 1.0.19 → 1.0.20

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

@@ -1005,6 +1005,7 @@ var REQUIRED_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_f
 var OPTIONAL_FIELDS = CEAL_CLIENT_WIRE_CONTRACT.command_response.bare_document_optional_fields;
 
 // 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"]);
@@ -1088,6 +1089,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 },
@@ -1573,7 +1575,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" }),
@@ -1603,6 +1605,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",
@@ -2100,6 +2103,21 @@ var MAX_STATE_BYTES = 8 * 1024 * 1024;
 // host/relay/src/current-prompt-custody.ts
 var HOST_CURRENT_PROMPT_MAX_BYTES = 256 * 1024;
 
+// host/service-log.ts
+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;
+var HOST_SERVICE_LOG_TAIL_BYTES = 64 * 1024;
+
 // host/relay/src/relay-ipc.ts
 var HOST_RELAY_REQUEST_BINDING_KEYS = Object.freeze([
   "schema_version",
@@ -2118,6 +2136,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;
@@ -2176,6 +2195,12 @@ 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;
 }
@@ -2215,8 +2240,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);
@@ -2299,7 +2330,7 @@ function decodeResponseBuffer(buffer) {
 function decodeCurrentPromptResponseBuffer(buffer) {
   const value = decodeLengthPrefixedJson(buffer, HOST_RELAY_ADMISSION_RESPONSE_MAX_BYTES);
   if (value === null) return null;
-  if (!record3(value) || !exactKeys3(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 (!record3(value) || !exactKeys3(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) {
@@ -2335,6 +2366,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);
@@ -2443,10 +2497,15 @@ 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;
@@ -2455,7 +2514,7 @@ var HostTranscriptWatcher = class {
       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();
@@ -3095,6 +3154,7 @@ var TOKEN_OBSERVATION_SOURCE = "claude_transcript.message.usage";
 var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
   store;
   registerCurrentPrompt;
+  releaseCurrentPrompt;
   diagnostic;
   constructor(options) {
     super(options, {
@@ -3104,6 +3164,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) {
@@ -3116,19 +3177,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) {
@@ -3175,10 +3240,10 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       if (isUserTurnLine(record6)) await this.openTurn(registration, draft, record6);
       else if (isAssistantUsageLine(record6)) this.accumulateUsage(draft, toUsage(record6.uuid, record6.timestamp, record6.message.usage));
       else if (isAssistantLine(record6) && record6.message.usage !== void 0) throw new ClaudeHostError("payload_rejected", "Claude transcript usage is malformed.");
+      if (isAssistantTerminalLine(record6)) await this.releaseOpenTurn(registration, draft);
     }
   }
   async openTurn(registration, draft, record6) {
-    this.diagnostic("watcher_turn_observed");
     await this.closeTurn(registration, draft, record6.timestamp);
     const sessionRef = registration.host_session_ref;
     const turnRef = claudeLocalTurnRef(registration.claude_session_id, record6.uuid);
@@ -3194,23 +3259,40 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
       if (session !== null) observations.push({ observation_ref: observationRef("transcript_session", sessionRef, session.value), observation_kind: "session", observed_at: record6.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: record6.timestamp,
-      expires_at: this.expire(this.outboxRetentionMs)
-    });
-    draft.enqueued += 1;
-    await this.registerPrompt(sessionRef, turnRef, promptRef, record6.message.content);
+    await this.persistOpenedTurnContext(registration, draft, record6, inputRef, turnRef, promptRef, identity, observations);
+  }
+  async persistOpenedTurnContext(registration, draft, record6, 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, record6.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: record6.timestamp,
+        expires_at: expiresAt
+      });
+      draft.enqueued += 1;
+      await this.activateOpenedTurnContext(identity, promptRef, expiresAt);
+      this.setOpenedTurn(draft, record6, 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, record6, inputRef, turnRef, promptRef) {
     const folded = foldUnattributed(draft.unattributed);
     draft.open_turn = {
       turn_key: turnRef,
@@ -3229,9 +3311,18 @@ var ClaudeTranscriptWatcher = class extends HostTranscriptWatcher {
     draft.open_turn = void 0;
     if (turn === void 0) return;
     const digest2 = terminalDigest(turn);
-    if (digest2 === turn.last_terminal_digest) return;
-    await this.putTerminalEnvelope(registration, turn, digest2, turn.message_ids.length === 0 ? at : void 0);
-    draft.enqueued += 1;
+    if (digest2 !== turn.last_terminal_digest) {
+      await this.putTerminalEnvelope(registration, turn, digest2, 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;
@@ -3265,6 +3356,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);
@@ -3379,27 +3472,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 releaseStoredPromptBestEffort(sessionRef, cursor) {
+    await this.releaseOpenTurnBestEffort(sessionRef, cursor?.open_turn);
   }
-  async activateContext(identity, promptRef, turnGenerationRef) {
+  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");
@@ -3407,6 +3506,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;
   }
@@ -3523,21 +3623,12 @@ function isUserTurnLine(record6) {
   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(record6) {
   return isTranscriptRecord(record6) && record6.type === "assistant" && isTranscriptRecord(record6.message);
 }
+function isAssistantTerminalLine(record6) {
+  return isAssistantLine(record6) && (record6.message.stop_reason === "end_turn" || record6.message.stop_reason === "stop_sequence");
+}
 function isAssistantUsageLine(record6) {
   if (!isTranscriptRecord(record6)) return false;
   if (!isAssistantLine(record6) || record6.message.usage === void 0) return false;
@@ -3565,17 +3656,29 @@ 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-adapter.ts
 import { createHash as createHash4, randomUUID } from "node:crypto";
 import { O_NOFOLLOW as O_NOFOLLOW3, O_RDONLY as O_RDONLY4 } from "node:constants";
-import { open as open4 } from "node:fs/promises";
+import { open as open4, readdir as readdir3 } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute as isAbsolute2, join as join5, relative, resolve } from "node:path";
 var ClaudeHookAdapter = class {
@@ -3743,11 +3846,43 @@ async function makeClaudeBaselineCursor(handle, registration, now, file, offset)
     offset,
     anchor_start: anchorStart,
     anchor_sha256: createHash4("sha256").update(anchor).digest("hex"),
-    subagents: {},
+    subagents: await readClaudeSubagentBaseline(registration.transcript_path),
     status: "active",
     updated_at: timestamp4(now)
   };
 }
+async function readClaudeSubagentBaseline(transcriptPath) {
+  const directory = subagentsDirectory(transcriptPath);
+  let names;
+  try {
+    names = (await readdir3(directory)).filter((name) => name.endsWith(".jsonl") && !name.endsWith(".meta.json")).sort();
+  } catch {
+    return {};
+  }
+  const cursors = {};
+  for (const name of names) {
+    const seed = await readClaudeSubagentSeed(directory, name).catch(() => void 0);
+    if (seed !== void 0) cursors[name] = seed;
+  }
+  return cursors;
+}
+async function readClaudeSubagentSeed(directory, name) {
+  let handle;
+  try {
+    handle = await open4(join5(directory, name), O_RDONLY4 | O_NOFOLLOW3);
+    const stats = await handle.stat();
+    if (!stats.isFile()) throw new ClaudeHostError("storage", "Claude subagent baseline source is not a regular file.");
+    return {
+      device: String(stats.dev),
+      inode: String(stats.ino),
+      offset: stats.size,
+      anchor_start: 0,
+      anchor_sha256: createHash4("sha256").update(Buffer.alloc(0)).digest("hex")
+    };
+  } finally {
+    await handle?.close();
+  }
+}
 async function readLastClaudeTranscriptLine(handle, size) {
   if (size === 0) return null;
   const last = Buffer.alloc(1);
@@ -3925,17 +4060,6 @@ function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-// host/service-log.ts
-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;
-var HOST_SERVICE_LOG_TAIL_BYTES = 64 * 1024;
-
 // host/claude/src/claude-producer-runtime.ts
 async function drainClaudeProducerOnce(options) {
   const promptPort = new HostRelayCurrentPromptPort(options.relay_endpoint, options.timeout_ms);
@@ -3943,9 +4067,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 } });
@@ -4199,11 +4324,11 @@ function claudeHookEventFromArgs(args) {
 async function runClaudeHook(event, stdin, options) {
   try {
     const result = await runClaudeHookFromStdin(event, stdin, options);
-    if (result.disposition === "rejected") writeHostServiceDiagnostic("claude", "hook_failed");
-    else if (result.reason === "transcript_registered") writeHostServiceDiagnostic("claude", "registration_written");
+    if (result.disposition === "rejected") writeHostServiceDiagnostic("claude", "hook_failed", void 0, void 0, options.diagnostic_sink);
+    else if (result.reason === "transcript_registered") writeHostServiceDiagnostic("claude", "registration_written", void 0, void 0, options.diagnostic_sink);
     return 0;
   } catch {
-    writeHostServiceDiagnostic("claude", "hook_failed");
+    writeHostServiceDiagnostic("claude", "hook_failed", void 0, void 0, options.diagnostic_sink);
     return 0;
   }
 }