@vtxmacro/cli 2026.8.21 → 2026.8.23

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.21",
+      package_version: "2026.8.23",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       platforms: {
@@ -20047,11 +20047,27 @@ child.once('close', async () => {
           });
         }
       }
-      async requireModel(modelName, reasoningEffort, deadlineAtMs, signal) {
+      async readModelCapabilities(deadlineAtMs, signal) {
         let cursor = null;
         const seen = /* @__PURE__ */ new Set();
-        let match = null;
+        const capabilities = [];
         do {
+          if (signal?.aborted) {
+            throw new CodexAppServerError({
+              message: "Codex model catalog request was cancelled before dispatch.",
+              category: "cancelled",
+              code: "cancelled",
+              retryable: false
+            });
+          }
+          if (Date.now() >= deadlineAtMs) {
+            throw new CodexAppServerError({
+              message: "Codex model catalog request exceeded the immutable deadline before dispatch.",
+              category: "timeout",
+              code: "deadline_exceeded",
+              retryable: false
+            });
+          }
           const result2 = await this.request("model/list", {
             includeHidden: true,
             ...cursor ? { cursor } : {}
@@ -20062,7 +20078,19 @@ child.once('close', async () => {
           const data = Array.isArray(result2.data) ? result2.data : [];
           for (const raw of data) {
             const candidate = objectOrNull(raw);
-            if (candidate && (candidate.model === modelName || candidate.id === modelName)) match = candidate;
+            if (!candidate) continue;
+            const id2 = typeof candidate.id === "string" && candidate.id.trim() ? candidate.id.trim() : null;
+            const model = typeof candidate.model === "string" && candidate.model.trim() ? candidate.model.trim() : null;
+            if (!id2 && !model) continue;
+            const supportedReasoningEfforts = Array.isArray(candidate.supportedReasoningEfforts) ? candidate.supportedReasoningEfforts.flatMap((item) => {
+              const reasoningEffort = objectOrNull(item)?.reasoningEffort;
+              return typeof reasoningEffort === "string" && reasoningEffort.trim() ? [reasoningEffort.trim()] : [];
+            }) : [];
+            capabilities.push(Object.freeze({
+              id: id2,
+              model,
+              supportedReasoningEfforts: Object.freeze(supportedReasoningEfforts)
+            }));
           }
           cursor = typeof result2.nextCursor === "string" && result2.nextCursor ? result2.nextCursor : null;
           if (cursor && seen.has(cursor)) {
@@ -20075,6 +20103,10 @@ child.once('close', async () => {
           }
           if (cursor) seen.add(cursor);
         } while (cursor);
+        return Object.freeze(capabilities);
+      }
+      requireModelCapability(capabilities, modelName, reasoningEffort) {
+        const match = capabilities.find((candidate) => candidate.model === modelName || candidate.id === modelName);
         if (!match) {
           throw new CodexAppServerError({
             message: "The requested Codex model is unavailable.",
@@ -20083,8 +20115,7 @@ child.once('close', async () => {
             retryable: false
           });
         }
-        const efforts = Array.isArray(match.supportedReasoningEfforts) ? match.supportedReasoningEfforts.map((item) => objectOrNull(item)?.reasoningEffort) : [];
-        if (!efforts.includes(reasoningEffort)) {
+        if (!match.supportedReasoningEfforts.includes(reasoningEffort)) {
           throw new CodexAppServerError({
             message: "The requested Codex reasoning effort is unavailable.",
             category: "model",
@@ -20093,7 +20124,30 @@ child.once('close', async () => {
           });
         }
       }
+      async requireModel(modelName, reasoningEffort, deadlineAtMs, signal) {
+        this.requireModelCapability(
+          await this.readModelCapabilities(deadlineAtMs, signal),
+          modelName,
+          reasoningEffort
+        );
+      }
       async startThread(options) {
+        if (options.signal?.aborted) {
+          throw new CodexAppServerError({
+            message: "Codex thread request was cancelled before dispatch.",
+            category: "cancelled",
+            code: "cancelled",
+            retryable: false
+          });
+        }
+        if (Date.now() >= options.deadlineAtMs) {
+          throw new CodexAppServerError({
+            message: "Codex thread request exceeded the immutable deadline before dispatch.",
+            category: "timeout",
+            code: "deadline_exceeded",
+            retryable: false
+          });
+        }
         const result2 = await this.request("thread/start", {
           model: options.requestedModel,
           modelProvider: "openai",
@@ -20823,7 +20877,7 @@ import {
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { tmpdir as tmpdir2 } from "node:os";
 import { isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
-var INITIAL_CODEX_INFERENCE_MODEL, SUPPORTED_CODEX_REASONING_EFFORTS, MAX_PROMPT_BYTES2, tokenUsageReceiptSchema, turnResultReceiptSchema, terminalReceiptSchema, recoveryCheckpointSchema, recoveryFileSchema, FileCodexAttemptRecoveryStore, utf8Bytes, tomlString, permissionConfig, ensureDedicatedCodexHome, createIsolatedCodexAttemptResources, createIsolatedCodexHostResources, validateAttemptInput, isStrictDescendant, assertRecoveryResourceScope, removeRecoveredThread, confirmGuardianTerminatedForRecovery, reconcileCodexAttemptRecovery, CodexSubscriptionAdapter;
+var INITIAL_CODEX_INFERENCE_MODEL, SUPPORTED_CODEX_REASONING_EFFORTS, MAX_PROMPT_BYTES2, tokenUsageReceiptSchema, turnResultReceiptSchema, terminalReceiptSchema, recoveryCheckpointSchema, recoveryFileSchema, FileCodexAttemptRecoveryStore, utf8Bytes, assertAttemptActive, tomlString, permissionConfig, ensureDedicatedCodexHome, createIsolatedCodexAttemptResources, createIsolatedCodexHostResources, validateAttemptInput, isStrictDescendant, assertRecoveryResourceScope, removeRecoveredThread, confirmGuardianTerminatedForRecovery, reconcileCodexAttemptRecovery, CodexSubscriptionAdapter;
 var init_codex_adapter = __esm({
   "lib/inference-host/codex-adapter.ts"() {
     "use strict";
@@ -20971,6 +21025,24 @@ var init_codex_adapter = __esm({
       }
     };
     utf8Bytes = (value) => Buffer.byteLength(value, "utf8");
+    assertAttemptActive = (deadlineAtMs, signal) => {
+      if (signal?.aborted) {
+        throw new CodexAppServerError({
+          message: "Codex attempt was cancelled before dispatch.",
+          category: "cancelled",
+          code: "cancelled",
+          retryable: false
+        });
+      }
+      if (Date.now() >= deadlineAtMs) {
+        throw new CodexAppServerError({
+          message: "Codex attempt exceeded the immutable deadline before dispatch.",
+          category: "timeout",
+          code: "deadline_exceeded",
+          retryable: false
+        });
+      }
+    };
     tomlString = (value) => JSON.stringify(value);
     permissionConfig = (codexHome) => [
       'forced_login_method = "chatgpt"',
@@ -21308,6 +21380,7 @@ var init_codex_adapter = __esm({
     CodexSubscriptionAdapter = class {
       constructor(dependencies = {}) {
         this.inFlightAttempts = /* @__PURE__ */ new Map();
+        this.attemptCleanups = /* @__PURE__ */ new Map();
         this.durableSession = null;
         this.durableSessionStart = null;
         this.closing = false;
@@ -21334,6 +21407,7 @@ var init_codex_adapter = __esm({
         return {
           session,
           codexHome,
+          capabilityPreflight: null,
           processToken,
           processReceiptPath,
           bootIdentity,
@@ -21416,6 +21490,65 @@ var init_codex_adapter = __esm({
         }
         await session.closePromise;
       }
+      async requireDurableSessionCapability(durableSession, modelName, reasoningEffort, deadlineAtMs, signal) {
+        assertAttemptActive(deadlineAtMs, signal);
+        if (!durableSession.capabilityPreflight) {
+          durableSession.capabilityPreflight = (async () => {
+            try {
+              await durableSession.session.requireManagedChatGptAuth(deadlineAtMs, signal);
+              assertAttemptActive(deadlineAtMs, signal);
+              return await durableSession.session.readModelCapabilities(deadlineAtMs, signal);
+            } catch (error48) {
+              try {
+                await this.invalidateDurableSession(durableSession);
+              } catch (invalidationError) {
+                throw new CodexAppServerError({
+                  message: "Codex capability preflight failed and session shutdown was not confirmed.",
+                  category: "adapter",
+                  code: "capability_preflight_invalidation_unconfirmed",
+                  retryable: false,
+                  cause: new AggregateError([error48, invalidationError])
+                });
+              }
+              throw error48;
+            }
+          })();
+        }
+        const preflight = durableSession.capabilityPreflight;
+        const capabilities = await new Promise((resolve6, reject) => {
+          let settled = false;
+          const finish = (callback) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            callback();
+          };
+          const onAbort = () => finish(() => reject(new CodexAppServerError({
+            message: "Codex capability preflight wait was cancelled.",
+            category: "cancelled",
+            code: "cancelled",
+            retryable: false
+          })));
+          const timer = setTimeout(() => finish(() => reject(new CodexAppServerError({
+            message: "Codex capability preflight wait exceeded the immutable deadline.",
+            category: "timeout",
+            code: "deadline_exceeded",
+            retryable: false
+          }))), Math.max(1, deadlineAtMs - Date.now()));
+          signal?.addEventListener("abort", onAbort, { once: true });
+          if (signal?.aborted) {
+            onAbort();
+            return;
+          }
+          void preflight.then(
+            (value) => finish(() => resolve6(value)),
+            (error48) => finish(() => reject(error48))
+          );
+        });
+        assertAttemptActive(deadlineAtMs, signal);
+        durableSession.session.requireModelCapability(capabilities, modelName, reasoningEffort);
+      }
       runAttempt(input) {
         const active = this.inFlightAttempts.get(input.attemptId);
         if (active) {
@@ -21430,15 +21563,21 @@ var init_codex_adapter = __esm({
           }
           return active.promise;
         }
-        const promise2 = this.executeAttempt(input).finally(() => {
-          if (this.inFlightAttempts.get(input.attemptId)?.promise === promise2) {
-            this.inFlightAttempts.delete(input.attemptId);
-          }
-        });
+        const promise2 = this.executeAttempt(input);
         this.inFlightAttempts.set(input.attemptId, {
           inputSha256: input.inputSha256,
           promise: promise2
         });
+        void promise2.then(async () => {
+          await this.attemptCleanups.get(input.attemptId)?.catch(() => void 0);
+          if (this.inFlightAttempts.get(input.attemptId)?.promise === promise2) {
+            this.inFlightAttempts.delete(input.attemptId);
+          }
+        }, () => {
+          if (this.inFlightAttempts.get(input.attemptId)?.promise === promise2) {
+            this.inFlightAttempts.delete(input.attemptId);
+          }
+        }).catch(() => void 0);
         return promise2;
       }
       async acknowledgeAttempt(attemptId) {
@@ -21450,8 +21589,27 @@ var init_codex_adapter = __esm({
             retryable: false
           });
         }
+        const activeCleanup = this.attemptCleanups.get(attemptId);
+        if (activeCleanup) {
+          try {
+            await activeCleanup;
+          } catch (error48) {
+            throw new CodexAppServerError({
+              message: "Codex attempt cleanup could not be confirmed.",
+              category: "adapter",
+              code: "attempt_cleanup_unconfirmed",
+              retryable: false,
+              cause: error48
+            });
+          }
+        }
         const recoveryHooks = this.dependencies.recoveryHooks;
-        if (!recoveryHooks) return;
+        if (!recoveryHooks) {
+          if (activeCleanup && this.attemptCleanups.get(attemptId) === activeCleanup) {
+            this.attemptCleanups.delete(attemptId);
+          }
+          return;
+        }
         const checkpoint = await recoveryHooks.load(attemptId);
         if (checkpoint && !checkpoint.cleanupConfirmed) {
           throw new CodexAppServerError({
@@ -21479,6 +21637,9 @@ var init_codex_adapter = __esm({
           }
         }
         await recoveryHooks.clear(attemptId);
+        if (activeCleanup && this.attemptCleanups.get(attemptId) === activeCleanup) {
+          this.attemptCleanups.delete(attemptId);
+        }
       }
       async close() {
         if (!this.adapterClosePromise) {
@@ -21497,8 +21658,29 @@ var init_codex_adapter = __esm({
             await Promise.allSettled(
               [...this.inFlightAttempts.values()].map((attempt) => attempt.promise)
             );
+            await Promise.allSettled(
+              [...this.attemptCleanups.values()]
+            );
+            let unconfirmedReceiptPaths = /* @__PURE__ */ new Set();
+            const recoveryHooks = this.dependencies.recoveryHooks;
+            if (recoveryHooks) {
+              if (!recoveryHooks.loadAll) {
+                unconfirmedReceiptPaths = null;
+              } else {
+                try {
+                  const checkpoints = await recoveryHooks.loadAll();
+                  unconfirmedReceiptPaths = new Set(
+                    Object.values(checkpoints).filter((checkpoint) => !checkpoint.cleanupConfirmed && checkpoint.processReceiptPath !== null).map((checkpoint) => resolve3(checkpoint.processReceiptPath))
+                  );
+                } catch {
+                  unconfirmedReceiptPaths = null;
+                }
+              }
+            }
             for (const session of sessions) {
-              if (session.processReceiptPath) await rm3(session.processReceiptPath, { force: true });
+              if (session.processReceiptPath && unconfirmedReceiptPaths !== null && !unconfirmedReceiptPaths.has(resolve3(session.processReceiptPath))) {
+                await rm3(session.processReceiptPath, { force: true });
+              }
             }
           })();
         }
@@ -21597,13 +21779,14 @@ var init_codex_adapter = __esm({
           };
           latestCheckpoint = baseCheckpoint;
           await recoveryHooks?.save(baseCheckpoint);
-          await session.requireManagedChatGptAuth(input.deadlineAtMs, input.signal);
-          await session.requireModel(
+          await this.requireDurableSessionCapability(
+            sessionLease,
             input.requestedModel,
             input.requestedReasoningEffort,
             input.deadlineAtMs,
             input.signal
           );
+          assertAttemptActive(input.deadlineAtMs, input.signal);
           const thread = await session.startThread({
             workspacePath: resources.workspacePath,
             systemPrompt: input.systemPrompt,
@@ -21651,8 +21834,6 @@ var init_codex_adapter = __esm({
             terminal: { kind: "completed", result: result2 }
           };
           await recoveryHooks?.save(latestCheckpoint);
-          await session.deleteThread(thread.threadId);
-          threadId = null;
           return result2;
         } catch (error48) {
           caughtError = error48;
@@ -21660,6 +21841,7 @@ var init_codex_adapter = __esm({
             "rpc_rejected",
             "invalid_rpc_result",
             "rpc_timeout",
+            "capability_preflight_invalidation_unconfirmed",
             "invalid_thread_provenance",
             "thread_cleanup_identity_missing",
             "thread_delete_unconfirmed"
@@ -21732,50 +21914,63 @@ var init_codex_adapter = __esm({
           }
           throw classified;
         } finally {
-          let cleanupError = sessionInvalidationError;
-          if (session && threadId) {
-            try {
-              await session.deleteThread(threadId);
-            } catch (error48) {
-              cleanupError = error48;
+          const cleanup = async () => {
+            let cleanupError = sessionInvalidationError;
+            if (session && threadId) {
+              try {
+                await session.deleteThread(threadId);
+              } catch (error48) {
+                cleanupError = error48;
+              }
             }
-          }
-          if (sessionLease && cleanupError) {
-            try {
-              await this.invalidateDurableSession(sessionLease);
-            } catch (error48) {
-              cleanupError ??= error48;
+            if (sessionLease && cleanupError) {
+              try {
+                await this.invalidateDurableSession(sessionLease);
+              } catch (error48) {
+                cleanupError ??= error48;
+              }
             }
-          }
-          if (resources && cleanupError === null) {
-            try {
-              await resources.cleanup();
-            } catch (error48) {
-              cleanupError = error48;
+            if (resources && cleanupError === null) {
+              try {
+                await resources.cleanup();
+              } catch (error48) {
+                cleanupError = error48;
+              }
             }
-          }
-          if (latestCheckpoint && recoveryHooks && cleanupError === null) {
-            latestCheckpoint = {
-              ...latestCheckpoint,
-              processState: latestCheckpoint.processToken ? sessionLease?.terminated ? "terminated" : "running" : "unmanaged",
-              cleanupConfirmed: true
-            };
+            if (latestCheckpoint && recoveryHooks && cleanupError === null) {
+              latestCheckpoint = {
+                ...latestCheckpoint,
+                processState: latestCheckpoint.processToken ? sessionLease?.terminated ? "terminated" : "running" : "unmanaged",
+                cleanupConfirmed: true
+              };
+              try {
+                await recoveryHooks.save(latestCheckpoint);
+              } catch (error48) {
+                cleanupError = error48;
+              }
+            }
+            if (cleanupError) {
+              throw new CodexAppServerError({
+                message: "Codex attempt cleanup could not be confirmed.",
+                category: "adapter",
+                code: "attempt_cleanup_unconfirmed",
+                retryable: false,
+                dispatchOutcome: currentDispatchOutcome,
+                cause: cleanupError
+              });
+            }
+          };
+          if (completedResult && caughtError === null) {
+            const cleanupPromise = cleanup();
+            void cleanupPromise.catch(() => void 0);
+            this.attemptCleanups.set(input.attemptId, cleanupPromise);
+          } else {
             try {
-              await recoveryHooks.save(latestCheckpoint);
+              await cleanup();
             } catch (error48) {
-              cleanupError = error48;
+              if (caughtError === null) throw error48;
             }
           }
-          if (cleanupError && caughtError === null) {
-            throw new CodexAppServerError({
-              message: "Codex attempt cleanup could not be confirmed.",
-              category: "adapter",
-              code: "attempt_cleanup_unconfirmed",
-              retryable: false,
-              dispatchOutcome: currentDispatchOutcome,
-              cause: cleanupError
-            });
-          }
         }
       }
     };

package/package.json

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