@vtxmacro/cli 2026.8.39 → 2026.8.41

package/bin/vtx.js

@@ -38,9 +38,13 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.8.39",
+      package_version: "2026.8.41",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
+      copilot_sdk_package_name: "@github/copilot-sdk",
+      copilot_sdk_version: "1.0.0-beta.8",
+      copilot_cli_package_name: "@github/copilot",
+      copilot_cli_version: "1.0.80",
       platforms: {
         "linux-x64": {
           package_name: "@openai/codex-linux-x64",
@@ -14725,6 +14729,7 @@ var init_external_inference_contract = __esm({
       key_generation: generationSchema,
       adapter: externalInferenceAdapterIdSchema,
       display_name: displayNameSchema,
+      authenticated_account_identity: safeCodeSchema.nullable().optional(),
       authenticated_account_email: authenticatedAccountEmailSchema.nullable().optional(),
       authenticated_account_plan: safeCodeSchema.nullable().optional(),
       protocol_version: protocolVersionSchema,
@@ -15644,6 +15649,7 @@ var init_external_inference_contract = __esm({
     hostStatusReadSchema = external_exports.strictObject({
       host_id: identifierSchema,
       display_name: displayNameSchema,
+      authenticated_account_identity: safeCodeSchema.nullable().optional(),
       authenticated_account_email: authenticatedAccountEmailSchema.nullable().optional(),
       authenticated_account_plan: safeCodeSchema.nullable().optional(),
       adapter: externalInferenceAdapterIdSchema,
@@ -18179,7 +18185,7 @@ var init_mcp_client = __esm({
         if (!host) return invalidBoundResult(name);
         if (host.host_id !== request.host_id || host.host_generation !== request.host_generation || host.advertisement_generation !== request.advertisement_generation || host.key_generation !== request.key_generation || request.adapter !== void 0 && host.adapter !== request.adapter) invalidBoundResult(name);
         if (name !== "inference.host.heartbeat") {
-          if (host.display_name !== request.display_name || host.authenticated_account_email !== void 0 && host.authenticated_account_email !== null && host.authenticated_account_email !== request.authenticated_account_email || (host.authenticated_account_plan ?? null) !== (request.authenticated_account_plan ?? null) || !exactJson(host.models, request.models) || host.status === "revoked") invalidBoundResult(name);
+          if (host.display_name !== request.display_name || host.authenticated_account_identity !== void 0 && host.authenticated_account_identity !== null && host.authenticated_account_identity !== request.authenticated_account_identity || host.authenticated_account_email !== void 0 && host.authenticated_account_email !== null && host.authenticated_account_email !== request.authenticated_account_email || (host.authenticated_account_plan ?? null) !== (request.authenticated_account_plan ?? null) || !exactJson(host.models, request.models) || host.status === "revoked") invalidBoundResult(name);
           return;
         }
         const expectedStatus = request.status === "healthy" ? "online" : request.status;
@@ -19478,8 +19484,8 @@ async function preflightCodexSubscription(options) {
       });
     }
     const rateLimits = await session.readAccountRateLimits(options.deadlineAtMs, options.signal);
-    const modelCapabilities = await session.readModelCapabilities(options.deadlineAtMs, options.signal);
-    if (modelCapabilities.length === 0) {
+    const modelCapabilities2 = await session.readModelCapabilities(options.deadlineAtMs, options.signal);
+    if (modelCapabilities2.length === 0) {
       throw new CodexAppServerError({
         message: "Codex did not return any visible models with supported reasoning efforts.",
         category: "model",
@@ -19491,7 +19497,7 @@ async function preflightCodexSubscription(options) {
       authenticated_account_email: account.authenticatedChatGptAccount.email,
       authenticated_account_plan: account.authenticatedChatGptAccount.planType,
       rate_limits: rateLimits,
-      model_capabilities: modelCapabilities
+      model_capabilities: modelCapabilities2
     };
   } finally {
     await session.close();
@@ -21473,10 +21479,10 @@ import {
   realpath as realpath3,
   rm as rm3
 } from "node:fs/promises";
-import { randomBytes as randomBytes3 } from "node:crypto";
+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, 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, reconcileCodexAttemptRecovery, CodexSubscriptionAdapter;
 var init_codex_adapter = __esm({
   "lib/inference-host/codex-adapter.ts"() {
     "use strict";
@@ -21487,6 +21493,34 @@ var init_codex_adapter = __esm({
     MAX_PROMPT_BYTES2 = 3e5;
     CODEX_MODEL_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/u;
     CODEX_REASONING_EFFORT_PATTERN = /^[a-z][a-z0-9_-]{0,31}$/u;
+    codexRecoveryCheckpointProcessFingerprint = (checkpoint) => createHash4("sha256").update(JSON.stringify({
+      attemptId: checkpoint.attemptId,
+      processToken: checkpoint.processToken,
+      processReceiptPath: checkpoint.processReceiptPath,
+      processState: checkpoint.processState,
+      bootIdentity: checkpoint.bootIdentity ?? null,
+      cleanupConfirmed: checkpoint.cleanupConfirmed
+    })).digest("hex");
+    proveCodexSameBootQuiescence = async (options) => {
+      const readBootIdentity = options.readBootIdentity ?? readInferenceSystemBootIdentity;
+      const bootIdentityBefore = await readBootIdentity();
+      await options.confirmNoManagedCodexProcesses();
+      const bootIdentityAfter = await readBootIdentity();
+      if (bootIdentityAfter !== bootIdentityBefore) {
+        throw new Error("System boot identity changed during Codex recovery process inspection.");
+      }
+      return {
+        schemaVersion: "vtx_codex_same_boot_quiescence_v1",
+        bootIdentity: bootIdentityAfter,
+        observedAtMs: (options.now ?? Date.now)(),
+        checkpointFingerprints: Object.fromEntries(
+          Object.entries(options.attempts).map(([attemptId, checkpoint]) => [
+            attemptId,
+            codexRecoveryCheckpointProcessFingerprint(checkpoint)
+          ])
+        )
+      };
+    };
     tokenUsageReceiptSchema = external_exports.strictObject({
       inputTokens: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
       cachedInputTokens: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
@@ -21959,11 +21993,20 @@ var init_codex_adapter = __esm({
             throw new Error("Codex cross-boot recovery receipt ownership is unconfirmed.");
           }
         } else {
-          await confirmGuardianTerminatedForRecovery(
-            checkpoint,
-            guardian,
-            options.deadlineMs ?? 5e3
-          );
+          const receipt = await readCodexGuardianReceipt(guardian.receiptPath);
+          if (receipt === null && options.sameBootQuiescenceProof) {
+            const proof = options.sameBootQuiescenceProof;
+            const expectedFingerprint = proof.checkpointFingerprints[checkpoint.attemptId];
+            if (proof.schemaVersion !== "vtx_codex_same_boot_quiescence_v1" || proof.bootIdentity !== currentBootIdentity || checkpoint.bootIdentity !== currentBootIdentity || !Number.isFinite(proof.observedAtMs) || proof.observedAtMs > Date.now() + 1e3 || Date.now() - proof.observedAtMs > 3e4 || expectedFingerprint !== codexRecoveryCheckpointProcessFingerprint(checkpoint)) {
+              throw new Error("Codex same-boot recovery process fence is invalid or stale.");
+            }
+          } else {
+            await confirmGuardianTerminatedForRecovery(
+              checkpoint,
+              guardian,
+              options.deadlineMs ?? 5e3
+            );
+          }
         }
         assertRecoveryResourceScope(checkpoint);
         await removeRecoveredThread(checkpoint, options.codexHome);
@@ -22607,11 +22650,458 @@ var init_codex_adapter = __esm({
   }
 });
 
+// lib/inference-host/codex-recovery-process.ts
+import { spawn as spawn5 } from "node:child_process";
+var normalizedWindowsPath, classifyCodexRecoveryProcesses, WINDOWS_PROCESS_QUERY, queryWindowsProcesses, confirmNoVtxManagedCodexProcesses;
+var init_codex_recovery_process = __esm({
+  "lib/inference-host/codex-recovery-process.ts"() {
+    "use strict";
+    normalizedWindowsPath = (value) => value.replaceAll("\\", "/").replaceAll(/\/+$/gu, "").toLowerCase();
+    classifyCodexRecoveryProcesses = (processes, pinnedBinaryPath) => {
+      const pinned = normalizedWindowsPath(pinnedBinaryPath);
+      let managedProcessCount = 0;
+      let ambiguousProcessCount = 0;
+      for (const process3 of processes) {
+        const name = process3.name.trim().toLowerCase();
+        if (name === "codex.exe") {
+          if (!process3.executable_path || !process3.command_line || !process3.creation_date) {
+            ambiguousProcessCount += 1;
+            continue;
+          }
+          const executable = normalizedWindowsPath(process3.executable_path);
+          const packageOwned = executable === pinned || executable.includes("/node_modules/@vtxmacro/") && executable.includes("/node_modules/@openai/codex-win32-x64/") || executable.includes("/node_modules/@vtxmacro/.cli-") && executable.includes("/node_modules/@openai/codex-win32-x64/");
+          if (packageOwned) managedProcessCount += 1;
+          continue;
+        }
+        if (name !== "node.exe") continue;
+        if (!process3.executable_path || !process3.command_line || !process3.creation_date) {
+          ambiguousProcessCount += 1;
+          continue;
+        }
+        if (process3.command_line.includes("--input-type=module") && process3.command_line.includes("vtx_codex_guardian_v1") && process3.command_line.includes("processToken") && process3.command_line.includes("receiptPath")) {
+          managedProcessCount += 1;
+        }
+      }
+      return {
+        managed_process_count: managedProcessCount,
+        ambiguous_process_count: ambiguousProcessCount
+      };
+    };
+    WINDOWS_PROCESS_QUERY = String.raw`
+$ErrorActionPreference = 'Stop'
+$items = @(Get-CimInstance Win32_Process | Where-Object { $_.Name -in @('node.exe', 'codex.exe') } | ForEach-Object {
+  [ordered]@{
+    process_id = [int]$_.ProcessId
+    name = [string]$_.Name
+    executable_path = if ($null -eq $_.ExecutablePath) { $null } else { [string]$_.ExecutablePath }
+    command_line = if ($null -eq $_.CommandLine) { $null } else { [string]$_.CommandLine }
+    creation_date = if ($null -eq $_.CreationDate) { $null } else { [string]$_.CreationDate }
+  }
+})
+[Console]::Out.Write(($items | ConvertTo-Json -Depth 3 -Compress))
+`;
+    queryWindowsProcesses = async () => {
+      const args = [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        Buffer.from(WINDOWS_PROCESS_QUERY, "utf16le").toString("base64")
+      ];
+      const result2 = await new Promise(
+        (resolvePromise, reject) => {
+          const child = spawn5("powershell.exe", args, {
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          let stdout = "";
+          let stderr = "";
+          child.stdout.on("data", (chunk) => {
+            stdout = `${stdout}${chunk.toString("utf8")}`.slice(-4e6);
+          });
+          child.stderr.on("data", (chunk) => {
+            stderr = `${stderr}${chunk.toString("utf8")}`.slice(-4096);
+          });
+          child.once("error", reject);
+          child.once("close", (code) => {
+            if (code !== 0) {
+              reject(new Error("Windows process ownership inventory failed."));
+              return;
+            }
+            resolvePromise({ exitCode: code ?? 1, stdout });
+          });
+        }
+      );
+      if (result2.exitCode !== 0) throw new Error("Windows process ownership inventory failed.");
+      let parsed;
+      try {
+        parsed = result2.stdout.trim() ? JSON.parse(result2.stdout) : [];
+      } catch {
+        throw new Error("Windows process ownership inventory was invalid.");
+      }
+      const entries = Array.isArray(parsed) ? parsed : [parsed];
+      return entries.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+          throw new Error("Windows process ownership inventory was invalid.");
+        }
+        const record2 = entry;
+        if (!Number.isSafeInteger(record2.process_id) || Number(record2.process_id) < 1 || typeof record2.name !== "string" || record2.executable_path !== null && typeof record2.executable_path !== "string" || record2.command_line !== null && typeof record2.command_line !== "string" || record2.creation_date !== null && typeof record2.creation_date !== "string") {
+          throw new Error("Windows process ownership inventory was invalid.");
+        }
+        return {
+          process_id: Number(record2.process_id),
+          name: record2.name,
+          executable_path: record2.executable_path,
+          command_line: record2.command_line,
+          creation_date: record2.creation_date
+        };
+      });
+    };
+    confirmNoVtxManagedCodexProcesses = async (options) => {
+      if ((options.platform ?? process.platform) !== "win32") {
+        throw new Error("Same-boot service recovery is currently supported only on Windows.");
+      }
+      const queryProcesses = options.queryProcesses ?? queryWindowsProcesses;
+      const sleep4 = options.sleep ?? (async (milliseconds) => {
+        await new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+      });
+      for (let observation = 0; observation < 2; observation += 1) {
+        const classification = classifyCodexRecoveryProcesses(
+          await queryProcesses(),
+          options.pinnedBinaryPath
+        );
+        if (classification.ambiguous_process_count > 0) {
+          throw new Error(
+            "Codex process ownership could not be inspected completely; recovery evidence was preserved."
+          );
+        }
+        if (classification.managed_process_count > 0) {
+          throw new Error(
+            "VTX-managed Codex automation is still running; recovery evidence was preserved."
+          );
+        }
+        if (observation === 0) await sleep4(250);
+      }
+    };
+  }
+});
+
+// lib/inference-host/copilot-adapter.ts
+import { mkdtemp as mkdtemp2, rm as rm4 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join5 } from "node:path";
+import { CopilotClient } from "@github/copilot-sdk";
+var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, CopilotSubscriptionAdapter;
+var init_copilot_adapter = __esm({
+  "lib/inference-host/copilot-adapter.ts"() {
+    "use strict";
+    init_codex_app_server();
+    COPILOT_SDK_VERSION = "1.0.0-beta.8";
+    MAX_RESULT_BYTES = 3e5;
+    createPrivateWorkspace = async () => {
+      const path = await mkdtemp2(join5(tmpdir3(), "vtx-copilot-"));
+      return {
+        path,
+        cleanup: async () => {
+          await rm4(path, { recursive: true, force: true });
+        }
+      };
+    };
+    cleanCopilotEnvironment = () => {
+      const environment = { ...process.env };
+      for (const name of [
+        "COPILOT_GITHUB_TOKEN",
+        "GH_TOKEN",
+        "GITHUB_TOKEN",
+        "COPILOT_PROVIDER_API_KEY",
+        "COPILOT_PROVIDER_BASE_URL",
+        "COPILOT_PROVIDER_TYPE",
+        "COPILOT_CLI_PATH",
+        "COPILOT_SDK_AUTH_TOKEN",
+        "COPILOT_CONNECTION_TOKEN",
+        "COPILOT_HOME"
+      ]) delete environment[name];
+      return environment;
+    };
+    defaultClient = (workingDirectory) => new CopilotClient({
+      workingDirectory,
+      env: cleanCopilotEnvironment(),
+      useLoggedInUser: true,
+      logLevel: "error"
+    });
+    modelCapabilities = (models) => {
+      const capabilities = models.filter((model) => model.policy?.state !== "disabled" && model.policy?.state !== "unconfigured").flatMap((model) => {
+        const efforts = model.capabilities.supports.reasoningEffort ? [...model.supportedReasoningEfforts ?? []] : ["none"];
+        if (efforts.length === 0) return [];
+        const defaultEffort = model.defaultReasoningEffort && efforts.includes(model.defaultReasoningEffort) ? model.defaultReasoningEffort : efforts[0];
+        return [{
+          id: model.id,
+          model: model.id,
+          displayName: model.name,
+          hidden: false,
+          supportedReasoningEfforts: efforts,
+          defaultReasoningEffort: defaultEffort,
+          isDefault: false
+        }];
+      });
+      return capabilities.map((capability, index) => ({
+        ...capability,
+        isDefault: index === 0
+      }));
+    };
+    requiredUsageInteger = (value, field) => {
+      if (!Number.isSafeInteger(value) || Number(value) < 0) {
+        throw new Error(`copilot_usage_${field}_missing`);
+      }
+      return Number(value);
+    };
+    optionalUsageInteger = (value, field) => {
+      if (value === void 0) return 0;
+      if (!Number.isSafeInteger(value) || Number(value) < 0) {
+        throw new Error(`copilot_usage_${field}_invalid`);
+      }
+      return Number(value);
+    };
+    CopilotSubscriptionAdapter = class {
+      constructor(dependencies = {}) {
+        this.inFlight = /* @__PURE__ */ new Map();
+        this.dependencies = dependencies;
+      }
+      async preflight(signal) {
+        const workspace = await (this.dependencies.createWorkspace ?? createPrivateWorkspace)();
+        const client = (this.dependencies.createClient ?? defaultClient)(workspace.path);
+        try {
+          signal?.throwIfAborted();
+          await client.start();
+          const [status, auth, models] = await Promise.all([
+            client.getStatus(),
+            client.getAuthStatus(),
+            client.listModels()
+          ]);
+          if (!auth.isAuthenticated || auth.authType !== "user" && auth.authType !== "gh-cli") {
+            throw new CodexAppServerError({
+              message: "GitHub Copilot must use a logged-in Copilot subscription, not BYOK.",
+              category: "auth",
+              code: "copilot_subscription_auth_required",
+              retryable: false
+            });
+          }
+          const accountIdentity = auth.login?.trim().toLowerCase() ?? "";
+          if (!/^[a-z0-9][a-z0-9._-]{0,95}$/u.test(accountIdentity)) {
+            throw new CodexAppServerError({
+              message: "GitHub Copilot did not return a stable authenticated login identity.",
+              category: "auth",
+              code: "copilot_account_identity_required",
+              retryable: false
+            });
+          }
+          const capabilities = modelCapabilities(models);
+          if (capabilities.length === 0) {
+            throw new CodexAppServerError({
+              message: "GitHub Copilot did not return an enabled model catalog.",
+              category: "model",
+              code: "copilot_model_catalog_empty",
+              retryable: false
+            });
+          }
+          return {
+            adapterId: "copilot",
+            runtimeVersion: `${COPILOT_SDK_VERSION}+cli.${status.version}.rpc${status.protocolVersion}`,
+            authenticatedAccountIdentity: accountIdentity,
+            authenticatedAccountEmail: null,
+            authenticatedAccountPlan: null,
+            modelCapabilities: capabilities,
+            rateLimits: null,
+            sameAttemptRecovery: false
+          };
+        } finally {
+          await client.stop().catch(async () => {
+            await client.forceStop();
+          });
+          await workspace.cleanup();
+        }
+      }
+      runAttempt(input) {
+        const active = this.inFlight.get(input.attemptId);
+        if (active) return active;
+        const promise2 = this.executeAttempt(input).finally(() => {
+          if (this.inFlight.get(input.attemptId) === promise2) this.inFlight.delete(input.attemptId);
+        });
+        this.inFlight.set(input.attemptId, promise2);
+        return promise2;
+      }
+      async executeAttempt(input) {
+        const startedAt = (this.dependencies.now ?? Date.now)();
+        const workspace = await (this.dependencies.createWorkspace ?? createPrivateWorkspace)();
+        const client = (this.dependencies.createClient ?? defaultClient)(workspace.path);
+        let session = null;
+        let dispatchEntered = false;
+        let providerReceiptObserved = false;
+        try {
+          input.signal?.throwIfAborted();
+          if (Date.now() >= input.deadlineAtMs) throw new Error("deadline_exceeded");
+          await client.start();
+          session = await client.createSession({
+            clientName: "@vtxmacro/cli durable Copilot inference host",
+            model: input.requestedModel,
+            ...input.requestedReasoningEffort === "none" ? {} : { reasoningEffort: input.requestedReasoningEffort },
+            systemMessage: {
+              mode: "replace",
+              content: `${input.systemPrompt}
+
+Return only one JSON value matching this JSON Schema exactly:
+${input.outputSchemaJson}`
+            },
+            tools: [],
+            availableTools: [],
+            enableConfigDiscovery: false,
+            enableSessionTelemetry: true,
+            workingDirectory: workspace.path,
+            streaming: true
+          });
+          const usageEvents = [];
+          session.on((event) => {
+            if (event.type === "assistant.usage" && !event.agentId) {
+              providerReceiptObserved = true;
+              usageEvents.push(event);
+            }
+          });
+          const onAbort = () => {
+            void session?.abort().catch(() => void 0);
+          };
+          input.signal?.addEventListener("abort", onAbort, { once: true });
+          dispatchEntered = true;
+          let response;
+          try {
+            response = await session.sendAndWait(
+              { prompt: input.userPrompt },
+              Math.max(1, input.deadlineAtMs - Date.now())
+            );
+            providerReceiptObserved = true;
+          } finally {
+            input.signal?.removeEventListener("abort", onAbort);
+          }
+          if (!response?.data.content || Buffer.byteLength(response.data.content, "utf8") > MAX_RESULT_BYTES) {
+            throw new Error("copilot_invalid_result");
+          }
+          const observedModels = /* @__PURE__ */ new Set();
+          const observedEfforts = /* @__PURE__ */ new Set();
+          let inputTokens = 0;
+          let cachedInputTokens = 0;
+          let outputTokens = 0;
+          let reasoningOutputTokens = 0;
+          let cacheWriteInputTokens = 0;
+          let cacheWriteSupported = false;
+          let timeToFirstTokenMs = null;
+          let providerCallId = null;
+          for (const event of usageEvents) {
+            if (event.type !== "assistant.usage") continue;
+            observedModels.add(event.data.model);
+            if (event.data.reasoningEffort) observedEfforts.add(event.data.reasoningEffort);
+            inputTokens += requiredUsageInteger(event.data.inputTokens, "input_tokens");
+            cachedInputTokens += optionalUsageInteger(event.data.cacheReadTokens, "cache_read_tokens");
+            outputTokens += requiredUsageInteger(event.data.outputTokens, "output_tokens");
+            reasoningOutputTokens += optionalUsageInteger(event.data.reasoningTokens, "reasoning_tokens");
+            if (event.data.cacheWriteTokens !== void 0) {
+              cacheWriteSupported = true;
+              cacheWriteInputTokens += optionalUsageInteger(
+                event.data.cacheWriteTokens,
+                "cache_write_tokens"
+              );
+            }
+            if (timeToFirstTokenMs === null && Number.isSafeInteger(event.data.timeToFirstTokenMs)) {
+              timeToFirstTokenMs = Number(event.data.timeToFirstTokenMs);
+            }
+            providerCallId = event.data.providerCallId ?? event.data.apiCallId ?? providerCallId;
+          }
+          if (usageEvents.length === 0) {
+            throw new Error("copilot_usage_receipt_missing");
+          }
+          if (response.data.model) observedModels.add(response.data.model);
+          if (observedModels.size !== 1 || !observedModels.has(input.requestedModel)) {
+            throw new Error("copilot_effective_model_mismatch");
+          }
+          const effectiveEffort = input.requestedReasoningEffort === "none" ? observedEfforts.size === 0 ? "none" : observedEfforts.size === 1 ? [...observedEfforts][0] : null : observedEfforts.size === 1 ? [...observedEfforts][0] : null;
+          if (effectiveEffort !== input.requestedReasoningEffort) {
+            throw new Error("copilot_effective_effort_mismatch");
+          }
+          const usage = {
+            inputTokens,
+            cachedInputTokens: Math.min(cachedInputTokens, inputTokens),
+            outputTokens,
+            reasoningOutputTokens: Math.min(reasoningOutputTokens, outputTokens),
+            totalTokens: inputTokens + outputTokens,
+            cacheWriteInputTokens: cacheWriteSupported ? cacheWriteInputTokens : null,
+            cacheWriteSupported
+          };
+          return {
+            text: response.data.content,
+            reasoningContent: response.data.reasoningText ?? null,
+            reasoningSummary: null,
+            requestedModel: input.requestedModel,
+            effectiveModel: input.requestedModel,
+            requestedReasoningEffort: input.requestedReasoningEffort,
+            effectiveReasoningEffort: effectiveEffort,
+            adapterRequestId: providerCallId ?? response.data.requestId ?? response.data.messageId,
+            adapterResponseId: response.data.serviceRequestId ?? response.data.messageId,
+            usage,
+            latencyMs: Math.max(0, (this.dependencies.now ?? Date.now)() - startedAt),
+            timeToFirstTokenMs,
+            terminalStatus: "completed"
+          };
+        } catch (error48) {
+          if (error48 instanceof CodexAppServerError) throw error48;
+          const cancelled = input.signal?.aborted === true;
+          const deadline = Date.now() >= input.deadlineAtMs;
+          if (dispatchEntered && session) {
+            await session.abort().catch(() => void 0);
+          }
+          throw new CodexAppServerError({
+            message: cancelled ? "GitHub Copilot attempt was cancelled." : deadline ? "GitHub Copilot attempt exceeded its immutable deadline." : error48 instanceof Error ? error48.message : "GitHub Copilot adapter failed.",
+            category: cancelled ? "cancelled" : deadline ? "timeout" : "adapter",
+            code: cancelled ? "cancelled" : deadline ? "deadline_exceeded" : "copilot_adapter_failure",
+            retryable: false,
+            dispatchOutcome: providerReceiptObserved ? "confirmed_dispatched" : dispatchEntered ? "outcome_unknown" : "not_dispatched",
+            cause: error48
+          });
+        } finally {
+          if (session) {
+            const sessionId = session.sessionId;
+            await session.disconnect().catch(() => void 0);
+            await client.deleteSession(sessionId).catch(() => void 0);
+          }
+          await client.stop().catch(async () => {
+            await client.forceStop();
+          });
+          await workspace.cleanup();
+        }
+      }
+    };
+  }
+});
+
+// lib/inference-host/durable-adapter.ts
+var DURABLE_INFERENCE_ADAPTER_IDS, isDurableInferenceAdapterId, durableAdapterDisplayName;
+var init_durable_adapter = __esm({
+  "lib/inference-host/durable-adapter.ts"() {
+    "use strict";
+    DURABLE_INFERENCE_ADAPTER_IDS = [
+      "codex",
+      "copilot"
+    ];
+    isDurableInferenceAdapterId = (value) => DURABLE_INFERENCE_ADAPTER_IDS.includes(value);
+    durableAdapterDisplayName = (adapter) => ({
+      codex: "Codex",
+      copilot: "GitHub Copilot"
+    })[adapter];
+  }
+});
+
 // lib/inference-host/crypto.ts
 import {
   createCipheriv,
   createDecipheriv,
-  createHash as createHash4,
+  createHash as createHash5,
   createPrivateKey,
   createPublicKey,
   diffieHellman,
@@ -22650,7 +23140,7 @@ var init_crypto = __esm({
       const aad = envelopeAadSchema.parse(input);
       return Buffer.from(JSON.stringify(canonicalize(aad)), "utf8");
     };
-    externalInferenceSha256 = (value) => createHash4("sha256").update(value).digest("hex");
+    externalInferenceSha256 = (value) => createHash5("sha256").update(value).digest("hex");
     decodeCanonicalBase64Url = (value, fieldName, expectedBytes) => {
       if (!/^[A-Za-z0-9_-]+$/u.test(value)) {
         throw new ExternalInferenceEnvelopeError("invalid_encoding", `${fieldName} is invalid.`);
@@ -22749,7 +23239,7 @@ var init_crypto = __esm({
       return Buffer.from(hkdfSync(
         "sha256",
         root,
-        createHash4("sha256").update(aadBytes).digest(),
+        createHash5("sha256").update(aadBytes).digest(),
         info,
         32
       ));
@@ -29163,7 +29653,7 @@ var require_ajv = __commonJS({
 });
 
 // lib/inference-host/runner.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function createDefaultInferenceHostRunnerDependencies(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
   return {
@@ -29198,7 +29688,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, UNBOUNDED_AVAILABLE_SLOTS, buildCodexInferenceAdvertisedModels, 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, 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, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_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, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner;
 var init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -29223,18 +29713,18 @@ var init_runner = __esm({
     DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS = 5 * 60 * 1e3;
     MIN_CLAIM_START_WINDOW_MS = 5e3;
     UNBOUNDED_AVAILABLE_SLOTS = Number.MAX_SAFE_INTEGER;
-    buildCodexInferenceAdvertisedModels = (capabilities, adapterRuntimeVersion) => {
+    buildInferenceAdvertisedModels = (capabilities, adapterRuntimeVersion, adapter = "codex", structuredOutput = true, sameAttemptRecovery = adapter === "codex") => {
       const visible = capabilities.filter((capability) => !capability.hidden);
       if (visible.length === 0 || visible.length > 64) {
         throw new InferenceHostRunnerError(
           "invalid_configuration",
-          visible.length === 0 ? "Codex did not return any visible models that VTX can advertise." : "Codex returned more models than the VTX advertisement contract can represent."
+          visible.length === 0 ? `${adapter} did not return any visible models that VTX can advertise.` : `${adapter} returned more models than the VTX advertisement contract can represent.`
         );
       }
       const models = visible.map((capability) => ({
         model_id: capability.model,
         label: capability.displayName,
-        adapter: "codex",
+        adapter,
         supported_lanes: ["main", "review", "screener"],
         supported_reasoning_efforts: [...capability.supportedReasoningEfforts],
         default_reasoning_effort: capability.defaultReasoningEffort,
@@ -29243,14 +29733,14 @@ var init_runner = __esm({
           requested_model: capability.model,
           effective_models: [capability.model]
         }],
-        structured_output: true,
-        same_attempt_recovery: true,
+        structured_output: structuredOutput,
+        same_attempt_recovery: sameAttemptRecovery,
         adapter_runtime_version: adapterRuntimeVersion
       }));
       if (new Set(models.map((model) => model.model_id)).size !== models.length) {
         throw new InferenceHostRunnerError(
           "invalid_configuration",
-          "Codex returned duplicate runtime model identities."
+          `${adapter} returned duplicate runtime model identities.`
         );
       }
       return models;
@@ -29471,7 +29961,7 @@ var init_runner = __esm({
         attempts
       };
     };
-    sha256 = (value) => createHash5("sha256").update(value, "utf8").digest("hex");
+    sha256 = (value) => createHash6("sha256").update(value, "utf8").digest("hex");
     stableOperationId = (kind, parts) => `${kind}_${sha256(JSON.stringify(parts)).slice(0, 48)}`;
     buildAttemptStartRequest = (claim, attemptId, startedAt) => attemptStartRequestSchema.parse({
       schema_version: "external_inference_attempt_start_v1",
@@ -29526,6 +30016,10 @@ var init_runner = __esm({
       return result2;
     };
     validateRunnerOptions = (options) => {
+      const adapterId = options.adapterId ?? "codex";
+      if (!/^[a-z0-9][a-z0-9._-]{0,63}$/u.test(adapterId)) {
+        throw new InferenceHostRunnerError("invalid_configuration", "Inference adapter ID is invalid.");
+      }
       if (!options.displayName.trim() || options.displayName.length > 128) {
         throw new InferenceHostRunnerError("invalid_configuration", "Inference host display name is invalid.");
       }
@@ -29549,9 +30043,15 @@ var init_runner = __esm({
         );
       }
       return {
-        advertisedModels: buildCodexInferenceAdvertisedModels(
+        adapterId,
+        usageSource: options.usageSource ?? (adapterId === "codex" ? "codex_app_server" : adapterId),
+        sameAttemptRecovery: options.sameAttemptRecovery ?? adapterId === "codex",
+        advertisedModels: buildInferenceAdvertisedModels(
           options.codexModelCapabilities,
-          options.adapterRuntimeVersion
+          options.adapterRuntimeVersion,
+          adapterId,
+          options.structuredOutput ?? adapterId === "codex",
+          options.sameAttemptRecovery ?? adapterId === "codex"
         ),
         maxConcurrency: options.maxConcurrency === null || options.maxConcurrency === void 0 ? null : finitePositiveOption(options.maxConcurrency, 1, "Maximum concurrency"),
         advertisementTtlMs,
@@ -29756,12 +30256,12 @@ var init_runner = __esm({
     };
     assertAdvertisementResult = (advertisement, result2) => {
       const host = result2.host;
-      if (host.host_id !== advertisement.host_id || host.host_generation !== advertisement.host_generation || host.advertisement_generation !== advertisement.advertisement_generation || host.key_generation !== advertisement.key_generation || host.display_name !== advertisement.display_name || host.authenticated_account_email !== void 0 && host.authenticated_account_email !== null && host.authenticated_account_email !== advertisement.authenticated_account_email || (host.authenticated_account_plan ?? null) !== (advertisement.authenticated_account_plan ?? null) || host.adapter !== advertisement.adapter || host.status === "revoked" || !exactJson2(host.models, advertisement.models)) runnerIdentityMismatch("Host advertisement");
+      if (host.host_id !== advertisement.host_id || host.host_generation !== advertisement.host_generation || host.advertisement_generation !== advertisement.advertisement_generation || host.key_generation !== advertisement.key_generation || host.display_name !== advertisement.display_name || host.authenticated_account_identity !== void 0 && host.authenticated_account_identity !== null && host.authenticated_account_identity !== advertisement.authenticated_account_identity || host.authenticated_account_email !== void 0 && host.authenticated_account_email !== null && host.authenticated_account_email !== advertisement.authenticated_account_email || (host.authenticated_account_plan ?? null) !== (advertisement.authenticated_account_plan ?? null) || host.adapter !== advertisement.adapter || host.status === "revoked" || !exactJson2(host.models, advertisement.models)) runnerIdentityMismatch("Host advertisement");
     };
-    assertHostHeartbeatResult = (request, result2, allowOfflineProjection = false) => {
+    assertHostHeartbeatResult = (request, result2, expectedAdapter, allowOfflineProjection = false) => {
       const expectedStatus = request.status === "healthy" ? "online" : request.status;
       const expectedTemporaryOffline = allowOfflineProjection && request.status === "healthy" && result2.host.status === "offline";
-      if (result2.host.host_id !== request.host_id || result2.host.host_generation !== request.host_generation || result2.host.advertisement_generation !== request.advertisement_generation || result2.host.key_generation !== request.key_generation || result2.host.adapter !== "codex" || result2.host.status !== expectedStatus && !expectedTemporaryOffline) runnerIdentityMismatch("Host heartbeat");
+      if (result2.host.host_id !== request.host_id || result2.host.host_generation !== request.host_generation || result2.host.advertisement_generation !== request.advertisement_generation || result2.host.key_generation !== request.key_generation || result2.host.adapter !== expectedAdapter || result2.host.status !== expectedStatus && !expectedTemporaryOffline) runnerIdentityMismatch("Host heartbeat");
     };
     assertClaimResult = (request, result2) => {
       if (result2.claim_request_id !== request.claim_request_id) {
@@ -29837,10 +30337,10 @@ var init_runner = __esm({
         "authentication_timeout"
       ].includes(code);
     };
-    reportedTokenUsage = (usage) => ({
+    reportedTokenUsage = (usage, source = "codex_app_server") => ({
       schema_version: EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION,
       availability: "reported",
-      source: "codex_app_server",
+      source,
       input_tokens: usage.inputTokens,
       cached_input_tokens: usage.cachedInputTokens,
       output_tokens: usage.outputTokens,
@@ -29849,7 +30349,7 @@ var init_runner = __esm({
       cache_write_input_tokens: usage.cacheWriteInputTokens,
       cache_write_support: usage.cacheWriteSupported ? "reported" : "unsupported"
     });
-    reportedUsage = (result2) => reportedTokenUsage(result2.usage);
+    reportedUsage = (result2, source) => reportedTokenUsage(result2.usage, source);
     InferenceHostRunner = class {
       constructor(dependencies, options) {
         this.receiptWriteChain = Promise.resolve();
@@ -30079,8 +30579,9 @@ var init_runner = __esm({
                 host_generation: localState.host_generation,
                 advertisement_generation: generation,
                 key_generation: localState.key_generation,
-                adapter: "codex",
+                adapter: settings.adapterId,
                 display_name: this.options.displayName.trim(),
+                authenticated_account_identity: this.options.authenticatedAccountIdentity ?? null,
                 authenticated_account_email: this.options.authenticatedAccountEmail ?? null,
                 authenticated_account_plan: this.options.authenticatedAccountPlan ?? null,
                 protocol_version: this.options.protocolVersion,
@@ -30189,7 +30690,7 @@ var init_runner = __esm({
               }
               throw error48;
             }
-            assertHostHeartbeatResult(request, result2, allowOfflineProjection);
+            assertHostHeartbeatResult(request, result2, settings.adapterId, allowOfflineProjection);
             if (result2.host.status === "revoked" || result2.host.status === "offline" && !allowOfflineProjection) {
               const error48 = new InferenceHostRunnerError(
                 result2.host.status === "revoked" ? "host_revoked" : "host_offline",
@@ -30633,6 +31134,9 @@ var init_runner = __esm({
           signal,
           now
         } = options;
+        const adapterId = this.options.adapterId ?? "codex";
+        const usageSource = this.options.usageSource ?? (adapterId === "codex" ? "codex_app_server" : adapterId);
+        const sameAttemptRecovery = this.options.sameAttemptRecovery ?? adapterId === "codex";
         const decryptClaim = this.dependencies.decryptClaim ?? decryptExternalInferenceClaim;
         const sealCandidate = this.dependencies.sealCandidate ?? sealExternalInferenceCandidate;
         const validateOutput = this.dependencies.validateOutput ?? defaultValidateOutput;
@@ -30809,6 +31313,15 @@ var init_runner = __esm({
             phase: "dispatched",
             dispatch_outcome: "outcome_unknown"
           });
+          if (options.resumeReceipt?.phase === "dispatched" && !sameAttemptRecovery) {
+            throw new CodexAppServerError({
+              message: `${adapterId} cannot prove the exact result of the interrupted attempt.`,
+              category: "adapter",
+              code: "same_attempt_recovery_unavailable",
+              retryable: false,
+              dispatchOutcome: "outcome_unknown"
+            });
+          }
           adapterResult = await this.dependencies.codexAdapter.runAttempt({
             attemptId,
             inputSha256: jobInput.input_sha256,
@@ -30834,7 +31347,7 @@ var init_runner = __esm({
           } catch (error48) {
             throw new InferenceHostRunnerError(
               "invalid_structured_output",
-              "Codex did not return valid structured JSON.",
+              `${adapterId} did not return valid structured JSON.`,
               { cause: error48 }
             );
           }
@@ -30846,7 +31359,7 @@ var init_runner = __esm({
             if (Buffer.byteLength(adapterResult.text, "utf8") > outputContract.providerResponseTextMaxUtf8Bytes) {
               throw new InferenceHostRunnerError(
                 "output_schema_response_text_too_large",
-                "Codex response text exceeds the immutable provider-response UTF-8 byte limit."
+                `${adapterId} response text exceeds the immutable provider-response UTF-8 byte limit.`
               );
             }
             if (outputContract.providerReasoningContentSupported && outputContract.providerReasoningContentMaxUtf8Bytes !== null && adapterResult.reasoningContent !== null && Buffer.byteLength(adapterResult.reasoningContent, "utf8") > outputContract.providerReasoningContentMaxUtf8Bytes) {
@@ -30919,7 +31432,7 @@ var init_runner = __esm({
               adapter_request_id: adapterResult.adapterRequestId,
               adapter_response_id: adapterResult.adapterResponseId
             },
-            usage: reportedUsage(adapterResult),
+            usage: reportedUsage(adapterResult, usageSource),
             outcome: {
               dispatch_outcome: "confirmed_dispatched",
               response_outcome: "completed"
@@ -31034,7 +31547,7 @@ var init_runner = __esm({
               adapter_request_id: canReportEffective ? adapterResult?.adapterRequestId ?? null : null,
               adapter_response_id: canReportEffective ? adapterResult?.adapterResponseId ?? null : null
             },
-            usage: adapterResult ? reportedUsage(adapterResult) : error48 instanceof CodexAppServerError && error48.usage ? reportedTokenUsage(error48.usage) : null,
+            usage: adapterResult ? reportedUsage(adapterResult, usageSource) : error48 instanceof CodexAppServerError && error48.usage ? reportedTokenUsage(error48.usage, usageSource) : null,
             failure_category: failure.category,
             failure_code: failure.code,
             retryable: failure.retryable,
@@ -31101,7 +31614,7 @@ var init_runner = __esm({
         if (result2.requestedModel !== jobInput.requested_model || result2.requestedReasoningEffort !== jobInput.requested_reasoning_effort || !mapping?.effective_models.includes(result2.effectiveModel) || !jobInput.allowed_effective_reasoning_efforts.includes(result2.effectiveReasoningEffort)) {
           throw new InferenceHostRunnerError(
             "effective_model_mismatch",
-            "Codex effective model provenance did not match the immutable allowance."
+            "The effective adapter model provenance did not match the immutable allowance."
           );
         }
       }
@@ -31110,16 +31623,17 @@ var init_runner = __esm({
 });
 
 // lib/inference-host/service.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createWriteStream, readFileSync } from "node:fs";
-import { access as access3, chmod as chmod3, mkdir as mkdir3, readFile as readFile5, rm as rm4, writeFile as writeFile2 } from "node:fs/promises";
+import { access as access3, chmod as chmod3, mkdir as mkdir3, readFile as readFile5, rm as rm5, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname4, join as join5, resolve as resolve4 } from "node:path";
+import { dirname as dirname4, join as join6, resolve as resolve4 } from "node:path";
 var SERVICE_NAME, SYSTEMD_UNIT, LAUNCHD_LABEL, SERVICE_COOPERATIVE_STOP_SECONDS, INFERENCE_HOST_SERVICE_DRAIN_COMMAND, inferenceHostServiceChildEnvironment, isWindowsSubsystemForLinux, inferenceHostServiceManifestPath, inferenceHostServiceDesiredPath, inferenceHostServiceLogPath, inferenceHostServiceRuntimePath, xmlEscape, plistEscape, systemdQuote, defaultRunCommand, managerName, assertRuntimeEnvironment, withoutConcurrencyLimit, assertServicePath, manifestGeneration, assertWorker, assertManifest, assertServiceRuntimeState, assertDesiredState, readInferenceHostServiceManifest, readManifestAcrossAtomicReplacement, readInferenceHostServiceRuntime, readRuntimeAcrossAtomicReplacement, readInferenceHostServiceDesired, readDesiredAcrossAtomicReplacement, writeDesired, runtimeEnvironment, serviceArguments, windowsOwnedCommandLine, vbScriptString, windowsServiceLauncher, windowsTaskXml, systemdUnit, launchAgentPlist, sameWorker, sameServiceDefinition, sameWorkerSet, InferenceHostServiceManager, appendServiceLog, spawnInferenceHostServiceChild, runInferenceHostServiceSupervisor;
 var init_service = __esm({
   "lib/inference-host/service.ts"() {
     "use strict";
+    init_durable_adapter();
     init_config();
     SERVICE_NAME = "VTX Macro Inference Host";
     SYSTEMD_UNIT = "vtx-inference-host.service";
@@ -31156,7 +31670,7 @@ var init_service = __esm({
     plistEscape = xmlEscape;
     systemdQuote = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%")}"`;
     defaultRunCommand = async (command, args) => await new Promise((resolvePromise) => {
-      const child = spawn5(command, [...args], {
+      const child = spawn6(command, [...args], {
         windowsHide: true,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -31208,14 +31722,15 @@ var init_service = __esm({
         throw new Error("Inference-host service worker is invalid.");
       }
       const record2 = value;
-      if (typeof record2.instance_name !== "string" || !/^[a-z0-9](?:[a-z0-9-]{0,46}[a-z0-9])?$/u.test(record2.instance_name) || record2.adapter !== "codex" || typeof record2.display_name !== "string" || !record2.display_name || record2.max_concurrency !== null && (!Number.isSafeInteger(record2.max_concurrency) || Number(record2.max_concurrency) < 1) || record2.authenticated_account_email !== null && typeof record2.authenticated_account_email !== "string" || record2.authenticated_account_plan !== null && typeof record2.authenticated_account_plan !== "string") {
+      if (typeof record2.instance_name !== "string" || !/^[a-z0-9](?:[a-z0-9-]{0,46}[a-z0-9])?$/u.test(record2.instance_name) || typeof record2.adapter !== "string" || !isDurableInferenceAdapterId(record2.adapter) || typeof record2.display_name !== "string" || !record2.display_name || record2.max_concurrency !== null && (!Number.isSafeInteger(record2.max_concurrency) || Number(record2.max_concurrency) < 1) || record2.authenticated_account_email !== null && typeof record2.authenticated_account_email !== "string" || record2.authenticated_account_identity !== void 0 && record2.authenticated_account_identity !== null && typeof record2.authenticated_account_identity !== "string" || record2.authenticated_account_plan !== null && typeof record2.authenticated_account_plan !== "string") {
         throw new Error("Inference-host service worker is invalid.");
       }
       return {
         instance_name: record2.instance_name,
-        adapter: "codex",
+        adapter: record2.adapter,
         display_name: record2.display_name,
         max_concurrency: record2.max_concurrency === null ? null : Number(record2.max_concurrency),
+        authenticated_account_identity: record2.authenticated_account_identity,
         authenticated_account_email: record2.authenticated_account_email,
         authenticated_account_plan: record2.authenticated_account_plan,
         runtime_environment: assertRuntimeEnvironment(record2.runtime_environment)
@@ -31582,8 +32097,8 @@ WantedBy=default.target
       }
       definitionPath() {
         if (this.platform === "win32") return `${this.config.supervisorStatePath}.service-task.xml`;
-        if (this.platform === "darwin") return join5(this.home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-        return join5(this.home, ".config", "systemd", "user", SYSTEMD_UNIT);
+        if (this.platform === "darwin") return join6(this.home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+        return join6(this.home, ".config", "systemd", "user", SYSTEMD_UNIT);
       }
       windowsLauncherPath() {
         return `${this.config.supervisorStatePath}.service-launcher.vbs`;
@@ -31629,8 +32144,10 @@ WantedBy=default.target
         }
         throw new Error("Background service did not reach an active state within 10 seconds.");
       }
-      async restoreRunningSupervisor(manifest) {
-        const restoredManifest = assertManifest({
+      async restoreRunningSupervisor(manifest, preserveGeneration = false, targetInstanceName) {
+        const previousRuntime = await readRuntimeAcrossAtomicReplacement(this.runtimePath()).catch(() => null);
+        const previousRuntimeUpdatedAt = previousRuntime?.manifest_generation === manifest.generation ? Date.parse(previousRuntime.updated_at) : Number.NaN;
+        const restoredManifest = preserveGeneration ? manifest : assertManifest({
           ...manifest,
           generation: randomUUID(),
           installed_at: this.now().toISOString()
@@ -31658,10 +32175,15 @@ ${result2.stderr}`)) {
         }
         await this.waitForManagerActive();
         if (!this.confirmInitialReadiness) return await this.status();
-        const runtime = await this.waitForManifestApplied(restoredManifest);
+        const runtime = await this.waitForManifestApplied(
+          restoredManifest,
+          targetInstanceName,
+          this.reconcileWaitAttempts,
+          Number.isFinite(previousRuntimeUpdatedAt) ? previousRuntimeUpdatedAt : void 0
+        );
         return await this.status(runtime);
       }
-      async waitForManifestApplied(manifest, targetInstanceName, maxAttempts = this.reconcileWaitAttempts) {
+      async waitForManifestApplied(manifest, targetInstanceName, maxAttempts = this.reconcileWaitAttempts, minimumRuntimeUpdatedAtExclusive) {
         let consecutiveReadyObservations = 0;
         for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
           let runtime = null;
@@ -31672,7 +32194,9 @@ ${result2.stderr}`)) {
               throw error48;
             }
           }
-          if (runtime?.manifest_generation === manifest.generation) {
+          const runtimeUpdatedAt = runtime ? Date.parse(runtime.updated_at) : Number.NaN;
+          const runtimeIsFresh = minimumRuntimeUpdatedAtExclusive === void 0 || Number.isFinite(runtimeUpdatedAt) && runtimeUpdatedAt > minimumRuntimeUpdatedAtExclusive;
+          if (runtime?.manifest_generation === manifest.generation && runtimeIsFresh) {
             const configuredNames = manifest.workers.map((worker) => worker.instance_name).sort();
             const runtimeNames = runtime.workers.map((worker) => worker.instance_name).sort();
             const exactWorkerSet = JSON.stringify(configuredNames) === JSON.stringify(runtimeNames);
@@ -31756,13 +32280,13 @@ ${cleanup.stderr}`)) {
               );
             }
           }
-          await rm4(this.definitionPath(), { force: true }).catch(() => void 0);
+          await rm5(this.definitionPath(), { force: true }).catch(() => void 0);
           if (this.platform === "win32") {
-            await rm4(this.windowsLauncherPath(), { force: true }).catch(() => void 0);
+            await rm5(this.windowsLauncherPath(), { force: true }).catch(() => void 0);
           }
-          await rm4(this.manifestPath(), { force: true }).catch(() => void 0);
-          await rm4(this.desiredPath(), { force: true }).catch(() => void 0);
-          await rm4(this.runtimePath(), { force: true }).catch(() => void 0);
+          await rm5(this.manifestPath(), { force: true }).catch(() => void 0);
+          await rm5(this.desiredPath(), { force: true }).catch(() => void 0);
+          await rm5(this.runtimePath(), { force: true }).catch(() => void 0);
           if (this.platform === "linux") {
             await this.runCommand("systemctl", ["--user", "daemon-reload"]).catch(() => void 0);
           }
@@ -31858,18 +32382,31 @@ ${cleanup.stderr}`)) {
       }
       async installUnlocked(options) {
         const existing = await readInferenceHostServiceManifest(this.manifestPath());
+        const currentWorker = existing?.workers.find(
+          (worker) => worker.instance_name === this.config.instanceName
+        );
+        if (currentWorker && currentWorker.adapter !== options.adapter) {
+          throw new Error(
+            `Inference-host instance ${this.config.instanceName} is already bound to ${currentWorker.adapter}; install ${options.adapter} under a distinct --instance and VTX grant.`
+          );
+        }
         const normalizedEmail = options.authenticatedAccountEmail?.trim().toLowerCase() || null;
+        const normalizedAccountIdentity = options.authenticatedAccountIdentity?.trim().toLowerCase() || null;
+        const normalizedIdentity = normalizedAccountIdentity || normalizedEmail;
         const otherWorkers = existing?.workers.filter(
           (worker) => worker.instance_name !== this.config.instanceName
         ) ?? [];
-        if (otherWorkers.length > 0 && (!normalizedEmail || otherWorkers.some((worker) => !worker.authenticated_account_email))) {
+        const peerAdapterWorkers = otherWorkers.filter(
+          (worker) => worker.adapter === options.adapter
+        );
+        if (peerAdapterWorkers.length > 0 && (!normalizedIdentity || peerAdapterWorkers.some((worker) => !(worker.authenticated_account_identity || worker.authenticated_account_email)))) {
           throw new Error(
-            "Cannot prove that every installed instance uses a distinct ChatGPT subscription. Reinstall instances with live account identity before adding another."
+            `Cannot prove that every installed ${options.adapter} instance uses a distinct subscription identity.`
           );
         }
-        if (normalizedEmail && otherWorkers.some((worker) => worker.authenticated_account_email?.trim().toLowerCase() === normalizedEmail)) {
+        if (normalizedIdentity && peerAdapterWorkers.some((worker) => (worker.authenticated_account_identity || worker.authenticated_account_email)?.trim().toLowerCase() === normalizedIdentity)) {
           throw new Error(
-            "This ChatGPT subscription is already installed under another inference-host instance."
+            `This ${options.adapter} subscription is already installed under another inference-host instance.`
           );
         }
         if (this.config.credentialFilePath && otherWorkers.some((worker) => {
@@ -31890,6 +32427,7 @@ ${cleanup.stderr}`)) {
             adapter: options.adapter,
             display_name: options.displayName,
             max_concurrency: maxConcurrency,
+            ...normalizedAccountIdentity ? { authenticated_account_identity: normalizedAccountIdentity } : {},
             authenticated_account_email: normalizedEmail,
             authenticated_account_plan: options.authenticatedAccountPlan ?? null,
             runtime_environment: runtimeEnvironment(this.config, maxConcurrency)
@@ -31934,7 +32472,71 @@ ${result2.stderr}`)) {
       async stop() {
         return await this.withControlLock(async () => await this.stopUnlocked());
       }
-      async stopUnlocked() {
+      /**
+       * Quiesce the complete installed worker boundary while one exact instance's
+       * durable Codex recovery evidence is reconciled. The service process lock is
+       * held for the callback, so neither the manager nor a manual run-internal can
+       * recreate workers during the same-boot process inspection.
+       */
+      async recoverInstance(instanceName, operation, options = {}) {
+        return await this.withControlLock(async () => {
+          const manifest = await readInferenceHostServiceManifest(this.manifestPath());
+          if (!manifest) throw new Error("Inference-host service is not installed.");
+          if (!manifest.workers.some((worker) => worker.instance_name === instanceName)) {
+            throw new Error(`Inference-host instance ${instanceName} is not installed.`);
+          }
+          if (options.expectedManifestGeneration && options.expectedManifestGeneration !== manifest.generation) {
+            throw new Error("Inference-host service manifest changed during recovery.");
+          }
+          const recordedDesiredRunning = await readInferenceHostServiceDesired(this.desiredPath());
+          const desiredRunning = options.restoreDesiredRunning ?? recordedDesiredRunning;
+          const context = { manifest, desiredRunning };
+          await options.prepare?.(context);
+          const before = await this.status();
+          if (recordedDesiredRunning || before.manager_active) {
+            await this.stopUnlocked(true);
+          } else {
+            await writeDesired(this.desiredPath(), false, this.now());
+          }
+          let serviceFence = null;
+          let result2;
+          let operationError = null;
+          try {
+            serviceFence = await this.acquireProcessLock(
+              `${this.config.supervisorProcessLockPath}.service`
+            );
+            const stopped = await this.status();
+            if (stopped.manager_active) {
+              throw new Error("Background service manager became active during recovery quiescence.");
+            }
+            result2 = await operation(context);
+          } catch (error48) {
+            operationError = error48;
+          } finally {
+            await serviceFence?.release().catch((error48) => {
+              operationError = operationError ?? error48;
+            });
+          }
+          let restoredStatus;
+          try {
+            restoredStatus = desiredRunning ? await this.restoreRunningSupervisor(manifest, true, instanceName) : await this.status();
+          } catch (restoreError) {
+            if (operationError) {
+              throw new Error(
+                "Inference-host recovery failed and the previous supervisor could not be restored.",
+                { cause: new AggregateError([operationError, restoreError]) }
+              );
+            }
+            throw new Error(
+              "Inference-host recovery completed, but the previous supervisor could not be restored.",
+              { cause: restoreError }
+            );
+          }
+          if (operationError) throw operationError;
+          return { result: result2, status: restoredStatus };
+        });
+      }
+      async stopUnlocked(preserveManifestGenerationOnFailure = false) {
         const manifest = await readInferenceHostServiceManifest(this.manifestPath());
         if (!manifest) {
           throw new Error("Inference-host service is not installed.");
@@ -31976,7 +32578,7 @@ ${result2.stderr}`)) {
         } catch (error48) {
           if (!restoreOnFailure) throw error48;
           try {
-            await this.restoreRunningSupervisor(manifest);
+            await this.restoreRunningSupervisor(manifest, preserveManifestGenerationOnFailure);
           } catch (restoreError) {
             throw new Error(
               "Inference-host stop failed and the previous supervisor could not be restored.",
@@ -31999,12 +32601,14 @@ ${result2.stderr}`)) {
           manager_active: managerActive,
           manager: managerName(this.platform),
           manager_state: result2.exitCode === 0 ? output3 || "installed" : "not-installed",
-          adapter: manifest ? "codex" : null,
+          adapter: manifest && new Set(manifest.workers.map((worker) => worker.adapter)).size === 1 ? manifest.workers[0]?.adapter ?? null : null,
           log_path: manifest?.log_path ?? this.logPath(),
           workers: manifest?.workers.map((worker) => ({
             instance_name: worker.instance_name,
+            adapter: worker.adapter,
             display_name: worker.display_name,
             max_concurrency: worker.max_concurrency,
+            authenticated_account_identity: worker.authenticated_account_identity ?? null,
             authenticated_account_email: worker.authenticated_account_email,
             authenticated_account_plan: worker.authenticated_account_plan,
             runtime_state: runtime?.manifest_generation === manifest.generation && managerActive ? runtime.workers.find((item) => item.instance_name === worker.instance_name)?.state ?? "unknown" : "unknown"
@@ -32068,12 +32672,12 @@ ${result2.stderr}`)) {
 ${result2.stderr}`)) {
           throw new Error(`Background service uninstall failed: ${result2.stderr.trim()}`);
         }
-        await rm4(this.definitionPath(), { force: true });
-        if (this.platform === "win32") await rm4(this.windowsLauncherPath(), { force: true });
+        await rm5(this.definitionPath(), { force: true });
+        if (this.platform === "win32") await rm5(this.windowsLauncherPath(), { force: true });
         if (this.platform === "linux") await this.runCommand("systemctl", ["--user", "daemon-reload"]);
-        await rm4(this.manifestPath(), { force: true });
-        await rm4(this.desiredPath(), { force: true });
-        await rm4(this.runtimePath(), { force: true });
+        await rm5(this.manifestPath(), { force: true });
+        await rm5(this.desiredPath(), { force: true });
+        await rm5(this.runtimePath(), { force: true });
         return {
           installed: false,
           desired_running: false,
@@ -32102,6 +32706,8 @@ ${result2.stderr}`)) {
         "inference-host",
         "run",
         "--json",
+        "--adapter",
+        worker.adapter,
         "--display-name",
         worker.display_name
       ];
@@ -32143,7 +32749,7 @@ ${result2.stderr}`)) {
 `);
           }
         };
-        const child = spawn5(manifest.executable, args, {
+        const child = spawn6(manifest.executable, args, {
           env: inferenceHostServiceChildEnvironment(worker.runtime_environment),
           windowsHide: true,
           stdio: ["pipe", "pipe", "pipe"]
@@ -32214,7 +32820,7 @@ ${result2.stderr}`)) {
       });
       const launch = options.runWorker ?? options.spawnChild ?? spawnInferenceHostServiceChild;
       await appendServiceLog(initialManifest.log_path, "service_supervisor_started", {
-        adapter: "codex",
+        adapters: [...new Set(initialManifest.workers.map((worker) => worker.adapter))].sort(),
         instances: initialManifest.workers.map((worker) => worker.instance_name)
       });
       const workers = /* @__PURE__ */ new Map();
@@ -32433,10 +33039,10 @@ __export(cli_exports, {
   registerInferenceHostServiceControlInput: () => registerInferenceHostServiceControlInput,
   runInferenceHostCli: () => runInferenceHostCli
 });
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { spawn as spawn6 } from "node:child_process";
-import { lstat as lstat4, realpath as realpath4, rm as rm5 } from "node:fs/promises";
-import { join as join6, resolve as resolve5 } from "node:path";
+import { createHash as createHash7, randomUUID as randomUUID2 } from "node:crypto";
+import { spawn as spawn7 } from "node:child_process";
+import { lstat as lstat4, realpath as realpath4, rm as rm6 } from "node:fs/promises";
+import { join as join7, resolve as resolve5 } from "node:path";
 async function runInferenceHostCli(argv2, env = process.env, dependencies = {}) {
   const warnings = [];
   try {
@@ -32444,6 +33050,21 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
       return { exitCode: 0, stdout: INFERENCE_HOST_HELP, stderr: "" };
     }
     const parsed = parseInferenceHostArgs(argv2, env);
+    if (parsed.forceRecovery && !(parsed.command === "service" && parsed.serviceAction === "recover")) {
+      throw new Error("--force-recovery is accepted only by service recover.");
+    }
+    if (parsed.command === "service" && parsed.serviceAction === "recover") {
+      if (!parsed.instanceFlagExplicit) {
+        throw new Error(
+          "Service recovery requires an explicit --instance NAME; an environment or default instance is not accepted."
+        );
+      }
+      if (!parsed.forceRecovery) {
+        throw new Error(
+          `Service recovery is disruptive. Rerun with --instance ${parsed.instanceName} --force-recovery after checking service status and logs.`
+        );
+      }
+    }
     const config2 = await resolveInferenceHostCommandConfig(parsed, env, dependencies);
     if (parsed.command === "login") {
       return await login(config2, parsed, env, dependencies, warnings);
@@ -32482,7 +33103,18 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
       );
     }
     if (parsed.command === "service") {
-      return await serviceCommand(config2, parsed, env, dependencies, warnings);
+      const mutationActions = /* @__PURE__ */ new Set(["install", "start", "stop", "recover", "uninstall"]);
+      if (!parsed.serviceAction || !mutationActions.has(parsed.serviceAction)) {
+        return await serviceCommand(config2, parsed, env, dependencies, warnings);
+      }
+      const recoveryCommandLock = await acquireInferenceHostProcessLock(
+        serviceRecoveryCommandLockPath(config2)
+      );
+      try {
+        return await serviceCommand(config2, parsed, env, dependencies, warnings);
+      } finally {
+        await recoveryCommandLock.release();
+      }
     }
     if (parsed.command === "status") {
       return await localStatus(config2, parsed, dependencies, warnings);
@@ -32511,7 +33143,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     };
   }
 }
-var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, credentialLifecycleLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, login, codexLogin, codexLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, agentOperationId, agentSession, agentConnect, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, serviceCommand, hasExplicitCredentialStoreConfiguration, credentialEnvironmentForIdentity, commandRequiresRetainedCredentialStore, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
+var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, credentialLifecycleLockPath, serviceRecoveryCommandLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, preparePortableDurableAdapter, defaultRunPortableDurableAdapter, login, codexLogin, codexLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, agentOperationId, agentSession, agentConnect, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, recoveryBackupPath, serviceRecoveryTransactionPath, readServiceRecoveryTransaction, assertResumableCodexRecoveryEvidence, recoverInstalledCodexService, serviceCommand, hasExplicitCredentialStoreConfiguration, credentialEnvironmentForIdentity, commandRequiresRetainedCredentialStore, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
 var init_cli = __esm({
   "lib/inference-host/cli.ts"() {
     "use strict";
@@ -32520,6 +33152,9 @@ var init_cli = __esm({
     init_agent_client();
     init_agent_state();
     init_codex_adapter();
+    init_codex_recovery_process();
+    init_copilot_adapter();
+    init_durable_adapter();
     init_codex_app_server();
     init_codex_binary();
     init_config();
@@ -32536,6 +33171,7 @@ var init_cli = __esm({
     revocationCheckpointPath = (config2) => `${config2.statePath}.revoke.json`;
     foregroundHostLockPath = (config2) => `${config2.processLockPath}.foreground`;
     credentialLifecycleLockPath = (config2) => `${inferenceHostCredentialContextPath(config2)}.lock`;
+    serviceRecoveryCommandLockPath = (config2) => `${config2.supervisorProcessLockPath}.service-recovery-command`;
     AGENT_HEARTBEAT_INTERVAL_MS = 3e3;
     AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS = 9e3;
     retryableAgentHeartbeatError = (error48) => {
@@ -32601,7 +33237,7 @@ var init_cli = __esm({
 Commands:
   login           Authorize the isolated VTX insights:inference grant
   codex-login     Sign the automated Codex host into a ChatGPT subscription
-  run             Run the automated Codex inference host in the foreground
+  run             Run a supported durable inference adapter in the foreground
   agent-connect   Advertise a model from a compatible agent harness
   agent-run       Keep an agent-driven host online in the foreground
   agent-next      Claim the next exact VTX inference request
@@ -32609,7 +33245,7 @@ Commands:
   agent-fail      Submit one truthful agent failure from stdin
   service         Install and control the durable background host
   status          Inspect local host and credential state
-  doctor          Verify credentials, Codex, and private runtime state
+  doctor          Verify credentials, provider runtime, and private state
   logout          Remove local VTX host state without revoking the grant
   revoke          Revoke the VTX grant and remove local host state
   codex-logout    Remove the automated host's dedicated Codex login
@@ -32617,7 +33253,8 @@ Commands:
 Common options:
   --json           Emit machine-readable JSON
   --instance NAME  Target an isolated local subscription instance (default: default)
-  --max-concurrency N  Optional positive-integer Codex slot limit (default: unlimited)
+  --adapter ID     Durable adapter: codex or copilot
+  --max-concurrency N  Optional positive-integer local slot limit (default: unlimited)
   --help, -h       Show this help
 
 If the OS credential store cannot retain the VTX grant, set
@@ -32631,8 +33268,10 @@ Durable service:
   vtx inference-host login --instance codex-2
   vtx inference-host codex-login --instance codex-2
   vtx inference-host service install --instance codex-2
+  vtx inference-host service install --adapter copilot --instance copilot-1
   vtx inference-host service uninstall --instance codex-2
-  vtx inference-host service <start|stop|status|logs|uninstall>
+  vtx inference-host service recover --instance codex-1 --force-recovery
+  vtx inference-host service <start|stop|status|logs|recover|uninstall>
 `;
     parseHostConcurrency = (raw, label) => {
       const value = Number(raw);
@@ -32648,6 +33287,7 @@ Durable service:
       let maxConcurrency = configuredConcurrency ? parseHostConcurrency(configuredConcurrency, "VTX_INFERENCE_HOST_MAX_CONCURRENCY") : null;
       let instanceName = String(env.VTX_INFERENCE_HOST_INSTANCE || "default").trim();
       let instanceExplicit = Boolean(String(env.VTX_INFERENCE_HOST_INSTANCE || "").trim());
+      let instanceFlagExplicit = false;
       let displayName = String(env.VTX_INFERENCE_HOST_DISPLAY_NAME || "").trim() || "Codex subscription host";
       let displayNameExplicit = Boolean(String(env.VTX_INFERENCE_HOST_DISPLAY_NAME || "").trim());
       let adapter = null;
@@ -32657,6 +33297,7 @@ Durable service:
       let waitSeconds = 50;
       let lines = 100;
       let serviceManifestPath = null;
+      let forceRecovery = false;
       const positionals = [];
       for (let index = 0; index < argv2.length; index += 1) {
         const argument = argv2[index];
@@ -32668,6 +33309,10 @@ Durable service:
           once = true;
           continue;
         }
+        if (argument === "--force-recovery") {
+          forceRecovery = true;
+          continue;
+        }
         if (argument === "--max-concurrency") {
           const raw = argv2[index + 1];
           if (!raw) throw new Error("--max-concurrency requires a value.");
@@ -32706,6 +33351,7 @@ Durable service:
           if (argument === "--instance") {
             instanceName = raw.trim();
             instanceExplicit = true;
+            instanceFlagExplicit = true;
           }
           index += 1;
           continue;
@@ -32728,6 +33374,8 @@ Durable service:
       }
       if (command === "agent-connect" && !displayNameExplicit) {
         displayName = "Agent-driven inference host";
+      } else if (adapter && isDurableInferenceAdapterId(adapter) && !displayNameExplicit) {
+        displayName = `${durableAdapterDisplayName(adapter)} subscription host`;
       }
       return {
         command,
@@ -32736,6 +33384,7 @@ Durable service:
         maxConcurrency,
         instanceName,
         instanceExplicit,
+        instanceFlagExplicit,
         displayName,
         adapter,
         modelId,
@@ -32744,13 +33393,14 @@ Durable service:
         waitSeconds,
         lines,
         serviceAction,
-        serviceManifestPath
+        serviceManifestPath,
+        forceRecovery
       };
     };
     defaultOpenBrowser = (url2) => {
       const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
       const args = process.platform === "win32" ? ["/c", "start", "", url2] : [url2];
-      const child = spawn6(command, args, {
+      const child = spawn7(command, args, {
         detached: true,
         stdio: "ignore",
         windowsHide: true
@@ -32870,7 +33520,7 @@ Durable service:
       return raw !== null;
     };
     inspectCodexAuthentication = async (config2) => {
-      const path = join6(config2.codexHomePath, "auth.json");
+      const path = join7(config2.codexHomePath, "auth.json");
       try {
         const before = await lstat4(path);
         const canonical = await realpath4(path);
@@ -32888,7 +33538,7 @@ Durable service:
         runtimeReceiptPath(config2),
         "Inference host runtime receipt file"
       );
-      await rm5(codexGuardianReceiptRoot(config2), { recursive: true, force: true });
+      await rm6(codexGuardianReceiptRoot(config2), { recursive: true, force: true });
       await clearInferencePrivateFile(
         codexRecoveryPath(config2),
         "Codex attempt recovery file"
@@ -32914,10 +33564,14 @@ Durable service:
         codexRecoveryPath(config2),
         "Codex attempt recovery file"
       );
+      const serviceRecoveryPresent = await fileExistsPrivately(
+        `${config2.supervisorStatePath}.service-recovery.json`,
+        "Inference-host service recovery transaction"
+      );
       const revocationCheckpointPresent = await readRevocationCheckpoint(config2) !== null;
       const agentAttemptPresent = await readInferenceAgentAttemptState(config2.statePath) !== null;
       const agentNextRecoveryPresent = await readInferenceAgentNextState(config2.statePath) !== null;
-      if (pendingAttempts > 0 || codexRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent) {
+      if (pendingAttempts > 0 || codexRecoveryPresent || serviceRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent) {
         throw new Error(
           "Inference host logout refused because attempt recovery is still pending (Codex, agent-driven, or revocation recovery). Rerun agent-next, complete or fail the active attempt, run the automated host to reconcile it, or resume revoke."
         );
@@ -32966,6 +33620,49 @@ Durable service:
         signal: options.signal
       }).run();
     };
+    preparePortableDurableAdapter = async (adapterId, signal) => {
+      const adapter = new CopilotSubscriptionAdapter();
+      return { adapter, preflight: await adapter.preflight(signal) };
+    };
+    defaultRunPortableDurableAdapter = async (options) => {
+      const dependencies = createDefaultInferenceHostRunnerDependencies({
+        apiUrl: options.config.apiUrl,
+        statePath: options.config.statePath,
+        processLockPath: options.config.processLockPath,
+        credentialStore: options.credentialStore,
+        codexAdapter: options.adapter,
+        envelopePublicKey: (credential) => externalInferenceEnvelopePublicKey(credential.x25519_private_key),
+        clientVersion: INFERENCE_HOST_CLI_VERSION,
+        runtimeReceiptPath: runtimeReceiptPath(options.config)
+      });
+      const borrowedProcessLock = {
+        path: options.processLock.path,
+        ownerToken: options.processLock.ownerToken,
+        release: async () => void 0
+      };
+      return await new InferenceHostRunner({
+        ...dependencies,
+        acquireProcessLock: async () => borrowedProcessLock
+      }, {
+        adapterId: options.preflight.adapterId,
+        usageSource: options.preflight.adapterId,
+        structuredOutput: false,
+        sameAttemptRecovery: options.preflight.sameAttemptRecovery,
+        instanceName: options.config.instanceName,
+        displayName: options.displayName,
+        authenticatedAccountIdentity: options.preflight.authenticatedAccountIdentity,
+        authenticatedAccountEmail: options.preflight.authenticatedAccountEmail,
+        authenticatedAccountPlan: options.preflight.authenticatedAccountPlan,
+        codexRateLimits: options.preflight.rateLimits,
+        codexModelCapabilities: options.preflight.modelCapabilities,
+        protocolVersion: EXTERNAL_INFERENCE_CONTRACT_VERSION,
+        adapterRuntimeVersion: options.preflight.runtimeVersion,
+        maxConcurrency: options.maxConcurrency,
+        once: options.once,
+        emitDiagnosticEvent: options.emitDiagnosticEvent,
+        signal: options.signal
+      }).run();
+    };
     login = async (config2, parsed, env, dependencies, warnings) => {
       const credentialLock = await acquireInferenceHostProcessLock(
         credentialLifecycleLockPath(config2)
@@ -33232,6 +33929,10 @@ Waiting for approval...
         codexRecoveryPath(config2),
         "Codex attempt recovery file"
       );
+      const serviceRecoveryPresent = await fileExistsPrivately(
+        `${config2.supervisorStatePath}.service-recovery.json`,
+        "Inference-host service recovery transaction"
+      );
       const agentAttempt = await readInferenceAgentAttemptState(config2.statePath);
       const agentNextRecoveryPresent = await readInferenceAgentNextState(config2.statePath) !== null;
       return {
@@ -33260,6 +33961,7 @@ Waiting for approval...
           } : null,
           agent_next_recovery_present: agentNextRecoveryPresent,
           codex_recovery_present: recoveryPresent,
+          service_recovery_present: serviceRecoveryPresent,
           codex_auth: codexAuthentication,
           source: "local_only"
         }, parsed.json),
@@ -33308,6 +34010,35 @@ Waiting for approval...
           detail: error48 instanceof Error ? error48.message : "unavailable"
         });
       }
+      const adapterId = parsed.adapter ?? "codex";
+      if (!isDurableInferenceAdapterId(adapterId)) {
+        checks.push({ name: "provider_runtime", ok: false, detail: "unsupported-adapter" });
+      } else if (adapterId !== "codex") {
+        try {
+          const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
+            adapterId
+          );
+          checks.push({
+            name: "provider_runtime",
+            ok: true,
+            detail: `${adapterId}:${prepared.preflight.runtimeVersion}:${prepared.preflight.modelCapabilities.length}-models`
+          });
+          await prepared.adapter.close?.();
+        } catch (error48) {
+          checks.push({
+            name: "provider_runtime",
+            ok: false,
+            detail: error48 instanceof Error ? error48.message : "unavailable"
+          });
+        }
+        const healthy2 = checks.every((check2) => check2.ok);
+        return {
+          exitCode: healthy2 ? 0 : 1,
+          stdout: render({ healthy: healthy2, adapter: adapterId, checks, source: "local_only" }, parsed.json),
+          stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+        };
+      }
       try {
         const binary = await (dependencies.resolveBinary ?? resolvePinnedCodexBinary)(env);
         checks.push({
@@ -33524,6 +34255,37 @@ Waiting for approval...
         if (await store.readRecovery?.()) {
           throw new Error("Inference host credential recovery is required before the runner can start.");
         }
+        const adapterId = parsed.adapter ?? "codex";
+        if (!isDurableInferenceAdapterId(adapterId)) {
+          throw new Error(`Adapter ${adapterId} does not have a supported durable integration.`);
+        }
+        const emitDiagnosticEvent = parsed.json ? (event) => (dependencies.emitStdout ?? ((text) => {
+          process.stdout.write(text);
+        }))(`${JSON.stringify(event)}
+`) : void 0;
+        if (adapterId !== "codex") {
+          const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
+            adapterId,
+            cancellation.signal
+          );
+          const summary = await (dependencies.runPortableDurableAdapter ?? defaultRunPortableDurableAdapter)({
+            config: config2,
+            credentialStore: store,
+            ...prepared,
+            displayName: parsed.displayName,
+            maxConcurrency: parsed.maxConcurrency,
+            once: parsed.once,
+            processLock,
+            emitDiagnosticEvent,
+            signal: cancellation.signal
+          });
+          return {
+            exitCode: 0,
+            stdout: render({ status: "stopped", ...summary }, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
         const verifiedBinary = await (dependencies.resolveBinary ?? resolvePinnedCodexBinary)(env);
         cancellation.signal.throwIfAborted();
         await reconcileCodexAttemptRecovery({
@@ -33554,10 +34316,7 @@ Waiting for approval...
             once: parsed.once,
             env,
             processLock,
-            emitDiagnosticEvent: parsed.json ? (event) => (dependencies.emitStdout ?? ((text) => {
-              process.stdout.write(text);
-            }))(`${JSON.stringify(event)}
-`) : void 0,
+            emitDiagnosticEvent,
             signal: cancellation.signal
           });
           return {
@@ -34016,10 +34775,303 @@ Waiting for approval...
         await lock2.release();
       }
     };
+    recoveryBackupPath = (config2, transactionId) => `${codexRecoveryPath(config2)}.service-recovery-${transactionId}.backup`;
+    serviceRecoveryTransactionPath = (config2) => `${config2.supervisorStatePath}.service-recovery.json`;
+    readServiceRecoveryTransaction = async (config2) => {
+      const raw = await readInferencePrivateFile(
+        serviceRecoveryTransactionPath(config2),
+        "Inference-host service recovery transaction"
+      );
+      if (raw === null) return null;
+      let value;
+      try {
+        value = JSON.parse(raw);
+      } catch {
+        throw new Error("Inference-host service recovery transaction is not valid JSON.");
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Inference-host service recovery transaction is invalid.");
+      }
+      const record2 = value;
+      const exactKeys = [
+        "schema_version",
+        "phase",
+        "transaction_id",
+        "instance_name",
+        "manifest_generation",
+        "restore_desired_running",
+        "recovery_backup_path",
+        "recovery_backup_sha256",
+        "cleanup_confirmed_attempt_ids",
+        "started_at"
+      ];
+      if (Object.keys(record2).sort().join("\0") !== exactKeys.sort().join("\0") || record2.schema_version !== "vtx_inference_service_recovery_v1" || record2.phase !== "prepared" && record2.phase !== "reconciled" || typeof record2.transaction_id !== "string" || !/^[0-9a-f-]{36}$/u.test(record2.transaction_id) || typeof record2.instance_name !== "string" || typeof record2.manifest_generation !== "string" || typeof record2.restore_desired_running !== "boolean" || typeof record2.recovery_backup_path !== "string" || typeof record2.recovery_backup_sha256 !== "string" || !/^[0-9a-f]{64}$/u.test(record2.recovery_backup_sha256) || !Array.isArray(record2.cleanup_confirmed_attempt_ids) || record2.cleanup_confirmed_attempt_ids.some(
+        (attemptId) => typeof attemptId !== "string" || attemptId.length < 1 || attemptId.length > 256
+      ) || new Set(record2.cleanup_confirmed_attempt_ids).size !== record2.cleanup_confirmed_attempt_ids.length || [...record2.cleanup_confirmed_attempt_ids].sort().join("\0") !== record2.cleanup_confirmed_attempt_ids.join("\0") || typeof record2.started_at !== "string" || !Number.isFinite(Date.parse(record2.started_at)) || new Date(record2.started_at).toISOString() !== record2.started_at) {
+        throw new Error("Inference-host service recovery transaction is invalid.");
+      }
+      if (resolve5(record2.recovery_backup_path) !== resolve5(recoveryBackupPath(config2, record2.transaction_id))) {
+        throw new Error("Inference-host service recovery backup path is invalid.");
+      }
+      return record2;
+    };
+    assertResumableCodexRecoveryEvidence = (backupAttempts, currentAttempts, cleanupConfirmedAttemptIds, phase) => {
+      const backupIds = Object.keys(backupAttempts).sort();
+      const currentIds = Object.keys(currentAttempts).sort();
+      const backupIdSet = new Set(backupIds);
+      const cleanupConfirmedIdSet = new Set(cleanupConfirmedAttemptIds);
+      if (backupIds.length === 0 || currentIds.some((attemptId) => !backupIdSet.has(attemptId)) || cleanupConfirmedAttemptIds.some((attemptId) => !backupIdSet.has(attemptId)) || phase === "reconciled" && backupIds.some((attemptId) => !cleanupConfirmedIdSet.has(attemptId))) {
+        throw new Error("Codex recovery evidence does not match the retained service recovery backup.");
+      }
+      for (const attemptId of backupIds) {
+        const original = backupAttempts[attemptId];
+        const current = currentAttempts[attemptId];
+        if (!current) {
+          if (!cleanupConfirmedIdSet.has(attemptId)) {
+            throw new Error("Codex recovery evidence does not match the retained service recovery backup.");
+          }
+          continue;
+        }
+        if (cleanupConfirmedIdSet.has(attemptId) && !original.cleanupConfirmed && !(current.processState === "terminated" && current.cleanupConfirmed)) {
+          throw new Error("Codex recovery evidence regressed after confirmed cleanup.");
+        }
+        const {
+          processState: _originalProcessState,
+          cleanupConfirmed: _originalCleanupConfirmed,
+          ...originalStable
+        } = original;
+        const {
+          processState: _currentProcessState,
+          cleanupConfirmed: _currentCleanupConfirmed,
+          ...currentStable
+        } = current;
+        if (JSON.stringify(originalStable) !== JSON.stringify(currentStable) || !(current.processState === original.processState && current.cleanupConfirmed === original.cleanupConfirmed) && !(current.processState === "terminated" && current.cleanupConfirmed)) {
+          throw new Error("Codex recovery evidence changed outside an exact cleanup transition.");
+        }
+      }
+    };
+    recoverInstalledCodexService = async (config2, parsed, env, dependencies, manager) => {
+      if (!parsed.instanceFlagExplicit) {
+        throw new Error(
+          "Service recovery requires an explicit --instance NAME; an environment or default instance is not accepted."
+        );
+      }
+      if (!parsed.forceRecovery) {
+        throw new Error(
+          `Service recovery is disruptive. Rerun with --instance ${config2.instanceName} --force-recovery after checking service status and logs.`
+        );
+      }
+      const credentialLock = await acquireInferenceHostProcessLock(
+        credentialLifecycleLockPath(config2)
+      );
+      try {
+        const installedManifest = await readInferenceHostServiceManifest(
+          `${config2.supervisorStatePath}.service.json`
+        );
+        const installedWorker = installedManifest?.workers.find(
+          (worker) => worker.instance_name === config2.instanceName
+        );
+        if (installedWorker && installedWorker.adapter !== "codex") {
+          throw new Error(
+            `Guarded same-attempt recovery is not supported for ${installedWorker.adapter}; interrupted attempts remain quarantined as outcome_unknown.`
+          );
+        }
+        const recoveryStore = new FileCodexAttemptRecoveryStore(codexRecoveryPath(config2));
+        const existingTransaction = await readServiceRecoveryTransaction(config2);
+        if (existingTransaction && existingTransaction.instance_name !== config2.instanceName) {
+          throw new Error(
+            `Service recovery for instance ${existingTransaction.instance_name} must finish before another instance can recover.`
+          );
+        }
+        const initialAttempts = await recoveryStore.loadAll();
+        const pendingAttempts = Object.values(initialAttempts).filter(
+          (checkpoint) => !checkpoint.cleanupConfirmed
+        );
+        if (pendingAttempts.length === 0 && !existingTransaction) {
+          const status = await manager.status();
+          return {
+            exitCode: 0,
+            stdout: render({
+              status: "service_recovery_not_needed",
+              instance_name: config2.instanceName,
+              recovery_needed: false,
+              recovered_attempt_count: 0,
+              outcome_unknown_attempt_count: 0,
+              desired_running: status.desired_running,
+              manager_active: status.manager_active,
+              worker_runtime_state: status.workers.find(
+                (worker) => worker.instance_name === config2.instanceName
+              )?.runtime_state ?? "unknown"
+            }, parsed.json),
+            stderr: ""
+          };
+        }
+        const recoveryRaw = await readInferencePrivateFile(
+          codexRecoveryPath(config2),
+          "Codex attempt recovery file"
+        );
+        if (recoveryRaw === null && existingTransaction?.phase !== "reconciled") {
+          throw new Error("Codex recovery evidence changed before service recovery began.");
+        }
+        const transactionId = existingTransaction?.transaction_id ?? randomUUID2();
+        const backupPath = existingTransaction?.recovery_backup_path ?? recoveryBackupPath(config2, transactionId);
+        if (!existingTransaction) {
+          await writeAtomicInferencePrivateFile(backupPath, recoveryRaw);
+        }
+        const backupRaw = await readInferencePrivateFile(
+          backupPath,
+          "Codex service recovery backup"
+        );
+        const backupSha256 = backupRaw === null ? null : createHash7("sha256").update(backupRaw).digest("hex");
+        if (backupSha256 === null || existingTransaction && backupSha256 !== existingTransaction.recovery_backup_sha256) {
+          throw new Error("Codex service recovery backup is missing or changed.");
+        }
+        const backupAttempts = await new FileCodexAttemptRecoveryStore(backupPath).loadAll();
+        assertResumableCodexRecoveryEvidence(
+          backupAttempts,
+          initialAttempts,
+          existingTransaction?.cleanup_confirmed_attempt_ids ?? [],
+          existingTransaction?.phase ?? "prepared"
+        );
+        const recoverySha256 = recoveryRaw === null ? null : createHash7("sha256").update(recoveryRaw).digest("hex");
+        const unresolvedAttemptIds = Object.keys(backupAttempts).filter((attemptId) => !existingTransaction?.cleanup_confirmed_attempt_ids.includes(attemptId) && !initialAttempts[attemptId]?.cleanupConfirmed);
+        const binary = unresolvedAttemptIds.length > 0 ? await (dependencies.resolveBinary ?? resolvePinnedCodexBinary)(env) : null;
+        let activeTransaction = existingTransaction;
+        let completed = false;
+        try {
+          const recovered = await manager.recoverInstance(config2.instanceName, async ({ manifest }) => {
+            const workerLocks = [];
+            try {
+              for (const worker of [...manifest.workers].sort(
+                (left, right) => left.instance_name.localeCompare(right.instance_name)
+              )) {
+                const workerConfig = resolveInferenceHostConfig({
+                  ...env,
+                  ...worker.runtime_environment,
+                  VTX_INFERENCE_HOST_INSTANCE: worker.instance_name
+                });
+                workerLocks.push(await acquireInferenceHostProcessLock(
+                  foregroundHostLockPath(workerConfig)
+                ));
+                workerLocks.push(await acquireInferenceHostProcessLock(workerConfig.processLockPath));
+              }
+              try {
+                if (!activeTransaction) {
+                  throw new Error("Inference-host service recovery transaction was not prepared.");
+                }
+                const attempts = await recoveryStore.loadAll();
+                assertResumableCodexRecoveryEvidence(
+                  backupAttempts,
+                  attempts,
+                  activeTransaction.cleanup_confirmed_attempt_ids,
+                  activeTransaction.phase
+                );
+                const unresolved = Object.keys(backupAttempts).filter((attemptId) => !activeTransaction.cleanup_confirmed_attempt_ids.includes(attemptId) && !attempts[attemptId]?.cleanupConfirmed);
+                if (unresolved.length === 0) return 0;
+                const currentRaw = await readInferencePrivateFile(
+                  codexRecoveryPath(config2),
+                  "Codex attempt recovery file"
+                );
+                if (currentRaw === null || recoverySha256 === null || createHash7("sha256").update(currentRaw).digest("hex") !== recoverySha256) {
+                  throw new Error("Codex recovery evidence changed while the service was stopping.");
+                }
+                const proof = await (dependencies.proveCodexQuiescence ?? proveCodexSameBootQuiescence)({
+                  attempts,
+                  confirmNoManagedCodexProcesses: async () => await (dependencies.confirmNoManagedCodexProcesses ?? confirmNoVtxManagedCodexProcesses)({ pinnedBinaryPath: binary.path })
+                });
+                return await (dependencies.reconcileCodexRecovery ?? reconcileCodexAttemptRecovery)({
+                  recoveryHooks: recoveryStore,
+                  codexHome: config2.codexHomePath,
+                  guardianReceiptRoot: codexGuardianReceiptRoot(config2),
+                  sameBootQuiescenceProof: proof
+                });
+              } finally {
+                if (!activeTransaction) {
+                  throw new Error("Inference-host service recovery transaction was not prepared.");
+                }
+                const progressedAttempts = await recoveryStore.loadAll();
+                assertResumableCodexRecoveryEvidence(
+                  backupAttempts,
+                  progressedAttempts,
+                  activeTransaction.cleanup_confirmed_attempt_ids,
+                  activeTransaction.phase
+                );
+                const priorConfirmedIds = new Set(activeTransaction.cleanup_confirmed_attempt_ids);
+                const cleanupConfirmedAttemptIds = Object.keys(backupAttempts).filter((attemptId) => priorConfirmedIds.has(attemptId) || progressedAttempts[attemptId]?.cleanupConfirmed).sort();
+                activeTransaction = {
+                  ...activeTransaction,
+                  phase: cleanupConfirmedAttemptIds.length === Object.keys(backupAttempts).length ? "reconciled" : "prepared",
+                  cleanup_confirmed_attempt_ids: cleanupConfirmedAttemptIds
+                };
+                await writeAtomicInferencePrivateFile(
+                  serviceRecoveryTransactionPath(config2),
+                  `${JSON.stringify(activeTransaction, null, 2)}
+`
+                );
+              }
+            } finally {
+              for (const lock2 of workerLocks.reverse()) await lock2.release();
+            }
+          }, {
+            restoreDesiredRunning: existingTransaction?.restore_desired_running,
+            expectedManifestGeneration: existingTransaction?.manifest_generation,
+            prepare: existingTransaction ? void 0 : async ({ manifest, desiredRunning }) => {
+              activeTransaction = {
+                schema_version: "vtx_inference_service_recovery_v1",
+                phase: "prepared",
+                transaction_id: transactionId,
+                instance_name: config2.instanceName,
+                manifest_generation: manifest.generation,
+                restore_desired_running: desiredRunning,
+                recovery_backup_path: backupPath,
+                recovery_backup_sha256: backupSha256,
+                cleanup_confirmed_attempt_ids: [],
+                started_at: (/* @__PURE__ */ new Date()).toISOString()
+              };
+              await writeAtomicInferencePrivateFile(
+                serviceRecoveryTransactionPath(config2),
+                `${JSON.stringify(activeTransaction, null, 2)}
+`
+              );
+            }
+          });
+          completed = true;
+          const outcomeUnknownAttemptCount = Object.values(backupAttempts).filter(
+            (checkpoint) => checkpoint.dispatchOutcome === "outcome_unknown"
+          ).length;
+          return {
+            exitCode: 0,
+            stdout: render({
+              status: "service_recovered",
+              instance_name: config2.instanceName,
+              recovery_needed: true,
+              recovered_attempt_count: recovered.result,
+              outcome_unknown_attempt_count: outcomeUnknownAttemptCount,
+              desired_running: recovered.status.desired_running,
+              manager_active: recovered.status.manager_active,
+              worker_runtime_state: recovered.status.workers.find(
+                (worker) => worker.instance_name === config2.instanceName
+              )?.runtime_state ?? "unknown"
+            }, parsed.json),
+            stderr: ""
+          };
+        } finally {
+          if (completed) {
+            await clearInferencePrivateFile(
+              serviceRecoveryTransactionPath(config2),
+              "Inference-host service recovery transaction"
+            );
+            await rm6(backupPath, { force: true });
+          }
+        }
+      } finally {
+        await credentialLock.release();
+      }
+    };
     serviceCommand = async (config2, parsed, env, dependencies, warnings) => {
       const action = parsed.serviceAction;
       if (!action) {
-        throw new Error("Usage: vtx inference-host service <install|start|stop|status|logs|uninstall>.");
+        throw new Error("Usage: vtx inference-host service <install|start|stop|status|logs|recover|uninstall>.");
       }
       if (action === "run-internal") {
         if (!parsed.serviceManifestPath) throw new Error("Internal service manifest path is required.");
@@ -34046,17 +35098,34 @@ Waiting for approval...
           await serviceLock.release();
         }
       }
+      if (parsed.forceRecovery && action !== "recover") {
+        throw new Error("--force-recovery is accepted only by service recover.");
+      }
       const manager = dependencies.createServiceManager?.(
         config2,
         dependencies.serviceDependencies
       ) ?? new InferenceHostServiceManager(config2, dependencies.serviceDependencies);
+      if (action === "recover") {
+        return await recoverInstalledCodexService(
+          config2,
+          parsed,
+          env,
+          dependencies,
+          manager
+        );
+      }
       if (action === "install") {
         const credentialLock = await acquireInferenceHostProcessLock(
           credentialLifecycleLockPath(config2)
         );
         try {
+          if (await readServiceRecoveryTransaction(config2)) {
+            throw new Error(
+              "A guarded service recovery transaction must finish before installing a subscription."
+            );
+          }
           const adapter = parsed.adapter || "codex";
-          if (adapter !== "codex") {
+          if (!isDurableInferenceAdapterId(adapter)) {
             throw new Error(
               `Adapter ${adapter} does not have a supported durable service integration. Use foreground agent-run instead.`
             );
@@ -34068,7 +35137,31 @@ Waiting for approval...
           if (!credential) throw new Error("Inference-host credential is missing. Run login again.");
           assertCredentialMatchesState2(state, credential);
           if (parsed.modelId || parsed.modelLabel || parsed.reasoningEffort) {
-            throw new Error("Automated Codex service does not accept agent model or effort options.");
+            throw new Error("Durable services discover their exact model and effort catalog from the authenticated runtime.");
+          }
+          if (adapter !== "codex") {
+            const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
+              adapter
+            );
+            try {
+              const status2 = await manager.install({
+                adapter,
+                displayName: parsed.displayName,
+                maxConcurrency: parsed.maxConcurrency,
+                authenticatedAccountIdentity: prepared.preflight.authenticatedAccountIdentity,
+                authenticatedAccountEmail: prepared.preflight.authenticatedAccountEmail,
+                authenticatedAccountPlan: prepared.preflight.authenticatedAccountPlan
+              });
+              await writeInferenceHostCredentialContext(config2);
+              return {
+                exitCode: 0,
+                stdout: render({ status: "service_installed", ...status2 }, parsed.json),
+                stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+              };
+            } finally {
+              await prepared.adapter.close?.();
+            }
           }
           const auth = await inspectCodexAuthentication(config2);
           if (!auth.present || !auth.private) {
@@ -34112,9 +35205,15 @@ Waiting for approval...
         };
       }
       if (action === "start") {
+        if (await readServiceRecoveryTransaction(config2)) {
+          throw new Error("A guarded service recovery transaction must finish before starting the service.");
+        }
         return { exitCode: 0, stdout: render({ status: "service_started", ...await manager.start() }, parsed.json), stderr: "" };
       }
       if (action === "stop") {
+        if (await readServiceRecoveryTransaction(config2)) {
+          throw new Error("A guarded service recovery transaction must finish before stopping the service.");
+        }
         return { exitCode: 0, stdout: render({ status: "service_stopped", ...await manager.stop() }, parsed.json), stderr: "" };
       }
       if (action === "status") {
@@ -34127,6 +35226,11 @@ Waiting for approval...
           credentialLifecycleLockPath(config2)
         );
         try {
+          if (await readServiceRecoveryTransaction(config2)) {
+            throw new Error(
+              "A guarded service recovery transaction must finish before uninstalling a subscription."
+            );
+          }
           if (parsed.instanceExplicit) {
             const retained = await readInferenceHostCredentialContext(config2);
             const retainedIdentity = retained ? resolveInferenceHostConfig({
@@ -34145,7 +35249,7 @@ Waiting for approval...
           await credentialLock.release();
         }
       }
-      throw new Error("Usage: vtx inference-host service <install|start|stop|status|logs|uninstall>.");
+      throw new Error("Usage: vtx inference-host service <install|start|stop|status|logs|recover|uninstall>.");
     };
     hasExplicitCredentialStoreConfiguration = (env) => Boolean(
       String(env.VTX_INFERENCE_HOST_CREDENTIAL_STORE || "").trim() || String(env.VTX_INFERENCE_HOST_CREDENTIAL_FILE || "").trim()
@@ -34167,8 +35271,8 @@ Waiting for approval...
       }
       throw new Error("Inference host credential store identity is invalid.");
     };
-    commandRequiresRetainedCredentialStore = (parsed) => parsed.command === "logout" || parsed.command === "revoke" || parsed.command === "service" && parsed.instanceExplicit && (parsed.serviceAction === "install" || parsed.serviceAction === "uninstall");
-    commandUsesInstalledServiceCredentials = (parsed) => parsed.command === "login" || parsed.command === "logout" || parsed.command === "revoke" || parsed.command === "status" || parsed.command === "doctor" || parsed.command === "service" && parsed.serviceAction === "install" || parsed.command === "service" && parsed.serviceAction === "uninstall" && parsed.instanceExplicit;
+    commandRequiresRetainedCredentialStore = (parsed) => parsed.command === "logout" || parsed.command === "revoke" || parsed.command === "service" && parsed.instanceExplicit && (parsed.serviceAction === "install" || parsed.serviceAction === "recover" || parsed.serviceAction === "uninstall");
+    commandUsesInstalledServiceCredentials = (parsed) => parsed.command === "login" || parsed.command === "logout" || parsed.command === "revoke" || parsed.command === "status" || parsed.command === "doctor" || parsed.command === "service" && parsed.serviceAction === "install" || parsed.command === "service" && parsed.serviceAction === "recover" || parsed.command === "service" && parsed.serviceAction === "uninstall" && parsed.instanceExplicit;
     resolveInferenceHostCommandConfig = async (parsed, env, dependencies) => {
       const selectedEnv = {
         ...env,
@@ -34191,6 +35295,9 @@ Waiting for approval...
       const installedEnvironment = manifest?.workers.find(
         (worker) => worker.instance_name === baseConfig.instanceName
       )?.runtime_environment;
+      if (parsed.command === "service" && parsed.serviceAction === "recover" && !installedEnvironment) {
+        throw new Error(`Inference-host instance ${baseConfig.instanceName} is not installed.`);
+      }
       const persistedContext = installedEnvironment ? null : await readInferenceHostCredentialContext(baseConfig);
       const revocationCheckpoint = !installedEnvironment && !persistedContext && parsed.command === "revoke" ? await readRevocationCheckpoint(baseConfig) : null;
       const retainedEnvironment = installedEnvironment ?? (persistedContext ? {
@@ -34221,11 +35328,11 @@ Waiting for approval...
 });
 
 // lib/agent-core/config.ts
-import { mkdir as mkdir5, readFile as readFile6, rm as rm6, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname5, join as join7 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile6, rm as rm7, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname5, join as join8 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function defaultBaseDir() {
-  return join7(homedir3(), ".vtx");
+  return join8(homedir3(), ".vtx");
 }
 function resolveAgentCliConfig(env = process.env) {
   const baseDir = String(env.VTX_HOME || "").trim() || defaultBaseDir();
@@ -34233,8 +35340,8 @@ function resolveAgentCliConfig(env = process.env) {
   const parsedProfile = rawProfile ? Number(rawProfile) : NaN;
   return {
     apiUrl: String(env.VTX_API_URL || "http://localhost:8000").replace(/\/+$/, ""),
-    tokenPath: String(env.VTX_TOKEN_PATH || "").trim() || join7(baseDir, "token.json"),
-    statePath: String(env.VTX_RUNTIME_STATE_PATH || "").trim() || join7(baseDir, "runtime-state.json"),
+    tokenPath: String(env.VTX_TOKEN_PATH || "").trim() || join8(baseDir, "token.json"),
+    statePath: String(env.VTX_RUNTIME_STATE_PATH || "").trim() || join8(baseDir, "runtime-state.json"),
     runtimeDeviceId: String(env.VTX_RUNTIME_DEVICE_ID || "").trim() || null,
     activeProfileId: Number.isFinite(parsedProfile) && parsedProfile > 0 ? parsedProfile : null,
     outputJson: String(env.VTX_OUTPUT || "").trim().toLowerCase() === "json"
@@ -34265,7 +35372,7 @@ async function writeStoredAgentAuth(path, auth) {
 `, { encoding: "utf8", mode: 384 });
 }
 async function clearStoredAgentAuth(path) {
-  await rm6(path, { force: true });
+  await rm7(path, { force: true });
 }
 async function readRuntimeState(path) {
   try {
@@ -34298,7 +35405,7 @@ async function writeRuntimeState(path, state) {
 `, { encoding: "utf8", mode: 384 });
 }
 async function clearRuntimeState(path) {
-  await rm6(path, { force: true });
+  await rm7(path, { force: true });
 }
 var init_config2 = __esm({
   "lib/agent-core/config.ts"() {
@@ -38718,7 +39825,7 @@ var init_utils = __esm({
 });
 
 // node_modules/ethers/lib.esm/crypto/crypto.js
-import { createHash as createHash6, createHmac, pbkdf2Sync, randomBytes as randomBytes5 } from "crypto";
+import { createHash as createHash8, createHmac, pbkdf2Sync, randomBytes as randomBytes5 } from "crypto";
 var init_crypto2 = __esm({
   "node_modules/ethers/lib.esm/crypto/crypto.js"() {
   }
@@ -39932,10 +41039,10 @@ var init_sha22 = __esm({
     init_crypto2();
     init_utils();
     _sha256 = function(data) {
-      return createHash6("sha256").update(data).digest();
+      return createHash8("sha256").update(data).digest();
     };
     _sha512 = function(data) {
-      return createHash6("sha512").update(data).digest();
+      return createHash8("sha512").update(data).digest();
     };
     __sha256 = _sha256;
     __sha512 = _sha512;
@@ -52112,7 +53219,7 @@ __export(vtx_exports, {
   runVtxCli: () => runVtxCli
 });
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 function render2(value, json2) {
   if (json2) {
     return `${JSON.stringify(value, null, 2)}
@@ -52142,7 +53249,7 @@ function openBrowser(url2) {
   const platform = process.platform;
   const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
   const args = platform === "win32" ? ["/c", "start", "", url2] : [url2];
-  const child = spawn7(command, args, { detached: true, stdio: "ignore" });
+  const child = spawn8(command, args, { detached: true, stdio: "ignore" });
   child.unref();
 }
 function parseFlags(args) {