@vtxmacro/cli 2026.8.44 → 2026.8.46

package/bin/vtx.js

@@ -38,7 +38,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.8.44",
+      package_version: "2026.8.46",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -14379,7 +14379,7 @@ var init_zod = __esm({
 });
 
 // lib/external-inference-contract.ts
-var EXTERNAL_INFERENCE_CONTRACT_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION, EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION, EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, LEGACY_EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION, EXTERNAL_INFERENCE_INPUT_HASH_DOMAIN, MAX_EXTERNAL_INFERENCE_STATUS_HOSTS, MAX_GENERATION, MAX_SAFE_INTEGER, MAX_PROMPT_BYTES, MAX_IMMUTABLE_JOB_INPUT_BYTES, MAX_CANDIDATE_PLAINTEXT_BYTES, MAX_CIPHERTEXT_CHARS, SHA256_INITIAL_STATE, SHA256_ROUND_CONSTANTS, rotateRight, sha256BytesHex, sha256Utf8Hex, computeImmutableJobInputSha256, identifierSchema, operationIdentifierSchema, sha256HexSchema, generationSchema, zeroBasedGenerationSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, sqlIntegerTokenCountSchema, timestampSchema, safeCodeSchema, externalInferenceAdapterIdSchema, reasoningEffortSchema, modelNameSchema, displayNameSchema, authenticatedAccountEmailSchema, protocolVersionSchema, base64UrlAlphabet, isCanonicalBase64Url, base64Url32BytesSchema, base64UrlNonceSchema, base64UrlCiphertextSchema, claimHandleSchema, boundedJsonTextSchema, boundedPromptTextSchema, laneSchema, botModeSchema, executionModeSchema, responseModeSchema, dispatchOutcomeSchema, responseOutcomeSchema, nativeModelControllerSchema, externalAgentModelControllerSchema, externalAgentUnboundControllerSchema, orderedFallbackHostIdsSchema, externalInferenceFallbackHostIdsSchema, liveModelControllerSchema, snapshotModelControllerSchema, modelIdentityMappingSchema, advertisedModelSchema, hostAdvertisementSchema, envelopeAadSchema, validateEnvelopeAad, commonEnvelopeShape, sealedKeyWrapEnvelopeSchema, sealedInputEnvelopeSchema, sealedCandidateEnvelopeSchema, sealedEnvelopeSchema, screenerCandidateRuntimeBindingSchema, screenerClientLeaseBindingSchema, screenerRuntimeBindingSchema, serverRuntimeBindingSchema, clientRuntimeBindingSchema, runtimeBindingSchema, immutableJobInputSchema, canonicalizeJsonValue, serializeImmutableJobInput, reportedTokenUsageSchema, unavailableTokenUsageSchema, tokenUsageSchema, agentConnectRequestSchema, agentNextRequestSchema, agentHeartbeatRequestSchema, emptyAgentNextResultSchema, claimedAgentNextResultSchema, agentNextResultSchema, agentCompleteRequestSchema, agentFailRequestSchema, requestedModelSelectionSchema, completedModelProvenanceSchema, attemptModelProvenanceSchema, providerWeeklyQuotaReadSchema, hostHeartbeatRequestSchema, jobClaimRequestSchema, emptyJobClaimSchema, claimedJobSchema, jobClaimResultSchema, attemptStartRequestSchema, jobHeartbeatRequestSchema, continueHeartbeatDirectiveSchema, cancelHeartbeatDirectiveSchema, jobHeartbeatResultSchema, adapterOutcomeEvidenceSchema, completionBaseShape, validateCompletion, providerResponseCompletionSchema, decisionCandidateCompletionSchema, jobCompleteRequestSchema, jobFailRequestSchema, jobCancelRequestSchema, jobCancellationReceiptSchema, jobDeliveryRequestSchema, deliveryBaseShape, validateDeliveryCandidate, providerResponseDeliverySchema, decisionCandidateDeliverySchema, jobDeliveryResultSchema, jobConsumptionRequestSchema, jobConsumptionReceiptSchema, jobStateSchema, jobStatusReadSchema, hostStatusReadSchema, controllerBindingStatusReadSchema, queueStatusReadSchema, outcomeStatusReadSchema, externalInferenceVolumeWindowReadSchema, externalInferenceFailureCountReadSchema, externalInferenceHostDiagnosticsReadSchema, externalInferenceProfileActivityReadSchema, externalInferenceStatusReadSchema, nativeResearchEvidenceSourceSchema, externalAgentResearchEvidenceSourceSchema, researchEvidenceSourceSchema, reportedResearchTokenUsageSchema, unavailableResearchTokenUsageSchema, researchTokenUsageSchema, externalInferenceProductLineageBaseShape, traderExternalInferenceProductLineageSchema, decisionChatExternalInferenceProductLineageSchema, screenerExternalInferenceProductLineageSchema, externalInferenceProductLineageSchema, normalProductLinkageSchema, evidenceMaterializationMarkerSchema, deliveredExternalAgentSourceIdentitySchema, deliveredRequestEvidenceSchema, researchEvidenceBaseShape, researchEvidenceBaseSchema, validateExactUtf8, validateResearchEvidence, providerResponseResearchEvidenceSchema, decisionCandidateResearchEvidenceSchema, researchEvidenceSchema;
+var EXTERNAL_INFERENCE_CONTRACT_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION, EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION, EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, LEGACY_EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION, EXTERNAL_INFERENCE_INPUT_HASH_DOMAIN, MAX_EXTERNAL_INFERENCE_STATUS_HOSTS, MAX_GENERATION, MAX_SAFE_INTEGER, MAX_PROMPT_BYTES, MAX_IMMUTABLE_JOB_INPUT_BYTES, MAX_CANDIDATE_PLAINTEXT_BYTES, MAX_CIPHERTEXT_CHARS, SHA256_INITIAL_STATE, SHA256_ROUND_CONSTANTS, rotateRight, sha256BytesHex, sha256Utf8Hex, computeImmutableJobInputSha256, identifierSchema, operationIdentifierSchema, sha256HexSchema, generationSchema, zeroBasedGenerationSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, sqlIntegerTokenCountSchema, timestampSchema, safeCodeSchema, processExitCodeSchema, externalInferenceAdapterIdSchema, reasoningEffortSchema, modelNameSchema, displayNameSchema, authenticatedAccountEmailSchema, protocolVersionSchema, base64UrlAlphabet, isCanonicalBase64Url, base64Url32BytesSchema, base64UrlNonceSchema, base64UrlCiphertextSchema, claimHandleSchema, boundedJsonTextSchema, boundedPromptTextSchema, laneSchema, botModeSchema, executionModeSchema, responseModeSchema, dispatchOutcomeSchema, responseOutcomeSchema, nativeModelControllerSchema, externalAgentModelControllerSchema, externalAgentUnboundControllerSchema, orderedFallbackHostIdsSchema, externalInferenceFallbackHostIdsSchema, liveModelControllerSchema, snapshotModelControllerSchema, modelIdentityMappingSchema, advertisedModelSchema, hostAdvertisementSchema, envelopeAadSchema, validateEnvelopeAad, commonEnvelopeShape, sealedKeyWrapEnvelopeSchema, sealedInputEnvelopeSchema, sealedCandidateEnvelopeSchema, sealedEnvelopeSchema, screenerCandidateRuntimeBindingSchema, screenerClientLeaseBindingSchema, screenerRuntimeBindingSchema, serverRuntimeBindingSchema, clientRuntimeBindingSchema, runtimeBindingSchema, immutableJobInputSchema, canonicalizeJsonValue, serializeImmutableJobInput, reportedTokenUsageSchema, unavailableTokenUsageSchema, tokenUsageSchema, agentConnectRequestSchema, agentNextRequestSchema, agentHeartbeatRequestSchema, emptyAgentNextResultSchema, claimedAgentNextResultSchema, agentNextResultSchema, agentCompleteRequestSchema, agentFailRequestSchema, requestedModelSelectionSchema, completedModelProvenanceSchema, attemptModelProvenanceSchema, providerWeeklyQuotaReadSchema, hostHeartbeatRequestSchema, jobClaimRequestSchema, emptyJobClaimSchema, claimedJobSchema, jobClaimResultSchema, attemptStartRequestSchema, jobHeartbeatRequestSchema, continueHeartbeatDirectiveSchema, cancelHeartbeatDirectiveSchema, jobHeartbeatResultSchema, adapterOutcomeEvidenceSchema, completionBaseShape, validateCompletion, providerResponseCompletionSchema, decisionCandidateCompletionSchema, jobCompleteRequestSchema, codexProcessExitDiagnosticsSchema, jobFailRequestSchema, jobCancelRequestSchema, jobCancellationReceiptSchema, jobDeliveryRequestSchema, deliveryBaseShape, validateDeliveryCandidate, providerResponseDeliverySchema, decisionCandidateDeliverySchema, jobDeliveryResultSchema, jobConsumptionRequestSchema, jobConsumptionReceiptSchema, jobStateSchema, jobStatusReadSchema, hostStatusReadSchema, controllerBindingStatusReadSchema, queueStatusReadSchema, outcomeStatusReadSchema, externalInferenceVolumeWindowReadSchema, externalInferenceFailureCountReadSchema, externalInferenceHostDiagnosticsReadSchema, externalInferenceProfileActivityReadSchema, externalInferenceStatusReadSchema, nativeResearchEvidenceSourceSchema, externalAgentResearchEvidenceSourceSchema, researchEvidenceSourceSchema, reportedResearchTokenUsageSchema, unavailableResearchTokenUsageSchema, researchTokenUsageSchema, externalInferenceProductLineageBaseShape, traderExternalInferenceProductLineageSchema, decisionChatExternalInferenceProductLineageSchema, screenerExternalInferenceProductLineageSchema, externalInferenceProductLineageSchema, normalProductLinkageSchema, evidenceMaterializationMarkerSchema, deliveredExternalAgentSourceIdentitySchema, deliveredRequestEvidenceSchema, researchEvidenceBaseShape, researchEvidenceBaseSchema, validateExactUtf8, validateResearchEvidence, providerResponseResearchEvidenceSchema, decisionCandidateResearchEvidenceSchema, researchEvidenceSchema;
 var init_external_inference_contract = __esm({
   "lib/external-inference-contract.ts"() {
     "use strict";
@@ -14582,6 +14582,7 @@ var init_external_inference_contract = __esm({
     sqlIntegerTokenCountSchema = external_exports.number().int().min(0).max(2147483647);
     timestampSchema = external_exports.iso.datetime({ offset: true });
     safeCodeSchema = external_exports.string().min(1).max(96).regex(/^[a-z0-9][a-z0-9._-]{0,95}$/);
+    processExitCodeSchema = external_exports.number().int().min(-(2 ** 31)).max(2 ** 31 - 1);
     externalInferenceAdapterIdSchema = external_exports.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]{0,63}$/);
     reasoningEffortSchema = external_exports.string().min(1).max(32).regex(/^[a-z][a-z0-9_-]{0,31}$/);
     modelNameSchema = external_exports.string().min(1).max(256);
@@ -15435,6 +15436,55 @@ var init_external_inference_contract = __esm({
       providerResponseCompletionSchema,
       decisionCandidateCompletionSchema
     ]);
+    codexProcessExitDiagnosticsSchema = external_exports.strictObject({
+      schema_version: external_exports.literal("external_inference_process_exit_v1"),
+      runtime: external_exports.literal("codex_app_server"),
+      source: external_exports.enum(["child_receipt", "direct_process", "guardian_process"]),
+      session_generation: generationSchema,
+      expected_shutdown: external_exports.boolean(),
+      exit_class: external_exports.enum(["zero", "nonzero", "signal", "unknown"]),
+      exit_code: processExitCodeSchema.nullable(),
+      signal: safeCodeSchema.nullable(),
+      uptime_ms: nonNegativeSafeIntegerSchema,
+      pending_request_count: nonNegativeSafeIntegerSchema.nullable(),
+      active_thread_count: nonNegativeSafeIntegerSchema.nullable(),
+      stderr_nonempty: external_exports.boolean().nullable(),
+      stderr_bytes_observed: external_exports.number().int().min(0).max(65536).nullable(),
+      stderr_truncated: external_exports.boolean().nullable(),
+      stderr_class: external_exports.enum([
+        "unknown",
+        "none",
+        "out_of_memory",
+        "runtime_fatal",
+        "memory_fault",
+        "pipe_or_connection",
+        "unclassified"
+      ])
+    }).superRefine((value, context) => {
+      const expectedExitClass = value.signal !== null ? "signal" : value.exit_code === null ? "unknown" : value.exit_code === 0 ? "zero" : "nonzero";
+      if (value.exit_class !== expectedExitClass) {
+        context.addIssue({ code: "custom", message: "process exit class does not match code and signal", path: ["exit_class"] });
+      }
+      if (value.signal !== null && value.exit_code !== null) {
+        context.addIssue({ code: "custom", message: "signal exits cannot also report an exit code", path: ["exit_code"] });
+      }
+      if (value.stderr_class === "unknown") {
+        if (value.stderr_nonempty !== null || value.stderr_bytes_observed !== null || value.stderr_truncated !== null) {
+          context.addIssue({ code: "custom", message: "unknown stderr diagnostics must not infer observations", path: ["stderr_class"] });
+        }
+      } else if (value.stderr_nonempty === null || value.stderr_bytes_observed === null || value.stderr_truncated === null) {
+        context.addIssue({ code: "custom", message: "observed stderr diagnostics must be complete", path: ["stderr_class"] });
+      } else if (!value.stderr_nonempty) {
+        if (value.stderr_bytes_observed !== 0 || value.stderr_truncated || value.stderr_class !== "none") {
+          context.addIssue({ code: "custom", message: "empty stderr diagnostics are inconsistent", path: ["stderr_nonempty"] });
+        }
+      } else if (value.stderr_bytes_observed === 0 || value.stderr_class === "none") {
+        context.addIssue({ code: "custom", message: "non-empty stderr diagnostics are inconsistent", path: ["stderr_nonempty"] });
+      }
+      if (value.stderr_truncated && value.stderr_bytes_observed !== 65536) {
+        context.addIssue({ code: "custom", message: "truncated stderr diagnostics must report the observation cap", path: ["stderr_truncated"] });
+      }
+    });
     jobFailRequestSchema = external_exports.strictObject({
       schema_version: external_exports.literal("external_inference_job_fail_v1"),
       contract_version: external_exports.literal(EXTERNAL_INFERENCE_CONTRACT_VERSION),
@@ -15457,6 +15507,7 @@ var init_external_inference_contract = __esm({
       failure_category: safeCodeSchema,
       failure_code: safeCodeSchema,
       retryable: external_exports.boolean(),
+      process_exit: codexProcessExitDiagnosticsSchema.nullable().optional(),
       membership_disposition: external_exports.enum([
         "retry_same_host",
         "cascade_cooldown",
@@ -15473,6 +15524,13 @@ var init_external_inference_contract = __esm({
       if (value.attempt_status !== expectedStatus) {
         context.addIssue({ code: "custom", message: "attempt_status must match dispatch outcome", path: ["attempt_status"] });
       }
+      if (value.process_exit != null && (value.failure_category !== "transport" || value.failure_code !== "codex_process_closed" || value.process_exit.expected_shutdown)) {
+        context.addIssue({
+          code: "custom",
+          message: "process exit diagnostics require an unexpected Codex process-close failure",
+          path: ["process_exit"]
+        });
+      }
       if (value.outcome.dispatch_outcome === "outcome_unknown" && value.membership_disposition !== void 0 && value.membership_disposition !== "quarantine_ambiguous") {
         context.addIssue({ code: "custom", message: "outcome-unknown failures must be quarantined", path: ["membership_disposition"] });
       }
@@ -19593,6 +19651,7 @@ var init_codex_app_server = __esm({
         this.retryAtMs = options.retryAtMs ?? null;
         this.usage = options.usage ?? null;
         this.rateLimits = options.rateLimits ?? null;
+        this.processExit = options.processExit ?? null;
       }
     };
     objectOrNull = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -19897,7 +19956,7 @@ var init_codex_app_server = __esm({
     };
     GUARDIAN_SCRIPT = String.raw`
 import { spawn } from 'node:child_process';
-import { chmod, open, rename, rm, writeFile } from 'node:fs/promises';
+import { chmod, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 const input = JSON.parse(Buffer.from(process.argv[1], 'base64url').toString('utf8'));
 // The guardian owns the process boundary for every attempt. Apply a private
@@ -19927,7 +19986,7 @@ const replaceReceipt = async (temporary) => {
 };
 let receiptWriteSequence = 0;
 let receiptWriteChain = Promise.resolve();
-const writeReceipt = (state, childPid) => {
+const writeReceipt = (state, childPid, termination = null) => {
   const write = async () => {
     const body = JSON.stringify({
       schema_version: 'vtx_codex_guardian_v1',
@@ -19936,6 +19995,7 @@ const writeReceipt = (state, childPid) => {
       guardian_pid: process.pid,
       child_pid: childPid ?? null,
       boot_identity: input.bootIdentity,
+      termination,
       updated_at: new Date().toISOString(),
     }) + '\n';
     receiptWriteSequence += 1;
@@ -19960,8 +20020,11 @@ const writeReceipt = (state, childPid) => {
 };
 let child = null;
 let shuttingDown = false;
+let shutdownRequested = false;
+let childStartedAt = null;
 let forceTimer = null;
-const shutdown = () => {
+const stopChild = (expected) => {
+  if (expected) shutdownRequested = true;
   if (shuttingDown) return;
   shuttingDown = true;
   if (!child) return;
@@ -19971,6 +20034,19 @@ const shutdown = () => {
   }, input.shutdownGraceMs);
   forceTimer.unref();
 };
+let shutdownStarted = false;
+const shutdown = async () => {
+  if (shutdownStarted) return;
+  shutdownStarted = true;
+  let expected = false;
+  try {
+    expected = (await readFile(input.shutdownIntentPath, 'utf8')) === input.processToken;
+    await rm(input.shutdownIntentPath, { force: true });
+  } catch {
+    expected = false;
+  }
+  stopChild(expected);
+};
 process.stdin.once('end', shutdown);
 process.stdin.once('close', shutdown);
 process.stdout.on('error', () => undefined);
@@ -19986,6 +20062,7 @@ child = spawn(input.binary, input.args, {
   windowsHide: true,
   detached: false,
 });
+childStartedAt = Date.now();
 child.stdin.on('error', () => undefined);
 process.stdin.pipe(child.stdin, { end: false });
 child.stdout.pipe(process.stdout);
@@ -19994,18 +20071,33 @@ child.once('spawn', async () => {
   try {
     await writeReceipt('running', child.pid ?? null);
   } catch {
-    shutdown();
+    stopChild(false);
   }
 });
-child.once('error', shutdown);
-child.once('close', async () => {
+child.once('error', () => stopChild(false));
+child.once('close', async (code, signal) => {
   if (forceTimer) clearTimeout(forceTimer);
   // A pending promise alone does not keep Node's event loop alive after the
   // child and parent stdin have both closed. Hold one local handle until the
   // serialized terminal tombstone is durably replaced.
   const receiptKeepAlive = setInterval(() => undefined, 1_000);
   try {
-    await writeReceipt('terminated', child.pid ?? null);
+    const normalizedSignal = typeof signal === 'string' && /^SIG[A-Z0-9]{1,28}$/.test(signal)
+      ? signal.toLowerCase()
+      : null;
+    const normalizedCode = normalizedSignal === null && Number.isInteger(code)
+      && code >= -(2 ** 31) && code <= (2 ** 31) - 1
+      ? code
+      : null;
+    await writeReceipt('terminated', child.pid ?? null, {
+      exit_code: normalizedCode,
+      signal: normalizedSignal,
+      expected: shutdownRequested,
+      uptime_ms: Math.min(
+        Math.max(0, Date.now() - (childStartedAt ?? Date.now())),
+        Number.MAX_SAFE_INTEGER,
+      ),
+    });
   } finally {
     clearInterval(receiptKeepAlive);
     process.exit(0);
@@ -20057,6 +20149,7 @@ child.once('close', async () => {
         guardian_pid: null,
         child_pid: null,
         boot_identity: guardian.bootIdentity ?? null,
+        termination: null,
         updated_at: (/* @__PURE__ */ new Date()).toISOString()
       })}
 `;
@@ -20081,12 +20174,15 @@ child.once('close', async () => {
     };
     parseGuardianReceipt = (raw) => {
       const value = JSON.parse(raw);
-      if (value.schema_version !== "vtx_codex_guardian_v1" || typeof value.process_token !== "string" || !/^[0-9a-f]{64}$/u.test(value.process_token) || !["spawn_intent", "starting", "running", "terminated"].includes(String(value.state)) || value.guardian_pid !== null && !Number.isSafeInteger(value.guardian_pid) || value.state === "spawn_intent" && value.guardian_pid !== null || value.state !== "spawn_intent" && !Number.isSafeInteger(value.guardian_pid) || value.child_pid !== null && !Number.isSafeInteger(value.child_pid) || value.boot_identity !== null && value.boot_identity !== void 0 && typeof value.boot_identity !== "string" || typeof value.updated_at !== "string" || !Number.isFinite(Date.parse(value.updated_at))) {
+      const rawTermination = value.termination;
+      const termination = rawTermination === null || rawTermination === void 0 ? null : objectOrNull(rawTermination);
+      if (value.schema_version !== "vtx_codex_guardian_v1" || typeof value.process_token !== "string" || !/^[0-9a-f]{64}$/u.test(value.process_token) || !["spawn_intent", "starting", "running", "terminated"].includes(String(value.state)) || value.guardian_pid !== null && !Number.isSafeInteger(value.guardian_pid) || value.state === "spawn_intent" && value.guardian_pid !== null || value.state !== "spawn_intent" && !Number.isSafeInteger(value.guardian_pid) || value.child_pid !== null && !Number.isSafeInteger(value.child_pid) || value.boot_identity !== null && value.boot_identity !== void 0 && typeof value.boot_identity !== "string" || typeof value.updated_at !== "string" || !Number.isFinite(Date.parse(value.updated_at)) || rawTermination !== null && rawTermination !== void 0 && termination === null || termination !== null && (value.state !== "terminated" || termination.exit_code !== null && (!Number.isInteger(termination.exit_code) || Number(termination.exit_code) < -(2 ** 31) || Number(termination.exit_code) > 2 ** 31 - 1) || termination.signal !== null && (typeof termination.signal !== "string" || !/^sig[a-z0-9]{1,28}$/u.test(termination.signal)) || termination.signal !== null && termination.exit_code !== null || typeof termination.expected !== "boolean" || !Number.isSafeInteger(termination.uptime_ms) || Number(termination.uptime_ms) < 0)) {
         throw new Error("Codex guardian receipt is invalid.");
       }
       return {
         ...value,
-        boot_identity: typeof value.boot_identity === "string" ? value.boot_identity : null
+        boot_identity: typeof value.boot_identity === "string" ? value.boot_identity : null,
+        termination
       };
     };
     readCodexGuardianReceipt = async (path) => {
@@ -20130,6 +20226,7 @@ child.once('close', async () => {
         args,
         processToken: options.guardian.processToken,
         receiptPath: options.guardian.receiptPath,
+        shutdownIntentPath: `${options.guardian.receiptPath}.shutdown-intent`,
         shutdownGraceMs: Math.max(25, options.guardian.shutdownGraceMs ?? 2e3),
         bootIdentity: options.guardian.bootIdentity
       }), "utf8").toString("base64url");
@@ -20151,13 +20248,33 @@ child.once('close', async () => {
         this.nextRequestId = 1;
         this.fatalError = null;
         this.closed = false;
+        this.processCloseObserved = false;
+        this.shutdownRequested = false;
+        this.stderrBytesObserved = 0;
+        this.stderrNonempty = false;
+        this.stderrTruncated = false;
+        this.stderrTail = "";
+        this.stderrClass = "none";
         this.process = options.process;
         this.codexHome = options.codexHome;
-        this.process.stderr.resume();
+        this.sessionGeneration = options.sessionGeneration;
+        this.startedAtMs = Date.now();
+        this.guardian = options.guardian;
+        this.onProcessExit = options.onProcessExit;
+        this.process.stderr.on("data", (chunk) => this.observeStderr(chunk));
         const lines = createInterface({ input: this.process.stdout, crlfDelay: Infinity });
         lines.on("line", (line) => this.handleLine(line));
-        this.process.once("error", () => this.failTransport("codex_process_error"));
-        this.process.once("close", () => this.failTransport("codex_process_closed"));
+        this.process.once("error", () => {
+        });
+        this.process.once("close", (code, signal) => {
+          void this.handleProcessClose(code, signal);
+        });
+      }
+      static {
+        this.STDERR_OBSERVATION_CAP_BYTES = 65536;
+      }
+      static {
+        this.STDERR_CLASSIFICATION_TAIL_CHARS = 1024;
       }
       static async start(options) {
         const spawnProcess = options.spawnProcess ?? defaultSpawn;
@@ -20218,7 +20335,13 @@ child.once('close', async () => {
             });
           }
         }
-        const session = new _CodexAppServerSession({ process: child, codexHome: options.codexHome });
+        const session = new _CodexAppServerSession({
+          process: child,
+          codexHome: options.codexHome,
+          sessionGeneration: options.sessionGeneration ?? 1,
+          guardian: guardian ?? null,
+          onProcessExit: options.onProcessExit ?? null
+        });
         try {
           const initialized = await session.request("initialize", {
             clientInfo: {
@@ -20333,13 +20456,14 @@ child.once('close', async () => {
         }
         for (const listener of this.notificationListeners) listener({ method, params });
       }
-      failTransport(code) {
+      failTransport(code, processExit = null) {
         if (this.fatalError) return;
         this.fatalError = new CodexAppServerError({
           message: "Codex app-server transport became unavailable.",
           category: "transport",
           code,
-          retryable: true
+          retryable: true,
+          processExit
         });
         for (const pending of this.pending.values()) {
           if (pending.timer) clearTimeout(pending.timer);
@@ -20440,6 +20564,77 @@ child.once('close', async () => {
         this.fatalListeners.add(listener);
         return () => this.fatalListeners.delete(listener);
       }
+      observeStderr(chunk) {
+        const bytes3 = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+        if (bytes3.length === 0) return;
+        this.stderrNonempty = true;
+        const remaining = Math.max(
+          0,
+          _CodexAppServerSession.STDERR_OBSERVATION_CAP_BYTES - this.stderrBytesObserved
+        );
+        if (remaining === 0) {
+          this.stderrTruncated = true;
+          return;
+        }
+        const observed = bytes3.subarray(0, remaining);
+        this.stderrBytesObserved += observed.length;
+        if (bytes3.length > remaining) this.stderrTruncated = true;
+        this.stderrTail = `${this.stderrTail}${observed.toString("utf8")}`.slice(-_CodexAppServerSession.STDERR_CLASSIFICATION_TAIL_CHARS).toLowerCase();
+        const classified = /heap out of memory|allocation failed|out of memory/u.test(this.stderrTail) ? "out_of_memory" : /fatal runtime error|fatal error|\bpanic(?:ked)?\b/u.test(this.stderrTail) ? "runtime_fatal" : /access violation|segmentation fault|\bsegfault\b/u.test(this.stderrTail) ? "memory_fault" : /broken pipe|econnreset|connection reset/u.test(this.stderrTail) ? "pipe_or_connection" : null;
+        if (classified) this.stderrClass = classified;
+        else if (this.stderrClass === "none") this.stderrClass = "unclassified";
+      }
+      async handleProcessClose(rawCode, rawSignal) {
+        this.processCloseObserved = true;
+        let termination = null;
+        if (this.guardian) {
+          try {
+            const receipt = await readCodexGuardianReceipt(this.guardian.receiptPath);
+            if (receipt?.process_token === this.guardian.processToken && receipt.state === "terminated") {
+              termination = receipt.termination;
+            }
+          } catch {
+          }
+        }
+        const diagnostics = this.processExitDiagnostics(rawCode, rawSignal, termination);
+        if (this.guardian) {
+          await rm2(`${this.guardian.receiptPath}.shutdown-intent`, { force: true }).catch(() => void 0);
+        }
+        try {
+          this.onProcessExit?.(diagnostics);
+        } catch {
+        }
+        this.failTransport("codex_process_closed", diagnostics);
+      }
+      processExitDiagnostics(rawCode, rawSignal, termination) {
+        const source = termination ? "child_receipt" : this.guardian ? "guardian_process" : "direct_process";
+        const reportedCode = termination?.exit_code ?? rawCode;
+        const reportedSignal = termination?.signal ?? rawSignal;
+        const signal = typeof reportedSignal === "string" && /^(?:SIG[A-Z0-9]{1,28}|sig[a-z0-9]{1,28})$/u.test(reportedSignal) ? reportedSignal.toLowerCase() : null;
+        const exitCode = signal === null && typeof reportedCode === "number" && Number.isInteger(reportedCode) && reportedCode >= -(2 ** 31) && reportedCode <= 2 ** 31 - 1 ? reportedCode : null;
+        const diagnostics = {
+          schema_version: "external_inference_process_exit_v1",
+          runtime: "codex_app_server",
+          source,
+          session_generation: this.sessionGeneration,
+          expected_shutdown: termination?.expected ?? this.shutdownRequested,
+          exit_class: signal !== null ? "signal" : exitCode === null ? "unknown" : exitCode === 0 ? "zero" : "nonzero",
+          exit_code: exitCode,
+          signal,
+          uptime_ms: termination?.uptime_ms ?? Math.min(
+            Math.max(0, Date.now() - this.startedAtMs),
+            Number.MAX_SAFE_INTEGER
+          ),
+          pending_request_count: this.pending.size,
+          active_thread_count: this.threads.size,
+          stderr_nonempty: this.stderrNonempty,
+          stderr_bytes_observed: this.stderrBytesObserved,
+          stderr_truncated: this.stderrTruncated,
+          stderr_class: this.stderrNonempty ? this.stderrClass : "none"
+        };
+        this.stderrTail = "";
+        return diagnostics;
+      }
       isUsable() {
         return !this.closed && this.fatalError === null && this.process.exitCode === null;
       }
@@ -20864,6 +21059,7 @@ child.once('close', async () => {
             code: error48.code,
             retryable: error48.retryable,
             dispatchOutcome: requestWritten ? "outcome_unknown" : "not_dispatched",
+            processExit: error48.processExit,
             cause: error48
           }));
         });
@@ -21067,6 +21263,7 @@ child.once('close', async () => {
                 code: error48.code,
                 retryable: error48.retryable,
                 dispatchOutcome: "outcome_unknown",
+                processExit: error48.processExit,
                 cause: error48
               });
             }
@@ -21319,6 +21516,20 @@ child.once('close', async () => {
       async close() {
         if (this.closed) return;
         this.closed = true;
+        if (this.processCloseObserved || this.process.exitCode !== null) {
+          if (this.guardian) {
+            await rm2(`${this.guardian.receiptPath}.shutdown-intent`, { force: true }).catch(() => void 0);
+          }
+          return;
+        }
+        this.shutdownRequested = true;
+        if (this.guardian) {
+          await writeFile(
+            `${this.guardian.receiptPath}.shutdown-intent`,
+            this.guardian.processToken,
+            { mode: 384 }
+          ).catch(() => void 0);
+        }
         this.process.stdin.end();
         const exited = await new Promise((resolve6) => {
           if (this.process.exitCode !== null) {
@@ -21527,11 +21738,12 @@ import {
 import { createHash as createHash4, randomBytes as randomBytes3 } from "node:crypto";
 import { tmpdir as tmpdir2 } from "node:os";
 import { isAbsolute as isAbsolute3, join as join4, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
-var MAX_PROMPT_BYTES2, CODEX_MODEL_NAME_PATTERN, CODEX_REASONING_EFFORT_PATTERN, codexRecoveryCheckpointProcessFingerprint, proveCodexSameBootQuiescence, tokenUsageReceiptSchema, turnResultReceiptSchema, terminalReceiptSchema, recoveryCheckpointSchema, recoveryFileSchema, FileCodexAttemptRecoveryStore, utf8Bytes, assertAttemptActive, tomlString, permissionConfig, ensureDedicatedCodexHome, createIsolatedCodexAttemptResources, createIsolatedCodexHostResources, validateAttemptInput, isStrictDescendant, assertRecoveryResourceScope, removeRecoveredThread, confirmGuardianTerminatedForRecovery, reconcileCodexAttemptRecovery, CodexSubscriptionAdapter;
+var MAX_PROMPT_BYTES2, CODEX_MODEL_NAME_PATTERN, CODEX_REASONING_EFFORT_PATTERN, codexRecoveryCheckpointProcessFingerprint, proveCodexSameBootQuiescence, tokenUsageReceiptSchema, turnResultReceiptSchema, terminalReceiptSchema, recoveryCheckpointSchema, recoveryFileSchema, FileCodexAttemptRecoveryStore, utf8Bytes, assertAttemptActive, tomlString, permissionConfig, ensureDedicatedCodexHome, createIsolatedCodexAttemptResources, createIsolatedCodexHostResources, validateAttemptInput, isStrictDescendant, assertRecoveryResourceScope, removeRecoveredThread, confirmGuardianTerminatedForRecovery, recoveredCodexProcessExit, reconcileCodexAttemptRecovery, CodexSubscriptionAdapter;
 var init_codex_adapter = __esm({
   "lib/inference-host/codex-adapter.ts"() {
     "use strict";
     init_zod();
+    init_external_inference_contract();
     init_codex_app_server();
     init_codex_binary();
     init_config();
@@ -21606,7 +21818,8 @@ var init_codex_adapter = __esm({
           dispatchOutcome: external_exports.enum(["not_dispatched", "confirmed_dispatched", "outcome_unknown"]),
           httpStatusCode: external_exports.number().int().min(100).max(599).nullable().optional(),
           retryAtMs: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).nullable().optional(),
-          usage: tokenUsageReceiptSchema.nullable().optional()
+          usage: tokenUsageReceiptSchema.nullable().optional(),
+          processExit: codexProcessExitDiagnosticsSchema.nullable().optional()
         })
       })
     ]);
@@ -21622,6 +21835,7 @@ var init_codex_adapter = __esm({
       processToken: external_exports.string().regex(/^[0-9a-f]{64}$/u).nullable(),
       processReceiptPath: external_exports.string().min(1).max(4096).nullable(),
       processState: external_exports.enum(["unmanaged", "spawn_intent", "running", "terminated"]),
+      sessionGeneration: external_exports.number().int().positive().max(2147483647).nullable().optional(),
       bootIdentity: external_exports.string().min(1).max(4096).nullable().optional(),
       cleanupConfirmed: external_exports.boolean(),
       adapterRequestId: external_exports.string().min(1).max(512).nullable(),
@@ -22016,6 +22230,30 @@ var init_codex_adapter = __esm({
         throw error48;
       }
     };
+    recoveredCodexProcessExit = (checkpoint, receipt) => {
+      const termination = receipt?.termination;
+      const sessionGeneration = checkpoint.sessionGeneration ?? null;
+      if (!termination || termination.expected || sessionGeneration === null) return null;
+      const signal = termination.signal;
+      const exitCode = signal === null ? termination.exit_code : null;
+      return {
+        schema_version: "external_inference_process_exit_v1",
+        runtime: "codex_app_server",
+        source: "child_receipt",
+        session_generation: sessionGeneration,
+        expected_shutdown: false,
+        exit_class: signal !== null ? "signal" : exitCode === null ? "unknown" : exitCode === 0 ? "zero" : "nonzero",
+        exit_code: exitCode,
+        signal,
+        uptime_ms: termination.uptime_ms,
+        pending_request_count: null,
+        active_thread_count: null,
+        stderr_nonempty: null,
+        stderr_bytes_observed: null,
+        stderr_truncated: null,
+        stderr_class: "unknown"
+      };
+    };
     reconcileCodexAttemptRecovery = async (options) => {
       const attempts = await options.recoveryHooks.loadAll?.() ?? {};
       const currentBootIdentity = options.bootIdentity ?? await readInferenceSystemBootIdentity();
@@ -22056,11 +22294,27 @@ var init_codex_adapter = __esm({
         assertRecoveryResourceScope(checkpoint);
         await removeRecoveredThread(checkpoint, options.codexHome);
         await rm3(checkpoint.resourceRoot, { recursive: true, force: true });
+        const recoveredProcessExit = recoveredCodexProcessExit(
+          checkpoint,
+          await readCodexGuardianReceipt(guardian.receiptPath)
+        );
+        const dispatchOutcome = crossedBoot ? "outcome_unknown" : checkpoint.dispatchOutcome;
         await options.recoveryHooks.save({
           ...checkpoint,
           processState: "terminated",
           cleanupConfirmed: true,
-          dispatchOutcome: crossedBoot ? "outcome_unknown" : checkpoint.dispatchOutcome
+          dispatchOutcome,
+          terminal: checkpoint.terminal ?? (recoveredProcessExit ? {
+            kind: "failed",
+            error: {
+              message: "Codex app-server transport became unavailable.",
+              category: "transport",
+              code: "codex_process_closed",
+              retryable: true,
+              dispatchOutcome,
+              processExit: recoveredProcessExit
+            }
+          } : null)
         });
         reconciled += 1;
       }
@@ -22074,8 +22328,15 @@ var init_codex_adapter = __esm({
         this.durableSessionStart = null;
         this.closing = false;
         this.adapterClosePromise = null;
+        this.sessionGeneration = 0;
         this.dependencies = dependencies;
       }
+      emitDiagnostic(event) {
+        try {
+          this.dependencies.emitDiagnosticEvent?.(event);
+        } catch {
+        }
+      }
       async readAccountRateLimits(deadlineAtMs, signal) {
         const codexHome = this.dependencies.codexHome;
         if (!codexHome) {
@@ -22094,6 +22355,9 @@ var init_codex_adapter = __esm({
         return await durableSession.session.readAccountRateLimits(deadlineAtMs, signal);
       }
       async startDurableSession(codexHome, deadlineAtMs) {
+        this.sessionGeneration = Math.min(this.sessionGeneration + 1, 2147483647);
+        const sessionGeneration = this.sessionGeneration;
+        const activeAttemptIds = /* @__PURE__ */ new Set();
         const binary = await (this.dependencies.resolveBinary ?? resolvePinnedCodexBinary)();
         const guardianManaged = Boolean(
           this.dependencies.recoveryHooks && !this.dependencies.spawnProcess
@@ -22108,10 +22372,26 @@ var init_codex_adapter = __esm({
           codexHome,
           deadlineAtMs,
           spawnProcess: this.dependencies.spawnProcess,
-          guardian: processToken && processReceiptPath ? { processToken, receiptPath: processReceiptPath, bootIdentity: bootIdentity ?? void 0 } : void 0
+          guardian: processToken && processReceiptPath ? { processToken, receiptPath: processReceiptPath, bootIdentity: bootIdentity ?? void 0 } : void 0,
+          sessionGeneration,
+          onProcessExit: (diagnostics) => {
+            this.emitDiagnostic({
+              event: "codex_app_server_closed",
+              process_exit: diagnostics,
+              active_attempt_ids: [...activeAttemptIds].sort().slice(0, 64),
+              active_attempt_ids_truncated: activeAttemptIds.size > 64
+            });
+          }
+        });
+        this.emitDiagnostic({
+          event: "codex_app_server_session_started",
+          session_generation: sessionGeneration,
+          replacement: sessionGeneration > 1
         });
         return {
           session,
+          sessionGeneration,
+          activeAttemptIds,
           codexHome,
           capabilityPreflight: null,
           processToken,
@@ -22351,6 +22631,7 @@ var init_codex_adapter = __esm({
             const receipt = await readCodexGuardianReceipt(checkpoint.processReceiptPath);
             if (checkpoint.processState === "terminated" || receipt === null || receipt.state === "terminated") {
               await rm3(checkpoint.processReceiptPath, { force: true });
+              await rm3(`${checkpoint.processReceiptPath}.shutdown-intent`, { force: true });
             }
           }
         }
@@ -22398,6 +22679,7 @@ var init_codex_adapter = __esm({
             for (const session of sessions) {
               if (session.processReceiptPath && unconfirmedReceiptPaths !== null && !unconfirmedReceiptPaths.has(resolve3(session.processReceiptPath))) {
                 await rm3(session.processReceiptPath, { force: true });
+                await rm3(`${session.processReceiptPath}.shutdown-intent`, { force: true });
               }
             }
           })();
@@ -22442,7 +22724,8 @@ var init_codex_adapter = __esm({
               dispatchOutcome: recovered.dispatchOutcome,
               httpStatusCode: recovered.httpStatusCode,
               retryAtMs: recovered.retryAtMs,
-              usage: recovered.usage
+              usage: recovered.usage,
+              processExit: recovered.processExit
             });
           }
           throw new CodexAppServerError({
@@ -22475,6 +22758,7 @@ var init_codex_adapter = __esm({
             input.deadlineAtMs,
             input.signal
           );
+          sessionLease.activeAttemptIds.add(input.attemptId);
           session = sessionLease.session;
           baseCheckpoint = {
             schemaVersion: "vtx_codex_attempt_recovery_v1",
@@ -22488,6 +22772,7 @@ var init_codex_adapter = __esm({
             processToken: sessionLease.processToken,
             processReceiptPath: sessionLease.processReceiptPath,
             processState: sessionLease.processToken ? "running" : "unmanaged",
+            sessionGeneration: sessionLease.sessionGeneration,
             bootIdentity: sessionLease.bootIdentity,
             cleanupConfirmed: false,
             adapterRequestId: null,
@@ -22586,7 +22871,8 @@ var init_codex_adapter = __esm({
                     dispatchOutcome,
                     httpStatusCode: error48.httpStatusCode,
                     retryAtMs: error48.retryAtMs,
-                    usage: error48.usage
+                    usage: error48.usage,
+                    processExit: error48.processExit
                   }
                 }
               };
@@ -22602,6 +22888,7 @@ var init_codex_adapter = __esm({
               httpStatusCode: error48.httpStatusCode,
               retryAtMs: error48.retryAtMs,
               usage: error48.usage,
+              processExit: error48.processExit,
               cause: error48
             });
           }
@@ -22632,6 +22919,7 @@ var init_codex_adapter = __esm({
           }
           throw classified;
         } finally {
+          sessionLease?.activeAttemptIds.delete(input.attemptId);
           const cleanup = async () => {
             let cleanupError = sessionInvalidationError;
             if (session && threadId) {
@@ -29762,7 +30050,7 @@ function createDefaultInferenceHostRunnerDependencies(options) {
     envelopePublicKey: options.envelopePublicKey
   };
 }
-var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner;
+var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner;
 var init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -29784,6 +30072,8 @@ var init_runner = __esm({
     DEFAULT_DRAIN_TIMEOUT_MS = 3e4;
     DEFAULT_REMOTE_RETRY_LIMIT = 3;
     MIN_SLEEP_MS = 10;
+    MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS = 1e4;
+    HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR = 3;
     DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS = 5 * 60 * 1e3;
     MIN_CLAIM_START_WINDOW_MS = 5e3;
     MAX_ATTEMPT_START_RETRY_DELAY_MS = 15e3;
@@ -30454,6 +30744,9 @@ var init_runner = __esm({
         let completed = 0;
         let failed = 0;
         let acceptAttemptUpdates = true;
+        let stopHostHeartbeatLoop = () => {
+        };
+        let hostHeartbeatLoop = Promise.resolve();
         let wakeDrain;
         const drainSignal = new Promise((resolve6) => {
           wakeDrain = resolve6;
@@ -30469,6 +30762,7 @@ var init_runner = __esm({
           if (drainRequested && priority(reason) <= priority(drainReason)) return;
           drainRequested = true;
           drainReason = reason;
+          stopHostHeartbeatLoop();
           wakeDrain();
         };
         try {
@@ -30600,6 +30894,18 @@ var init_runner = __esm({
             updated_at: isoAt(now())
           };
           await this.persistReceipt(receipt, now);
+          let receiptMutationChain = Promise.resolve();
+          const mutateReceipt = async (mutation) => {
+            let result2;
+            const operation = receiptMutationChain.then(async () => {
+              result2 = mutation(receipt);
+              receipt = result2;
+              await this.persistReceipt(receipt, now);
+            });
+            receiptMutationChain = operation;
+            await operation;
+            return result2;
+          };
           const envelopePublicKey = await this.dependencies.envelopePublicKey(credential);
           const retryExact = async (operation, boundary = {}) => {
             let lastError;
@@ -30642,40 +30948,48 @@ var init_runner = __esm({
           const publishAdvertisement = async (health, forceAdvance, retryRemote = true, allowDefinitiveReseed = true) => {
             let advertisement = receipt.pending_advertisement;
             if (!advertisement) {
-              const generation = receipt.registered && forceAdvance ? receipt.advertisement_generation + 1 : receipt.advertisement_generation;
-              const advertisedAt = now();
-              advertisement = hostAdvertisementSchema.parse({
-                schema_version: EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION,
-                contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
-                operation_id: stableOperationId("advertise", [
-                  localState.host_id,
-                  localState.host_generation,
-                  generation,
-                  localState.key_generation,
-                  advertisedAt
-                ]),
-                host_id: localState.host_id,
-                host_generation: localState.host_generation,
-                advertisement_generation: generation,
-                key_generation: localState.key_generation,
-                adapter: settings.adapterId,
-                display_name: this.options.displayName.trim(),
-                ...this.options.authenticatedAccountIdentity ? { authenticated_account_identity: this.options.authenticatedAccountIdentity } : {},
-                authenticated_account_email: this.options.authenticatedAccountEmail ?? null,
-                authenticated_account_plan: this.options.authenticatedAccountPlan ?? null,
-                protocol_version: this.options.protocolVersion,
-                envelope_public_key: envelopePublicKey,
-                health,
-                advertised_at: isoAt(advertisedAt),
-                expires_at: isoAt(advertisedAt + settings.advertisementTtlMs),
-                models: settings.advertisedModels
+              const updated = await mutateReceipt((current) => {
+                if (current.pending_advertisement) return current;
+                const generation = current.registered && forceAdvance ? current.advertisement_generation + 1 : current.advertisement_generation;
+                const advertisedAt = now();
+                const pendingAdvertisement = hostAdvertisementSchema.parse({
+                  schema_version: EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION,
+                  contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
+                  operation_id: stableOperationId("advertise", [
+                    localState.host_id,
+                    localState.host_generation,
+                    generation,
+                    localState.key_generation,
+                    advertisedAt
+                  ]),
+                  host_id: localState.host_id,
+                  host_generation: localState.host_generation,
+                  advertisement_generation: generation,
+                  key_generation: localState.key_generation,
+                  adapter: settings.adapterId,
+                  display_name: this.options.displayName.trim(),
+                  ...this.options.authenticatedAccountIdentity ? { authenticated_account_identity: this.options.authenticatedAccountIdentity } : {},
+                  authenticated_account_email: this.options.authenticatedAccountEmail ?? null,
+                  authenticated_account_plan: this.options.authenticatedAccountPlan ?? null,
+                  protocol_version: this.options.protocolVersion,
+                  envelope_public_key: envelopePublicKey,
+                  health,
+                  advertised_at: isoAt(advertisedAt),
+                  expires_at: isoAt(advertisedAt + settings.advertisementTtlMs),
+                  models: settings.advertisedModels
+                });
+                return {
+                  ...current,
+                  pending_advertisement: pendingAdvertisement,
+                  updated_at: isoAt(now())
+                };
               });
-              receipt = {
-                ...receipt,
-                pending_advertisement: advertisement,
-                updated_at: isoAt(now())
-              };
-              await this.persistReceipt(receipt, now);
+              advertisement = updated.pending_advertisement;
+            }
+            if (!advertisement) {
+              throw new InferenceHostRecoveryRequiredError(
+                "The durable host advertisement receipt is unavailable."
+              );
             }
             const tool = receipt.registered ? "inference.host.advertise" : "inference.host.register";
             let result2;
@@ -30690,26 +31004,24 @@ var init_runner = __esm({
               const definitivelyNotApplied = error48 instanceof ExternalInferenceMcpError ? error48.definitivelyNotApplied : Boolean(error48 && typeof error48 === "object" && error48.definitivelyNotApplied === true);
               const expectedGeneration = receipt.registered ? receipt.advertisement_generation + 1 : receipt.advertisement_generation;
               if (definitivelyNotApplied && advertisement.advertisement_generation === expectedGeneration && allowDefinitiveReseed) {
-                receipt = {
-                  ...receipt,
-                  pending_advertisement: null,
+                await mutateReceipt((current) => ({
+                  ...current,
+                  pending_advertisement: current.pending_advertisement?.operation_id === advertisement.operation_id ? null : current.pending_advertisement,
                   updated_at: isoAt(now())
-                };
-                await this.persistReceipt(receipt, now);
+                }));
                 return await publishAdvertisement(health, forceAdvance, retryRemote, false);
               }
               throw error48;
             }
             assertAdvertisementResult(advertisement, result2);
-            receipt = {
-              ...receipt,
+            await mutateReceipt((current) => ({
+              ...current,
               registered: true,
               advertisement_generation: result2.host.advertisement_generation,
               advertisement_expires_at: advertisement.expires_at,
-              pending_advertisement: null,
+              pending_advertisement: current.pending_advertisement?.operation_id === advertisement.operation_id ? null : current.pending_advertisement,
               updated_at: isoAt(now())
-            };
-            await this.persistReceipt(receipt, now);
+            }));
           };
           const wasRegistered = receipt.registered;
           await publishAdvertisement("healthy", wasRegistered);
@@ -30722,32 +31034,34 @@ var init_runner = __esm({
           let providerRateLimitsObservedAtMs = now();
           const hostHeartbeat = async (status, requestOptions = {
             signal: this.options.signal
-          }, retryRemote = true, allowOfflineProjection = false, definitiveReseedAttempt = 0) => {
-            const sequence = receipt.host_heartbeat_sequence + 1;
-            const request = {
-              schema_version: "external_inference_host_heartbeat_v1",
-              contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
-              host_id: localState.host_id,
-              host_generation: localState.host_generation,
-              advertisement_generation: receipt.advertisement_generation,
-              key_generation: localState.key_generation,
-              sequence,
-              status,
-              active_attempts: active.size,
-              available_slots: settings.maxConcurrency === null ? UNBOUNDED_AVAILABLE_SLOTS - active.size : Math.max(0, settings.maxConcurrency - active.size),
-              provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
-                providerRateLimits,
-                providerRateLimitsObservedAtMs,
-                now()
-              ),
-              observed_at: isoAt(now())
-            };
-            receipt = {
-              ...receipt,
-              host_heartbeat_sequence: sequence,
-              updated_at: isoAt(now())
-            };
-            await this.persistReceipt(receipt, now);
+          }, retryRemote = true, allowOfflineProjection = false, definitiveReseedAttempt = 0, advertisementGeneration = receipt.advertisement_generation) => {
+            let request;
+            await mutateReceipt((current) => {
+              const sequence = current.host_heartbeat_sequence + 1;
+              request = {
+                schema_version: "external_inference_host_heartbeat_v1",
+                contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
+                host_id: localState.host_id,
+                host_generation: localState.host_generation,
+                advertisement_generation: advertisementGeneration,
+                key_generation: localState.key_generation,
+                sequence,
+                status,
+                active_attempts: active.size,
+                available_slots: settings.maxConcurrency === null ? UNBOUNDED_AVAILABLE_SLOTS - active.size : Math.max(0, settings.maxConcurrency - active.size),
+                provider_weekly_quota: providerWeeklyQuotaFromRateLimits(
+                  providerRateLimits,
+                  providerRateLimitsObservedAtMs,
+                  now()
+                ),
+                observed_at: isoAt(now())
+              };
+              return {
+                ...current,
+                host_heartbeat_sequence: sequence,
+                updated_at: isoAt(now())
+              };
+            });
             const heartbeatOperation = () => mcp.callTool(
               "inference.host.heartbeat",
               request,
@@ -30764,7 +31078,8 @@ var init_runner = __esm({
                   requestOptions,
                   retryRemote,
                   allowOfflineProjection,
-                  definitiveReseedAttempt + 1
+                  definitiveReseedAttempt + 1,
+                  advertisementGeneration
                 );
               }
               throw error48;
@@ -30779,12 +31094,129 @@ var init_runner = __esm({
             }
           };
           await hostHeartbeat("healthy");
-          let nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
+          let lastHostHeartbeatSucceededAt = now();
+          let hostHeartbeatGapOpen = false;
+          const hostHeartbeatGapThresholdMs = Math.max(
+            MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS,
+            settings.hostHeartbeatMs * HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR
+          );
+          const observeHostHeartbeatGap = (observedAt) => {
+            const gapMs = Math.max(0, observedAt - lastHostHeartbeatSucceededAt);
+            if (gapMs >= hostHeartbeatGapThresholdMs && !hostHeartbeatGapOpen) {
+              hostHeartbeatGapOpen = true;
+              emitDiagnostic("host_heartbeat_gap_detected", {
+                gap_ms: gapMs,
+                configured_interval_ms: settings.hostHeartbeatMs,
+                diagnostic_threshold_ms: hostHeartbeatGapThresholdMs,
+                active_attempts: active.size,
+                host_heartbeat_sequence: receipt.host_heartbeat_sequence
+              });
+            }
+            return gapMs;
+          };
           let nextAdvertisementAttemptAt = 0;
           let nextProviderRateLimitRefreshAt = now() + settings.providerRateLimitRefreshMs;
           let nextClaimAt = Math.max(now(), providerRetryAtMs ?? 0);
           let pendingClaimPromotions = 0;
           let onceClaimed = false;
+          const hostHeartbeatAbort = new AbortController();
+          stopHostHeartbeatLoop = () => hostHeartbeatAbort.abort();
+          let nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
+          hostHeartbeatLoop = (async () => {
+            while (!drainRequested && !hostHeartbeatAbort.signal.aborted) {
+              try {
+                await sleep4(
+                  Math.max(MIN_SLEEP_MS, nextHostHeartbeatAt - now()),
+                  hostHeartbeatAbort.signal
+                );
+              } catch (error48) {
+                if (hostHeartbeatAbort.signal.aborted || drainRequested) return;
+                throw error48;
+              }
+              if (drainRequested || hostHeartbeatAbort.signal.aborted) return;
+              const heartbeatStartedAt = now();
+              observeHostHeartbeatGap(heartbeatStartedAt);
+              const attemptedAdvertisementGeneration = receipt.advertisement_generation;
+              try {
+                const expiresAt = receipt.advertisement_expires_at ? Date.parse(receipt.advertisement_expires_at) : 0;
+                const refreshPendingAcrossExpiry = receipt.pending_advertisement !== null && expiresAt <= heartbeatStartedAt;
+                await hostHeartbeat(
+                  "healthy",
+                  { signal: hostHeartbeatAbort.signal },
+                  false,
+                  refreshPendingAcrossExpiry,
+                  0,
+                  attemptedAdvertisementGeneration
+                );
+              } catch (error48) {
+                if (hostHeartbeatAbort.signal.aborted || drainRequested) return;
+                const errorCode = error48 && typeof error48 === "object" && "code" in error48 ? String(error48.code) : "";
+                const pendingAdvertisement = receipt.pending_advertisement;
+                const recoveryAdvertisementGeneration = receipt.advertisement_generation > attemptedAdvertisementGeneration ? receipt.advertisement_generation : errorCode === "generation_stale" && pendingAdvertisement && pendingAdvertisement.advertisement_generation === attemptedAdvertisementGeneration + 1 ? pendingAdvertisement.advertisement_generation : null;
+                if (errorCode === "generation_stale" && recoveryAdvertisementGeneration !== null) {
+                  try {
+                    await hostHeartbeat(
+                      "healthy",
+                      { signal: hostHeartbeatAbort.signal },
+                      false,
+                      false,
+                      0,
+                      recoveryAdvertisementGeneration
+                    );
+                    if (receipt.advertisement_generation < recoveryAdvertisementGeneration) {
+                      await mutateReceipt((current) => current.advertisement_generation >= recoveryAdvertisementGeneration ? current : {
+                        ...current,
+                        advertisement_generation: recoveryAdvertisementGeneration,
+                        advertisement_expires_at: pendingAdvertisement?.expires_at ?? current.advertisement_expires_at,
+                        updated_at: isoAt(now())
+                      });
+                    }
+                  } catch (recoveryError) {
+                    if (hostHeartbeatAbort.signal.aborted || drainRequested) return;
+                    if (controlPlaneFatal(recoveryError)) {
+                      requestDrain("authority_lost");
+                      return;
+                    }
+                    if (!retryableRemoteError(recoveryError)) {
+                      requestDrain("host_heartbeat_failed");
+                      return;
+                    }
+                    nextHostHeartbeatAt = now() + remoteRetryAfterMs(recoveryError, settings.hostHeartbeatMs);
+                    continue;
+                  }
+                } else if (controlPlaneFatal(error48)) {
+                  requestDrain("authority_lost");
+                  return;
+                } else if (!retryableRemoteError(error48)) {
+                  requestDrain("host_heartbeat_failed");
+                  return;
+                } else {
+                  nextHostHeartbeatAt = now() + remoteRetryAfterMs(error48, settings.hostHeartbeatMs);
+                  continue;
+                }
+              }
+              const heartbeatSucceededAt = now();
+              const gapMs = observeHostHeartbeatGap(heartbeatSucceededAt);
+              if (hostHeartbeatGapOpen) {
+                emitDiagnostic("host_heartbeat_gap_recovered", {
+                  gap_ms: gapMs,
+                  configured_interval_ms: settings.hostHeartbeatMs,
+                  diagnostic_threshold_ms: hostHeartbeatGapThresholdMs,
+                  active_attempts: active.size,
+                  host_heartbeat_sequence: receipt.host_heartbeat_sequence
+                });
+                hostHeartbeatGapOpen = false;
+              }
+              lastHostHeartbeatSucceededAt = heartbeatSucceededAt;
+              nextHostHeartbeatAt = Math.max(
+                nextHostHeartbeatAt + settings.hostHeartbeatMs,
+                heartbeatSucceededAt + MIN_SLEEP_MS
+              );
+            }
+          })().catch((error48) => {
+            if (hostHeartbeatAbort.signal.aborted || drainRequested) return;
+            requestDrain(controlPlaneFatal(error48) ? "authority_lost" : "host_heartbeat_failed");
+          });
           const recoveryQueue = [];
           const attemptStartRetryCounts = /* @__PURE__ */ new Map();
           const launchClaim = (claim, recovery, claimRequest) => {
@@ -30820,15 +31252,14 @@ var init_runner = __esm({
               credential,
               mcp,
               receipt: () => receipt,
-              updateReceipt: async (next) => {
+              updateReceipt: async (mutation) => {
                 if (!acceptAttemptUpdates) {
                   throw new InferenceHostRunnerError(
                     "runtime_closed",
                     "The drained inference runtime no longer accepts attempt updates."
                   );
                 }
-                receipt = next;
-                await this.persistReceipt(receipt, now);
+                await mutateReceipt(mutation);
               },
               retryExact,
               signal: controller.signal,
@@ -30926,10 +31357,11 @@ var init_runner = __esm({
             return attemptId;
           };
           const removeRecoveredAttempt = async (attemptId) => {
-            const attempts = { ...receipt.attempts };
-            delete attempts[attemptId];
-            receipt = { ...receipt, attempts, updated_at: isoAt(now()) };
-            await this.persistReceipt(receipt, now);
+            await mutateReceipt((current) => {
+              const attempts = { ...current.attempts };
+              delete attempts[attemptId];
+              return { ...current, attempts, updated_at: isoAt(now()) };
+            });
           };
           for (const recovery of Object.values({ ...receipt.attempts })) {
             if (recovery.phase === "terminal_pending") {
@@ -31044,59 +31476,37 @@ var init_runner = __esm({
                 nextClaimAt = Math.max(nextClaimAt, nextAdvertisementAttemptAt);
               }
             }
-            if (currentTime >= nextHostHeartbeatAt) {
-              try {
-                const refreshPendingAcrossExpiry = receipt.pending_advertisement !== null && expiresAt <= currentTime && nextAdvertisementAttemptAt > currentTime;
-                await hostHeartbeat(
-                  "healthy",
-                  { signal: this.options.signal },
-                  false,
-                  refreshPendingAcrossExpiry
-                );
-              } catch (error48) {
-                if (controlPlaneFatal(error48)) {
-                  requestDrain("authority_lost");
-                  break;
-                }
-                if (!retryableRemoteError(error48)) {
-                  requestDrain("host_heartbeat_failed");
-                  break;
-                }
-                nextHostHeartbeatAt = now() + remoteRetryAfterMs(error48, settings.hostHeartbeatMs);
-              }
-              if (!drainRequested && currentTime >= nextHostHeartbeatAt) {
-                nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
-              }
-            }
             while (recoveryQueue.length > 0 && (settings.maxConcurrency === null || active.size < settings.maxConcurrency)) {
               const recovery = recoveryQueue.shift();
               launchClaim(recovery.claim, recovery);
             }
             while (!drainRequested && recoveryQueue.length === 0 && (!this.options.once || !onceClaimed) && (settings.maxConcurrency === null || active.size < settings.maxConcurrency) && pendingClaimPromotions === 0 && now() >= nextClaimAt) {
               if (!receipt.pending_claim_request) {
-                const claimSequence = receipt.claim_sequence + 1;
-                const pendingClaimRequest = {
-                  schema_version: "external_inference_job_claim_v1",
-                  contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
-                  host_id: localState.host_id,
-                  host_generation: localState.host_generation,
-                  advertisement_generation: receipt.advertisement_generation,
-                  key_generation: localState.key_generation,
-                  claim_request_id: stableOperationId("claim", [
-                    localState.host_id,
-                    localState.host_generation,
-                    receipt.advertisement_generation,
-                    claimSequence
-                  ]),
-                  requested_at: isoAt(now())
-                };
-                receipt = {
-                  ...receipt,
-                  claim_sequence: claimSequence,
-                  pending_claim_request: pendingClaimRequest,
-                  updated_at: isoAt(now())
-                };
-                await this.persistReceipt(receipt, now);
+                await mutateReceipt((current) => {
+                  if (current.pending_claim_request) return current;
+                  const claimSequence = current.claim_sequence + 1;
+                  const pendingClaimRequest = {
+                    schema_version: "external_inference_job_claim_v1",
+                    contract_version: EXTERNAL_INFERENCE_CONTRACT_VERSION,
+                    host_id: localState.host_id,
+                    host_generation: localState.host_generation,
+                    advertisement_generation: current.advertisement_generation,
+                    key_generation: localState.key_generation,
+                    claim_request_id: stableOperationId("claim", [
+                      localState.host_id,
+                      localState.host_generation,
+                      current.advertisement_generation,
+                      claimSequence
+                    ]),
+                    requested_at: isoAt(now())
+                  };
+                  return {
+                    ...current,
+                    claim_sequence: claimSequence,
+                    pending_claim_request: pendingClaimRequest,
+                    updated_at: isoAt(now())
+                  };
+                });
               }
               const request = receipt.pending_claim_request;
               let claim;
@@ -31112,12 +31522,11 @@ var init_runner = __esm({
                   requestDrain("authority_lost");
                 } else if (!this.options.signal?.aborted && error48 instanceof ExternalInferenceMcpError && error48.definitivelyNotApplied) {
                   if (request.advertisement_generation < receipt.advertisement_generation) {
-                    receipt = {
-                      ...receipt,
-                      pending_claim_request: null,
+                    await mutateReceipt((current) => ({
+                      ...current,
+                      pending_claim_request: current.pending_claim_request?.claim_request_id === request.claim_request_id ? null : current.pending_claim_request,
                       updated_at: isoAt(now())
-                    };
-                    await this.persistReceipt(receipt, now);
+                    }));
                     nextClaimAt = now();
                   } else {
                     requestDrain("claim_failed");
@@ -31130,23 +31539,21 @@ var init_runner = __esm({
                 break;
               }
               if (claim.claim_state === "empty") {
-                receipt = {
-                  ...receipt,
-                  pending_claim_request: null,
+                await mutateReceipt((current) => ({
+                  ...current,
+                  pending_claim_request: current.pending_claim_request?.claim_request_id === request.claim_request_id ? null : current.pending_claim_request,
                   updated_at: isoAt(now())
-                };
-                await this.persistReceipt(receipt, now);
+                }));
                 nextClaimAt = now() + Math.max(MIN_SLEEP_MS, claim.retry_after_ms);
                 if (this.options.once) requestDrain("once_empty");
                 break;
               }
               if (Date.parse(claim.lease_expires_at) <= now() + MIN_CLAIM_START_WINDOW_MS || Date.parse(claim.deadline_at) <= now() + MIN_CLAIM_START_WINDOW_MS) {
-                receipt = {
-                  ...receipt,
-                  pending_claim_request: null,
+                await mutateReceipt((current) => ({
+                  ...current,
+                  pending_claim_request: current.pending_claim_request?.claim_request_id === request.claim_request_id ? null : current.pending_claim_request,
                   updated_at: isoAt(now())
-                };
-                await this.persistReceipt(receipt, now);
+                }));
                 nextClaimAt = now();
                 break;
               }
@@ -31157,7 +31564,8 @@ var init_runner = __esm({
             const advertisementDueAt = nextAdvertisementAttemptAt > now() ? nextAdvertisementAttemptAt : receipt.advertisement_expires_at ? Date.parse(receipt.advertisement_expires_at) - settings.advertisementRefreshLeadMs : now() + MIN_SLEEP_MS;
             const wakeAt = Math.min(
               nextClaimAt,
-              nextHostHeartbeatAt,
+              nextProviderRateLimitRefreshAt,
+              now() + settings.hostHeartbeatMs,
               Math.max(now() + MIN_SLEEP_MS, advertisementDueAt)
             );
             await Promise.race([
@@ -31166,6 +31574,8 @@ var init_runner = __esm({
               ...active.values()
             ]);
           }
+          stopHostHeartbeatLoop();
+          await hostHeartbeatLoop;
           try {
             await hostHeartbeat("draining", {
               deadlineAtMs: now() + settings.drainTimeoutMs,
@@ -31200,6 +31610,8 @@ var init_runner = __esm({
           });
           return { claimed, completed, failed, drain_reason: drainReason };
         } finally {
+          stopHostHeartbeatLoop();
+          await hostHeartbeatLoop;
           removeAbortListener();
           unregisterSignals();
           try {
@@ -31271,35 +31683,39 @@ var init_runner = __esm({
           );
         }
         if (!options.resumeReceipt) {
-          const currentReceipt = options.receipt();
-          const pendingClaimRequest = options.claimRequest && currentReceipt.pending_claim_request?.claim_request_id === options.claimRequest.claim_request_id ? null : currentReceipt.pending_claim_request ?? null;
-          await options.updateReceipt({
-            ...currentReceipt,
-            pending_claim_request: pendingClaimRequest,
-            attempts: { ...currentReceipt.attempts, [attemptId]: attemptReceipt },
-            updated_at: isoAt(now())
+          await options.updateReceipt((current) => {
+            const pendingClaimRequest = options.claimRequest && current.pending_claim_request?.claim_request_id === options.claimRequest.claim_request_id ? null : current.pending_claim_request ?? null;
+            return {
+              ...current,
+              pending_claim_request: pendingClaimRequest,
+              attempts: { ...current.attempts, [attemptId]: attemptReceipt },
+              updated_at: isoAt(now())
+            };
           });
           options.onClaimPersisted?.();
         }
         const updateAttempt = async (changes) => {
-          attemptReceipt = validateAttemptReceipt({
+          const nextAttemptReceipt = validateAttemptReceipt({
             ...attemptReceipt,
             ...changes,
             updated_at: isoAt(now())
           });
-          await options.updateReceipt({
-            ...options.receipt(),
-            attempts: { ...options.receipt().attempts, [attemptId]: attemptReceipt },
+          attemptReceipt = nextAttemptReceipt;
+          await options.updateReceipt((current) => ({
+            ...current,
+            attempts: { ...current.attempts, [attemptId]: nextAttemptReceipt },
             updated_at: isoAt(now())
-          });
+          }));
         };
         const removeAttempt = async () => {
-          const attempts = { ...options.receipt().attempts };
-          delete attempts[attemptId];
-          await options.updateReceipt({
-            ...options.receipt(),
-            attempts,
-            updated_at: isoAt(now())
+          await options.updateReceipt((current) => {
+            const attempts = { ...current.attempts };
+            delete attempts[attemptId];
+            return {
+              ...current,
+              attempts,
+              updated_at: isoAt(now())
+            };
           });
         };
         if (attemptReceipt.phase === "claimed") {
@@ -31612,6 +32028,7 @@ var init_runner = __esm({
             });
           }
           const classified = classifyFailure(heartbeatFailure ?? error48, adapterResult);
+          const processExit = heartbeatFailure === void 0 && error48 instanceof CodexAppServerError && error48.code === "codex_process_closed" && error48.processExit?.expected_shutdown === false ? error48.processExit : null;
           const heartbeatAmbiguous = ambiguousHeartbeatTransport(heartbeatFailure);
           const failure = heartbeatAmbiguous ? {
             ...classified,
@@ -31665,6 +32082,7 @@ var init_runner = __esm({
             failure_category: failure.category,
             failure_code: failure.code,
             retryable: failure.retryable,
+            ...processExit ? { process_exit: processExit } : {},
             membership_disposition: membershipFailureDisposition({
               ...failure,
               dispatchOutcome
@@ -31699,6 +32117,7 @@ var init_runner = __esm({
             failure_category: failureRequest.failure_category,
             failure_code: failureRequest.failure_code,
             retryable: failureRequest.retryable,
+            process_exit: failureRequest.process_exit ?? null,
             dispatch_outcome: failureRequest.outcome.dispatch_outcome,
             response_outcome: failureRequest.outcome.response_outcome,
             latency_ms: adapterResult?.latencyMs ?? null,
@@ -33692,6 +34111,17 @@ Durable service:
       }
     };
     defaultRunForeground = async (options) => {
+      const localState = await readInferenceHostLocalState(options.config.statePath);
+      const emitCodexDiagnostic = (event) => {
+        options.emitDiagnosticEvent?.({
+          ...event,
+          schema_version: "vtx_inference_host_diagnostic_v1",
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          instance_name: options.config.instanceName,
+          host_id: localState?.host_id ?? null,
+          display_name: options.displayName
+        });
+      };
       const adapter = new CodexSubscriptionAdapter({
         resolveBinary: async () => options.verifiedBinary,
         createAttemptResources: options.hostResources.createAttemptResources,
@@ -33699,7 +34129,8 @@ Durable service:
         guardianReceiptRoot: codexGuardianReceiptRoot(options.config),
         recoveryHooks: new FileCodexAttemptRecoveryStore(
           codexRecoveryPath(options.config)
-        )
+        ),
+        emitDiagnosticEvent: emitCodexDiagnostic
       });
       const dependencies = createDefaultInferenceHostRunnerDependencies({
         apiUrl: options.config.apiUrl,
@@ -34376,7 +34807,15 @@ Waiting for approval...
         const emitDiagnosticEvent = parsed.json ? (event) => (dependencies.emitStdout ?? ((text) => {
           process.stdout.write(text);
         }))(`${JSON.stringify(event)}
-`) : void 0;
+`) : adapterId === "codex" ? (event) => {
+          if (!["codex_app_server_closed", "codex_app_server_session_started"].includes(
+            String(event.event ?? "")
+          )) return;
+          (dependencies.emitStderr ?? ((text) => {
+            process.stderr.write(text);
+          }))(`[VTX inference-host] ${JSON.stringify(event)}
+`);
+        } : void 0;
         if (adapterId !== "codex") {
           const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
             adapterId,