@vtxmacro/cli 2026.8.52 → 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.52",
+      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,32 +19749,88 @@ var init_agent_client = __esm({
 });
 
 // lib/inference-host/agent-state.ts
-async function readCodexAgentRuntimeState(statePath) {
+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),
+    "Inference Agent runtime recovery state"
+  );
+  if (raw === null) return null;
+  try {
+    return assertInferenceAgentRuntimeState(JSON.parse(raw));
+  } catch (error48) {
+    if (error48 instanceof SyntaxError) {
+      throw new Error("Inference Agent runtime recovery state is not valid JSON.");
+    }
+    throw error48;
+  }
+}
+async function writeInferenceAgentRuntimeState(statePath, value) {
+  await writeAtomicInferencePrivateFile(
+    inferenceAgentRuntimeStatePath(statePath),
+    `${JSON.stringify(assertInferenceAgentRuntimeState(value), null, 2)}
+`
+  );
+}
+async function clearInferenceAgentRuntimeState(statePath) {
+  await clearInferencePrivateFile(
+    inferenceAgentRuntimeStatePath(statePath),
+    "Inference Agent runtime recovery state"
+  );
+}
+async function readInferenceForegroundAgentControlState(statePath) {
   const raw = await readInferencePrivateFile(
-    codexAgentRuntimeStatePath(statePath),
-    "Codex Agent runtime recovery state"
+    foregroundAgentControlStatePath(statePath),
+    "Foreground Agent control recovery state"
   );
   if (raw === null) return null;
   try {
-    return assertCodexAgentRuntimeState(JSON.parse(raw));
+    return assertForegroundAgentControlState(JSON.parse(raw));
   } catch (error48) {
     if (error48 instanceof SyntaxError) {
-      throw new Error("Codex Agent runtime recovery state is not valid JSON.");
+      throw new Error("Foreground Agent control recovery state is not valid JSON.");
     }
     throw error48;
   }
 }
