@vtxmacro/cli 2026.8.21 → 2026.8.22

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.22",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       platforms: {
@@ -21308,6 +21308,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;
@@ -21430,15 +21431,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 +21457,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 +21505,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 +21526,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 });
+              }
             }
           })();
         }
@@ -21651,8 +21701,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;
@@ -21732,50 +21780,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.22",
   "description": "VTX Macro CLI, MCP server, and durable subscription inference host.",
   "type": "module",
   "license": "UNLICENSED",