@vtxmacro/cli 2026.8.53 → 2026.8.54

package/bin/vtx.js

@@ -47,13 +47,67 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.8.53",
+      package_version: "2026.8.54",
       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",
+      deepseek_harness_version: "0.1.1-rc.2",
+      deepseek_harness_packages: [
+        "@deepseek-ai/dsh-agent",
+        "@deepseek-ai/dsh-agent-instructions",
+        "@deepseek-ai/dsh-agent-loop",
+        "@deepseek-ai/dsh-agent-spine-demo",
+        "@deepseek-ai/dsh-anonymous-user-id",
+        "@deepseek-ai/dsh-atomic-write",
+        "@deepseek-ai/dsh-attachment",
+        "@deepseek-ai/dsh-brand",
+        "@deepseek-ai/dsh-code-runtime",
+        "@deepseek-ai/dsh-credentials",
+        "@deepseek-ai/dsh-fs",
+        "@deepseek-ai/dsh-goal",
+        "@deepseek-ai/dsh-goal-round-driver",
+        "@deepseek-ai/dsh-home-paths",
+        "@deepseek-ai/dsh-invariants",
+        "@deepseek-ai/dsh-jobs",
+        "@deepseek-ai/dsh-jobs-local",
+        "@deepseek-ai/dsh-launch-environment",
+        "@deepseek-ai/dsh-llm",
+        "@deepseek-ai/dsh-llm-deepseek",
+        "@deepseek-ai/dsh-llm-retry",
+        "@deepseek-ai/dsh-output-retention",
+        "@deepseek-ai/dsh-sandbox",
+        "@deepseek-ai/dsh-sandbox-policy",
+        "@deepseek-ai/dsh-scope",
+        "@deepseek-ai/dsh-session",
+        "@deepseek-ai/dsh-session-checkpoint-policy",
+        "@deepseek-ai/dsh-session-persistence",
+        "@deepseek-ai/dsh-session-persistence-jsonl",
+        "@deepseek-ai/dsh-session-projection",
+        "@deepseek-ai/dsh-session-title",
+        "@deepseek-ai/dsh-settings",
+        "@deepseek-ai/dsh-shell",
+        "@deepseek-ai/dsh-shell-env",
+        "@deepseek-ai/dsh-skill",
+        "@deepseek-ai/dsh-skill-filesystem",
+        "@deepseek-ai/dsh-subprocess",
+        "@deepseek-ai/dsh-system-prompt",
+        "@deepseek-ai/dsh-timeout",
+        "@deepseek-ai/dsh-tool-bash",
+        "@deepseek-ai/dsh-tool-goal",
+        "@deepseek-ai/dsh-tool-jobs",
+        "@deepseek-ai/dsh-tool-skill",
+        "@deepseek-ai/dsh-tools",
+        "@deepseek-ai/dsh-typert-protocol",
+        "@deepseek-ai/dsh-user-approval"
+      ],
+      deepseek_cordis_package_name: "@deepseek-ai/cordis",
+      deepseek_cordis_version: "4.0.1",
+      deepseek_support_packages: {
+        "@deepseek-ai/cordis-plugin-timer": "1.1.3"
+      },
       platforms: {
         "linux-x64": {
           package_name: "@openai/codex-linux-x64",
@@ -19695,6 +19749,34 @@ var init_agent_client = __esm({
 });
 
 // lib/inference-host/agent-state.ts
+async function readInferenceAgentFailureFence(statePath) {
+  const raw = await readInferencePrivateFile(
+    inferenceAgentFailureFencePath(statePath),
+    "Inference Agent failure fence"
+  );
+  if (raw === null) return null;
+  try {
+    return assertInferenceAgentFailureFence(JSON.parse(raw));
+  } catch (error48) {
+    if (error48 instanceof SyntaxError) {
+      throw new Error("Inference Agent failure fence is not valid JSON.");
+    }
+    throw error48;
+  }
+}
+async function writeInferenceAgentFailureFence(statePath, value) {
+  await writeAtomicInferencePrivateFile(
+    inferenceAgentFailureFencePath(statePath),
+    `${JSON.stringify(assertInferenceAgentFailureFence(value), null, 2)}
+`
+  );
+}
+async function clearInferenceAgentFailureFence(statePath) {
+  await clearInferencePrivateFile(
+    inferenceAgentFailureFencePath(statePath),
+    "Inference Agent failure fence"
+  );
+}
 async function readInferenceAgentRuntimeState(statePath) {
   const raw = await readInferencePrivateFile(
     inferenceAgentRuntimeStatePath(statePath),
@@ -19807,7 +19889,7 @@ async function clearInferenceAgentNextState(statePath) {
     "Agent-driven inference next recovery state"
   );
 }
-var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, inferenceAgentRuntimeStatePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
+var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, inferenceAgentRuntimeStatePath, inferenceAgentFailureFencePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentFailureFence, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
 var init_agent_state = __esm({
   "lib/inference-host/agent-state.ts"() {
     "use strict";
@@ -19816,12 +19898,31 @@ var init_agent_state = __esm({
     inferenceAgentAttemptStatePath = (statePath) => `${statePath}.agent-attempt.json`;
     inferenceAgentNextStatePath = (statePath) => `${statePath}.agent-next.json`;
     inferenceAgentRuntimeStatePath = (statePath) => `${statePath}.codex-agent-runtime.json`;
+    inferenceAgentFailureFencePath = (statePath) => `${statePath}.agent-failure-fence.json`;
     isIsoTimestamp = (value) => typeof value === "string" && Number.isFinite(Date.parse(value));
     assertPlainObject = (value, message) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(message);
       return value;
     };
     hasExactKeys = (record2, keys) => Object.keys(record2).sort().join("\0") === [...keys].sort().join("\0");
+    assertInferenceAgentFailureFence = (value) => {
+      const message = "Inference Agent failure fence is invalid.";
+      const fence = assertPlainObject(value, message);
+      if (!hasExactKeys(fence, [
+        "schema_version",
+        "adapter_id",
+        "host_id",
+        "assignment_id",
+        "failure_category",
+        "failure_code",
+        "dispatch_outcome",
+        "retry_at",
+        "created_at"
+      ]) || fence.schema_version !== "vtx_inference_agent_failure_fence_v1" || typeof fence.adapter_id !== "string" || !/^[a-z0-9][a-z0-9._-]{0,63}$/u.test(fence.adapter_id) || typeof fence.host_id !== "string" || !fence.host_id || fence.assignment_id !== null && (typeof fence.assignment_id !== "string" || !fence.assignment_id) || typeof fence.failure_category !== "string" || !/^[a-z0-9][a-z0-9._-]{0,159}$/u.test(fence.failure_category) || typeof fence.failure_code !== "string" || !/^[a-z0-9][a-z0-9._-]{0,159}$/u.test(fence.failure_code) || !["not_dispatched", "confirmed_dispatched", "outcome_unknown"].includes(
+        String(fence.dispatch_outcome)
+      ) || fence.retry_at !== null && !isIsoTimestamp(fence.retry_at) || !isIsoTimestamp(fence.created_at)) throw new Error(message);
+      return fence;
+    };
     assertInferenceAgentRuntimeState = (value) => {
       const message = "Inference Agent runtime recovery state is invalid.";
       const state = assertPlainObject(value, message);
@@ -24722,6 +24823,995 @@ ${JSON.stringify(input.outputSchema)}`
   }
 });
 
+// lib/inference-host/deepseek-transport-proxy.ts
+import { createServer as createServer2 } from "node:http";
+import { randomBytes as randomBytes4 } from "node:crypto";
+var MAX_REQUEST_BYTES, DeepSeekTransportProxy;
+var init_deepseek_transport_proxy = __esm({
+  "lib/inference-host/deepseek-transport-proxy.ts"() {
+    "use strict";
+    MAX_REQUEST_BYTES = 8 * 1024 * 1024;
+    DeepSeekTransportProxy = class {
+      constructor(apiKey, expectedModel, expectedEffort, upstreamBaseUrl = "https://api.deepseek.com", fetchImpl = fetch) {
+        this.apiKey = apiKey;
+        this.expectedModel = expectedModel;
+        this.expectedEffort = expectedEffort;
+        this.upstreamBaseUrl = upstreamBaseUrl;
+        this.fetchImpl = fetchImpl;
+        this.server = null;
+        this.urlValue = null;
+        this.receiptsValue = [];
+        this.controllers = /* @__PURE__ */ new Set();
+        this.token = randomBytes4(24).toString("hex");
+        this.upstreamRequestStartedValue = false;
+        this.providerResponseObservedValue = false;
+        this.unansweredUpstreamRequestsValue = 0;
+      }
+      get baseUrl() {
+        if (!this.urlValue) throw new Error("deepseek_transport_proxy_not_started");
+        return `${this.urlValue}/${this.token}`;
+      }
+      get receipts() {
+        return [...this.receiptsValue];
+      }
+      get providerResponseObserved() {
+        return this.providerResponseObservedValue;
+      }
+      get upstreamRequestStarted() {
+        return this.upstreamRequestStartedValue;
+      }
+      get unansweredUpstreamRequest() {
+        return this.unansweredUpstreamRequestsValue > 0;
+      }
+      async start() {
+        if (this.server) return;
+        this.server = createServer2(async (request, response) => {
+          try {
+            const prefix = `/${this.token}`;
+            const requestUrl = request.url ?? "";
+            if (request.method !== "POST" || requestUrl !== `${prefix}/chat/completions`) {
+              response.writeHead(404).end();
+              return;
+            }
+            const chunks = [];
+            let requestBytes = 0;
+            for await (const chunk of request) {
+              const buffer = Buffer.from(chunk);
+              requestBytes += buffer.byteLength;
+              if (requestBytes > MAX_REQUEST_BYTES) throw new Error("deepseek_proxy_request_too_large");
+              chunks.push(buffer);
+            }
+            const body = Buffer.concat(chunks);
+            let requestedModel = "";
+            let requestedEffort = "off";
+            const payload = JSON.parse(body.toString("utf8"));
+            requestedModel = String(payload.model ?? "");
+            const thinking = payload.thinking;
+            requestedEffort = thinking?.type === "disabled" ? "off" : String(payload.reasoning_effort ?? "");
+            if (requestedModel !== this.expectedModel || requestedEffort !== this.expectedEffort) throw new Error("deepseek_outbound_model_or_effort_mismatch");
+            const controller = new AbortController();
+            this.controllers.add(controller);
+            try {
+              this.upstreamRequestStartedValue = true;
+              this.unansweredUpstreamRequestsValue += 1;
+              const upstream = await this.fetchImpl(
+                `${this.upstreamBaseUrl}/chat/completions`,
+                {
+                  method: request.method,
+                  headers: {
+                    "authorization": `Bearer ${this.apiKey}`,
+                    "content-type": String(request.headers["content-type"] ?? "application/json"),
+                    "accept": String(request.headers.accept ?? "application/json"),
+                    "user-agent": String(request.headers["user-agent"] ?? "@vtxmacro/cli")
+                  },
+                  body,
+                  signal: controller.signal
+                }
+              );
+              this.unansweredUpstreamRequestsValue -= 1;
+              this.providerResponseObservedValue = true;
+              const headers = {};
+              upstream.headers.forEach((value, name) => {
+                if (!["connection", "transfer-encoding", "content-length"].includes(name)) {
+                  headers[name] = value;
+                }
+              });
+              response.writeHead(upstream.status, headers);
+              if (!upstream.body) {
+                response.end();
+                return;
+              }
+              if (!upstream.ok) {
+                const errorReader = upstream.body.getReader();
+                while (true) {
+                  const part = await errorReader.read();
+                  if (part.done) break;
+                  response.write(Buffer.from(part.value));
+                }
+                response.end();
+                return;
+              }
+              const reader = upstream.body.getReader();
+              const decoder2 = new TextDecoder();
+              let pending = "";
+              let observedId = "";
+              let terminalObserved = false;
+              const forwardLine = (line) => {
+                if (!line.startsWith("data:")) {
+                  response.write(`${line}
+`);
+                  return;
+                }
+                const value = line.slice(5).trim();
+                if (!value) {
+                  response.write(`${line}
+`);
+                  return;
+                }
+                if (value === "[DONE]") {
+                  if (terminalObserved || !observedId) {
+                    throw new Error("deepseek_provider_receipt_missing_or_mismatched");
+                  }
+                  terminalObserved = true;
+                  this.receiptsValue.push({
+                    id: observedId,
+                    model: this.expectedModel,
+                    requestedModel,
+                    requestedReasoningEffort: requestedEffort
+                  });
+                  response.write(`${line}
+`);
+                  return;
+                }
+                const event = JSON.parse(value);
+                const eventId = typeof event.id === "string" ? event.id.trim() : "";
+                const eventModel = typeof event.model === "string" ? event.model.trim() : "";
+                if (!eventId || eventModel !== this.expectedModel || observedId && eventId !== observedId) throw new Error("deepseek_provider_receipt_missing_or_mismatched");
+                observedId = eventId;
+                response.write(`${line}
+`);
+              };
+              while (true) {
+                const part = await reader.read();
+                if (part.done) break;
+                pending += decoder2.decode(part.value, { stream: true });
+                const lines = pending.split(/\r?\n/u);
+                pending = lines.pop() ?? "";
+                for (const line of lines) forwardLine(line);
+              }
+              pending += decoder2.decode();
+              if (pending) forwardLine(pending);
+              if (!terminalObserved) {
+                throw new Error("deepseek_provider_receipt_missing_or_mismatched");
+              }
+              response.end();
+            } finally {
+              this.controllers.delete(controller);
+            }
+          } catch {
+            if (!response.headersSent) response.writeHead(502);
+            response.end();
+          }
+        });
+        await new Promise((resolve6, reject) => {
+          this.server.once("error", reject);
+          this.server.listen(0, "127.0.0.1", () => resolve6());
+        });
+        const address = this.server.address();
+        if (!address || typeof address === "string") throw new Error("deepseek_proxy_bind_failed");
+        this.urlValue = `http://127.0.0.1:${address.port}`;
+      }
+      async close() {
+        for (const controller of this.controllers) controller.abort();
+        const server = this.server;
+        this.server = null;
+        this.urlValue = null;
+        if (!server) return;
+        await new Promise((resolve6) => server.close(() => resolve6()));
+      }
+    };
+  }
+});
+
+// lib/inference-host/deepseek-harness-adapter.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdtemp as mkdtemp3, realpath as realpath4, rm as rm5 } from "node:fs/promises";
+import { tmpdir as tmpdir4 } from "node:os";
+import { basename, dirname as dirname4, join as join6 } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import * as AgentSpine from "@deepseek-ai/dsh-agent-spine-demo";
+import {
+  createUserMessage,
+  LlmError
+} from "@deepseek-ai/dsh-llm";
+import {
+  DeepSeekAdapter,
+  resolveAdapterOptions
+} from "@deepseek-ai/dsh-llm-deepseek";
+import * as LlmDeepSeek from "@deepseek-ai/dsh-llm-deepseek";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import * as SessionCheckpointPolicy from "@deepseek-ai/dsh-session-checkpoint-policy";
+import { JsonlSessionPersistence } from "@deepseek-ai/dsh-session-persistence-jsonl";
+var DEEPSEEK_HARNESS_VERSION, MAX_RESULT_BYTES2, DEEPSEEK_MODELS, DEEPSEEK_API_BASE_URL, isSupportedNodeVersion, effortForHarness, supportedEfforts, toVtxUsage, sumUsage, textFromBlocks, validateText, createDeadlineBoundary, nonDispatchedError, proxyDispatchOutcome, mapDeepSeekFailure, createPrivateWorkspace2, directAdapter, normalizeJsonValue, DeepSeekHarnessAdapter;
+var init_deepseek_harness_adapter = __esm({
+  "lib/inference-host/deepseek-harness-adapter.ts"() {
+    "use strict";
+    init_codex_app_server();
+    init_deepseek_transport_proxy();
+    DEEPSEEK_HARNESS_VERSION = "0.1.1-rc.2";
+    MAX_RESULT_BYTES2 = 3e5;
+    DEEPSEEK_MODELS = ["deepseek-v4-flash", "deepseek-v4-pro"];
+    DEEPSEEK_API_BASE_URL = "https://api.deepseek.com";
+    isSupportedNodeVersion = (version3) => {
+      const [major, minor] = version3.replace(/^v/u, "").split(".").map(Number);
+      return major === 22 && minor >= 19 || major >= 24;
+    };
+    effortForHarness = (effort) => {
+      if (effort === "none") return "off";
+      if (effort === "low" || effort === "high" || effort === "max") return effort;
+      throw new Error(`deepseek_reasoning_effort_unsupported:${effort}`);
+    };
+    supportedEfforts = (model) => model === "deepseek-v4-pro" ? ["none", "high", "max"] : ["none", "low", "high", "max"];
+    toVtxUsage = (usage) => {
+      const cacheRead = usage.cacheReadTokens ?? 0;
+      const cacheWrite = usage.cacheWriteTokens ?? 0;
+      const inclusiveInput = usage.inputTokens + cacheRead + cacheWrite;
+      return {
+        inputTokens: inclusiveInput,
+        cachedInputTokens: cacheRead,
+        outputTokens: usage.outputTokens,
+        reasoningOutputTokens: Math.min(usage.reasoningTokens ?? 0, usage.outputTokens),
+        totalTokens: inclusiveInput + usage.outputTokens,
+        cacheWriteInputTokens: usage.cacheWriteTokens ?? null,
+        cacheWriteSupported: usage.cacheWriteTokens !== void 0
+      };
+    };
+    sumUsage = (values) => toVtxUsage({
+      inputTokens: values.reduce((sum, value) => sum + value.inputTokens, 0),
+      outputTokens: values.reduce((sum, value) => sum + value.outputTokens, 0),
+      cacheReadTokens: values.reduce((sum, value) => sum + (value.cacheReadTokens ?? 0), 0),
+      cacheWriteTokens: values.some((value) => value.cacheWriteTokens !== void 0) ? values.reduce((sum, value) => sum + (value.cacheWriteTokens ?? 0), 0) : void 0,
+      reasoningTokens: values.reduce((sum, value) => sum + (value.reasoningTokens ?? 0), 0)
+    });
+    textFromBlocks = (blocks, type) => blocks.flatMap((block) => block.type === type ? [block.text] : []).join("");
+    validateText = (text, code) => {
+      if (!text.trim() || Buffer.byteLength(text, "utf8") > MAX_RESULT_BYTES2) throw new Error(code);
+      return text;
+    };
+    createDeadlineBoundary = (source, deadlineAtMs) => {
+      const controller = new AbortController();
+      const relayAbort = () => controller.abort(source?.reason);
+      source?.addEventListener("abort", relayAbort, { once: true });
+      if (source?.aborted) controller.abort(source.reason);
+      const timeout = setTimeout(
+        () => controller.abort(new Error("deadline_exceeded")),
+        Math.max(1, deadlineAtMs - Date.now())
+      );
+      timeout.unref();
+      return {
+        signal: controller.signal,
+        cleanup: () => {
+          clearTimeout(timeout);
+          source?.removeEventListener("abort", relayAbort);
+        }
+      };
+    };
+    nonDispatchedError = (message, category, code, retryable = false) => new CodexAppServerError({
+      message,
+      category,
+      code,
+      retryable,
+      dispatchOutcome: "not_dispatched"
+    });
+    proxyDispatchOutcome = (proxy) => {
+      if (proxy.unansweredUpstreamRequest) return "outcome_unknown";
+      if (proxy.providerResponseObserved) return "confirmed_dispatched";
+      return proxy.upstreamRequestStarted ? "outcome_unknown" : "not_dispatched";
+    };
+    mapDeepSeekFailure = (options) => {
+      if (options.error instanceof CodexAppServerError) return options.error;
+      if (options.cancelled || options.deadline) {
+        return new CodexAppServerError({
+          message: options.cancelled ? "DeepSeek Harness request was cancelled." : "DeepSeek Harness request exceeded its deadline.",
+          category: options.cancelled ? "cancelled" : "timeout",
+          code: options.cancelled ? "cancelled" : "deadline_exceeded",
+          retryable: false,
+          dispatchOutcome: options.dispatchOutcome,
+          cause: options.error
+        });
+      }
+      if (options.error instanceof LlmError) {
+        const failure = options.error.failure;
+        const auth = ["AUTH", "INVALID_CREDENTIAL", "MISSING_CREDENTIAL"].includes(failure.code);
+        const quota = failure.code === "QUOTA" || failure.status === 402;
+        const rateLimit = failure.code === "RATE_LIMIT";
+        const clientError = failure.status !== void 0 && failure.status >= 400 && failure.status < 500;
+        const model = !auth && !quota && !rateLimit && clientError || [
+          "CONTEXT_WINDOW_EXCEEDED",
+          "INVALID_REQUEST",
+          "UNSUPPORTED_CONTENT",
+          "UNSUPPORTED_REASONING_EFFORT"
+        ].includes(failure.code);
+        const transport = [
+          "EMPTY_RESPONSE",
+          "MALFORMED_RESPONSE",
+          "SERVER",
+          "STREAM_CLOSED",
+          "TIMEOUT",
+          "TRANSPORT"
+        ].includes(failure.code) || failure.code.startsWith("HTTP_") && !clientError;
+        const code = auth ? "deepseek_auth_failed" : quota ? "quota_exceeded" : rateLimit ? "provider_rate_limited" : model ? `deepseek_${failure.code.toLowerCase()}` : transport ? `deepseek_${failure.code.toLowerCase()}` : "deepseek_harness_adapter_failure";
+        return new CodexAppServerError({
+          message: failure.message,
+          category: auth ? "auth" : model || quota || rateLimit ? "model" : transport ? "transport" : "adapter",
+          code,
+          retryable: transport && !quota,
+          dispatchOutcome: options.dispatchOutcome,
+          httpStatusCode: failure.status ?? null,
+          retryAtMs: failure.providerRetryAfterMs === void 0 ? null : Date.now() + failure.providerRetryAfterMs,
+          cause: options.error
+        });
+      }
+      return new CodexAppServerError({
+        message: options.error instanceof Error ? options.error.message : "DeepSeek Harness adapter failed.",
+        category: "adapter",
+        code: "deepseek_harness_adapter_failure",
+        retryable: false,
+        dispatchOutcome: options.dispatchOutcome,
+        cause: options.error
+      });
+    };
+    createPrivateWorkspace2 = async () => {
+      const path = await mkdtemp3(join6(tmpdir4(), "vtx-deepseek-harness-"));
+      return { path, cleanup: async () => {
+        await rm5(path, { recursive: true, force: true });
+      } };
+    };
+    directAdapter = (proxy, model, effort) => {
+      const connection = resolveAdapterOptions({
+        apiKeyEnv: "VTX_DSH_LOOPBACK_TOKEN",
+        baseURL: proxy.baseUrl,
+        reasoningEffort: effort,
+        thinking: "enabled",
+        models: [{ id: model }],
+        retryPolicy: { mode: "normal", maxRetries: 0 }
+      });
+      return new DeepSeekAdapter({
+        options: () => connection,
+        resolveApiKey: async () => "vtx-loopback-only",
+        resolveUserId: () => "vtx-macro"
+      });
+    };
+    normalizeJsonValue = (value) => JSON.parse(JSON.stringify(value));
+    DeepSeekHarnessAdapter = class {
+      constructor(dependencies) {
+        this.agentWorkspaces = /* @__PURE__ */ new Map();
+        this.closing = false;
+        this.dependencies = dependencies;
+      }
+      async preflight(signal) {
+        if (!isSupportedNodeVersion(this.dependencies.nodeVersion ?? process.version)) {
+          throw new CodexAppServerError({
+            message: "DeepSeek Harness requires Node 22.19 or newer in the Node 22 line, or Node 24+.",
+            category: "adapter",
+            code: "deepseek_harness_node_version_unsupported",
+            retryable: false
+          });
+        }
+        const credential = await this.dependencies.credentialStore.read(signal);
+        if (!credential) {
+          throw new CodexAppServerError({
+            message: "Import a DeepSeek API key with vtx inference-host deepseek-login first.",
+            category: "auth",
+            code: "deepseek_harness_credential_required",
+            retryable: false
+          });
+        }
+        const response = await (this.dependencies.fetch ?? fetch)(
+          `${this.dependencies.apiBaseUrl ?? DEEPSEEK_API_BASE_URL}/models`,
+          { headers: { authorization: `Bearer ${credential.apiKey}` }, signal }
+        );
+        if (!response.ok) {
+          throw new CodexAppServerError({
+            message: `DeepSeek model catalog request failed with HTTP ${response.status}.`,
+            category: response.status === 401 || response.status === 403 ? "auth" : "transport",
+            code: "deepseek_harness_model_catalog_failed",
+            retryable: false
+          });
+        }
+        const payload = await response.json();
+        const live = new Set((payload.data ?? []).map((item) => String(item.id ?? "")));
+        const models = DEEPSEEK_MODELS.filter((model) => live.has(model));
+        if (models.length === 0) {
+          throw new CodexAppServerError({
+            message: "DeepSeek returned no VTX-supported Harness models.",
+            category: "model",
+            code: "deepseek_harness_model_catalog_empty",
+            retryable: false
+          });
+        }
+        return {
+          adapterId: "deepseek-harness",
+          runtimeVersion: DEEPSEEK_HARNESS_VERSION,
+          authenticatedAccountIdentity: null,
+          authenticatedAccountEmail: null,
+          authenticatedAccountPlan: null,
+          modelCapabilities: models.map((model, index) => ({
+            id: model,
+            model,
+            displayName: model === "deepseek-v4-flash" ? "DeepSeek V4 Flash" : "DeepSeek V4 Pro",
+            hidden: false,
+            supportedReasoningEfforts: [...supportedEfforts(model)],
+            defaultReasoningEffort: "high",
+            isDefault: index === 0
+          })),
+          rateLimits: null,
+          sameAttemptRecovery: false
+        };
+      }
+      async runAttempt(input) {
+        const startedAt = (this.dependencies.now ?? Date.now)();
+        if (Date.now() >= input.deadlineAtMs) {
+          throw nonDispatchedError(
+            "DeepSeek Harness attempt exceeded its deadline.",
+            "timeout",
+            "deadline_exceeded"
+          );
+        }
+        if (!DEEPSEEK_MODELS.includes(input.requestedModel)) {
+          throw nonDispatchedError(
+            "The requested DeepSeek Harness model is unsupported.",
+            "model",
+            "deepseek_model_unsupported"
+          );
+        }
+        if (!supportedEfforts(input.requestedModel).includes(input.requestedReasoningEffort)) {
+          throw nonDispatchedError(
+            "The requested DeepSeek Harness reasoning effort is unsupported.",
+            "model",
+            "deepseek_reasoning_effort_unsupported"
+          );
+        }
+        const effort = effortForHarness(input.requestedReasoningEffort);
+        const boundary = createDeadlineBoundary(input.signal, input.deadlineAtMs);
+        let credential;
+        try {
+          credential = await this.dependencies.credentialStore.read(boundary.signal);
+          if (!credential) {
+            throw nonDispatchedError(
+              "Import a DeepSeek API key with vtx inference-host deepseek-login first.",
+              "auth",
+              "deepseek_harness_credential_required"
+            );
+          }
+        } catch (error48) {
+          const cancelled = input.signal?.aborted === true;
+          const deadline = !cancelled && boundary.signal.aborted;
+          boundary.cleanup();
+          if (error48 instanceof CodexAppServerError) throw error48;
+          throw nonDispatchedError(
+            cancelled ? "DeepSeek Harness attempt was cancelled." : deadline ? "DeepSeek Harness attempt exceeded its deadline." : "DeepSeek Harness could not read its local credential.",
+            cancelled ? "cancelled" : deadline ? "timeout" : "auth",
+            cancelled ? "cancelled" : deadline ? "deadline_exceeded" : "deepseek_harness_credential_read_failed"
+          );
+        }
+        const proxy = new DeepSeekTransportProxy(
+          credential.apiKey,
+          input.requestedModel,
+          effort,
+          this.dependencies.apiBaseUrl ?? DEEPSEEK_API_BASE_URL,
+          this.dependencies.fetch ?? fetch
+        );
+        try {
+          boundary.signal.throwIfAborted();
+          await proxy.start();
+          const adapter = directAdapter(proxy, input.requestedModel, effort);
+          const blocks = [];
+          let usage = null;
+          let finish = null;
+          for await (const chunk of adapter.stream({
+            provider: "deepseek-official",
+            model: input.requestedModel,
+            reasoningEffort: effort,
+            system: `${input.systemPrompt}
+
+Return only one JSON value matching this JSON Schema exactly:
+${input.outputSchemaJson}`,
+            messages: [createUserMessage({
+              content: [{ type: "text", text: input.userPrompt }],
+              source: { kind: "user" }
+            })],
+            tools: [],
+            signal: boundary.signal
+          })) {
+            if (chunk.type === "block-end") blocks.push(chunk.block);
+            if (chunk.type === "usage") usage = chunk.usage;
+            if (chunk.type === "finish") finish = chunk;
+          }
+          const receipts = proxy.receipts;
+          if (receipts.length !== 1 || !usage || finish?.type !== "finish" || finish.reason.kind !== "stop") {
+            throw new Error("deepseek_harness_terminal_receipt_invalid");
+          }
+          const text = validateText(textFromBlocks(blocks, "text"), "deepseek_harness_result_invalid");
+          return {
+            text,
+            reasoningContent: textFromBlocks(blocks, "reasoning") || null,
+            reasoningSummary: null,
+            requestedModel: input.requestedModel,
+            effectiveModel: receipts[0].model,
+            requestedReasoningEffort: input.requestedReasoningEffort,
+            effectiveReasoningEffort: input.requestedReasoningEffort,
+            adapterRequestId: receipts[0].id,
+            adapterResponseId: receipts[0].id,
+            usage: toVtxUsage(usage),
+            latencyMs: Math.max(0, (this.dependencies.now ?? Date.now)() - startedAt),
+            timeToFirstTokenMs: null,
+            terminalStatus: "completed"
+          };
+        } catch (error48) {
+          const cancelled = input.signal?.aborted === true;
+          const deadline = !cancelled && boundary.signal.aborted;
+          throw mapDeepSeekFailure({
+            error: error48,
+            cancelled,
+            deadline,
+            dispatchOutcome: proxyDispatchOutcome(proxy)
+          });
+        } finally {
+          boundary.cleanup();
+          await proxy.close();
+        }
+      }
+      async runTurn(input) {
+        if (this.closing) {
+          throw nonDispatchedError(
+            "DeepSeek Harness Agent adapter is closing.",
+            "transport",
+            "transport_closed",
+            true
+          );
+        }
+        if (Date.now() >= input.deadlineAtMs) {
+          throw nonDispatchedError(
+            "DeepSeek Harness Agent turn exceeded its deadline.",
+            "timeout",
+            "deadline_exceeded"
+          );
+        }
+        if (!DEEPSEEK_MODELS.includes(input.requestedModel)) {
+          throw nonDispatchedError(
+            "The requested DeepSeek Harness model is unsupported.",
+            "model",
+            "deepseek_model_unsupported"
+          );
+        }
+        if (input.dataContract.length === 0 || !supportedEfforts(input.requestedModel).includes(input.requestedReasoningEffort)) {
+          throw nonDispatchedError(
+            "DeepSeek Harness Agent turn input is invalid.",
+            "schema",
+            "invalid_agent_turn_input"
+          );
+        }
+        const startedAt = (this.dependencies.now ?? Date.now)();
+        const effort = effortForHarness(input.requestedReasoningEffort);
+        const boundary = createDeadlineBoundary(input.signal, input.deadlineAtMs);
+        let credential;
+        try {
+          credential = await this.dependencies.credentialStore.read(boundary.signal);
+          if (!credential) {
+            throw nonDispatchedError(
+              "Import a DeepSeek API key with vtx inference-host deepseek-login first.",
+              "auth",
+              "deepseek_harness_credential_required"
+            );
+          }
+        } catch (error48) {
+          const cancelled = input.signal?.aborted === true;
+          const deadline = !cancelled && boundary.signal.aborted;
+          boundary.cleanup();
+          if (error48 instanceof CodexAppServerError) throw error48;
+          throw nonDispatchedError(
+            cancelled ? "DeepSeek Harness Agent turn was cancelled." : deadline ? "DeepSeek Harness Agent turn exceeded its deadline." : "DeepSeek Harness could not read its local credential.",
+            cancelled ? "cancelled" : deadline ? "timeout" : "auth",
+            cancelled ? "cancelled" : deadline ? "deadline_exceeded" : "deepseek_harness_credential_read_failed"
+          );
+        }
+        const owned = input.durableThread ? null : await (this.dependencies.createWorkspace ?? createPrivateWorkspace2)();
+        const rootPath = input.durableThread?.threadPath ?? owned.path;
+        if (owned) this.agentWorkspaces.set(rootPath, owned.cleanup);
+        const proxy = new DeepSeekTransportProxy(
+          credential.apiKey,
+          input.requestedModel,
+          effort,
+          this.dependencies.apiBaseUrl ?? DEEPSEEK_API_BASE_URL,
+          this.dependencies.fetch ?? fetch
+        );
+        const ctx = new Context();
+        const loopbackEnvName = `VTX_DSH_LOOPBACK_TOKEN_${randomUUID2().replaceAll("-", "").toUpperCase()}`;
+        process.env[loopbackEnvName] = "vtx-loopback-only";
+        let durableCheckpointed = input.durableThread !== null;
+        let cleanupUnpublishedWorkspace = false;
+        let removeAgentAbortListener = () => void 0;
+        let cancelAgentTurn = () => void 0;
+        let releaseAgentDispatch = () => void 0;
+        let permitAgentDispatch = false;
+        try {
+          await proxy.start();
+          await ctx.plugin(AgentSpine, {
+            agents: [],
+            maxParallelToolCalls: 1,
+            includeHarnessIdentity: false,
+            includeRuntimeContext: false,
+            persona: `${input.systemPrompt}
+
+Return only one JSON value matching this JSON Schema exactly:
+${JSON.stringify(input.outputSchema)}`,
+            tools: { mode: "native" },
+            workspaceContext: false,
+            skills: { enabled: false },
+            toolBash: false,
+            toolJobs: false,
+            goals: false
+          });
+          await ctx.plugin(JsonlSessionPersistence, { root: rootPath, compression: "none" });
+          await ctx.plugin(SessionCheckpointPolicy);
+          await ctx.plugin(LlmDeepSeek, {
+            apiKeyEnv: loopbackEnvName,
+            baseURL: proxy.baseUrl,
+            reasoningEffort: effort,
+            thinking: "enabled",
+            models: [{ id: input.requestedModel }],
+            retryPolicy: { mode: "normal", maxRetries: 0 }
+          });
+          const evidence = [];
+          const setup = (agentCtx) => {
+            const definitions = [
+              {
+                name: "vtx_get_data",
+                description: "Request assignment-scoped VTX data.",
+                parameters: { oneOf: input.dataContract.map((entry) => ({
+                  type: "object",
+                  additionalProperties: false,
+                  required: ["capability", "arguments"],
+                  properties: { capability: { const: entry.id }, arguments: entry.input_schema }
+                })) }
+              },
+              {
+                name: "vtx_submit_decision",
+                description: "Submit one VTX structured trading decision candidate.",
+                parameters: { type: "object", additionalProperties: false, required: ["candidate"], properties: { candidate: input.decisionSchema } }
+              },
+              {
+                name: "vtx_decision_status",
+                description: "Resolve the durable status of a decision operation.",
+                parameters: { type: "object", additionalProperties: false, required: ["operation_id"], properties: { operation_id: { type: "string", minLength: 1 } } }
+              }
+            ];
+            for (const definition of definitions) {
+              agentCtx.tools.register({
+                ...definition,
+                output: {
+                  schema: {},
+                  render: (_arguments, value) => [{ type: "text", text: JSON.stringify(value) }]
+                },
+                execute: async (argumentsValue) => {
+                  const argumentsRecord = argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue) ? argumentsValue : {};
+                  const callId = randomUUID2();
+                  const result2 = await input.executeTool({ callId, tool: definition.name, arguments: argumentsRecord });
+                  evidence.push({ callId, tool: definition.name, arguments: argumentsRecord, success: result2.success });
+                  return normalizeJsonValue(result2.success ? result2.value : { error: result2.value });
+                }
+              });
+            }
+          };
+          const sessionId = input.durableThread ? SessionId(input.durableThread.threadId) : SessionId(`vtx-${randomUUID2()}`);
+          const handle = input.durableThread ? await ctx.agents.resume({
+            resumeSessionId: sessionId,
+            agentOptions: { provider: "deepseek-official", model: input.requestedModel, reasoningEffort: effort },
+            signal: boundary.signal,
+            setup
+          }) : await ctx.agents.create({
+            sessionId,
+            meta: { cwd: rootPath },
+            agentOptions: { provider: "deepseek-official", model: input.requestedModel, reasoningEffort: effort },
+            signal: boundary.signal,
+            setup
+          });
+          const onAbort = () => handle.agent.cancel({ kind: "user" });
+          cancelAgentTurn = onAbort;
+          boundary.signal.addEventListener("abort", onAbort, { once: true });
+          removeAgentAbortListener = () => boundary.signal.removeEventListener("abort", onAbort);
+          if (boundary.signal.aborted) onAbort();
+          boundary.signal.throwIfAborted();
+          let checkpointReached = false;
+          let resolveCheckpoint;
+          const checkpoint = new Promise((resolve6) => {
+            resolveCheckpoint = resolve6;
+          });
+          const dispatchGate = new Promise((resolve6) => {
+            releaseAgentDispatch = resolve6;
+          });
+          ctx.on("llm/stream", (options, next) => {
+            if (String(options.sessionId ?? "") !== String(sessionId)) return next();
+            return (async function* () {
+              await ctx.sessions.flush(handle.agent.session);
+              checkpointReached = true;
+              resolveCheckpoint();
+              await dispatchGate;
+              boundary.signal.throwIfAborted();
+              if (!permitAgentDispatch) throw new Error("deepseek_agent_publication_not_committed");
+              yield* next();
+            })();
+          });
+          const thread = {
+            threadId: String(sessionId),
+            threadPath: rootPath,
+            effectiveModel: input.requestedModel,
+            effectiveReasoningEffort: input.requestedReasoningEffort
+          };
+          const startSeq = handle.agent.session.seq;
+          handle.agent.followup(createUserMessage({
+            content: [{ type: "text", text: input.userPrompt }],
+            source: { kind: "user" }
+          }));
+          const idle = handle.agent.whenIdle();
+          await Promise.race([
+            checkpoint,
+            idle.then(() => {
+              if (!checkpointReached) throw new Error("deepseek_agent_checkpoint_not_reached");
+            })
+          ]);
+          boundary.signal.throwIfAborted();
+          if (input.onThreadReady) {
+            await input.onThreadReady(thread);
+            durableCheckpointed = true;
+          }
+          boundary.signal.throwIfAborted();
+          permitAgentDispatch = true;
+          releaseAgentDispatch();
+          releaseAgentDispatch = () => void 0;
+          await idle;
+          const events = handle.agent.session.events.slice(startSeq);
+          const assistantEvents = events.filter((event) => event.type === "assistant/message");
+          const turnEnd = [...events].reverse().find((event) => event.type === "turn/end");
+          if (!turnEnd || turnEnd.type !== "turn/end" || turnEnd.data.reason.kind !== "completed") {
+            if (turnEnd?.type === "turn/end" && turnEnd.data.reason.kind === "error") {
+              const failure = turnEnd.data.reason.error;
+              throw new LlmError(failure.message, failure.code, {
+                ...failure.status === void 0 ? {} : { status: failure.status },
+                ...failure.providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: failure.providerRetryAfterMs }
+              });
+            }
+            const reason = turnEnd?.type === "turn/end" ? turnEnd.data.reason : { kind: "missing" };
+            throw new Error(`deepseek_harness_agent_turn_incomplete:${JSON.stringify(reason)}`);
+          }
+          const last = assistantEvents.at(-1);
+          if (!last || last.type !== "assistant/message" || last.data.interrupted) {
+            throw new Error("deepseek_harness_agent_result_missing");
+          }
+          const usages = assistantEvents.flatMap((event) => event.type === "assistant/message" && event.data.usage ? [event.data.usage] : []);
+          if (usages.length === 0 || proxy.receipts.length !== usages.length) {
+            throw new Error("deepseek_harness_agent_receipt_missing");
+          }
+          const text = validateText(textFromBlocks(last.data.message.content, "text"), "deepseek_harness_agent_result_invalid");
+          const receipts = proxy.receipts;
+          await handle.dispose();
+          return {
+            thread,
+            turn: {
+              text,
+              reasoningContent: textFromBlocks(last.data.message.content, "reasoning") || null,
+              reasoningSummary: null,
+              requestedModel: input.requestedModel,
+              effectiveModel: receipts.at(-1).model,
+              requestedReasoningEffort: input.requestedReasoningEffort,
+              effectiveReasoningEffort: input.requestedReasoningEffort,
+              adapterRequestId: receipts[0].id,
+              adapterResponseId: receipts.at(-1).id,
+              usage: sumUsage(usages),
+              latencyMs: Math.max(0, (this.dependencies.now ?? Date.now)() - startedAt),
+              timeToFirstTokenMs: null,
+              terminalStatus: "completed",
+              toolCalls: evidence,
+              webSearches: []
+            }
+          };
+        } catch (error48) {
+          cancelAgentTurn();
+          releaseAgentDispatch();
+          releaseAgentDispatch = () => void 0;
+          if (!durableCheckpointed && owned) {
+            cleanupUnpublishedWorkspace = true;
+          }
+          throw mapDeepSeekFailure({
+            error: error48,
+            cancelled: input.signal?.aborted === true,
+            deadline: input.signal?.aborted !== true && boundary.signal.aborted,
+            dispatchOutcome: proxyDispatchOutcome(proxy)
+          });
+        } finally {
+          removeAgentAbortListener();
+          boundary.cleanup();
+          await ctx.fiber.dispose().catch(() => void 0);
+          await proxy.close();
+          if (cleanupUnpublishedWorkspace && owned) {
+            await owned.cleanup().catch(() => void 0);
+            this.agentWorkspaces.delete(rootPath);
+          }
+          delete process.env[loopbackEnvName];
+        }
+      }
+      async releaseThread(thread) {
+        const cleanup = this.agentWorkspaces.get(thread.threadPath);
+        if (cleanup) {
+          await cleanup();
+          this.agentWorkspaces.delete(thread.threadPath);
+          return;
+        }
+        const resolved = await realpath4(thread.threadPath);
+        const temporaryRoot = await realpath4(tmpdir4());
+        if (dirname4(resolved) !== temporaryRoot || !basename(resolved).startsWith("vtx-deepseek-harness-")) throw new Error("deepseek_harness_thread_path_not_owned");
+        await rm5(resolved, { recursive: true, force: true });
+      }
+      async close() {
+        this.closing = true;
+      }
+    };
+  }
+});
+
+// lib/inference-host/deepseek-credential-store.ts
+import { createHash as createHash5 } from "node:crypto";
+var DEEPSEEK_CREDENTIAL_NAMESPACE, MAX_API_KEY_BYTES, validateApiKey, credentialIdentity, parseCredential, serializeCredential, platformCommands, createDeepSeekHarnessCredentialStore;
+var init_deepseek_credential_store = __esm({
+  "lib/inference-host/deepseek-credential-store.ts"() {
+    "use strict";
+    init_config();
+    init_credential_store();
+    DEEPSEEK_CREDENTIAL_NAMESPACE = "vtxmacro-deepseek-harness";
+    MAX_API_KEY_BYTES = 512;
+    validateApiKey = (raw) => {
+      const apiKey = raw.trim();
+      if (apiKey.length < 16 || Buffer.byteLength(apiKey, "utf8") > MAX_API_KEY_BYTES || /[\s\u0000-\u001f\u007f]/u.test(apiKey)) {
+        throw new Error("DeepSeek API key is invalid. Provide one private key through stdin.");
+      }
+      return apiKey;
+    };
+    credentialIdentity = (apiKey) => `deepseek-key-${createHash5("sha256").update(apiKey).digest("hex").slice(0, 24)}`;
+    parseCredential = (raw) => {
+      let value;
+      try {
+        value = JSON.parse(raw);
+      } catch {
+        throw new Error("Stored DeepSeek Harness credential is invalid JSON.");
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Stored DeepSeek Harness credential is invalid.");
+      }
+      const record2 = value;
+      const apiKey = validateApiKey(String(record2.api_key ?? ""));
+      const identity = credentialIdentity(apiKey);
+      if (record2.schema_version !== 1 || record2.adapter !== "deepseek-harness" || record2.identity !== identity || Object.keys(record2).sort().join(",") !== "adapter,api_key,identity,schema_version") {
+        throw new Error("Stored DeepSeek Harness credential failed validation.");
+      }
+      return { apiKey, identity };
+    };
+    serializeCredential = (apiKey) => {
+      const validated = validateApiKey(apiKey);
+      return `${JSON.stringify({
+        schema_version: 1,
+        adapter: "deepseek-harness",
+        api_key: validated,
+        identity: credentialIdentity(validated)
+      })}
+`;
+    };
+    platformCommands = (env, platform) => {
+      if (platform === "win32") return windowsInferenceCredentialCommands;
+      if (platform === "linux" && String(env.WSL_INTEROP || "").trim()) {
+        return windowsInferenceCredentialCommands;
+      }
+      if (platform === "linux") return linuxSecretServiceInferenceCredentialCommands;
+      if (platform === "darwin") return macosKeychainInferenceCredentialCommands;
+      return null;
+    };
+    createDeepSeekHarnessCredentialStore = (config2, dependencies = {}) => {
+      const accountKey = `deepseek-harness:${config2.instanceName}`;
+      const path = `${config2.statePath}.deepseek-harness-secret.json`;
+      const env = dependencies.env ?? process.env;
+      const platform = dependencies.platform ?? process.platform;
+      const commands = dependencies.commands === void 0 ? platformCommands(env, platform) : dependencies.commands;
+      const runner = dependencies.commandRunner ?? runCredentialCommand;
+      if (config2.credentialStoreMode === "os") {
+        if (!commands) {
+          throw new Error("OS credential storage is unavailable for the DeepSeek API key.");
+        }
+        return {
+          read: async (signal) => {
+            const command = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            const result2 = await runner(command, { stdin: null, signal });
+            if ((command.notFoundExitCodes ?? []).includes(result2.exitCode)) return null;
+            if (result2.exitCode !== 0) throw new Error("DeepSeek OS credential lookup failed.");
+            return parseCredential(result2.stdout);
+          },
+          write: async (apiKey, signal) => {
+            const serialized = serializeCredential(apiKey);
+            const priorLookup = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            const priorResult = await runner(priorLookup, { stdin: null, signal });
+            const prior = (priorLookup.notFoundExitCodes ?? []).includes(priorResult.exitCode) ? null : priorResult.exitCode === 0 ? parseCredential(priorResult.stdout) : void 0;
+            if (prior === void 0) throw new Error("DeepSeek OS credential lookup failed before write.");
+            const command = commands.store(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            if (command.args.some((value) => value.includes(validateApiKey(apiKey)))) {
+              throw new Error("DeepSeek API key must never be passed in command arguments.");
+            }
+            try {
+              const result2 = await runner(command, { stdin: serialized, signal });
+              if (result2.exitCode !== 0) throw new Error("DeepSeek OS credential write failed.");
+              const retainedCommand = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+              const retained = await runner(retainedCommand, { stdin: null, signal });
+              if (retained.exitCode !== 0) {
+                throw new Error("DeepSeek OS credential write could not be verified.");
+              }
+              const expected = parseCredential(serialized);
+              const observed = parseCredential(retained.stdout);
+              if (observed.identity !== expected.identity || observed.apiKey !== expected.apiKey) {
+                throw new Error("DeepSeek OS credential write could not be verified.");
+              }
+              return observed;
+            } catch (error48) {
+              const rollback = prior ? commands.store(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey) : commands.remove(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+              const rollbackResult = await runner(rollback, {
+                stdin: prior ? serializeCredential(prior.apiKey) : null
+              });
+              if (rollbackResult.exitCode !== 0 && !(rollback.notFoundExitCodes ?? []).includes(rollbackResult.exitCode)) {
+                throw new Error("DeepSeek OS credential write failed and rollback failed.", {
+                  cause: error48
+                });
+              }
+              const verifyCommand = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+              const verified = await runner(verifyCommand, { stdin: null });
+              const absent = (verifyCommand.notFoundExitCodes ?? []).includes(verified.exitCode);
+              const restored = prior && verified.exitCode === 0 ? parseCredential(verified.stdout) : null;
+              if (prior === null && !absent || prior !== null && (!restored || restored.identity !== prior.identity || restored.apiKey !== prior.apiKey)) {
+                throw new Error("DeepSeek OS credential write failed and rollback could not be verified.", {
+                  cause: error48
+                });
+              }
+              throw error48;
+            }
+          },
+          remove: async (signal) => {
+            const command = commands.remove(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            const result2 = await runner(command, { stdin: null, signal });
+            if (result2.exitCode !== 0 && !(command.notFoundExitCodes ?? []).includes(result2.exitCode)) throw new Error("DeepSeek OS credential removal failed.");
+            const retainedCommand = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            const retained = await runner(retainedCommand, { stdin: null });
+            if (!(retainedCommand.notFoundExitCodes ?? []).includes(retained.exitCode)) {
+              throw new Error("DeepSeek OS credential removal could not be verified.");
+            }
+          }
+        };
+      }
+      return {
+        read: async () => {
+          const raw = await readInferencePrivateFile(path, "DeepSeek Harness credential file");
+          return raw === null ? null : parseCredential(raw);
+        },
+        write: async (apiKey) => {
+          const serialized = serializeCredential(apiKey);
+          await writeAtomicInferencePrivateFile(path, serialized);
+          const retained = await readInferencePrivateFile(path, "DeepSeek Harness credential file");
+          if (retained !== serialized) throw new Error("DeepSeek credential write could not be verified.");
+          return parseCredential(serialized);
+        },
+        remove: async () => {
+          await clearInferencePrivateFile(path, "DeepSeek Harness credential file");
+        }
+      };
+    };
+  }
+});
+
 // lib/inference-host/durable-adapter.ts
 var DURABLE_INFERENCE_ADAPTER_IDS, isDurableInferenceAdapterId, durableAdapterDisplayName;
 var init_durable_adapter = __esm({
@@ -24729,12 +25819,14 @@ var init_durable_adapter = __esm({
     "use strict";
     DURABLE_INFERENCE_ADAPTER_IDS = [
       "codex",
-      "copilot"
+      "copilot",
+      "deepseek-harness"
     ];
     isDurableInferenceAdapterId = (value) => DURABLE_INFERENCE_ADAPTER_IDS.includes(value);
     durableAdapterDisplayName = (adapter) => ({
       codex: "Codex",
-      copilot: "GitHub Copilot"
+      copilot: "GitHub Copilot",
+      "deepseek-harness": "DeepSeek Harness"
     })[adapter];
   }
 });
@@ -24743,13 +25835,13 @@ var init_durable_adapter = __esm({
 import {
   createCipheriv,
   createDecipheriv,
-  createHash as createHash5,
+  createHash as createHash6,
   createPrivateKey,
   createPublicKey,
   diffieHellman,
   generateKeyPairSync,
   hkdfSync,
-  randomBytes as randomBytes4
+  randomBytes as randomBytes5
 } from "node:crypto";
 var ENVELOPE_SUITE, JOB_KEY_PAYLOAD_SCHEMA_VERSION, WRAP_HKDF_INFO, PAYLOAD_HKDF_INFO, X25519_PKCS8_PREFIX, X25519_SPKI_PREFIX, ExternalInferenceEnvelopeError, canonicalize, canonicalEnvelopeAadBytes, externalInferenceSha256, decodeCanonicalBase64Url, rawPrivateKey, rawPublicKey, rawPublicBytes, aesGcmDecrypt, aesGcmEncrypt, assertIdentity, validatePlaintext, generateExternalInferenceEnvelopeKeyPair, externalInferenceEnvelopePublicKey, deriveKey, deriveExternalInferencePayloadKey, unwrapExternalInferenceJobKey, decryptExternalInferenceJobInput, decryptExternalInferenceClaim, sealExternalInferenceCandidate;
 var init_crypto = __esm({
@@ -24782,7 +25874,7 @@ var init_crypto = __esm({
       const aad = envelopeAadSchema.parse(input);
       return Buffer.from(JSON.stringify(canonicalize(aad)), "utf8");
     };
-    externalInferenceSha256 = (value) => createHash5("sha256").update(value).digest("hex");
+    externalInferenceSha256 = (value) => createHash6("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.`);
@@ -24881,7 +25973,7 @@ var init_crypto = __esm({
       return Buffer.from(hkdfSync(
         "sha256",
         root,
-        createHash5("sha256").update(aadBytes).digest(),
+        createHash6("sha256").update(aadBytes).digest(),
         info,
         32
       ));
@@ -25023,7 +26115,7 @@ var init_crypto = __esm({
           "External inference candidate must not be empty."
         );
       }
-      const nonce = options.nonce ? Buffer.from(options.nonce) : randomBytes4(12);
+      const nonce = options.nonce ? Buffer.from(options.nonce) : randomBytes5(12);
       if (nonce.length !== 12) {
         throw new ExternalInferenceEnvelopeError(
           "invalid_nonce",
@@ -31295,7 +32387,7 @@ var require_ajv = __commonJS({
 });
 
 // lib/inference-host/runner.ts
-import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
 function createDefaultInferenceHostRunnerDependencies(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
   return {
@@ -31330,7 +32422,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, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createInferenceAgentControlClient, INFERENCE_AGENT_SYSTEM_PROMPT, INFERENCE_AGENT_WAKE_SCHEMA, parseInferenceAgentWake, InferenceAgentRuntime;
+var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS, DEFAULT_AGENT_QUOTA_COOLDOWN_MS, DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createInferenceAgentControlClient, INFERENCE_AGENT_SYSTEM_PROMPT, INFERENCE_AGENT_WAKE_SCHEMA, parseInferenceAgentWake, InferenceAgentRuntime;
 var init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -31356,6 +32448,9 @@ var init_runner = __esm({
     MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS = 1e4;
     HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR = 3;
     DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS = 5 * 60 * 1e3;
+    DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS = 6e4;
+    DEFAULT_AGENT_QUOTA_COOLDOWN_MS = 5 * 60 * 1e3;
+    DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS = 5e3;
     MIN_CLAIM_START_WINDOW_MS = 5e3;
     MAX_ATTEMPT_START_RETRY_DELAY_MS = 15e3;
     UNBOUNDED_AVAILABLE_SLOTS = Number.MAX_SAFE_INTEGER;
@@ -31622,7 +32717,7 @@ var init_runner = __esm({
         attempts
       };
     };
-    sha256 = (value) => createHash6("sha256").update(value, "utf8").digest("hex");
+    sha256 = (value) => createHash7("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",
@@ -31895,7 +32990,7 @@ var init_runner = __esm({
     membershipFailureDisposition = (failure) => {
       if (failure.dispatchOutcome === "outcome_unknown") return "quarantine_ambiguous";
       if (failure.category === "auth" || ["auth_expired", "managed_chatgpt_auth_required", "invalid_account_metadata"].includes(failure.code)) return "cascade_disable";
-      if (failure.category === "quota" || ["quota_exceeded", "codex_rate_limited"].includes(failure.code)) return "cascade_cooldown";
+      if (failure.category === "quota" || ["quota_exceeded", "codex_rate_limited", "provider_rate_limited"].includes(failure.code)) return "cascade_cooldown";
       if (failure.retryable && (["adapter", "network", "transport"].includes(failure.category) || failure.code === "rpc_timeout")) return "retry_same_host";
       if (["model_unavailable", "reasoning_effort_unavailable"].includes(failure.code)) return "cascade_cooldown";
       if ([
@@ -32169,6 +33264,43 @@ var init_runner = __esm({
             const agentRuntimeSettings = settings.agentRuntime;
             agentLoop = (async () => {
               while (!agentAbort.signal.aborted) {
+                const existingFence = await readInferenceAgentFailureFence(
+                  agentRuntimeSettings.statePath
+                );
+                if (existingFence) {
+                  if (existingFence.adapter_id !== settings.adapterId || existingFence.host_id !== localState.host_id) {
+                    throw new InferenceHostRecoveryRequiredError(
+                      "Inference Agent failure fence belongs to another host or adapter."
+                    );
+                  }
+                  if (existingFence.retry_at === null) {
+                    emitDiagnostic("agent_runtime_quarantined", {
+                      assignment_id: existingFence.assignment_id,
+                      failure_category: existingFence.failure_category,
+                      failure_code: existingFence.failure_code,
+                      dispatch_outcome: existingFence.dispatch_outcome
+                    });
+                    return;
+                  }
+                  const retryAtMs = Date.parse(existingFence.retry_at);
+                  if (retryAtMs > now()) {
+                    emitDiagnostic("agent_runtime_cooldown", {
+                      assignment_id: existingFence.assignment_id,
+                      failure_category: existingFence.failure_category,
+                      failure_code: existingFence.failure_code,
+                      dispatch_outcome: existingFence.dispatch_outcome,
+                      cooldown_until: existingFence.retry_at
+                    });
+                    if (this.options.once) return;
+                    try {
+                      await sleep4(Math.max(MIN_SLEEP_MS, retryAtMs - now()), agentAbort.signal);
+                    } catch {
+                      return;
+                    }
+                    continue;
+                  }
+                  await clearInferenceAgentFailureFence(agentRuntimeSettings.statePath);
+                }
                 const agentRuntime = new InferenceAgentRuntime({
                   adapterId: settings.adapterId,
                   hostId: localState.host_id,
@@ -32189,6 +33321,51 @@ var init_runner = __esm({
                     requestDrain("authority_lost");
                     return;
                   }
+                  if (error48 instanceof CodexAppServerError) {
+                    const failure = classifyFailure(error48);
+                    const providerLimited = failure.category === "auth" || failure.category === "quota" || ["quota_exceeded", "codex_rate_limited", "provider_rate_limited"].includes(failure.code);
+                    const deepSeekTransient = settings.adapterId === "deepseek-harness" && failure.retryable;
+                    if (failure.dispatchOutcome === "outcome_unknown" || providerLimited || deepSeekTransient) {
+                      const runtimeState = await readInferenceAgentRuntimeState(
+                        agentRuntimeSettings.statePath
+                      );
+                      const retryAtMs = failure.dispatchOutcome === "outcome_unknown" || failure.category === "auth" && settings.adapterId === "deepseek-harness" ? null : error48.retryAtMs !== null && error48.retryAtMs > now() ? error48.retryAtMs : now() + (failure.category === "quota" || failure.code === "quota_exceeded" ? DEFAULT_AGENT_QUOTA_COOLDOWN_MS : failure.category === "auth" ? DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS : failure.code === "provider_rate_limited" || failure.code === "codex_rate_limited" ? DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS : DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS);
+                      await writeInferenceAgentFailureFence(agentRuntimeSettings.statePath, {
+                        schema_version: "vtx_inference_agent_failure_fence_v1",
+                        adapter_id: settings.adapterId,
+                        host_id: localState.host_id,
+                        assignment_id: runtimeState?.schema_version === "vtx_inference_agent_runtime_v3" ? runtimeState.assignment.assignment_id : null,
+                        failure_category: safeFailureCode(failure.category, "adapter"),
+                        failure_code: safeFailureCode(failure.code, "adapter_failure"),
+                        dispatch_outcome: failure.dispatchOutcome,
+                        retry_at: retryAtMs === null ? null : isoAt(retryAtMs),
+                        created_at: isoAt(now())
+                      });
+                      if (failure.dispatchOutcome !== "outcome_unknown") {
+                        try {
+                          await agentRuntime.releaseAfterProviderFailure(failure.code);
+                        } catch {
+                        }
+                      }
+                      emitDiagnostic(
+                        retryAtMs === null ? "agent_runtime_quarantined" : "agent_runtime_cooldown",
+                        {
+                          assignment_id: runtimeState?.schema_version === "vtx_inference_agent_runtime_v3" ? runtimeState.assignment.assignment_id : null,
+                          failure_category: failure.category,
+                          failure_code: failure.code,
+                          dispatch_outcome: failure.dispatchOutcome,
+                          cooldown_until: retryAtMs === null ? null : isoAt(retryAtMs)
+                        }
+                      );
+                      if (this.options.once || retryAtMs === null) return;
+                      try {
+                        await sleep4(Math.max(MIN_SLEEP_MS, retryAtMs - now()), agentAbort.signal);
+                      } catch {
+                        return;
+                      }
+                      continue;
+                    }
+                  }
                   emitDiagnostic("agent_runtime_retry", {
                     error_code: error48 && typeof error48 === "object" && "code" in error48 ? String(error48.code) : "agent_runtime_error"
                   });
@@ -32201,7 +33378,13 @@ var init_runner = __esm({
                 }
               }
             })();
-            void agentLoop.catch(() => void 0);
+            void agentLoop.catch((error48) => {
+              if (agentAbort.signal.aborted) return;
+              emitDiagnostic("agent_runtime_fence_failed", {
+                error_code: error48 && typeof error48 === "object" && "code" in error48 ? String(error48.code) : "agent_runtime_fence_failed"
+              });
+              requestDrain("agent_recovery_failed");
+            });
           }
           const existingReceipt = await this.dependencies.receiptStore.read();
           const identityMatches = existingReceipt && existingReceipt.host_id === localState.host_id && existingReceipt.host_generation === localState.host_generation && existingReceipt.key_generation === localState.key_generation;
@@ -33379,10 +34562,10 @@ var init_runner = __esm({
           if (error48 instanceof InferenceHostRunnerError && error48.code === "terminal_outcome_unconfirmed") {
             throw error48;
           }
-          if (error48 instanceof CodexAppServerError && error48.retryAtMs !== null && ["quota_exceeded", "codex_rate_limited"].includes(error48.code)) {
+          if (error48 instanceof CodexAppServerError && error48.retryAtMs !== null && ["quota_exceeded", "codex_rate_limited", "provider_rate_limited"].includes(error48.code)) {
             options.onProviderCooldown?.({
               retryAtMs: error48.retryAtMs,
-              reason: error48.code === "quota_exceeded" ? "quota_exceeded" : "codex_rate_limited",
+              reason: error48.code === "quota_exceeded" ? "quota_exceeded" : error48.code === "provider_rate_limited" ? "provider_rate_limited" : "codex_rate_limited",
               rateLimits: error48.rateLimits
             });
           }
@@ -33597,6 +34780,9 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
       stop() {
         this.stopped = true;
       }
+      async releaseAfterProviderFailure(reasonCode) {
+        await this.releaseForHostStop(safeFailureCode(reasonCode, "provider_failure"));
+      }
       async run(signal) {
         let exitedNormally = false;
         try {
@@ -33613,10 +34799,14 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
       }
       async runSingle(signal) {
+        let exitedNormally = false;
         try {
           await this.runOnce(signal);
+          exitedNormally = true;
         } finally {
-          await this.releaseForHostStop();
+          if (exitedNormally || this.stopped || signal?.aborted) {
+            await this.releaseForHostStop();
+          }
         }
       }
       async runOnce(signal) {
@@ -33662,7 +34852,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
         if (!state) {
           const assignment2 = await this.options.controlClient.nextAssignment({
-            operation_id: randomUUID2(),
+            operation_id: randomUUID3(),
             host_id: this.options.hostId,
             requested_at: nowIso()
           }, { signal });
@@ -33695,7 +34885,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         state = await this.resolvePendingDecision(state, signal);
         let assignment = state.assignment;
         const preTurnHeartbeat = await this.options.controlClient.heartbeat({
-          operation_id: randomUUID2(),
+          operation_id: randomUUID3(),
           host_id: this.options.hostId,
           assignment_id: assignment.assignment_id,
           assignment_generation: assignment.assignment_generation,
@@ -33720,7 +34910,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         const heartbeatTask = (async () => {
           while (!heartbeatStopped && !turnAbort.signal.aborted) {
             const heartbeat = await this.options.controlClient.heartbeat({
-              operation_id: randomUUID2(),
+              operation_id: randomUUID3(),
               host_id: this.options.hostId,
               assignment_id: assignment.assignment_id,
               assignment_generation: assignment.assignment_generation,
@@ -33777,7 +34967,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   return { success: false, value: { error: "invalid_data_request" } };
                 }
                 const value = await this.options.controlClient.dataCall({
-                  operation_id: randomUUID2(),
+                  operation_id: randomUUID3(),
                   host_id: this.options.hostId,
                   assignment_id: assignment.assignment_id,
                   assignment_generation: assignment.assignment_generation,
@@ -33801,7 +34991,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   return { success: false, value: { error: "decision_outcome_unresolved" } };
                 }
                 const pending = {
-                  operation_id: randomUUID2(),
+                  operation_id: randomUUID3(),
                   candidate,
                   observed_at: nowIso(),
                   provenance: {
@@ -33875,7 +35065,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           const nextWakeAtMs = this.now() + wakeSeconds * 1e3;
           const scheduledWakeAt = new Date(nextWakeAtMs).toISOString();
           const wakeHeartbeat = await this.options.controlClient.heartbeat({
-            operation_id: randomUUID2(),
+            operation_id: randomUUID3(),
             host_id: this.options.hostId,
             assignment_id: assignment.assignment_id,
             assignment_generation: assignment.assignment_generation,
@@ -33993,7 +35183,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           if (state?.schema_version !== "vtx_inference_agent_runtime_v3" || state.adapter_id !== this.options.adapterId) return "cancelled";
           const requestedAt = new Date(this.now()).toISOString();
           const heartbeat = await this.options.controlClient.heartbeat({
-            operation_id: randomUUID2(),
+            operation_id: randomUUID3(),
             host_id: this.options.hostId,
             assignment_id: state.assignment.assignment_id,
             assignment_generation: state.assignment.assignment_generation,
@@ -34014,7 +35204,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
         return this.stopped || signal?.aborted ? "stopped" : "ready";
       }
-      async releaseForHostStop() {
+      async releaseForHostStop(reasonCode = "host_stopped") {
         const recovered = await readInferenceAgentRuntimeState(this.options.statePath);
         if (!recovered) return;
         let state;
@@ -34040,11 +35230,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
         if (state.pending_decision) return;
         await this.options.controlClient.releaseAssignment({
-          operation_id: randomUUID2(),
+          operation_id: randomUUID3(),
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
           assignment_generation: state.assignment.assignment_generation,
-          reason_code: "host_stopped",
+          reason_code: reasonCode,
           requested_at: new Date(this.now()).toISOString()
         }, {});
         if (state.thread) await this.options.adapter.releaseThread(state.thread);
@@ -34056,11 +35246,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
 
 // lib/inference-host/service.ts
 import { spawn as spawn6 } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { createWriteStream, readFileSync } from "node:fs";
-import { access as access3, chmod as chmod3, mkdir as mkdir3, readFile as readFile5, rm as rm5, writeFile as writeFile2 } from "node:fs/promises";
+import { access as access3, chmod as chmod3, mkdir as mkdir3, readFile as readFile5, rm as rm6, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname4, join as join6, resolve as resolve4 } from "node:path";
+import { dirname as dirname5, join as join7, 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"() {
@@ -34529,8 +35719,8 @@ WantedBy=default.target
       }
       definitionPath() {
         if (this.platform === "win32") return `${this.config.supervisorStatePath}.service-task.xml`;
-        if (this.platform === "darwin") return join6(this.home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-        return join6(this.home, ".config", "systemd", "user", SYSTEMD_UNIT);
+        if (this.platform === "darwin") return join7(this.home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+        return join7(this.home, ".config", "systemd", "user", SYSTEMD_UNIT);
       }
       windowsLauncherPath() {
         return `${this.config.supervisorStatePath}.service-launcher.vbs`;
@@ -34581,7 +35771,7 @@ WantedBy=default.target
         const previousRuntimeUpdatedAt = previousRuntime?.manifest_generation === manifest.generation ? Date.parse(previousRuntime.updated_at) : Number.NaN;
         const restoredManifest = preserveGeneration ? manifest : assertManifest({
           ...manifest,
-          generation: randomUUID3(),
+          generation: randomUUID4(),
           installed_at: this.now().toISOString()
         });
         await writeAtomicInferencePrivateFile(
@@ -34663,7 +35853,7 @@ ${result2.stderr}`)) {
           await writeAtomicInferencePrivateFile(this.manifestPath(), `${JSON.stringify(manifest, null, 2)}
 `);
           await writeDesired(this.desiredPath(), desiredRunning, this.now());
-          await mkdir3(dirname4(this.definitionPath()), { recursive: true, mode: 448 });
+          await mkdir3(dirname5(this.definitionPath()), { recursive: true, mode: 448 });
           if (this.platform === "win32") {
             await writeAtomicInferencePrivateFile(
               this.windowsLauncherPath(),
@@ -34712,13 +35902,13 @@ ${cleanup.stderr}`)) {
               );
             }
           }
-          await rm5(this.definitionPath(), { force: true }).catch(() => void 0);
+          await rm6(this.definitionPath(), { force: true }).catch(() => void 0);
           if (this.platform === "win32") {
-            await rm5(this.windowsLauncherPath(), { force: true }).catch(() => void 0);
+            await rm6(this.windowsLauncherPath(), { 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);
+          await rm6(this.manifestPath(), { force: true }).catch(() => void 0);
+          await rm6(this.desiredPath(), { force: true }).catch(() => void 0);
+          await rm6(this.runtimePath(), { force: true }).catch(() => void 0);
           if (this.platform === "linux") {
             await this.runCommand("systemctl", ["--user", "daemon-reload"]).catch(() => void 0);
           }
@@ -34867,7 +36057,7 @@ ${cleanup.stderr}`)) {
         ].sort((left, right) => left.instance_name.localeCompare(right.instance_name));
         const manifest = assertManifest({
           schema_version: "vtx_inference_service_v3",
-          generation: randomUUID3(),
+          generation: randomUUID4(),
           installed_at: this.now().toISOString(),
           executable: this.executable,
           script: this.script,
@@ -35081,7 +36271,7 @@ ${result2.stderr}`)) {
           if (remaining.length === 0) return await this.uninstallUnlocked();
           return await this.replaceManifestUnlocked({
             ...manifest,
-            generation: randomUUID3(),
+            generation: randomUUID4(),
             installed_at: this.now().toISOString(),
             workers: remaining
           }, await readInferenceHostServiceDesired(this.desiredPath()));
@@ -35104,12 +36294,12 @@ ${result2.stderr}`)) {
 ${result2.stderr}`)) {
           throw new Error(`Background service uninstall failed: ${result2.stderr.trim()}`);
         }
-        await rm5(this.definitionPath(), { force: true });
-        if (this.platform === "win32") await rm5(this.windowsLauncherPath(), { force: true });
+        await rm6(this.definitionPath(), { force: true });
+        if (this.platform === "win32") await rm6(this.windowsLauncherPath(), { force: true });
         if (this.platform === "linux") await this.runCommand("systemctl", ["--user", "daemon-reload"]);
-        await rm5(this.manifestPath(), { force: true });
-        await rm5(this.desiredPath(), { force: true });
-        await rm5(this.runtimePath(), { force: true });
+        await rm6(this.manifestPath(), { force: true });
+        await rm6(this.desiredPath(), { force: true });
+        await rm6(this.runtimePath(), { force: true });
         return {
           installed: false,
           desired_running: false,
@@ -35123,7 +36313,7 @@ ${result2.stderr}`)) {
       }
     };
     appendServiceLog = async (path, event, fields = {}) => {
-      await mkdir3(dirname4(path), { recursive: true, mode: 448 });
+      await mkdir3(dirname5(path), { recursive: true, mode: 448 });
       const stream = createWriteStream(path, { flags: "a", mode: 384 });
       await new Promise((resolvePromise, reject) => {
         stream.once("error", reject);
@@ -35471,11 +36661,11 @@ __export(cli_exports, {
   registerInferenceHostServiceControlInput: () => registerInferenceHostServiceControlInput,
   runInferenceHostCli: () => runInferenceHostCli
 });
-import { createHash as createHash7, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID5 } 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 { lstat as lstat4, realpath as realpath5, rm as rm7 } from "node:fs/promises";
 import { hostname as osHostname } from "node:os";
-import { join as join7, resolve as resolve5 } from "node:path";
+import { join as join8, resolve as resolve5 } from "node:path";
 async function runInferenceHostCli(argv2, env = process.env, dependencies = {}) {
   const warnings = [];
   try {
@@ -35505,6 +36695,9 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     if (parsed.command === "codex-login") {
       return await codexLogin(config2, parsed, env, dependencies);
     }
+    if (parsed.command === "deepseek-login") {
+      return await deepSeekLogin(config2, parsed, dependencies);
+    }
     if (parsed.command === "run") {
       return await runHost(config2, parsed, env, dependencies, warnings);
     }
@@ -35597,11 +36790,14 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     if (parsed.command === "codex-logout") {
       return await codexLogout(config2, parsed, env, dependencies);
     }
+    if (parsed.command === "deepseek-logout") {
+      return await deepSeekLogout(config2, parsed, dependencies);
+    }
     if (parsed.command === "revoke") {
       return await cleanupLogin(config2, parsed, dependencies, warnings, true);
     }
     throw new Error(
-      "Usage: vtx inference-host <login|codex-login|run|agent-connect|agent-run|agent-next|agent-complete|agent-fail|agent-assignment-next|agent-assignment-heartbeat|agent-data-call|agent-decision-submit|agent-decision-status|agent-assignment-release|service|status|doctor|logout|codex-logout|revoke> [--json]"
+      "Usage: vtx inference-host <login|codex-login|deepseek-login|run|agent-connect|agent-run|agent-next|agent-complete|agent-fail|agent-assignment-next|agent-assignment-heartbeat|agent-data-call|agent-decision-submit|agent-decision-status|agent-assignment-release|service|status|doctor|logout|codex-logout|deepseek-logout|revoke> [--json]"
     );
   } catch (error48) {
     return {
@@ -35612,7 +36808,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     };
   }
 }
-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, resolveDurableServiceDisplayName, 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, parseOptionalAgentStdin, agentOperationId, agentSession, agentConnect, foregroundAgentControlState, requireForegroundAgentState, assignmentFromClaim, foregroundAssignmentNext, foregroundAssignmentHeartbeat, foregroundDataCall, foregroundDecisionStatusRequest, foregroundAssignmentLeaseEnded, handleForegroundCancelledAssignment, foregroundDecisionStatus, foregroundDecisionSubmit, foregroundAssignmentRelease, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, recoveryBackupPath, serviceRecoveryTransactionPath, readServiceRecoveryTransaction, assertResumableCodexRecoveryEvidence, recoverInstalledCodexService, 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, resolveDurableServiceDisplayName, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, preparePortableDurableAdapter, defaultRunPortableDurableAdapter, login, codexLogin, codexLogout, deepSeekCredentialStore, deepSeekLogin, deepSeekLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, parseOptionalAgentStdin, agentOperationId, agentSession, agentConnect, foregroundAgentControlState, requireForegroundAgentState, assignmentFromClaim, foregroundAssignmentNext, foregroundAssignmentHeartbeat, foregroundDataCall, foregroundDecisionStatusRequest, foregroundAssignmentLeaseEnded, handleForegroundCancelledAssignment, foregroundDecisionStatus, foregroundDecisionSubmit, foregroundAssignmentRelease, 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";
@@ -35623,6 +36819,8 @@ var init_cli = __esm({
     init_codex_adapter();
     init_codex_recovery_process();
     init_copilot_adapter();
+    init_deepseek_harness_adapter();
+    init_deepseek_credential_store();
     init_durable_adapter();
     init_codex_app_server();
     init_codex_binary();
@@ -35706,6 +36904,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
+  deepseek-login  Import a DeepSeek API key privately from stdin
   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
@@ -35724,11 +36923,12 @@ Commands:
   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
+  deepseek-logout Remove the locally stored DeepSeek API key
 
 Common options:
   --json           Emit machine-readable JSON
   --instance NAME  Target an isolated local subscription instance (default: default)
-  --adapter ID     Durable adapter: codex or copilot
+  --adapter ID     Durable adapter: codex, copilot, or deepseek-harness
   --max-concurrency N  Optional positive-integer local slot limit (default: unlimited)
   --help, -h       Show this help
 
@@ -35744,6 +36944,8 @@ Durable service:
   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 deepseek-login --instance deepseek-1 < /private/path/deepseek.key
+  vtx inference-host service install --adapter deepseek-harness --instance deepseek-1
   vtx inference-host service uninstall --instance codex-2
   vtx inference-host service recover --instance codex-1 --force-recovery
   vtx inference-host service <start|stop|status|logs|recover|uninstall>
@@ -35850,7 +37052,7 @@ Durable service:
       if (command === "agent-connect" && !displayNameExplicit) {
         displayName = "Agent-driven inference host";
       } else if (adapter && isDurableInferenceAdapterId(adapter) && !displayNameExplicit) {
-        displayName = `${durableAdapterDisplayName(adapter)} subscription host`;
+        displayName = `${durableAdapterDisplayName(adapter)} host`;
       }
       return {
         command,
@@ -36007,10 +37209,10 @@ Durable service:
       return raw !== null;
     };
     inspectCodexAuthentication = async (config2) => {
-      const path = join7(config2.codexHomePath, "auth.json");
+      const path = join8(config2.codexHomePath, "auth.json");
       try {
         const before = await lstat4(path);
-        const canonical = await realpath4(path);
+        const canonical = await realpath5(path);
         const isPrivate = before.isFile() && !before.isSymbolicLink() && canonical === resolve5(path) && before.size <= 8 * 1024 * 1024 && (process.platform === "win32" || (before.mode & 63) === 0 && (typeof process.getuid !== "function" || before.uid === process.getuid()));
         return { present: true, private: isPrivate };
       } catch (error48) {
@@ -36025,7 +37227,7 @@ Durable service:
         runtimeReceiptPath(config2),
         "Inference host runtime receipt file"
       );
-      await rm6(codexGuardianReceiptRoot(config2), { recursive: true, force: true });
+      await rm7(codexGuardianReceiptRoot(config2), { recursive: true, force: true });
       await clearInferencePrivateFile(
         codexRecoveryPath(config2),
         "Codex attempt recovery file"
@@ -36034,6 +37236,7 @@ Durable service:
       await clearInferenceAgentNextState(config2.statePath);
       await clearInferenceForegroundAgentControlState(config2.statePath);
       await clearCodexAgentRuntimeState(config2.statePath);
+      await clearInferenceAgentFailureFence(config2.statePath);
       await clearInferenceHostLocalState(config2.statePath);
     };
     assertDurableServiceUninstalled = async (config2) => {
@@ -36062,7 +37265,8 @@ Durable service:
       const agentNextRecoveryPresent = await readInferenceAgentNextState(config2.statePath) !== null;
       const foregroundAgentControlPresent = await readInferenceForegroundAgentControlState(config2.statePath) !== null;
       const codexAgentRuntimePresent = await readCodexAgentRuntimeState(config2.statePath) !== null;
-      if (pendingAttempts > 0 || codexRecoveryPresent || serviceRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent || foregroundAgentControlPresent || codexAgentRuntimePresent) {
+      const agentFailureFencePresent = await readInferenceAgentFailureFence(config2.statePath) !== null;
+      if (pendingAttempts > 0 || codexRecoveryPresent || serviceRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent || foregroundAgentControlPresent || codexAgentRuntimePresent || agentFailureFencePresent) {
         throw new Error(
           "Inference host logout refused because attempt recovery is still pending (Codex, Provider, Agent-control, or revocation recovery). Reconcile or release the exact active operation before retrying logout, or resume revoke."
         );
@@ -36132,8 +37336,10 @@ Durable service:
         signal: options.signal
       }).run();
     };
-    preparePortableDurableAdapter = async (adapterId, signal) => {
-      const adapter = new CopilotSubscriptionAdapter();
+    preparePortableDurableAdapter = async (adapterId, config2, signal) => {
+      const adapter = adapterId === "copilot" ? new CopilotSubscriptionAdapter() : new DeepSeekHarnessAdapter({
+        credentialStore: createDeepSeekHarnessCredentialStore(config2)
+      });
       return { adapter, preflight: await adapter.preflight(signal) };
     };
     defaultRunPortableDurableAdapter = async (options) => {
@@ -36215,7 +37421,7 @@ Durable service:
         await writeInferenceHostCredentialContextTransition(config2, previousCredentialContext);
         await writeInferenceHostCredentialContext(config2);
         const keyPair = generateExternalInferenceEnvelopeKeyPair();
-        const hostId = randomUUID4();
+        const hostId = randomUUID5();
         const beginLogin = dependencies.beginLogin ?? beginInferenceOAuthLogin;
         const loginStore = {
           kind: store.kind,
@@ -36413,6 +37619,53 @@ Waiting for approval...
         cancellation.unregister();
       }
     };
+    deepSeekCredentialStore = (config2, dependencies) => dependencies.createDeepSeekCredentialStore?.(config2) ?? createDeepSeekHarnessCredentialStore(config2);
+    deepSeekLogin = async (config2, parsed, dependencies) => {
+      await assertDurableServiceUninstalled(config2);
+      if (!dependencies.readStdin && process.stdin.isTTY) {
+        throw new Error("DeepSeek API key must be supplied through stdin, never as an argument.");
+      }
+      const cancellation = lifecycleCancellation(dependencies);
+      let lock2 = null;
+      try {
+        lock2 = await acquireInferenceHostProcessLock(config2.processLockPath);
+        const raw = await (dependencies.readStdin ?? defaultReadStdin)();
+        const credential = await deepSeekCredentialStore(config2, dependencies).write(
+          raw,
+          cancellation.signal
+        );
+        const failureFence = await readInferenceAgentFailureFence(config2.statePath);
+        if (failureFence?.adapter_id === "deepseek-harness" && failureFence.failure_category === "auth") {
+          await clearInferenceAgentFailureFence(config2.statePath);
+        }
+        return {
+          exitCode: 0,
+          stdout: render({
+            status: "deepseek_api_key_imported",
+            identity: credential.identity,
+            credential_store: config2.credentialStoreMode
+          }, parsed.json),
+          stderr: ""
+        };
+      } finally {
+        await lock2?.release();
+        cancellation.unregister();
+      }
+    };
+    deepSeekLogout = async (config2, parsed, dependencies) => {
+      await assertDurableServiceUninstalled(config2);
+      const lock2 = await acquireInferenceHostProcessLock(config2.processLockPath);
+      try {
+        await deepSeekCredentialStore(config2, dependencies).remove();
+        return {
+          exitCode: 0,
+          stdout: render({ status: "deepseek_api_key_removed" }, parsed.json),
+          stderr: ""
+        };
+      } finally {
+        await lock2.release();
+      }
+    };
     localStatus = async (config2, parsed, dependencies, warnings) => {
       const codexAuthentication = await inspectCodexAuthentication(config2);
       const state = await readInferenceHostLocalState(config2.statePath);
@@ -36457,6 +37710,7 @@ Waiting for approval...
       );
       const agentAttempt = await readInferenceAgentAttemptState(config2.statePath);
       const agentNextRecoveryPresent = await readInferenceAgentNextState(config2.statePath) !== null;
+      const agentFailureFence = await readInferenceAgentFailureFence(config2.statePath);
       return {
         exitCode: 0,
         stdout: render({
@@ -36482,6 +37736,13 @@ Waiting for approval...
             deadline_at: agentAttempt.deadline_at
           } : null,
           agent_next_recovery_present: agentNextRecoveryPresent,
+          agent_failure_fence: agentFailureFence ? {
+            adapter: agentFailureFence.adapter_id,
+            failure_category: agentFailureFence.failure_category,
+            failure_code: agentFailureFence.failure_code,
+            dispatch_outcome: agentFailureFence.dispatch_outcome,
+            retry_at: agentFailureFence.retry_at
+          } : null,
           codex_recovery_present: recoveryPresent,
           service_recovery_present: serviceRecoveryPresent,
           codex_auth: codexAuthentication,
@@ -36500,6 +37761,12 @@ Waiting for approval...
         ok: state !== null,
         detail: state ? "valid" : "missing"
       });
+      const agentFailureFence = await readInferenceAgentFailureFence(config2.statePath);
+      checks.push({
+        name: "agent_runtime_fence",
+        ok: agentFailureFence === null,
+        detail: agentFailureFence === null ? "clear" : `${agentFailureFence.failure_code}:${agentFailureFence.dispatch_outcome}`
+      });
       checks.push({
         name: "revocation_recovery",
         ok: revocationCheckpoint === null,
@@ -36538,7 +37805,8 @@ Waiting for approval...
       } else if (adapterId !== "codex") {
         try {
           const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
-            adapterId
+            adapterId,
+            config2
           );
           checks.push({
             name: "provider_runtime",
@@ -36796,6 +38064,7 @@ Waiting for approval...
         if (adapterId !== "codex") {
           const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
             adapterId,
+            config2,
             cancellation.signal
           );
           const summary = await (dependencies.runPortableDurableAdapter ?? defaultRunPortableDurableAdapter)({
@@ -36915,7 +38184,7 @@ Waiting for approval...
       }
       return record2;
     };
-    agentOperationId = (kind) => `${kind}-${randomUUID4()}`;
+    agentOperationId = (kind) => `${kind}-${randomUUID5()}`;
     agentSession = async (config2, dependencies, warnings, signal) => {
       if (await readRevocationCheckpoint(config2)) {
         throw new Error("Inference host revocation recovery must finish first.");
@@ -37932,7 +39201,7 @@ Waiting for approval...
         if (recoveryRaw === null && existingTransaction?.phase !== "reconciled") {
           throw new Error("Codex recovery evidence changed before service recovery began.");
         }
-        const transactionId = existingTransaction?.transaction_id ?? randomUUID4();
+        const transactionId = existingTransaction?.transaction_id ?? randomUUID5();
         const backupPath = existingTransaction?.recovery_backup_path ?? recoveryBackupPath(config2, transactionId);
         if (!existingTransaction) {
           await writeAtomicInferencePrivateFile(backupPath, recoveryRaw);
@@ -37941,7 +39210,7 @@ Waiting for approval...
           backupPath,
           "Codex service recovery backup"
         );
-        const backupSha256 = backupRaw === null ? null : createHash7("sha256").update(backupRaw).digest("hex");
+        const backupSha256 = backupRaw === null ? null : createHash8("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.");
         }
@@ -37952,7 +39221,7 @@ Waiting for approval...
           existingTransaction?.cleanup_confirmed_attempt_ids ?? [],
           existingTransaction?.phase ?? "prepared"
         );
-        const recoverySha256 = recoveryRaw === null ? null : createHash7("sha256").update(recoveryRaw).digest("hex");
+        const recoverySha256 = recoveryRaw === null ? null : createHash8("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;
@@ -37991,7 +39260,7 @@ Waiting for approval...
                   codexRecoveryPath(config2),
                   "Codex attempt recovery file"
                 );
-                if (currentRaw === null || recoverySha256 === null || createHash7("sha256").update(currentRaw).digest("hex") !== recoverySha256) {
+                if (currentRaw === null || recoverySha256 === null || createHash8("sha256").update(currentRaw).digest("hex") !== recoverySha256) {
                   throw new Error("Codex recovery evidence changed while the service was stopping.");
                 }
                 const proof = await (dependencies.proveCodexQuiescence ?? proveCodexSameBootQuiescence)({
@@ -38080,7 +39349,7 @@ Waiting for approval...
               serviceRecoveryTransactionPath(config2),
               "Inference-host service recovery transaction"
             );
-            await rm6(backupPath, { force: true });
+            await rm7(backupPath, { force: true });
           }
         }
       } finally {
@@ -38161,7 +39430,8 @@ Waiting for approval...
           const displayName = resolveDurableServiceDisplayName(parsed, dependencies);
           if (adapter !== "codex") {
             const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
-              adapter
+              adapter,
+              config2
             );
             try {
               const status2 = await manager.install({
@@ -38348,11 +39618,11 @@ Waiting for approval...
 });
 
 // lib/agent-core/config.ts
-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 { mkdir as mkdir5, readFile as readFile6, rm as rm8, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname6, join as join9 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function defaultBaseDir() {
-  return join8(homedir3(), ".vtx");
+  return join9(homedir3(), ".vtx");
 }
 function resolveAgentCliConfig(env = process.env) {
   const baseDir = String(env.VTX_HOME || "").trim() || defaultBaseDir();
@@ -38360,8 +39630,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() || join8(baseDir, "token.json"),
-    statePath: String(env.VTX_RUNTIME_STATE_PATH || "").trim() || join8(baseDir, "runtime-state.json"),
+    tokenPath: String(env.VTX_TOKEN_PATH || "").trim() || join9(baseDir, "token.json"),
+    statePath: String(env.VTX_RUNTIME_STATE_PATH || "").trim() || join9(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"
@@ -38387,12 +39657,12 @@ async function readStoredAgentAuth(path) {
   }
 }
 async function writeStoredAgentAuth(path, auth) {
-  await mkdir5(dirname5(path), { recursive: true });
+  await mkdir5(dirname6(path), { recursive: true });
   await writeFile3(path, `${JSON.stringify(auth, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 async function clearStoredAgentAuth(path) {
-  await rm7(path, { force: true });
+  await rm8(path, { force: true });
 }
 async function readRuntimeState(path) {
   try {
@@ -38422,12 +39692,12 @@ async function readRuntimeState(path) {
   }
 }
 async function writeRuntimeState(path, state) {
-  await mkdir5(dirname5(path), { recursive: true });
+  await mkdir5(dirname6(path), { recursive: true });
   await writeFile3(path, `${JSON.stringify(state, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 async function clearRuntimeState(path) {
-  await rm7(path, { force: true });
+  await rm8(path, { force: true });
 }
 var init_config2 = __esm({
   "lib/agent-core/config.ts"() {
@@ -38453,7 +39723,7 @@ var init_types = __esm({
 });
 
 // lib/agent-core/client.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function normalizeApiUrl(value) {
   const parsed = String(value || "").trim();
   if (!parsed) {
@@ -38715,7 +39985,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/decision", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -38724,7 +39994,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/trade-sync", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -38733,7 +40003,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/error", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -38745,7 +40015,7 @@ var init_client = __esm({
         return this.request("/trading/market-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38753,7 +40023,7 @@ var init_client = __esm({
         return this.request("/trading/limit-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38761,7 +40031,7 @@ var init_client = __esm({
         return this.request("/trading/cancel-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38780,7 +40050,7 @@ var init_client = __esm({
         return this.request("/trading/ai/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38788,7 +40058,7 @@ var init_client = __esm({
         return this.request("/trading/ai/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: {}
         });
       }
@@ -38796,7 +40066,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: {}
         });
       }
@@ -38804,7 +40074,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: {}
         });
       }
@@ -38812,7 +40082,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/session/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38823,7 +40093,7 @@ var init_client = __esm({
           return this.request("/trading/ai/runtime/session/stop", {
             method: "POST",
             profileId,
-            idempotencyKey: randomUUID5(),
+            idempotencyKey: randomUUID6(),
             body: payload
           });
         }
@@ -38840,7 +40110,7 @@ var init_client = __esm({
         }).request("/trading/ai/runtime/session/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38857,8 +40127,8 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { dirname as dirname6 } from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { dirname as dirname7 } from "node:path";
 var parseStoredValues, FileBackedProtectionStorage, clientRuntimeProtectionStatePath;
 var init_protection_storage = __esm({
   "lib/agent-core/protection-storage.ts"() {
@@ -38911,10 +40181,10 @@ var init_protection_storage = __esm({
         }
       }
       writeValues(values) {
-        mkdirSync(dirname6(this.path), { recursive: true, mode: 448 });
+        mkdirSync(dirname7(this.path), { recursive: true, mode: 448 });
         const serialized = `${JSON.stringify(values)}
 `;
-        const temporaryPath = `${this.path}.${process.pid}.${randomUUID6()}.tmp`;
+        const temporaryPath = `${this.path}.${process.pid}.${randomUUID7()}.tmp`;
         try {
           writeFileSync(temporaryPath, serialized, {
             encoding: "utf8",
@@ -38941,7 +40211,7 @@ var init_protection_storage = __esm({
 });
 
 // lib/agent-core/headless-runtime.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 function objectOrNull2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -39039,8 +40309,8 @@ async function runAndReportLocalWorkCycle(options, state, leaseToken, context) {
   return Boolean(result2.decision || tradeSync || result2.afterDecision);
 }
 async function startHeadlessRuntime(options) {
-  const runtimeSessionId = randomUUID7();
-  const deviceId = String(options.deviceId || "").trim() || randomUUID7();
+  const runtimeSessionId = randomUUID8();
+  const deviceId = String(options.deviceId || "").trim() || randomUUID8();
   const startResponse = await options.client.startRuntime(options.profileId, {
     session_id: runtimeSessionId,
     device_id: deviceId,
@@ -43725,8 +44995,8 @@ var init_rlp_encode = __esm({
 });
 
 // node_modules/ethers/lib.esm/utils/uuid.js
-function uuidV4(randomBytes8) {
-  const bytes3 = getBytes(randomBytes8, "randomBytes");
+function uuidV4(randomBytes9) {
+  const bytes3 = getBytes(randomBytes9, "randomBytes");
   bytes3[6] = bytes3[6] & 15 | 64;
   bytes3[8] = bytes3[8] & 63 | 128;
   const value = hexlify(bytes3);
@@ -43760,7 +45030,7 @@ var init_utils = __esm({
 });
 
 // node_modules/ethers/lib.esm/crypto/crypto.js
-import { createHash as createHash8, createHmac, pbkdf2Sync, randomBytes as randomBytes5 } from "crypto";
+import { createHash as createHash9, createHmac, pbkdf2Sync, randomBytes as randomBytes6 } from "crypto";
 var init_crypto2 = __esm({
   "node_modules/ethers/lib.esm/crypto/crypto.js"() {
   }
@@ -44414,7 +45684,7 @@ var init_pbkdf2 = __esm({
 });
 
 // node_modules/ethers/lib.esm/crypto/random.js
-function randomBytes6(length) {
+function randomBytes7(length) {
   return __randomBytes(length);
 }
 var locked5, _randomBytes, __randomBytes;
@@ -44423,20 +45693,20 @@ var init_random = __esm({
     init_crypto2();
     locked5 = false;
     _randomBytes = function(length) {
-      return new Uint8Array(randomBytes5(length));
+      return new Uint8Array(randomBytes6(length));
     };
     __randomBytes = _randomBytes;
-    randomBytes6._ = _randomBytes;
-    randomBytes6.lock = function() {
+    randomBytes7._ = _randomBytes;
+    randomBytes7.lock = function() {
       locked5 = true;
     };
-    randomBytes6.register = function(func) {
+    randomBytes7.register = function(func) {
       if (locked5) {
         throw new Error("randomBytes is locked");
       }
       __randomBytes = func;
     };
-    Object.freeze(randomBytes6);
+    Object.freeze(randomBytes7);
   }
 });
 
@@ -44974,10 +46244,10 @@ var init_sha22 = __esm({
     init_crypto2();
     init_utils();
     _sha256 = function(data) {
-      return createHash8("sha256").update(data).digest();
+      return createHash9("sha256").update(data).digest();
     };
     _sha512 = function(data) {
-      return createHash8("sha512").update(data).digest();
+      return createHash9("sha512").update(data).digest();
     };
     __sha256 = _sha256;
     __sha512 = _sha512;
@@ -45084,7 +46354,7 @@ function wrapConstructor2(hashCons) {
   hashC.create = () => hashCons();
   return hashC;
 }
-function randomBytes7(bytesLength = 32) {
+function randomBytes8(bytesLength = 32) {
   if (crypto2 && typeof crypto2.getRandomValues === "function") {
     return crypto2.getRandomValues(new Uint8Array(bytesLength));
   }
@@ -46623,7 +47893,7 @@ function weierstrass(curveDef) {
   function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
     if (["recovered", "canonical"].some((k) => k in opts))
       throw new Error("sign() legacy options not supported");
-    const { hash: hash4, randomBytes: randomBytes8 } = CURVE;
+    const { hash: hash4, randomBytes: randomBytes9 } = CURVE;
     let { lowS, prehash, extraEntropy: ent } = opts;
     if (lowS == null)
       lowS = true;
@@ -46634,7 +47904,7 @@ function weierstrass(curveDef) {
     const d = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d), int2octets(h1int)];
     if (ent != null) {
-      const e = ent === true ? randomBytes8(Fp2.BYTES) : ent;
+      const e = ent === true ? randomBytes9(Fp2.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e));
     }
     const seed = concatBytes2(...seedArgs);
@@ -46871,7 +48141,7 @@ function getHash(hash4) {
   return {
     hash: hash4,
     hmac: (key, ...msgs) => hmac2(hash4, key, concatBytes(...msgs)),
-    randomBytes: randomBytes7
+    randomBytes: randomBytes8
   };
 }
 function createCurve(curveDef, defHash) {
@@ -50845,7 +52115,7 @@ async function decryptKeystoreJson(json2, _password, progress) {
   return getAccount(data, key);
 }
 function getEncryptKdfParams(options) {
-  const salt = options.salt != null ? getBytes(options.salt, "options.salt") : randomBytes6(32);
+  const salt = options.salt != null ? getBytes(options.salt, "options.salt") : randomBytes7(32);
   let N2 = 1 << 17, r = 8, p = 1;
   if (options.scrypt) {
     if (options.scrypt.N) {
@@ -50865,9 +52135,9 @@ function getEncryptKdfParams(options) {
 }
 function _encryptKeystore(key, kdf, account, options) {
   const privateKey = getBytes(account.privateKey, "privateKey");
-  const iv = options.iv != null ? getBytes(options.iv, "options.iv") : randomBytes6(16);
+  const iv = options.iv != null ? getBytes(options.iv, "options.iv") : randomBytes7(16);
   assertArgument(iv.length === 16, "invalid options.iv length", "options.iv", options.iv);
-  const uuidRandom = options.uuid != null ? getBytes(options.uuid, "options.uuid") : randomBytes6(16);
+  const uuidRandom = options.uuid != null ? getBytes(options.uuid, "options.uuid") : randomBytes7(16);
   assertArgument(uuidRandom.length === 16, "invalid options.uuid length", "options.uuid", options.iv);
   const derivedKey = key.slice(0, 16);
   const macPrefix = key.slice(16, 32);
@@ -50901,7 +52171,7 @@ function _encryptKeystore(key, kdf, account, options) {
     const locale = account.mnemonic.locale || "en";
     const mnemonicKey = key.slice(32, 64);
     const entropy = getBytes(account.mnemonic.entropy, "account.mnemonic.entropy");
-    const mnemonicIv = randomBytes6(16);
+    const mnemonicIv = randomBytes7(16);
     const mnemonicAesCtr = new CTR(mnemonicKey, mnemonicIv);
     const mnemonicCiphertext = getBytes(mnemonicAesCtr.encrypt(entropy));
     const now = /* @__PURE__ */ new Date();
@@ -51239,7 +52509,7 @@ var init_hdwallet = __esm({
         if (wordlist2 == null) {
           wordlist2 = LangEn.wordlist();
         }
-        const mnemonic = Mnemonic.fromEntropy(randomBytes6(16), password, wordlist2);
+        const mnemonic = Mnemonic.fromEntropy(randomBytes7(16), password, wordlist2);
         return _HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path);
       }
       /**
@@ -61592,7 +62862,7 @@ var headless_local_worker_exports = {};
 __export(headless_local_worker_exports, {
   createHeadlessLocalWorker: () => createHeadlessLocalWorker
 });
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function objectOrNull3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -62009,7 +63279,7 @@ function createHeadlessLocalWorker(options) {
       const statusMatch = errorText.match(/\b([45]\d{2})\b/);
       const statusCode = statusMatch ? Number(statusMatch[1]) : null;
       const failedInvocation = normalizeAiInvocationTelemetry({
-        client_invocation_id: randomUUID8(),
+        client_invocation_id: randomUUID9(),
         use_case: "trader",
         role: "primary",
         attempt_index: 0,
@@ -62065,7 +63335,7 @@ function createHeadlessLocalWorker(options) {
       billable_cached_input_tokens: normalizedUsage.cached_input_tokens
     };
     const invocation = normalizeAiInvocationTelemetry({
-      client_invocation_id: randomUUID8(),
+      client_invocation_id: randomUUID9(),
       use_case: "trader",
       role: "primary",
       attempt_index: 0,
@@ -62284,7 +63554,7 @@ var vtx_exports = {};
 __export(vtx_exports, {
   runVtxCli: () => runVtxCli
 });
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { spawn as spawn8 } from "node:child_process";
 function render2(value, json2) {
   if (json2) {
@@ -62698,8 +63968,8 @@ async function runVtxCli(argv2, env = process.env) {
         });
         return { exitCode: 0, stdout: render2(redactCliOutput(response2), json2), stderr: "" };
       }
-      const runtimeSessionId = randomUUID9();
-      const deviceId = config2.runtimeDeviceId ?? randomUUID9();
+      const runtimeSessionId = randomUUID10();
+      const deviceId = config2.runtimeDeviceId ?? randomUUID10();
       const response = await client.startRuntime(profileId, {
         session_id: runtimeSessionId,
         device_id: deviceId,