-async function writeCodexAgentRuntimeState(statePath, value) {
+async function writeInferenceForegroundAgentControlState(statePath, value) {
   await writeAtomicInferencePrivateFile(
-    codexAgentRuntimeStatePath(statePath),
-    `${JSON.stringify(assertCodexAgentRuntimeState(value), null, 2)}
+    foregroundAgentControlStatePath(statePath),
+    `${JSON.stringify(assertForegroundAgentControlState(value), null, 2)}
 `
   );
 }
-async function clearCodexAgentRuntimeState(statePath) {
+async function clearInferenceForegroundAgentControlState(statePath) {
   await clearInferencePrivateFile(
-    codexAgentRuntimeStatePath(statePath),
-    "Codex Agent runtime recovery state"
+    foregroundAgentControlStatePath(statePath),
+    "Foreground Agent control recovery state"
   );
 }
 async function readInferenceAgentAttemptState(statePath) {
@@ -19779,7 +19889,7 @@ async function clearInferenceAgentNextState(statePath) {
     "Agent-driven inference next recovery state"
   );
 }
-var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, codexAgentRuntimeStatePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertCodexAgentRuntimeState, 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";
@@ -19787,18 +19897,39 @@ var init_agent_state = __esm({
     init_external_inference_contract();
     inferenceAgentAttemptStatePath = (statePath) => `${statePath}.agent-attempt.json`;
     inferenceAgentNextStatePath = (statePath) => `${statePath}.agent-next.json`;
-    codexAgentRuntimeStatePath = (statePath) => `${statePath}.codex-agent-runtime.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");
-    assertCodexAgentRuntimeState = (value) => {
-      const message = "Codex Agent runtime recovery state is invalid.";
+    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);
+      const generic = state.schema_version === "vtx_inference_agent_runtime_v3";
       if (!hasExactKeys(state, [
         "schema_version",
+        ...generic ? ["adapter_id"] : [],
         "host_id",
         "assignment",
         "thread",
@@ -19807,9 +19938,13 @@ var init_agent_state = __esm({
         "updated_at"
       ])) throw new Error(message);
       const assignment = assertPlainObject(state.assignment, message);
-      if (!["vtx_codex_agent_runtime_v1", "vtx_codex_agent_runtime_v2"].includes(
+      if (![
+        "vtx_codex_agent_runtime_v1",
+        "vtx_codex_agent_runtime_v2",
+        "vtx_inference_agent_runtime_v3"
+      ].includes(
         String(state.schema_version)
-      ) || typeof state.host_id !== "string" || !state.host_id || !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at) || !hasExactKeys(
+      ) || generic && (typeof state.adapter_id !== "string" || !/^[a-z0-9][a-z0-9._-]{0,63}$/u.test(state.adapter_id)) || typeof state.host_id !== "string" || !state.host_id || !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at) || !hasExactKeys(
         assignment,
         [
           "assignment_id",
@@ -19823,10 +19958,10 @@ var init_agent_state = __esm({
           "minimum_wake_seconds",
           "maximum_wake_seconds",
           "lease_expires_at",
-          ...state.schema_version === "vtx_codex_agent_runtime_v2" ? ["data_contract"] : []
+          ...state.schema_version !== "vtx_codex_agent_runtime_v1" ? ["data_contract"] : []
         ]
       ) || typeof assignment.assignment_id !== "string" || !assignment.assignment_id || !Number.isSafeInteger(assignment.assignment_generation) || Number(assignment.assignment_generation) < 1 || typeof assignment.model_id !== "string" || !assignment.model_id || typeof assignment.reasoning_effort !== "string" || !assignment.reasoning_effort || !["trader", "assistant"].includes(String(assignment.bot_mode)) || !["server", "client"].includes(String(assignment.execution_mode)) || !Array.isArray(assignment.allowed_symbols) || assignment.allowed_symbols.some((symbol2) => typeof symbol2 !== "string" || !symbol2) || !assignment.output_schema || typeof assignment.output_schema !== "object" || Array.isArray(assignment.output_schema) || !Number.isSafeInteger(assignment.minimum_wake_seconds) || Number(assignment.minimum_wake_seconds) < 1 || !Number.isSafeInteger(assignment.maximum_wake_seconds) || Number(assignment.maximum_wake_seconds) < Number(assignment.minimum_wake_seconds) || !isIsoTimestamp(assignment.lease_expires_at)) throw new Error(message);
-      if (state.schema_version === "vtx_codex_agent_runtime_v2") {
+      if (state.schema_version !== "vtx_codex_agent_runtime_v1") {
         if (!Array.isArray(assignment.data_contract) || assignment.data_contract.length === 0) {
           throw new Error(message);
         }
@@ -19865,6 +20000,76 @@ var init_agent_state = __esm({
       }
       return state;
     };
+    readCodexAgentRuntimeState = readInferenceAgentRuntimeState;
+    clearCodexAgentRuntimeState = clearInferenceAgentRuntimeState;
+    foregroundAgentControlStatePath = (statePath) => `${statePath}.foreground-agent-control.json`;
+    assertRuntimeAssignment = (value, message) => {
+      const assignment = assertPlainObject(value, message);
+      if (!hasExactKeys(assignment, [
+        "assignment_id",
+        "assignment_generation",
+        "model_id",
+        "reasoning_effort",
+        "bot_mode",
+        "execution_mode",
+        "allowed_symbols",
+        "output_schema",
+        "data_contract",
+        "minimum_wake_seconds",
+        "maximum_wake_seconds",
+        "lease_expires_at"
+      ]) || typeof assignment.assignment_id !== "string" || !assignment.assignment_id || !Number.isSafeInteger(assignment.assignment_generation) || Number(assignment.assignment_generation) < 1 || typeof assignment.model_id !== "string" || !assignment.model_id || typeof assignment.reasoning_effort !== "string" || !assignment.reasoning_effort || !["trader", "assistant"].includes(String(assignment.bot_mode)) || !["server", "client"].includes(String(assignment.execution_mode)) || !Array.isArray(assignment.allowed_symbols) || assignment.allowed_symbols.some((symbol2) => typeof symbol2 !== "string" || !symbol2) || !assignment.output_schema || typeof assignment.output_schema !== "object" || Array.isArray(assignment.output_schema) || !Array.isArray(assignment.data_contract) || assignment.data_contract.length === 0 || !Number.isSafeInteger(assignment.minimum_wake_seconds) || Number(assignment.minimum_wake_seconds) < 1 || !Number.isSafeInteger(assignment.maximum_wake_seconds) || Number(assignment.maximum_wake_seconds) < Number(assignment.minimum_wake_seconds) || !isIsoTimestamp(assignment.lease_expires_at)) throw new Error(message);
+      const ids = assignment.data_contract.map((value2) => {
+        const descriptor = assertPlainObject(value2, message);
+        if (!hasExactKeys(descriptor, [
+          "id",
+          "title",
+          "description",
+          "input_schema",
+          "input_schema_sha256"
+        ]) || typeof descriptor.id !== "string" || !descriptor.id || typeof descriptor.title !== "string" || !descriptor.title || typeof descriptor.description !== "string" || !descriptor.description || !descriptor.input_schema || typeof descriptor.input_schema !== "object" || Array.isArray(descriptor.input_schema) || typeof descriptor.input_schema_sha256 !== "string" || !/^[0-9a-f]{64}$/u.test(descriptor.input_schema_sha256)) throw new Error(message);
+        return descriptor.id;
+      });
+      if (new Set(ids).size !== ids.length) throw new Error(message);
+      return assignment;
+    };
+    assertForegroundAgentControlState = (value) => {
+      const message = "Foreground Agent control recovery state is invalid.";
+      const state = assertPlainObject(value, message);
+      if (!hasExactKeys(state, [
+        "schema_version",
+        "host_id",
+        "assignment",
+        "pending_next",
+        "pending_decision",
+        "next_wake_at",
+        "updated_at"
+      ]) || state.schema_version !== "vtx_foreground_agent_control_v1" || typeof state.host_id !== "string" || !state.host_id || state.next_wake_at !== null && !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at)) throw new Error(message);
+      if (state.assignment !== null) assertRuntimeAssignment(state.assignment, message);
+      if (state.pending_next !== null) {
+        const pending = assertPlainObject(state.pending_next, message);
+        if (!hasExactKeys(pending, ["operation_id", "requested_at"]) || typeof pending.operation_id !== "string" || !pending.operation_id || !isIsoTimestamp(pending.requested_at)) throw new Error(message);
+      }
+      if (state.pending_decision !== null) {
+        if (state.assignment === null) throw new Error(message);
+        const pending = assertPlainObject(state.pending_decision, message);
+        if (!hasExactKeys(pending, [
+          "request",
+          "first_transmit_at",
+          "last_status_check_at"
+        ])) throw new Error(message);
+        const request = assertPlainObject(pending.request, message);
+        if (!hasExactKeys(request, [
+          "assignment_id",
+          "assignment_generation",
+          "operation_id",
+          "candidate",
+          "observed_at",
+          "provenance"
+        ]) || request.assignment_id !== state.assignment.assignment_id || request.assignment_generation !== state.assignment.assignment_generation || typeof request.operation_id !== "string" || !request.operation_id || !request.candidate || typeof request.candidate !== "object" || Array.isArray(request.candidate) || !isIsoTimestamp(request.observed_at) || !request.provenance || typeof request.provenance !== "object" || Array.isArray(request.provenance) || pending.first_transmit_at !== null && !isIsoTimestamp(pending.first_transmit_at) || pending.last_status_check_at !== null && !isIsoTimestamp(pending.last_status_check_at)) throw new Error(message);
+      }
+      return state;
+    };
     assertNextState = (value) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error("Agent-driven inference next recovery state is invalid.");
@@ -24019,15 +24224,17 @@ $items = @(Get-CimInstance Win32_Process | Where-Object { $_.Name -in @('node.ex
 });
 
 // lib/inference-host/copilot-adapter.ts
+import { randomUUID } from "node:crypto";
 import { mkdtemp as mkdtemp2, rm as rm4 } from "node:fs/promises";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join5 } from "node:path";
 import {
   CopilotClient,
-  RuntimeConnection
+  RuntimeConnection,
+  defineTool
 } from "@github/copilot-sdk";
-var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, resolveRuntimePackage, copilotRuntimePackageCandidates, resolvePinnedCopilotCliPath, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, CopilotSubscriptionAdapter;
+var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, resolveRuntimePackage, copilotRuntimePackageCandidates, resolvePinnedCopilotCliPath, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, copilotAgentToolDefinitions, CopilotSubscriptionAdapter;
 var init_copilot_adapter = __esm({
   "lib/inference-host/copilot-adapter.ts"() {
     "use strict";
@@ -24123,9 +24330,66 @@ var init_copilot_adapter = __esm({
       }
       return Number(value);
     };
+    copilotAgentToolDefinitions = (input, evidence) => {
+      const execute = async (tool, argumentsValue) => {
+        const argumentsRecord = argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue) ? argumentsValue : {};
+        const callId = randomUUID();
+        const result2 = await input.executeTool({
+          callId,
+          tool,
+          arguments: argumentsRecord
+        });
+        evidence.push({ callId, tool, arguments: argumentsRecord, success: result2.success });
+        return result2.success ? result2.value : { error: result2.value };
+      };
+      return [
+        defineTool("vtx_get_data", {
+          description: "Request assignment-scoped VTX data using one exact canonical capability schema.",
+          parameters: {
+            oneOf: input.dataContract.map((descriptor) => ({
+              type: "object",
+              additionalProperties: false,
+              required: ["capability", "arguments"],
+              description: descriptor.description,
+              properties: {
+                capability: { type: "string", const: descriptor.id, title: descriptor.title },
+                arguments: descriptor.input_schema
+              }
+            }))
+          },
+          skipPermission: true,
+          handler: async (args) => await execute("vtx_get_data", args)
+        }),
+        defineTool("vtx_submit_decision", {
+          description: "Submit one VTX structured trading decision candidate.",
+          parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["candidate"],
+            properties: { candidate: input.decisionSchema }
+          },
+          skipPermission: true,
+          handler: async (args) => await execute("vtx_submit_decision", args)
+        }),
+        defineTool("vtx_decision_status", {
+          description: "Resolve the durable status of a previously attempted decision operation.",
+          parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["operation_id"],
+            properties: { operation_id: { type: "string", minLength: 1 } }
+          },
+          skipPermission: true,
+          handler: async (args) => await execute("vtx_decision_status", args)
+        })
+      ];
+    };
     CopilotSubscriptionAdapter = class {
       constructor(dependencies = {}) {
         this.inFlight = /* @__PURE__ */ new Map();
+        this.agentConnection = null;
+        this.agentWorkspaceCleanups = /* @__PURE__ */ new Map();
+        this.closing = false;
         this.dependencies = dependencies;
       }
       async preflight(signal) {
@@ -24337,6 +24601,1213 @@ ${input.outputSchemaJson}`
           await workspace.cleanup();
         }
       }
+      async runTurn(input) {
+        if (this.closing) {
+          throw new CodexAppServerError({
+            message: "Copilot Agent adapter is closing.",
+            category: "transport",
+            code: "transport_closed",
+            retryable: true
+          });
+        }
+        input.signal?.throwIfAborted();
+        if (Date.now() >= input.deadlineAtMs || input.dataContract.length === 0) {
+          throw new CodexAppServerError({
+            message: "Copilot Agent turn input is invalid or expired.",
+            category: Date.now() >= input.deadlineAtMs ? "timeout" : "schema",
+            code: Date.now() >= input.deadlineAtMs ? "deadline_exceeded" : "invalid_agent_turn_input",
+            retryable: false
+          });
+        }
+        const startedAt = (this.dependencies.now ?? Date.now)();
+        const ownedWorkspace = input.durableThread ? null : await (this.dependencies.createAgentWorkspace ?? this.dependencies.createWorkspace ?? createPrivateWorkspace)();
+        const workspacePath = input.durableThread?.threadPath ?? ownedWorkspace.path;
+        if (ownedWorkspace) this.agentWorkspaceCleanups.set(workspacePath, ownedWorkspace.cleanup);
+        const client = (this.dependencies.createClient ?? defaultClient)(workspacePath);
+        let session = null;
+        let durableCheckpointed = input.durableThread !== null;
+        let dispatchEntered = false;
+        const toolEvidence = [];
+        try {
+          await client.start();
+          const tools = copilotAgentToolDefinitions(input, toolEvidence);
+          const sessionConfig = {
+            clientName: "@vtxmacro/cli durable Copilot Agent host",
+            model: input.requestedModel,
+            ...input.requestedReasoningEffort === "none" ? {} : { reasoningEffort: input.requestedReasoningEffort },
+            systemMessage: {
+              mode: "replace",
+              content: `${input.systemPrompt}
+
+Return only one JSON value matching this JSON Schema exactly:
+${JSON.stringify(input.outputSchema)}`
+            },
+            tools,
+            availableTools: tools.map((tool) => tool.name),
+            enableConfigDiscovery: false,
+            streaming: true,
+            workingDirectory: workspacePath,
+            infiniteSessions: { enabled: true }
+          };
+          session = input.durableThread ? await client.resumeSession(input.durableThread.threadId, sessionConfig) : await client.createSession(sessionConfig);
+          this.agentConnection = {
+            client,
+            session,
+            workspacePath,
+            cleanup: ownedWorkspace?.cleanup ?? null
+          };
+          const thread = {
+            threadId: session.sessionId,
+            threadPath: workspacePath,
+            effectiveModel: input.requestedModel,
+            effectiveReasoningEffort: input.requestedReasoningEffort
+          };
+          if (input.onThreadReady) {
+            await input.onThreadReady(thread);
+            durableCheckpointed = true;
+          }
+          const usageEvents = [];
+          session.on((event) => {
+            if (event.type === "assistant.usage" && !event.agentId) usageEvents.push(event);
+          });
+          const onAbort = () => {
+            void session?.abort().catch(() => void 0);
+          };
+          input.signal?.addEventListener("abort", onAbort, { once: true });
+          dispatchEntered = true;
+          let response;
+          try {
+            response = await session.sendAndWait(
+              { prompt: input.userPrompt },
+              Math.max(1, input.deadlineAtMs - Date.now())
+            );
+          } finally {
+            input.signal?.removeEventListener("abort", onAbort);
+          }
+          if (!response?.data.content || Buffer.byteLength(response.data.content, "utf8") > MAX_RESULT_BYTES) {
+            throw new Error("copilot_agent_invalid_result");
+          }
+          const observedModels = /* @__PURE__ */ new Set();
+          const observedEfforts = /* @__PURE__ */ new Set();
+          let inputTokens = 0;
+          let cachedInputTokens = 0;
+          let outputTokens = 0;
+          let reasoningOutputTokens = 0;
+          let cacheWriteInputTokens = 0;
+          let cacheWriteSupported = false;
+          let timeToFirstTokenMs = null;
+          let providerCallId = null;
+          for (const event of usageEvents) {
+            if (event.type !== "assistant.usage") continue;
+            observedModels.add(event.data.model);
+            if (event.data.reasoningEffort) observedEfforts.add(event.data.reasoningEffort);
+            inputTokens += requiredUsageInteger(event.data.inputTokens, "input_tokens");
+            cachedInputTokens += optionalUsageInteger(event.data.cacheReadTokens, "cache_read_tokens");
+            outputTokens += requiredUsageInteger(event.data.outputTokens, "output_tokens");
+            reasoningOutputTokens += optionalUsageInteger(event.data.reasoningTokens, "reasoning_tokens");
+            if (event.data.cacheWriteTokens !== void 0) {
+              cacheWriteSupported = true;
+              cacheWriteInputTokens += optionalUsageInteger(event.data.cacheWriteTokens, "cache_write_tokens");
+            }
+            if (timeToFirstTokenMs === null && Number.isSafeInteger(event.data.timeToFirstTokenMs)) {
+              timeToFirstTokenMs = Number(event.data.timeToFirstTokenMs);
+            }
+            providerCallId = event.data.providerCallId ?? event.data.apiCallId ?? providerCallId;
+          }
+          if (usageEvents.length === 0) throw new Error("copilot_agent_usage_receipt_missing");
+          if (response.data.model) observedModels.add(response.data.model);
+          if (observedModels.size !== 1 || !observedModels.has(input.requestedModel)) {
+            throw new Error("copilot_agent_effective_model_mismatch");
+          }
+          const effectiveEffort = input.requestedReasoningEffort === "none" ? observedEfforts.size === 0 ? "none" : observedEfforts.size === 1 ? [...observedEfforts][0] : null : observedEfforts.size === 1 ? [...observedEfforts][0] : null;
+          if (effectiveEffort !== input.requestedReasoningEffort) {
+            throw new Error("copilot_agent_effective_effort_mismatch");
+          }
+          const usage = {
+            inputTokens,
+            cachedInputTokens: Math.min(cachedInputTokens, inputTokens),
+            outputTokens,
+            reasoningOutputTokens: Math.min(reasoningOutputTokens, outputTokens),
+            totalTokens: inputTokens + outputTokens,
+            cacheWriteInputTokens: cacheWriteSupported ? cacheWriteInputTokens : null,
+            cacheWriteSupported
+          };
+          return {
+            thread,
+            turn: {
+              text: response.data.content,
+              reasoningContent: response.data.reasoningText ?? null,
+              reasoningSummary: null,
+              requestedModel: input.requestedModel,
+              effectiveModel: input.requestedModel,
+              requestedReasoningEffort: input.requestedReasoningEffort,
+              effectiveReasoningEffort: effectiveEffort,
+              adapterRequestId: providerCallId ?? response.data.requestId ?? response.data.messageId,
+              adapterResponseId: response.data.serviceRequestId ?? response.data.messageId,
+              usage,
+              latencyMs: Math.max(0, (this.dependencies.now ?? Date.now)() - startedAt),
+              timeToFirstTokenMs,
+              terminalStatus: "completed",
+              toolCalls: toolEvidence,
+              webSearches: []
+            }
+          };
+        } catch (error48) {
+          if (error48 instanceof CodexAppServerError) throw error48;
+          const cancelled = input.signal?.aborted === true;
+          const deadline = Date.now() >= input.deadlineAtMs;
+          if (dispatchEntered) await session?.abort().catch(() => void 0);
+          if (session && !durableCheckpointed) {
+            const abandonedSession = session;
+            session = null;
+            if (this.agentConnection?.session === abandonedSession) this.agentConnection = null;
+            await abandonedSession.disconnect().catch(() => void 0);
+            await client.deleteSession(abandonedSession.sessionId).catch(() => void 0);
+            const cleanup = this.agentWorkspaceCleanups.get(workspacePath);
+            if (cleanup) {
+              await cleanup().catch(() => void 0);
+              this.agentWorkspaceCleanups.delete(workspacePath);
+            }
+          }
+          throw new CodexAppServerError({
+            message: cancelled ? "Copilot Agent turn was cancelled." : deadline ? "Copilot Agent turn exceeded its deadline." : error48 instanceof Error ? error48.message : "Copilot Agent adapter failed.",
+            category: cancelled ? "cancelled" : deadline ? "timeout" : "adapter",
+            code: cancelled ? "cancelled" : deadline ? "deadline_exceeded" : "copilot_agent_adapter_failure",
+            retryable: false,
+            dispatchOutcome: dispatchEntered ? "confirmed_dispatched" : "not_dispatched",
+            cause: error48
+          });
+        } finally {
+          await session?.disconnect().catch(() => void 0);
+          await client.stop().catch(async () => {
+            await client.forceStop();
+          });
+          if (this.agentConnection?.session === session) this.agentConnection = null;
+        }
+      }
+      async releaseThread(thread) {
+        const active = this.agentConnection;
+        if (active?.session.sessionId === thread.threadId) {
+          await active.session.disconnect().catch(() => void 0);
+          await active.client.stop().catch(async () => {
+            await active.client.forceStop();
+          });
+          this.agentConnection = null;
+        }
+        const client = (this.dependencies.createClient ?? defaultClient)(thread.threadPath);
+        await client.start();
+        try {
+          await client.deleteSession(thread.threadId);
+        } finally {
+          await client.stop().catch(async () => {
+            await client.forceStop();
+          });
+        }
+        const cleanup = this.agentWorkspaceCleanups.get(thread.threadPath);
+        if (cleanup) {
+          await cleanup();
+          this.agentWorkspaceCleanups.delete(thread.threadPath);
+        }
+      }
+      async close() {
+        this.closing = true;
+        const active = this.agentConnection;
+        this.agentConnection = null;
+        if (!active) return;
+        await active.session.disconnect().catch(() => void 0);
+        await active.client.stop().catch(async () => {
+          await active.client.forceStop();
+        });
+      }
+    };
+  }
+});
+
+// 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");
+        }
+      };
     };
   }
 });
@@ -24348,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];
   }
 });
@@ -24362,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({
@@ -24401,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.`);
@@ -24500,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
       ));
@@ -24642,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",
@@ -30914,7 +32387,7 @@ var require_ajv = __commonJS({
 });
 
 // lib/inference-host/runner.ts
-import { createHash as createHash6, randomUUID } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
 function createDefaultInferenceHostRunnerDependencies(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
   return {
@@ -30949,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, createCodexAgentControlClient, CODEX_AGENT_SYSTEM_PROMPT, CODEX_AGENT_WAKE_SCHEMA, parseCodexAgentWake, CodexAgentRuntime;
+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";
@@ -30975,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;
@@ -31241,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",
@@ -31333,7 +32809,7 @@ var init_runner = __esm({
           adapterId,
           options.structuredOutput ?? adapterId === "codex",
           options.sameAttemptRecovery ?? adapterId === "codex",
-          options.agentRuntime && adapterId === "codex" ? ["provider", "agent"] : ["provider"]
+          options.agentRuntime ? ["provider", "agent"] : ["provider"]
         ),
         maxConcurrency: options.maxConcurrency === null || options.maxConcurrency === void 0 ? null : finitePositiveOption(options.maxConcurrency, 1, "Maximum concurrency"),
         advertisementTtlMs,
@@ -31514,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 ([
@@ -31788,10 +33264,48 @@ var init_runner = __esm({
             const agentRuntimeSettings = settings.agentRuntime;
             agentLoop = (async () => {
               while (!agentAbort.signal.aborted) {
-                const agentRuntime = new CodexAgentRuntime({
+                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,
                   statePath: agentRuntimeSettings.statePath,
-                  controlClient: createCodexAgentControlClient(mcp),
+                  controlClient: createInferenceAgentControlClient(mcp),
                   adapter: agentRuntimeSettings.adapter
                 });
                 try {
@@ -31807,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"
                   });
@@ -31819,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;
@@ -32997,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
             });
           }
@@ -33129,7 +34694,7 @@ var init_runner = __esm({
         }
       }
     };
-    createCodexAgentControlClient = (mcp) => ({
+    createInferenceAgentControlClient = (mcp) => ({
       nextAssignment: async (request, options) => {
         const result2 = await mcp.callTool("inference.agent.assignment.next", {
           ...request,
@@ -33172,9 +34737,9 @@ var init_runner = __esm({
         await mcp.callTool("inference.agent.assignment.release", request, options);
       }
     });
-    CODEX_AGENT_SYSTEM_PROMPT = `You autonomously control one running VTX bot.
+    INFERENCE_AGENT_SYSTEM_PROMPT = `You autonomously control one running VTX bot.
 VTX supplies no trading prompt or prepared market context. At your own cadence, request zero, some, or all assignment-scoped data with vtx_get_data and independently use web search when useful. Submit trading instructions only through vtx_submit_decision, using the assignment's exact decision schema. VTX remains responsible for validating and executing the same structured decision used by normal Server and Client modes. You have no shell, filesystem-write, app, plugin, browser-control, or subagent authority.`;
-    CODEX_AGENT_WAKE_SCHEMA = {
+    INFERENCE_AGENT_WAKE_SCHEMA = {
       type: "object",
       additionalProperties: false,
       required: ["next_wake_seconds", "summary"],
@@ -33183,29 +34748,29 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         summary: { type: "string", minLength: 1, maxLength: 2e3 }
       }
     };
-    parseCodexAgentWake = (text, assignment) => {
+    parseInferenceAgentWake = (text, assignment) => {
       let value;
       try {
         value = JSON.parse(text);
       } catch {
         throw new InferenceHostRunnerError(
           "invalid_agent_wake",
-          "Codex Agent returned invalid wake JSON."
+          "Inference Agent returned invalid wake JSON."
         );
       }
       if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new InferenceHostRunnerError("invalid_agent_wake", "Codex Agent wake is invalid.");
+        throw new InferenceHostRunnerError("invalid_agent_wake", "Inference Agent wake is invalid.");
       }
       const seconds = value.next_wake_seconds;
       if (!Number.isSafeInteger(seconds) || Number(seconds) < 1) {
-        throw new InferenceHostRunnerError("invalid_agent_wake", "Codex Agent wake is invalid.");
+        throw new InferenceHostRunnerError("invalid_agent_wake", "Inference Agent wake is invalid.");
       }
       return Math.max(
         assignment.minimum_wake_seconds,
         Math.min(assignment.maximum_wake_seconds, Number(seconds))
       );
     };
-    CodexAgentRuntime = class {
+    InferenceAgentRuntime = class {
       constructor(options) {
         this.options = options;
         this.stopped = false;
@@ -33215,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 {
@@ -33231,37 +34799,67 @@ 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) {
         const nowIso = () => new Date(this.now()).toISOString();
-        const recoveredState = await readCodexAgentRuntimeState(this.options.statePath);
+        const recoveredState = await readInferenceAgentRuntimeState(this.options.statePath);
         if (recoveredState && recoveredState.host_id !== this.options.hostId) {
           throw new InferenceHostRunnerError(
             "agent_recovery_scope_mismatch",
-            "Codex Agent recovery state belongs to another host."
+            "Inference Agent recovery state belongs to another host."
           );
         }
         let state;
         if (recoveredState?.schema_version === "vtx_codex_agent_runtime_v1") {
+          if (this.options.adapterId !== "codex") {
+            throw new InferenceHostRunnerError(
+              "agent_recovery_adapter_mismatch",
+              "Legacy Codex Agent recovery state cannot be opened by another adapter."
+            );
+          }
           state = await this.upgradeLegacyRuntimeState(recoveredState, signal);
           if (!state) return this.now() + (this.options.idlePollMs ?? 5e3);
+        } else if (recoveredState?.schema_version === "vtx_codex_agent_runtime_v2") {
+          if (this.options.adapterId !== "codex") {
+            throw new InferenceHostRunnerError(
+              "agent_recovery_adapter_mismatch",
+              "Legacy Codex Agent recovery state cannot be opened by another adapter."
+            );
+          }
+          state = {
+            ...recoveredState,
+            schema_version: "vtx_inference_agent_runtime_v3",
+            adapter_id: "codex"
+          };
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
         } else {
           state = recoveredState ?? null;
+          if (state && state.adapter_id !== this.options.adapterId) {
+            throw new InferenceHostRunnerError(
+              "agent_recovery_adapter_mismatch",
+              "Inference Agent recovery state belongs to another adapter."
+            );
+          }
         }
         if (!state) {
           const assignment2 = await this.options.controlClient.nextAssignment({
-            operation_id: randomUUID(),
+            operation_id: randomUUID3(),
             host_id: this.options.hostId,
             requested_at: nowIso()
           }, { signal });
           if (!assignment2) return this.now() + (this.options.idlePollMs ?? 5e3);
           state = {
-            schema_version: "vtx_codex_agent_runtime_v2",
+            schema_version: "vtx_inference_agent_runtime_v3",
+            adapter_id: this.options.adapterId,
             host_id: this.options.hostId,
             assignment: assignment2,
             thread: null,
@@ -33269,7 +34867,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             pending_decision: null,
             updated_at: nowIso()
           };
-          await writeCodexAgentRuntimeState(this.options.statePath, state);
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
         } else {
           const persistedWakeAtMs = Date.parse(state.next_wake_at);
           if (persistedWakeAtMs > this.now()) {
@@ -33277,8 +34875,8 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             if (wakeOutcome !== "ready") {
               return this.now() + (this.options.idlePollMs ?? 5e3);
             }
-            const rereadState = await readCodexAgentRuntimeState(this.options.statePath);
-            if (rereadState?.schema_version !== "vtx_codex_agent_runtime_v2") {
+            const rereadState = await readInferenceAgentRuntimeState(this.options.statePath);
+            if (rereadState?.schema_version !== "vtx_inference_agent_runtime_v3" || rereadState.adapter_id !== this.options.adapterId) {
               return this.now() + (this.options.idlePollMs ?? 5e3);
             }
             state = rereadState;
@@ -33287,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: randomUUID(),
+          operation_id: randomUUID3(),
           host_id: this.options.hostId,
           assignment_id: assignment.assignment_id,
           assignment_generation: assignment.assignment_generation,
@@ -33302,7 +34900,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           lease_expires_at: preTurnHeartbeat.lease_expires_at
         };
         state = { ...state, assignment, updated_at: nowIso() };
-        await writeCodexAgentRuntimeState(this.options.statePath, state);
+        await writeInferenceAgentRuntimeState(this.options.statePath, state);
         const turnAbort = new AbortController();
         const relayAbort = () => turnAbort.abort();
         signal?.addEventListener("abort", relayAbort, { once: true });
@@ -33312,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: randomUUID(),
+              operation_id: randomUUID3(),
               host_id: this.options.hostId,
               assignment_id: assignment.assignment_id,
               assignment_generation: assignment.assignment_generation,
@@ -33336,7 +34934,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           const deadlineAtMs = this.now() + (this.options.turnTimeoutMs ?? 10 * 6e4);
           const result2 = await this.options.adapter.runTurn({
             durableThread: state.thread,
-            systemPrompt: CODEX_AGENT_SYSTEM_PROMPT,
+            systemPrompt: INFERENCE_AGENT_SYSTEM_PROMPT,
             userPrompt: JSON.stringify({
               assignment_id: assignment.assignment_id,
               assignment_generation: assignment.assignment_generation,
@@ -33350,7 +34948,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                 maximum: assignment.maximum_wake_seconds
               }
             }),
-            outputSchema: CODEX_AGENT_WAKE_SCHEMA,
+            outputSchema: INFERENCE_AGENT_WAKE_SCHEMA,
             dataContract: assignment.data_contract,
             decisionSchema: assignment.output_schema,
             requestedModel: assignment.model_id,
@@ -33359,7 +34957,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             signal: turnAbort.signal,
             onThreadReady: async (thread) => {
               state = { ...state, thread, updated_at: nowIso() };
-              await writeCodexAgentRuntimeState(this.options.statePath, state);
+              await writeInferenceAgentRuntimeState(this.options.statePath, state);
             },
             executeTool: async (call) => {
               if (call.tool === "vtx_get_data") {
@@ -33369,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: randomUUID(),
+                  operation_id: randomUUID3(),
                   host_id: this.options.hostId,
                   assignment_id: assignment.assignment_id,
                   assignment_generation: assignment.assignment_generation,
@@ -33393,12 +34991,12 @@ 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: randomUUID(),
+                  operation_id: randomUUID3(),
                   candidate,
                   observed_at: nowIso(),
                   provenance: {
-                    source: "codex_agent",
-                    codex_thread_id: liveThread.threadId,
+                    source: "external_agent",
+                    agent_run_id: liveThread.threadId,
                     requested_model: assignment.model_id,
                     effective_model: liveThread.effectiveModel,
                     requested_reasoning_effort: assignment.reasoning_effort,
@@ -33408,13 +35006,13 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   last_status_check_at: null
                 };
                 state = { ...state, pending_decision: pending, updated_at: nowIso() };
-                await writeCodexAgentRuntimeState(this.options.statePath, state);
+                await writeInferenceAgentRuntimeState(this.options.statePath, state);
                 state = {
                   ...state,
                   pending_decision: { ...pending, first_transmit_at: nowIso() },
                   updated_at: nowIso()
                 };
-                await writeCodexAgentRuntimeState(this.options.statePath, state);
+                await writeInferenceAgentRuntimeState(this.options.statePath, state);
                 let submitStatus;
                 try {
                   submitStatus = await this.options.controlClient.submitDecision({
@@ -33431,7 +35029,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                 }
                 if (submitStatus.status === "applied" || submitStatus.status === "not_applied") {
                   state = { ...state, pending_decision: null, updated_at: nowIso() };
-                  await writeCodexAgentRuntimeState(this.options.statePath, state);
+                  await writeInferenceAgentRuntimeState(this.options.statePath, state);
                 }
                 return {
                   success: submitStatus.status === "applied",
@@ -33455,7 +35053,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   pending_decision: null,
                   updated_at: nowIso()
                 };
-                await writeCodexAgentRuntimeState(this.options.statePath, state);
+                await writeInferenceAgentRuntimeState(this.options.statePath, state);
               }
               return {
                 success: status.status === "applied" || status.status === "not_applied",
@@ -33463,11 +35061,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
               };
             }
           });
-          const wakeSeconds = parseCodexAgentWake(result2.turn.text, assignment);
+          const wakeSeconds = parseInferenceAgentWake(result2.turn.text, assignment);
           const nextWakeAtMs = this.now() + wakeSeconds * 1e3;
           const scheduledWakeAt = new Date(nextWakeAtMs).toISOString();
           const wakeHeartbeat = await this.options.controlClient.heartbeat({
-            operation_id: randomUUID(),
+            operation_id: randomUUID3(),
             host_id: this.options.hostId,
             assignment_id: assignment.assignment_id,
             assignment_generation: assignment.assignment_generation,
@@ -33477,7 +35075,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           if (wakeHeartbeat.directive === "cancel") {
             if (state.pending_decision) return this.now() + (this.options.idlePollMs ?? 5e3);
             await this.options.adapter.releaseThread(result2.thread).catch(() => void 0);
-            await clearCodexAgentRuntimeState(this.options.statePath);
+            await clearInferenceAgentRuntimeState(this.options.statePath);
             return this.now() + (this.options.idlePollMs ?? 5e3);
           }
           latestLeaseExpiry = wakeHeartbeat.lease_expires_at;
@@ -33488,7 +35086,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             next_wake_at: scheduledWakeAt,
             updated_at: nowIso()
           };
-          await writeCodexAgentRuntimeState(this.options.statePath, state);
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
           return nextWakeAtMs;
         } catch (error48) {
           if (!cancelled) throw error48;
@@ -33507,7 +35105,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         if (state.thread) {
           await this.options.adapter.releaseThread(state.thread).catch(() => void 0);
         }
-        await clearCodexAgentRuntimeState(this.options.statePath);
+        await clearInferenceAgentRuntimeState(this.options.statePath);
         return null;
       }
       async resolveLegacyPendingDecision(state, signal) {
@@ -33519,7 +35117,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: { ...pending, last_status_check_at: checkedAt },
           updated_at: checkedAt
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, checking);
+        await writeInferenceAgentRuntimeState(this.options.statePath, checking);
         const status = await this.options.controlClient.decisionStatus({
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
@@ -33532,7 +35130,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: null,
           updated_at: new Date(this.now()).toISOString()
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, resolved);
+        await writeInferenceAgentRuntimeState(this.options.statePath, resolved);
         return resolved;
       }
       async resolvePendingDecision(state, signal) {
@@ -33544,7 +35142,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: { ...pending, last_status_check_at: checkedAt },
           updated_at: checkedAt
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, checking);
+        await writeInferenceAgentRuntimeState(this.options.statePath, checking);
         const status = await this.options.controlClient.decisionStatus({
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
@@ -33557,7 +35155,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: null,
           updated_at: new Date(this.now()).toISOString()
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, resolved);
+        await writeInferenceAgentRuntimeState(this.options.statePath, resolved);
         return resolved;
       }
       async handleCancelledAssignment(state, signal) {
@@ -33573,7 +35171,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         if (current.thread) {
           await this.options.adapter.releaseThread(current.thread).catch(() => void 0);
         }
-        await clearCodexAgentRuntimeState(this.options.statePath);
+        await clearInferenceAgentRuntimeState(this.options.statePath);
       }
       async waitUntilWake(nextWakeAtMs, signal) {
         const heartbeatIntervalMs = this.options.heartbeatIntervalMs ?? 3e3;
@@ -33581,11 +35179,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           await this.sleep(Math.min(heartbeatIntervalMs, nextWakeAtMs - this.now()), signal);
           if (this.stopped || signal?.aborted) return "stopped";
           if (this.now() >= nextWakeAtMs) return "ready";
-          const state = await readCodexAgentRuntimeState(this.options.statePath);
-          if (state?.schema_version !== "vtx_codex_agent_runtime_v2") return "cancelled";
+          const state = await readInferenceAgentRuntimeState(this.options.statePath);
+          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: randomUUID(),
+            operation_id: randomUUID3(),
             host_id: this.options.hostId,
             assignment_id: state.assignment.assignment_id,
             assignment_generation: state.assignment.assignment_generation,
@@ -33595,7 +35193,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             await this.handleCancelledAssignment(state, signal);
             return "cancelled";
           }
-          await writeCodexAgentRuntimeState(this.options.statePath, {
+          await writeInferenceAgentRuntimeState(this.options.statePath, {
             ...state,
             assignment: {
               ...state.assignment,
@@ -33606,9 +35204,25 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
         return this.stopped || signal?.aborted ? "stopped" : "ready";
       }
-      async releaseForHostStop() {
-        let state = await readCodexAgentRuntimeState(this.options.statePath);
-        if (!state) return;
+      async releaseForHostStop(reasonCode = "host_stopped") {
+        const recovered = await readInferenceAgentRuntimeState(this.options.statePath);
+        if (!recovered) return;
+        let state;
+        if (recovered.schema_version === "vtx_codex_agent_runtime_v1") {
+          if (this.options.adapterId !== "codex") return;
+          state = recovered;
+        } else if (recovered.schema_version === "vtx_codex_agent_runtime_v2") {
+          if (this.options.adapterId !== "codex") return;
+          state = {
+            ...recovered,
+            schema_version: "vtx_inference_agent_runtime_v3",
+            adapter_id: "codex"
+          };
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
+        } else {
+          if (recovered.adapter_id !== this.options.adapterId) return;
+          state = recovered;
+        }
         try {
           state = state.schema_version === "vtx_codex_agent_runtime_v1" ? await this.resolveLegacyPendingDecision(state) : await this.resolvePendingDecision(state);
         } catch {
@@ -33616,15 +35230,15 @@ 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: randomUUID(),
+          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);
-        await clearCodexAgentRuntimeState(this.options.statePath);
+        await clearInferenceAgentRuntimeState(this.options.statePath);
       }
     };
   }
@@ -33632,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 randomUUID2 } 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"() {
@@ -34105,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`;
@@ -34157,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: randomUUID2(),
+          generation: randomUUID4(),
           installed_at: this.now().toISOString()
         });
         await writeAtomicInferencePrivateFile(
@@ -34239,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(),
@@ -34288,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);
           }
@@ -34443,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: randomUUID2(),
+          generation: randomUUID4(),
           installed_at: this.now().toISOString(),
           executable: this.executable,
           script: this.script,
@@ -34657,7 +36271,7 @@ ${result2.stderr}`)) {
           if (remaining.length === 0) return await this.uninstallUnlocked();
           return await this.replaceManifestUnlocked({
             ...manifest,
-            generation: randomUUID2(),
+            generation: randomUUID4(),
             installed_at: this.now().toISOString(),
             workers: remaining
           }, await readInferenceHostServiceDesired(this.desiredPath()));
@@ -34680,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,
@@ -34699,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);
@@ -35047,11 +36661,11 @@ __export(cli_exports, {
   registerInferenceHostServiceControlInput: () => registerInferenceHostServiceControlInput,
   runInferenceHostCli: () => runInferenceHostCli
 });
-import { createHash as createHash7, randomUUID as randomUUID3 } 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 {
@@ -35081,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);
     }
@@ -35111,6 +36728,42 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
         async () => await agentFail(config2, parsed, dependencies, warnings)
       );
     }
+    if (parsed.command === "agent-assignment-next") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundAssignmentNext(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-assignment-heartbeat") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundAssignmentHeartbeat(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-data-call") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundDataCall(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-decision-submit") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundDecisionSubmit(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-decision-status") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundDecisionStatus(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-assignment-release") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundAssignmentRelease(config2, parsed, dependencies, warnings)
+      );
+    }
     if (parsed.command === "service") {
       const mutationActions = /* @__PURE__ */ new Set(["install", "start", "stop", "recover", "uninstall"]);
       if (!parsed.serviceAction || !mutationActions.has(parsed.serviceAction)) {
@@ -35137,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|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 {
@@ -35152,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, agentOperationId, agentSession, agentConnect, 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";
@@ -35163,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();
@@ -35246,23 +36904,31 @@ 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
   agent-next      Claim the next exact VTX inference request
   agent-complete  Submit one completed agent result from stdin
   agent-fail      Submit one truthful agent failure from stdin
+  agent-assignment-next       Claim the assigned Main bot for Agent control
+  agent-assignment-heartbeat  Renew the current Agent assignment
+  agent-data-call             Request allowed assignment-scoped VTX data
+  agent-decision-submit       Submit the normal structured trading decision
+  agent-decision-status       Resolve an uncertain Agent decision submission
+  agent-assignment-release    Release the current Agent assignment
   service         Install and control the durable background host
   status          Inspect local host and credential state
   doctor          Verify credentials, provider runtime, and private state
   logout          Remove local VTX host state without revoking the grant
   revoke          Revoke the VTX grant and remove local host state
   codex-logout    Remove the automated host's dedicated Codex login
+  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
 
@@ -35278,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>
@@ -35384,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,
@@ -35541,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) {
@@ -35559,14 +37227,16 @@ 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"
       );
       await clearInferenceAgentAttemptState(config2.statePath);
       await clearInferenceAgentNextState(config2.statePath);
+      await clearInferenceForegroundAgentControlState(config2.statePath);
       await clearCodexAgentRuntimeState(config2.statePath);
+      await clearInferenceAgentFailureFence(config2.statePath);
       await clearInferenceHostLocalState(config2.statePath);
     };
     assertDurableServiceUninstalled = async (config2) => {
@@ -35593,10 +37263,12 @@ Durable service:
       const revocationCheckpointPresent = await readRevocationCheckpoint(config2) !== null;
       const agentAttemptPresent = await readInferenceAgentAttemptState(config2.statePath) !== null;
       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 || 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, agent-driven, or revocation recovery). Rerun agent-next, complete or fail the active attempt, run the automated host to reconcile it, or resume revoke."
+          "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."
         );
       }
     };
@@ -35664,11 +37336,19 @@ 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) => {
+      const agentAdapter = options.adapter;
+      if (typeof agentAdapter.runTurn !== "function" || typeof agentAdapter.releaseThread !== "function" || typeof agentAdapter.close !== "function") {
+        throw new Error(
+          `${options.preflight.adapterId} does not implement the durable Agent-control contract.`
+        );
+      }
       const dependencies = createDefaultInferenceHostRunnerDependencies({
         apiUrl: options.config.apiUrl,
         statePath: options.config.statePath,
@@ -35704,6 +37384,10 @@ Durable service:
         maxConcurrency: options.maxConcurrency,
         once: options.once,
         emitDiagnosticEvent: options.emitDiagnosticEvent,
+        agentRuntime: {
+          statePath: options.config.statePath,
+          adapter: agentAdapter
+        },
         signal: options.signal
       }).run();
     };
@@ -35737,7 +37421,7 @@ Durable service:
         await writeInferenceHostCredentialContextTransition(config2, previousCredentialContext);
         await writeInferenceHostCredentialContext(config2);
         const keyPair = generateExternalInferenceEnvelopeKeyPair();
-        const hostId = randomUUID3();
+        const hostId = randomUUID5();
         const beginLogin = dependencies.beginLogin ?? beginInferenceOAuthLogin;
         const loginStore = {
           kind: store.kind,
@@ -35935,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);
@@ -35979,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({
@@ -36004,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,
@@ -36022,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,
@@ -36060,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",
@@ -36318,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)({
@@ -36417,7 +38164,27 @@ Waiting for approval...
       }
       return record2;
     };
-    agentOperationId = (kind) => `${kind}-${randomUUID3()}`;
+    parseOptionalAgentStdin = async (dependencies, allowedKeys) => {
+      if (!dependencies.readStdin && process.stdin.isTTY) return {};
+      const raw = await (dependencies.readStdin ?? defaultReadStdin)();
+      if (!raw.trim()) return {};
+      let value;
+      try {
+        value = JSON.parse(raw);
+      } catch {
+        throw new Error("Agent-driven inference stdin must be one JSON object.");
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Agent-driven inference stdin must be one JSON object.");
+      }
+      const record2 = value;
+      const unexpected = Object.keys(record2).filter((key) => !allowedKeys.includes(key));
+      if (unexpected.length > 0) {
+        throw new Error(`Unsupported agent-driven inference fields: ${unexpected.join(", ")}.`);
+      }
+      return record2;
+    };
+    agentOperationId = (kind) => `${kind}-${randomUUID5()}`;
     agentSession = async (config2, dependencies, warnings, signal) => {
       if (await readRevocationCheckpoint(config2)) {
         throw new Error("Inference host revocation recovery must finish first.");
@@ -36461,11 +38228,419 @@ Waiting for approval...
           reasoning_effort: result2.reasoning_effort,
           lanes: ["main", "review", "screener"],
           response_modes: ["provider_response", "decision_candidate"],
+          control_modes: ["provider", "agent"],
           execution_modes: ["client", "server"],
           next_command: "vtx inference-host agent-next --wait-seconds 50 --json",
+          agent_next_command: "vtx inference-host agent-assignment-next --wait-seconds 50 --json",
           keeper_command: "vtx inference-host agent-run"
         }, parsed.json),
         stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundAgentControlState = (hostId, updatedAt) => ({
+      schema_version: "vtx_foreground_agent_control_v1",
+      host_id: hostId,
+      assignment: null,
+      pending_next: null,
+      pending_decision: null,
+      next_wake_at: null,
+      updated_at: updatedAt
+    });
+    requireForegroundAgentState = async (config2, hostId) => {
+      const state = await readInferenceForegroundAgentControlState(config2.statePath);
+      if (!state?.assignment) {
+        throw new Error("No active foreground Agent assignment. Run agent-assignment-next first.");
+      }
+      if (state.host_id !== hostId) {
+        throw new Error("Foreground Agent assignment belongs to another inference host.");
+      }
+      return state;
+    };
+    assignmentFromClaim = (result2) => ({
+      assignment_id: result2.assignment_id,
+      assignment_generation: result2.assignment_generation,
+      model_id: result2.model_id,
+      reasoning_effort: result2.reasoning_effort,
+      bot_mode: result2.bot_mode,
+      execution_mode: result2.execution_mode,
+      allowed_symbols: result2.allowed_symbols,
+      data_contract: result2.data_contract,
+      output_schema: result2.output_schema,
+      minimum_wake_seconds: result2.minimum_wake_seconds,
+      maximum_wake_seconds: result2.maximum_wake_seconds,
+      lease_expires_at: result2.lease_expires_at
+    });
+    foregroundAssignmentNext = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+      const sleep4 = dependencies.sleep ?? (async (milliseconds) => {
+        await new Promise((resolve6) => setTimeout(resolve6, milliseconds));
+      });
+      const stopAt = now().getTime() + parsed.waitSeconds * 1e3;
+      let state = await readInferenceForegroundAgentControlState(config2.statePath) ?? foregroundAgentControlState(session.localState.host_id, now().toISOString());
+      if (state.host_id !== session.localState.host_id) {
+        throw new Error("Foreground Agent recovery state belongs to another inference host.");
+      }
+      if (state.pending_decision) {
+        throw new Error("Resolve the pending Agent decision before claiming another assignment.");
+      }
+      while (true) {
+        if (!state.pending_next) {
+          const requestedAt = now().toISOString();
+          state = {
+            ...state,
+            pending_next: {
+              operation_id: agentOperationId("agent-assignment-next"),
+              requested_at: requestedAt
+            },
+            updated_at: requestedAt
+          };
+          await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        }
+        const pending = state.pending_next;
+        let result2;
+        try {
+          result2 = await session.client.callTool("inference.agent.assignment.next", {
+            operation_id: pending.operation_id,
+            host_id: session.localState.host_id,
+            requested_at: pending.requested_at,
+            contract_version: "agent_assignment_v2",
+            ...state.assignment ? {
+              assignment_id: state.assignment.assignment_id,
+              assignment_generation: state.assignment.assignment_generation
+            } : {}
+          });
+        } catch (error48) {
+          if (error48 && typeof error48 === "object" && error48.definitivelyNotApplied === true) {
+            state = { ...state, pending_next: null, updated_at: now().toISOString() };
+            await writeInferenceForegroundAgentControlState(config2.statePath, state);
+          }
+          throw error48;
+        }
+        if (result2.claim_state === "claimed") {
+          const assignment = assignmentFromClaim(result2);
+          state = {
+            ...state,
+            assignment,
+            pending_next: null,
+            next_wake_at: null,
+            updated_at: now().toISOString()
+          };
+          await writeInferenceForegroundAgentControlState(config2.statePath, state);
+          return {
+            exitCode: 0,
+            stdout: render({
+              ...result2,
+              instructions: "VTX supplied no trading prompt or prepared context. Choose your own cadence; use agent-data-call zero or more times, submit the exact output_schema through agent-decision-submit, then record the next wake with agent-assignment-heartbeat. Keep agent-run open for liveness.",
+              data_command: "vtx inference-host agent-data-call --json",
+              decision_command: "vtx inference-host agent-decision-submit --json",
+              decision_input: {
+                candidate: "<object matching output_schema>",
+                provenance: {
+                  source: "external_agent",
+                  agent_run_id: "<stable harness run id>",
+                  requested_model: result2.model_id,
+                  effective_model: "<actual model used>",
+                  requested_reasoning_effort: result2.reasoning_effort,
+                  effective_reasoning_effort: "<actual reasoning effort used>"
+                }
+              },
+              heartbeat_command: "vtx inference-host agent-assignment-heartbeat --json",
+              release_command: "vtx inference-host agent-assignment-release --json"
+            }, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
+        state = { ...state, pending_next: null, updated_at: now().toISOString() };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        const remaining = stopAt - now().getTime();
+        if (remaining <= 0 || parsed.waitSeconds === 0) {
+          return {
+            exitCode: 0,
+            stdout: render(result2, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
+        await sleep4(Math.min(remaining, Math.max(50, result2.retry_after_ms)));
+      }
+    };
+    foregroundAssignmentHeartbeat = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const state = await requireForegroundAgentState(
+        config2,
+        session.localState.host_id
+      );
+      const input = await parseOptionalAgentStdin(dependencies, ["next_wake_at"]);
+      const nextWakeAt = input.next_wake_at;
+      if (nextWakeAt !== void 0 && (typeof nextWakeAt !== "string" || !Number.isFinite(Date.parse(nextWakeAt)))) {
+        throw new Error("next_wake_at must be an ISO timestamp.");
+      }
+      const requestedAt = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+      const result2 = await session.client.callTool("inference.agent.assignment.heartbeat", {
+        operation_id: agentOperationId("agent-assignment-heartbeat"),
+        host_id: session.localState.host_id,
+        assignment_id: state.assignment.assignment_id,
+        assignment_generation: state.assignment.assignment_generation,
+        requested_at: requestedAt,
+        ...nextWakeAt === void 0 ? {} : { next_wake_at: nextWakeAt }
+      });
+      if (result2.directive === "cancel") {
+        await handleForegroundCancelledAssignment(config2, session, state, requestedAt);
+      } else {
+        await writeInferenceForegroundAgentControlState(config2.statePath, {
+          ...state,
+          assignment: { ...state.assignment, lease_expires_at: result2.lease_expires_at },
+          next_wake_at: result2.next_wake_at ?? state.next_wake_at,
+          updated_at: requestedAt
+        });
+      }
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundDataCall = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const state = await requireForegroundAgentState(config2, session.localState.host_id);
+      const input = await parseAgentStdin(dependencies, ["capability", "arguments"]);
+      const capability = typeof input.capability === "string" ? input.capability.trim() : "";
+      if (!capability || !state.assignment.data_contract.some((item) => item.id === capability)) {
+        throw new Error("Agent data capability is not allowed by the current assignment.");
+      }
+      if (!input.arguments || typeof input.arguments !== "object" || Array.isArray(input.arguments)) {
+        throw new Error("Agent data arguments must be one JSON object.");
+      }
+      const result2 = await session.client.callTool("inference.agent.data.call", {
+        operation_id: agentOperationId("agent-data-call"),
+        host_id: session.localState.host_id,
+        assignment_id: state.assignment.assignment_id,
+        assignment_generation: state.assignment.assignment_generation,
+        capability,
+        arguments: input.arguments,
+        requested_at: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+      });
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundDecisionStatusRequest = (hostId, state) => ({
+      operation_id: state.pending_decision.request.operation_id,
+      host_id: hostId,
+      assignment_id: state.assignment.assignment_id,
+      assignment_generation: state.assignment.assignment_generation
+    });
+    foregroundAssignmentLeaseEnded = (state, now) => Boolean(state.assignment) && Date.parse(state.assignment.lease_expires_at) <= now.getTime();
+    handleForegroundCancelledAssignment = async (config2, session, state, requestedAt, signal) => {
+      if (!state.pending_decision) {
+        await clearInferenceForegroundAgentControlState(config2.statePath);
+        return;
+      }
+      const cancelledState = {
+        ...state,
+        assignment: {
+          ...state.assignment,
+          lease_expires_at: requestedAt
+        },
+        pending_decision: {
+          ...state.pending_decision,
+          last_status_check_at: requestedAt
+        },
+        next_wake_at: null,
+        updated_at: requestedAt
+      };
+      await writeInferenceForegroundAgentControlState(config2.statePath, cancelledState);
+      try {
+        await session.client.callTool(
+          "inference.agent.decision.status",
+          foregroundDecisionStatusRequest(session.localState.host_id, cancelledState),
+          { signal }
+        );
+      } catch {
+        return;
+      }
+      await clearInferenceForegroundAgentControlState(config2.statePath);
+    };
+    foregroundDecisionStatus = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      let state = await requireForegroundAgentState(config2, session.localState.host_id);
+      if (!state.pending_decision) {
+        throw new Error("No uncertain foreground Agent decision requires status recovery.");
+      }
+      const checkedAt = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+      state = {
+        ...state,
+        pending_decision: { ...state.pending_decision, last_status_check_at: checkedAt },
+        updated_at: checkedAt
+      };
+      await writeInferenceForegroundAgentControlState(config2.statePath, state);
+      const result2 = await session.client.callTool(
+        "inference.agent.decision.status",
+        foregroundDecisionStatusRequest(session.localState.host_id, state)
+      );
+      const assignmentLeaseEnded = foregroundAssignmentLeaseEnded(state, new Date(checkedAt));
+      if (result2.found || assignmentLeaseEnded) {
+        if (assignmentLeaseEnded) {
+          await clearInferenceForegroundAgentControlState(config2.statePath);
+        } else {
+          await writeInferenceForegroundAgentControlState(config2.statePath, {
+            ...state,
+            pending_decision: null,
+            updated_at: checkedAt
+          });
+        }
+      }
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundDecisionSubmit = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+      let state = await requireForegroundAgentState(config2, session.localState.host_id);
+      if (!state.pending_decision) {
+        const input = await parseAgentStdin(dependencies, ["candidate", "provenance"]);
+        if (!input.candidate || typeof input.candidate !== "object" || Array.isArray(input.candidate)) {
+          throw new Error("Agent decision candidate must be one JSON object.");
+        }
+        if (!input.provenance || typeof input.provenance !== "object" || Array.isArray(input.provenance)) {
+          throw new Error("Agent decision provenance must be one JSON object.");
+        }
+        const observedAt = now().toISOString();
+        state = {
+          ...state,
+          pending_decision: {
+            request: {
+              assignment_id: state.assignment.assignment_id,
+              assignment_generation: state.assignment.assignment_generation,
+              operation_id: agentOperationId("agent-decision-submit"),
+              candidate: input.candidate,
+              observed_at: observedAt,
+              provenance: input.provenance
+            },
+            first_transmit_at: null,
+            last_status_check_at: null
+          },
+          updated_at: observedAt
+        };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+      } else {
+        const checkedAt = now().toISOString();
+        state = {
+          ...state,
+          pending_decision: { ...state.pending_decision, last_status_check_at: checkedAt },
+          updated_at: checkedAt
+        };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        const status = await session.client.callTool(
+          "inference.agent.decision.status",
+          foregroundDecisionStatusRequest(session.localState.host_id, state)
+        );
+        if (status.found) {
+          await writeInferenceForegroundAgentControlState(config2.statePath, {
+            ...state,
+            pending_decision: null,
+            updated_at: checkedAt
+          });
+          return {
+            exitCode: 0,
+            stdout: render({ ...status, recovered: true }, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
+      }
+      const transmittedAt = now().toISOString();
+      state = {
+        ...state,
+        pending_decision: {
+          ...state.pending_decision,
+          first_transmit_at: state.pending_decision.first_transmit_at ?? transmittedAt
+        },
+        updated_at: transmittedAt
+      };
+      await writeInferenceForegroundAgentControlState(config2.statePath, state);
+      try {
+        const result2 = await session.client.callTool(
+          "inference.agent.decision.submit",
+          state.pending_decision.request
+        );
+        await writeInferenceForegroundAgentControlState(config2.statePath, {
+          ...state,
+          pending_decision: null,
+          updated_at: now().toISOString()
+        });
+        return {
+          exitCode: 0,
+          stdout: render(result2, parsed.json),
+          stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+        };
+      } catch (error48) {
+        const checkedAt = now().toISOString();
+        state = {
+          ...state,
+          pending_decision: { ...state.pending_decision, last_status_check_at: checkedAt },
+          updated_at: checkedAt
+        };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        try {
+          const status = await session.client.callTool(
+            "inference.agent.decision.status",
+            foregroundDecisionStatusRequest(session.localState.host_id, state)
+          );
+          if (status.found) {
+            await writeInferenceForegroundAgentControlState(config2.statePath, {
+              ...state,
+              pending_decision: null,
+              updated_at: checkedAt
+            });
+            return {
+              exitCode: 0,
+              stdout: render({ ...status, recovered: true }, parsed.json),
+              stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+            };
+          }
+        } catch {
+        }
+        throw error48;
+      }
+    };
+    foregroundAssignmentRelease = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const state = await requireForegroundAgentState(config2, session.localState.host_id);
+      if (state.pending_decision) {
+        throw new Error("Resolve the pending Agent decision before releasing its assignment.");
+      }
+      const input = await parseOptionalAgentStdin(dependencies, ["reason_code"]);
+      const reasonCode = input.reason_code === void 0 ? "agent_released" : input.reason_code;
+      if (typeof reasonCode !== "string" || !/^[a-z0-9][a-z0-9._-]{0,95}$/u.test(reasonCode)) {
+        throw new Error("reason_code must be a safe lowercase code.");
+      }
+      const result2 = await session.client.callTool("inference.agent.assignment.release", {
+        operation_id: agentOperationId("agent-assignment-release"),
+        host_id: session.localState.host_id,
+        assignment_id: state.assignment.assignment_id,
+        assignment_generation: state.assignment.assignment_generation,
+        reason_code: reasonCode,
+        requested_at: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+      });
+      await clearInferenceForegroundAgentControlState(config2.statePath);
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
 ` : ""
       };
     };
@@ -36473,6 +38648,7 @@ Waiting for approval...
       const cancellation = lifecycleCancellation(dependencies);
       let keeperLock = null;
       let heartbeatCount = 0;
+      let assignmentHeartbeatCount = 0;
       try {
         keeperLock = await acquireInferenceHostProcessLock(foregroundHostLockPath(config2));
         const store = configuredCredentialStore(config2, dependencies, (message) => {
@@ -36506,6 +38682,7 @@ Waiting for approval...
           }
           if (commandLock) {
             let heartbeatSuppressed = false;
+            let assignmentHeartbeatComplete = true;
             try {
               const active = await readInferenceAgentAttemptState(config2.statePath);
               const pendingNext = await readInferenceAgentNextState(config2.statePath);
@@ -36565,10 +38742,65 @@ Waiting for approval...
                   }
                 }
               }
+              const control = await readInferenceForegroundAgentControlState(config2.statePath);
+              if (control && control.host_id !== session.localState.host_id) {
+                throw new Error("Foreground Agent control state belongs to another inference host.");
+              }
+              if (control?.assignment) {
+                assignmentHeartbeatComplete = false;
+                try {
+                  const requestedAt = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+                  const result2 = await session.client.callTool(
+                    "inference.agent.assignment.heartbeat",
+                    {
+                      operation_id: agentOperationId("agent-assignment-heartbeat"),
+                      host_id: session.localState.host_id,
+                      assignment_id: control.assignment.assignment_id,
+                      assignment_generation: control.assignment.assignment_generation,
+                      requested_at: requestedAt
+                    },
+                    { signal: cancellation.signal }
+                  );
+                  assignmentHeartbeatComplete = true;
+                  assignmentHeartbeatCount += 1;
+                  if (result2.directive === "cancel") {
+                    await handleForegroundCancelledAssignment(
+                      config2,
+                      session,
+                      control,
+                      requestedAt,
+                      cancellation.signal
+                    );
+                  } else {
+                    await writeInferenceForegroundAgentControlState(config2.statePath, {
+                      ...control,
+                      assignment: {
+                        ...control.assignment,
+                        lease_expires_at: result2.lease_expires_at
+                      },
+                      updated_at: requestedAt
+                    });
+                  }
+                } catch (error48) {
+                  if (cancellation.signal.aborted) break;
+                  if (!retryableAgentHeartbeatError(error48)) throw error48;
+                  consecutiveHeartbeatFailures += 1;
+                  retryDelayMs = Math.min(
+                    AGENT_HEARTBEAT_INTERVAL_MS * 2 ** Math.max(0, consecutiveHeartbeatFailures - 1),
+                    AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS
+                  );
+                  emitStderr(parsed.json ? `${JSON.stringify({
+                    status: "assignment_heartbeat_retry",
+                    retry_after_ms: retryDelayMs
+                  })}
+` : `Foreground Agent assignment heartbeat was temporarily unavailable; retrying in ${retryDelayMs}ms.
+`);
+                }
+              }
             } finally {
               await commandLock.release();
             }
-            if (parsed.once && (heartbeatCount > 0 || heartbeatSuppressed)) break;
+            if (parsed.once && (heartbeatCount > 0 || heartbeatSuppressed) && assignmentHeartbeatComplete) break;
           }
           if (parsed.once && !commandLock) break;
           await (dependencies.sleep ?? (async (milliseconds) => {
@@ -36577,7 +38809,11 @@ Waiting for approval...
         }
         return {
           exitCode: 0,
-          stdout: render({ status: "stopped", heartbeats: heartbeatCount }, parsed.json),
+          stdout: render({
+            status: "stopped",
+            heartbeats: heartbeatCount,
+            assignment_heartbeats: assignmentHeartbeatCount
+          }, parsed.json),
           stderr: warnings.length > 0 ? `${warnings.join("\n")}
 ` : ""
         };
@@ -36965,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 ?? randomUUID3();
+        const transactionId = existingTransaction?.transaction_id ?? randomUUID5();
         const backupPath = existingTransaction?.recovery_backup_path ?? recoveryBackupPath(config2, transactionId);
         if (!existingTransaction) {
           await writeAtomicInferencePrivateFile(backupPath, recoveryRaw);
@@ -36974,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.");
         }
@@ -36985,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;
@@ -37024,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)({
@@ -37113,7 +39349,7 @@ Waiting for approval...
               serviceRecoveryTransactionPath(config2),
               "Inference-host service recovery transaction"
             );
-            await rm6(backupPath, { force: true });
+            await rm7(backupPath, { force: true });
           }
         }
       } finally {
@@ -37194,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({
@@ -37381,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();
@@ -37393,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"
@@ -37420,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 {
@@ -37455,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"() {
@@ -37486,7 +39723,7 @@ var init_types = __esm({
 });
 
 // lib/agent-core/client.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function normalizeApiUrl(value) {
   const parsed = String(value || "").trim();
   if (!parsed) {
@@ -37748,7 +39985,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/decision", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -37757,7 +39994,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/trade-sync", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -37766,7 +40003,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/error", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -37778,7 +40015,7 @@ var init_client = __esm({
         return this.request("/trading/market-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -37786,7 +40023,7 @@ var init_client = __esm({
         return this.request("/trading/limit-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -37794,7 +40031,7 @@ var init_client = __esm({
         return this.request("/trading/cancel-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -37813,7 +40050,7 @@ var init_client = __esm({
         return this.request("/trading/ai/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -37821,7 +40058,7 @@ var init_client = __esm({
         return this.request("/trading/ai/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           body: {}
         });
       }
@@ -37829,7 +40066,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           body: {}
         });
       }
@@ -37837,7 +40074,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           body: {}
         });
       }
@@ -37845,7 +40082,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/session/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -37856,7 +40093,7 @@ var init_client = __esm({
           return this.request("/trading/ai/runtime/session/stop", {
             method: "POST",
             profileId,
-            idempotencyKey: randomUUID4(),
+            idempotencyKey: randomUUID6(),
             body: payload
           });
         }
@@ -37873,7 +40110,7 @@ var init_client = __esm({
         }).request("/trading/ai/runtime/session/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -37890,8 +40127,8 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { randomUUID as randomUUID5 } 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"() {
@@ -37944,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}.${randomUUID5()}.tmp`;
+        const temporaryPath = `${this.path}.${process.pid}.${randomUUID7()}.tmp`;
         try {
           writeFileSync(temporaryPath, serialized, {
             encoding: "utf8",
@@ -37974,7 +40211,7 @@ var init_protection_storage = __esm({
 });
 
 // lib/agent-core/headless-runtime.ts
-import { randomUUID as randomUUID6 } 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;
@@ -38072,8 +40309,8 @@ async function runAndReportLocalWorkCycle(options, state, leaseToken, context) {
   return Boolean(result2.decision || tradeSync || result2.afterDecision);
 }
 async function startHeadlessRuntime(options) {
-  const runtimeSessionId = randomUUID6();
-  const deviceId = String(options.deviceId || "").trim() || randomUUID6();
+  const runtimeSessionId = randomUUID8();
+  const deviceId = String(options.deviceId || "").trim() || randomUUID8();
   const startResponse = await options.client.startRuntime(options.profileId, {
     session_id: runtimeSessionId,
     device_id: deviceId,
@@ -42758,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);
@@ -42793,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"() {
   }
@@ -43447,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;
@@ -43456,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);
   }
 });
 
@@ -44007,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;
@@ -44117,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));
   }
@@ -45656,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;
@@ -45667,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);
@@ -45904,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) {
@@ -49878,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) {
@@ -49898,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);
@@ -49934,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();
@@ -50272,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);
       }
       /**
@@ -60625,7 +62862,7 @@ var headless_local_worker_exports = {};
 __export(headless_local_worker_exports, {
   createHeadlessLocalWorker: () => createHeadlessLocalWorker
 });
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function objectOrNull3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -61042,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: randomUUID7(),
+        client_invocation_id: randomUUID9(),
         use_case: "trader",
         role: "primary",
         attempt_index: 0,
@@ -61098,7 +63335,7 @@ function createHeadlessLocalWorker(options) {
       billable_cached_input_tokens: normalizedUsage.cached_input_tokens
     };
     const invocation = normalizeAiInvocationTelemetry({
-      client_invocation_id: randomUUID7(),
+      client_invocation_id: randomUUID9(),
       use_case: "trader",
       role: "primary",
       attempt_index: 0,
@@ -61317,7 +63554,7 @@ var vtx_exports = {};
 __export(vtx_exports, {
   runVtxCli: () => runVtxCli
 });
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { spawn as spawn8 } from "node:child_process";
 function render2(value, json2) {
   if (json2) {
@@ -61731,8 +63968,8 @@ async function runVtxCli(argv2, env = process.env) {
         });
         return { exitCode: 0, stdout: render2(redactCliOutput(response2), json2), stderr: "" };
       }
-      const runtimeSessionId = randomUUID8();
-      const deviceId = config2.runtimeDeviceId ?? randomUUID8();
+      const runtimeSessionId = randomUUID10();
+      const deviceId = config2.runtimeDeviceId ?? randomUUID10();
       const response = await client.startRuntime(profileId, {
         session_id: runtimeSessionId,
         device_id: deviceId,