@vtxmacro/cli 2026.8.44 → 2026.8.45

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.45",
       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;
@@ -30779,6 +31069,26 @@ var init_runner = __esm({
             }
           };
           await hostHeartbeat("healthy");
+          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 nextHostHeartbeatAt = now() + settings.hostHeartbeatMs;
           let nextAdvertisementAttemptAt = 0;
           let nextProviderRateLimitRefreshAt = now() + settings.providerRateLimitRefreshMs;
@@ -31045,6 +31355,7 @@ var init_runner = __esm({
               }
             }
             if (currentTime >= nextHostHeartbeatAt) {
+              observeHostHeartbeatGap(currentTime);
               try {
                 const refreshPendingAcrossExpiry = receipt.pending_advertisement !== null && expiresAt <= currentTime && nextAdvertisementAttemptAt > currentTime;
                 await hostHeartbeat(
@@ -31053,6 +31364,19 @@ var init_runner = __esm({
                   false,
                   refreshPendingAcrossExpiry
                 );
+                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;
               } catch (error48) {
                 if (controlPlaneFatal(error48)) {
                   requestDrain("authority_lost");
@@ -31612,6 +31936,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 +31990,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 +32025,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 +34019,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 +34037,8 @@ Durable service:
         guardianReceiptRoot: codexGuardianReceiptRoot(options.config),
         recoveryHooks: new FileCodexAttemptRecoveryStore(
           codexRecoveryPath(options.config)
-        )
+        ),
+        emitDiagnosticEvent: emitCodexDiagnostic
       });
       const dependencies = createDefaultInferenceHostRunnerDependencies({
         apiUrl: options.config.apiUrl,
@@ -34376,7 +34715,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtxmacro/cli",
-  "version": "2026.8.44",
+  "version": "2026.8.45",
   "description": "VTX Macro CLI, MCP server, and durable subscription inference host.",
   "type": "module",
   "license": "UNLICENSED",