@vtxmacro/cli 2026.8.53 → 2026.8.55

package/bin/vtx.js

@@ -47,13 +47,67 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.8.53",
+      package_version: "2026.8.55",
       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",
@@ -14388,7 +14442,7 @@ var init_zod = __esm({
 });
 
 // lib/external-inference-contract.ts
-var EXTERNAL_INFERENCE_CONTRACT_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION_V2, EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION, EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, LEGACY_EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION, EXTERNAL_INFERENCE_INPUT_HASH_DOMAIN, MAX_EXTERNAL_INFERENCE_STATUS_HOSTS, MAX_GENERATION, MAX_SAFE_INTEGER, MAX_PROMPT_BYTES, MAX_IMMUTABLE_JOB_INPUT_BYTES, MAX_CANDIDATE_PLAINTEXT_BYTES, MAX_CIPHERTEXT_CHARS, SHA256_INITIAL_STATE, SHA256_ROUND_CONSTANTS, rotateRight, sha256BytesHex, sha256Utf8Hex, computeImmutableJobInputSha256, identifierSchema, operationIdentifierSchema, sha256HexSchema, generationSchema, zeroBasedGenerationSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, sqlIntegerTokenCountSchema, timestampSchema, safeCodeSchema, processExitCodeSchema, externalInferenceAdapterIdSchema, reasoningEffortSchema, modelNameSchema, displayNameSchema, authenticatedAccountEmailSchema, protocolVersionSchema, base64UrlAlphabet, isCanonicalBase64Url, base64Url32BytesSchema, base64UrlNonceSchema, base64UrlCiphertextSchema, claimHandleSchema, boundedJsonTextSchema, boundedPromptTextSchema, laneSchema, botModeSchema, executionModeSchema, responseModeSchema, controlModeSchema, dispatchOutcomeSchema, responseOutcomeSchema, nativeModelControllerSchema, legacyExternalAgentModelControllerSchema, externalAgentModelControllerSchema, boundExternalAgentModelControllerSchema, externalAgentUnboundControllerSchema, externalAgentUnboundControllerV2Schema, orderedFallbackHostIdsSchema, externalInferenceFallbackHostIdsSchema, liveModelControllerSchema, snapshotModelControllerSchema, modelIdentityMappingSchema, advertisedModelSchema, hostAdvertisementSchema, envelopeAadSchema, validateEnvelopeAad, commonEnvelopeShape, sealedKeyWrapEnvelopeSchema, sealedInputEnvelopeSchema, sealedCandidateEnvelopeSchema, sealedEnvelopeSchema, screenerCandidateRuntimeBindingSchema, screenerClientLeaseBindingSchema, screenerRuntimeBindingSchema, serverRuntimeBindingSchema, clientRuntimeBindingSchema, runtimeBindingSchema, immutableJobInputSchema, canonicalizeJsonValue, serializeImmutableJobInput, reportedTokenUsageSchema, unavailableTokenUsageSchema, tokenUsageSchema, agentConnectRequestSchema, agentNextRequestSchema, agentHeartbeatRequestSchema, emptyAgentNextResultSchema, claimedAgentNextResultSchema, agentNextResultSchema, agentCompleteRequestSchema, agentFailRequestSchema, requestedModelSelectionSchema, completedModelProvenanceSchema, attemptModelProvenanceSchema, providerWeeklyQuotaReadSchema, hostHeartbeatRequestSchema, jobClaimRequestSchema, emptyJobClaimSchema, claimedJobSchema, jobClaimResultSchema, attemptStartRequestSchema, jobHeartbeatRequestSchema, continueHeartbeatDirectiveSchema, cancelHeartbeatDirectiveSchema, jobHeartbeatResultSchema, adapterOutcomeEvidenceSchema, completionBaseShape, validateCompletion, providerResponseCompletionSchema, decisionCandidateCompletionSchema, jobCompleteRequestSchema, codexProcessExitDiagnosticsSchema, jobFailRequestSchema, jobCancelRequestSchema, jobCancellationReceiptSchema, jobDeliveryRequestSchema, deliveryBaseShape, validateDeliveryCandidate, providerResponseDeliverySchema, decisionCandidateDeliverySchema, jobDeliveryResultSchema, jobConsumptionRequestSchema, jobConsumptionReceiptSchema, jobStateSchema, jobStatusReadSchema, hostStatusReadSchema, controllerBindingStatusReadSchema, queueStatusReadSchema, outcomeStatusReadSchema, externalInferenceVolumeWindowReadSchema, externalInferenceFailureCountReadSchema, externalInferenceHostDiagnosticsReadSchema, externalInferenceProfileActivityReadSchema, externalInferenceStatusReadSchema, nativeResearchEvidenceSourceSchema, externalAgentResearchEvidenceSourceSchema, researchEvidenceSourceSchema, reportedResearchTokenUsageSchema, unavailableResearchTokenUsageSchema, researchTokenUsageSchema, externalInferenceProductLineageBaseShape, traderExternalInferenceProductLineageSchema, decisionChatExternalInferenceProductLineageSchema, screenerExternalInferenceProductLineageSchema, externalInferenceProductLineageSchema, normalProductLinkageSchema, evidenceMaterializationMarkerSchema, deliveredExternalAgentSourceIdentitySchema, deliveredRequestEvidenceSchema, researchEvidenceBaseShape, researchEvidenceBaseSchema, validateExactUtf8, validateResearchEvidence, providerResponseResearchEvidenceSchema, decisionCandidateResearchEvidenceSchema, researchEvidenceSchema;
+var EXTERNAL_INFERENCE_CONTRACT_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION, EXTERNAL_INFERENCE_CONTROLLER_SCHEMA_VERSION_V2, EXTERNAL_INFERENCE_ADVERTISEMENT_SCHEMA_VERSION, EXTERNAL_INFERENCE_ENVELOPE_SCHEMA_VERSION, EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, LEGACY_EXTERNAL_INFERENCE_JOB_INPUT_SCHEMA_VERSION, EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION, EXTERNAL_INFERENCE_INPUT_HASH_DOMAIN, MAX_EXTERNAL_INFERENCE_STATUS_HOSTS, MAX_PROFILE_EXTERNAL_INFERENCE_FALLBACKS_PER_LANE, MAX_GENERATION, MAX_SAFE_INTEGER, MAX_PROMPT_BYTES, MAX_IMMUTABLE_JOB_INPUT_BYTES, MAX_CANDIDATE_PLAINTEXT_BYTES, MAX_CIPHERTEXT_CHARS, SHA256_INITIAL_STATE, SHA256_ROUND_CONSTANTS, rotateRight, sha256BytesHex, sha256Utf8Hex, computeImmutableJobInputSha256, identifierSchema, operationIdentifierSchema, sha256HexSchema, generationSchema, zeroBasedGenerationSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, sqlIntegerTokenCountSchema, timestampSchema, safeCodeSchema, processExitCodeSchema, externalInferenceAdapterIdSchema, reasoningEffortSchema, modelNameSchema, displayNameSchema, authenticatedAccountEmailSchema, protocolVersionSchema, base64UrlAlphabet, isCanonicalBase64Url, base64Url32BytesSchema, base64UrlNonceSchema, base64UrlCiphertextSchema, claimHandleSchema, boundedJsonTextSchema, boundedPromptTextSchema, laneSchema, botModeSchema, executionModeSchema, responseModeSchema, controlModeSchema, dispatchOutcomeSchema, responseOutcomeSchema, nativeModelControllerSchema, legacyExternalAgentModelControllerSchema, externalAgentModelControllerSchema, boundExternalAgentModelControllerSchema, externalAgentUnboundControllerSchema, externalAgentUnboundControllerV2Schema, orderedFallbackHostIdsSchema, externalInferenceFallbackHostIdsSchema, liveModelControllerSchema, snapshotModelControllerSchema, modelIdentityMappingSchema, advertisedModelSchema, hostAdvertisementSchema, envelopeAadSchema, validateEnvelopeAad, commonEnvelopeShape, sealedKeyWrapEnvelopeSchema, sealedInputEnvelopeSchema, sealedCandidateEnvelopeSchema, sealedEnvelopeSchema, screenerCandidateRuntimeBindingSchema, screenerClientLeaseBindingSchema, screenerRuntimeBindingSchema, serverRuntimeBindingSchema, clientRuntimeBindingSchema, runtimeBindingSchema, immutableJobInputSchema, canonicalizeJsonValue, serializeImmutableJobInput, reportedTokenUsageSchema, unavailableTokenUsageSchema, tokenUsageSchema, agentConnectRequestSchema, agentNextRequestSchema, agentHeartbeatRequestSchema, emptyAgentNextResultSchema, claimedAgentNextResultSchema, agentNextResultSchema, agentCompleteRequestSchema, agentFailRequestSchema, requestedModelSelectionSchema, completedModelProvenanceSchema, attemptModelProvenanceSchema, providerWeeklyQuotaReadSchema, hostHeartbeatRequestSchema, jobClaimRequestSchema, emptyJobClaimSchema, claimedJobSchema, jobClaimResultSchema, attemptStartRequestSchema, jobHeartbeatRequestSchema, continueHeartbeatDirectiveSchema, cancelHeartbeatDirectiveSchema, jobHeartbeatResultSchema, adapterOutcomeEvidenceSchema, completionBaseShape, validateCompletion, providerResponseCompletionSchema, decisionCandidateCompletionSchema, jobCompleteRequestSchema, codexProcessExitDiagnosticsSchema, jobFailRequestSchema, jobCancelRequestSchema, jobCancellationReceiptSchema, jobDeliveryRequestSchema, deliveryBaseShape, validateDeliveryCandidate, providerResponseDeliverySchema, decisionCandidateDeliverySchema, jobDeliveryResultSchema, jobConsumptionRequestSchema, jobConsumptionReceiptSchema, jobStateSchema, jobStatusReadSchema, hostStatusReadSchema, controllerBindingStatusReadSchema, queueStatusReadSchema, outcomeStatusReadSchema, externalInferenceVolumeWindowReadSchema, externalInferenceFailureCountReadSchema, externalInferenceHostDiagnosticsReadSchema, externalInferenceProfileActivityReadSchema, externalInferenceStatusReadSchema, nativeResearchEvidenceSourceSchema, externalAgentResearchEvidenceSourceSchema, researchEvidenceSourceSchema, reportedResearchTokenUsageSchema, unavailableResearchTokenUsageSchema, researchTokenUsageSchema, externalInferenceProductLineageBaseShape, traderExternalInferenceProductLineageSchema, decisionChatExternalInferenceProductLineageSchema, screenerExternalInferenceProductLineageSchema, externalInferenceProductLineageSchema, normalProductLinkageSchema, evidenceMaterializationMarkerSchema, deliveredExternalAgentSourceIdentitySchema, deliveredRequestEvidenceSchema, researchEvidenceBaseShape, researchEvidenceBaseSchema, validateExactUtf8, validateResearchEvidence, providerResponseResearchEvidenceSchema, decisionCandidateResearchEvidenceSchema, researchEvidenceSchema;
 var init_external_inference_contract = __esm({
   "lib/external-inference-contract.ts"() {
     "use strict";
@@ -14403,6 +14457,7 @@ var init_external_inference_contract = __esm({
     EXTERNAL_INFERENCE_USAGE_SCHEMA_VERSION = "external_inference_usage_v1";
     EXTERNAL_INFERENCE_INPUT_HASH_DOMAIN = "vtx.external-inference.input-sha256.v1\0";
     MAX_EXTERNAL_INFERENCE_STATUS_HOSTS = 640;
+    MAX_PROFILE_EXTERNAL_INFERENCE_FALLBACKS_PER_LANE = 127;
     MAX_GENERATION = 2147483647;
     MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
     MAX_PROMPT_BYTES = 3e5;
@@ -14684,7 +14739,7 @@ var init_external_inference_contract = __esm({
       control_mode_hint: controlModeSchema,
       binding_state: external_exports.literal("rebind_required")
     });
-    orderedFallbackHostIdsSchema = external_exports.array(identifierSchema).max(127).refine(
+    orderedFallbackHostIdsSchema = external_exports.array(identifierSchema).max(MAX_PROFILE_EXTERNAL_INFERENCE_FALLBACKS_PER_LANE).refine(
       (values) => new Set(values).size === values.length,
       { message: "fallback host IDs must be unique" }
     );
@@ -15762,6 +15817,8 @@ var init_external_inference_contract = __esm({
       authenticated_account_identity: safeCodeSchema.nullable().optional(),
       authenticated_account_email: authenticatedAccountEmailSchema.nullable().optional(),
       authenticated_account_plan: safeCodeSchema.nullable().optional(),
+      account_identity_status: external_exports.enum(["reported", "not_reported"]).default("not_reported"),
+      membership_identity_sha256: sha256HexSchema.nullable().optional(),
       adapter: externalInferenceAdapterIdSchema,
       status: external_exports.enum(["online", "degraded", "offline", "draining", "revoked"]),
       host_generation: generationSchema,
@@ -15775,7 +15832,8 @@ var init_external_inference_contract = __esm({
       lane: laneSchema,
       controller: liveModelControllerSchema,
       availability: external_exports.enum(["available", "host_offline", "model_unavailable", "rebind_required"]),
-      reason_code: safeCodeSchema.nullable()
+      reason_code: safeCodeSchema.nullable(),
+      membership_host_ids: external_exports.array(identifierSchema).max(MAX_PROFILE_EXTERNAL_INFERENCE_FALLBACKS_PER_LANE + 1).default([])
     });
     queueStatusReadSchema = external_exports.strictObject({
       queued: nonNegativeSafeIntegerSchema,
@@ -19695,6 +19753,34 @@ var init_agent_client = __esm({
 });
 
 // lib/inference-host/agent-state.ts
+async function readInferenceAgentFailureFence(statePath) {
+  const raw = await readInferencePrivateFile(
+    inferenceAgentFailureFencePath(statePath),
+    "Inference Agent failure fence"
+  );
+  if (raw === null) return null;
+  try {
+    return assertInferenceAgentFailureFence(JSON.parse(raw));
+  } catch (error48) {
+    if (error48 instanceof SyntaxError) {
+      throw new Error("Inference Agent failure fence is not valid JSON.");
+    }
+    throw error48;
+  }
+}
+async function writeInferenceAgentFailureFence(statePath, value) {
+  await writeAtomicInferencePrivateFile(
+    inferenceAgentFailureFencePath(statePath),
+    `${JSON.stringify(assertInferenceAgentFailureFence(value), null, 2)}
+`
+  );
+}
+async function clearInferenceAgentFailureFence(statePath) {
+  await clearInferencePrivateFile(
+    inferenceAgentFailureFencePath(statePath),
+    "Inference Agent failure fence"
+  );
+}
 async function readInferenceAgentRuntimeState(statePath) {
   const raw = await readInferencePrivateFile(
     inferenceAgentRuntimeStatePath(statePath),
@@ -19807,7 +19893,7 @@ async function clearInferenceAgentNextState(statePath) {
     "Agent-driven inference next recovery state"
   );
 }
-var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, inferenceAgentRuntimeStatePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
+var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, inferenceAgentRuntimeStatePath, inferenceAgentFailureFencePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentFailureFence, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
 var init_agent_state = __esm({
   "lib/inference-host/agent-state.ts"() {
     "use strict";
@@ -19816,12 +19902,31 @@ var init_agent_state = __esm({
     inferenceAgentAttemptStatePath = (statePath) => `${statePath}.agent-attempt.json`;
     inferenceAgentNextStatePath = (statePath) => `${statePath}.agent-next.json`;
     inferenceAgentRuntimeStatePath = (statePath) => `${statePath}.codex-agent-runtime.json`;
+    inferenceAgentFailureFencePath = (statePath) => `${statePath}.agent-failure-fence.json`;
     isIsoTimestamp = (value) => typeof value === "string" && Number.isFinite(Date.parse(value));
     assertPlainObject = (value, message) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(message);
       return value;
     };
     hasExactKeys = (record2, keys) => Object.keys(record2).sort().join("\0") === [...keys].sort().join("\0");
+    assertInferenceAgentFailureFence = (value) => {
+      const message = "Inference Agent failure fence is invalid.";
+      const fence = assertPlainObject(value, message);
+      if (!hasExactKeys(fence, [
+        "schema_version",
+        "adapter_id",
+        "host_id",
+        "assignment_id",
+        "failure_category",
+        "failure_code",
+        "dispatch_outcome",
+        "retry_at",
+        "created_at"
+      ]) || fence.schema_version !== "vtx_inference_agent_failure_fence_v1" || typeof fence.adapter_id !== "string" || !/^[a-z0-9][a-z0-9._-]{0,63}$/u.test(fence.adapter_id) || typeof fence.host_id !== "string" || !fence.host_id || fence.assignment_id !== null && (typeof fence.assignment_id !== "string" || !fence.assignment_id) || typeof fence.failure_category !== "string" || !/^[a-z0-9][a-z0-9._-]{0,159}$/u.test(fence.failure_category) || typeof fence.failure_code !== "string" || !/^[a-z0-9][a-z0-9._-]{0,159}$/u.test(fence.failure_code) || !["not_dispatched", "confirmed_dispatched", "outcome_unknown"].includes(
+        String(fence.dispatch_outcome)
+      ) || fence.retry_at !== null && !isIsoTimestamp(fence.retry_at) || !isIsoTimestamp(fence.created_at)) throw new Error(message);
+      return fence;
+    };
     assertInferenceAgentRuntimeState = (value) => {
       const message = "Inference Agent runtime recovery state is invalid.";
       const state = assertPlainObject(value, message);
@@ -24722,6 +24827,995 @@ ${JSON.stringify(input.outputSchema)}`
   }
 });
 
+// lib/inference-host/deepseek-transport-proxy.ts
+import { createServer as createServer2 } from "node:http";
+import { randomBytes as randomBytes4 } from "node:crypto";
+var MAX_REQUEST_BYTES, DeepSeekTransportProxy;
+var init_deepseek_transport_proxy = __esm({
+  "lib/inference-host/deepseek-transport-proxy.ts"() {
+    "use strict";
+    MAX_REQUEST_BYTES = 8 * 1024 * 1024;
+    DeepSeekTransportProxy = class {
+      constructor(apiKey, expectedModel, expectedEffort, upstreamBaseUrl = "https://api.deepseek.com", fetchImpl = fetch) {
+        this.apiKey = apiKey;
+        this.expectedModel = expectedModel;
+        this.expectedEffort = expectedEffort;
+        this.upstreamBaseUrl = upstreamBaseUrl;
+        this.fetchImpl = fetchImpl;
+        this.server = null;
+        this.urlValue = null;
+        this.receiptsValue = [];
+        this.controllers = /* @__PURE__ */ new Set();
+        this.token = randomBytes4(24).toString("hex");
+        this.upstreamRequestStartedValue = false;
+        this.providerResponseObservedValue = false;
+        this.unansweredUpstreamRequestsValue = 0;
+      }
+      get baseUrl() {
+        if (!this.urlValue) throw new Error("deepseek_transport_proxy_not_started");
+        return `${this.urlValue}/${this.token}`;
+      }
+      get receipts() {
+        return [...this.receiptsValue];
+      }
+      get providerResponseObserved() {
+        return this.providerResponseObservedValue;
+      }
+      get upstreamRequestStarted() {
+        return this.upstreamRequestStartedValue;
+      }
+      get unansweredUpstreamRequest() {
+        return this.unansweredUpstreamRequestsValue > 0;
+      }
+      async start() {
+        if (this.server) return;
+        this.server = createServer2(async (request, response) => {
+          try {
+            const prefix = `/${this.token}`;
+            const requestUrl = request.url ?? "";
+            if (request.method !== "POST" || requestUrl !== `${prefix}/chat/completions`) {
+              response.writeHead(404).end();
+              return;
+            }
+            const chunks = [];
+            let requestBytes = 0;
+            for await (const chunk of request) {
+              const buffer = Buffer.from(chunk);
+              requestBytes += buffer.byteLength;
+              if (requestBytes > MAX_REQUEST_BYTES) throw new Error("deepseek_proxy_request_too_large");
+              chunks.push(buffer);
+            }
+            const body = Buffer.concat(chunks);
+            let requestedModel = "";
+            let requestedEffort = "off";
+            const payload = JSON.parse(body.toString("utf8"));
+            requestedModel = String(payload.model ?? "");
+            const thinking = payload.thinking;
+            requestedEffort = thinking?.type === "disabled" ? "off" : String(payload.reasoning_effort ?? "");
+            if (requestedModel !== this.expectedModel || requestedEffort !== this.expectedEffort) throw new Error("deepseek_outbound_model_or_effort_mismatch");
+            const controller = new AbortController();
+            this.controllers.add(controller);
+            try {
+              this.upstreamRequestStartedValue = true;
+              this.unansweredUpstreamRequestsValue += 1;
+              const upstream = await this.fetchImpl(
+                `${this.upstreamBaseUrl}/chat/completions`,
+                {
+                  method: request.method,
+                  headers: {
+                    "authorization": `Bearer ${this.apiKey}`,
+                    "content-type": String(request.headers["content-type"] ?? "application/json"),
+                    "accept": String(request.headers.accept ?? "application/json"),
+                    "user-agent": String(request.headers["user-agent"] ?? "@vtxmacro/cli")
+                  },
+                  body,
+                  signal: controller.signal
+                }
+              );
+              this.unansweredUpstreamRequestsValue -= 1;
+              this.providerResponseObservedValue = true;
+              const headers = {};
+              upstream.headers.forEach((value, name) => {
+                if (!["connection", "transfer-encoding", "content-length"].includes(name)) {
+                  headers[name] = value;
+                }
+              });
+              response.writeHead(upstream.status, headers);
+              if (!upstream.body) {
+                response.end();
+                return;
+              }
+              if (!upstream.ok) {
+                const errorReader = upstream.body.getReader();
+                while (true) {
+                  const part = await errorReader.read();
+                  if (part.done) break;
+                  response.write(Buffer.from(part.value));
+                }
+                response.end();
+                return;
+              }
+              const reader = upstream.body.getReader();
+              const decoder2 = new TextDecoder();
+              let pending = "";
+              let observedId = "";
+              let terminalObserved = false;
+              const forwardLine = (line) => {
+                if (!line.startsWith("data:")) {
+                  response.write(`${line}
+`);
+                  return;
+                }
+                const value = line.slice(5).trim();
+                if (!value) {
+                  response.write(`${line}
+`);
+                  return;
+                }
+                if (value === "[DONE]") {
+                  if (terminalObserved || !observedId) {
+                    throw new Error("deepseek_provider_receipt_missing_or_mismatched");
+                  }
+                  terminalObserved = true;
+                  this.receiptsValue.push({
+                    id: observedId,
+                    model: this.expectedModel,
+                    requestedModel,
+                    requestedReasoningEffort: requestedEffort
+                  });
+                  response.write(`${line}
+`);
+                  return;
+                }
+                const event = JSON.parse(value);
+                const eventId = typeof event.id === "string" ? event.id.trim() : "";
+                const eventModel = typeof event.model === "string" ? event.model.trim() : "";
+                if (!eventId || eventModel !== this.expectedModel || observedId && eventId !== observedId) throw new Error("deepseek_provider_receipt_missing_or_mismatched");
+                observedId = eventId;
+                response.write(`${line}
+`);
+              };
+              while (true) {
+                const part = await reader.read();
+                if (part.done) break;
+                pending += decoder2.decode(part.value, { stream: true });
+                const lines = pending.split(/\r?\n/u);
+                pending = lines.pop() ?? "";
+                for (const line of lines) forwardLine(line);
+              }
+              pending += decoder2.decode();
+              if (pending) forwardLine(pending);
+              if (!terminalObserved) {
+                throw new Error("deepseek_provider_receipt_missing_or_mismatched");
+              }
+              response.end();
+            } finally {
+              this.controllers.delete(controller);
+            }
+          } catch {
+            if (!response.headersSent) response.writeHead(502);
+            response.end();
+          }
+        });
+        await new Promise((resolve6, reject) => {
+          this.server.once("error", reject);
+          this.server.listen(0, "127.0.0.1", () => resolve6());
+        });
+        const address = this.server.address();
+        if (!address || typeof address === "string") throw new Error("deepseek_proxy_bind_failed");
+        this.urlValue = `http://127.0.0.1:${address.port}`;
+      }
+      async close() {
+        for (const controller of this.controllers) controller.abort();
+        const server = this.server;
+        this.server = null;
+        this.urlValue = null;
+        if (!server) return;
+        await new Promise((resolve6) => server.close(() => resolve6()));
+      }
+    };
+  }
+});
+
+// lib/inference-host/deepseek-harness-adapter.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdtemp as mkdtemp3, realpath as realpath4, rm as rm5 } from "node:fs/promises";
+import { tmpdir as tmpdir4 } from "node:os";
+import { basename, dirname as dirname4, join as join6 } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import * as AgentSpine from "@deepseek-ai/dsh-agent-spine-demo";
+import {
+  createUserMessage,
+  LlmError
+} from "@deepseek-ai/dsh-llm";
+import {
+  DeepSeekAdapter,
+  resolveAdapterOptions
+} from "@deepseek-ai/dsh-llm-deepseek";
+import * as LlmDeepSeek from "@deepseek-ai/dsh-llm-deepseek";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import * as SessionCheckpointPolicy from "@deepseek-ai/dsh-session-checkpoint-policy";
+import { JsonlSessionPersistence } from "@deepseek-ai/dsh-session-persistence-jsonl";
+var DEEPSEEK_HARNESS_VERSION, MAX_RESULT_BYTES2, DEEPSEEK_MODELS, DEEPSEEK_API_BASE_URL, isSupportedNodeVersion, effortForHarness, supportedEfforts, toVtxUsage, sumUsage, textFromBlocks, validateText, createDeadlineBoundary, nonDispatchedError, proxyDispatchOutcome, mapDeepSeekFailure, createPrivateWorkspace2, directAdapter, normalizeJsonValue, DeepSeekHarnessAdapter;
+var init_deepseek_harness_adapter = __esm({
+  "lib/inference-host/deepseek-harness-adapter.ts"() {
+    "use strict";
+    init_codex_app_server();
+    init_deepseek_transport_proxy();
+    DEEPSEEK_HARNESS_VERSION = "0.1.1-rc.2";
+    MAX_RESULT_BYTES2 = 3e5;
+    DEEPSEEK_MODELS = ["deepseek-v4-flash", "deepseek-v4-pro"];
+    DEEPSEEK_API_BASE_URL = "https://api.deepseek.com";
+    isSupportedNodeVersion = (version3) => {
+      const [major, minor] = version3.replace(/^v/u, "").split(".").map(Number);
+      return major === 22 && minor >= 19 || major >= 24;
+    };
+    effortForHarness = (effort) => {
+      if (effort === "none") return "off";
+      if (effort === "low" || effort === "high" || effort === "max") return effort;
+      throw new Error(`deepseek_reasoning_effort_unsupported:${effort}`);
+    };
+    supportedEfforts = (model) => model === "deepseek-v4-pro" ? ["none", "high", "max"] : ["none", "low", "high", "max"];
+    toVtxUsage = (usage) => {
+      const cacheRead = usage.cacheReadTokens ?? 0;
+      const cacheWrite = usage.cacheWriteTokens ?? 0;
+      const inclusiveInput = usage.inputTokens + cacheRead + cacheWrite;
+      return {
+        inputTokens: inclusiveInput,
+        cachedInputTokens: cacheRead,
+        outputTokens: usage.outputTokens,
+        reasoningOutputTokens: Math.min(usage.reasoningTokens ?? 0, usage.outputTokens),
+        totalTokens: inclusiveInput + usage.outputTokens,
+        cacheWriteInputTokens: usage.cacheWriteTokens ?? null,
+        cacheWriteSupported: usage.cacheWriteTokens !== void 0
+      };
+    };
+    sumUsage = (values) => toVtxUsage({
+      inputTokens: values.reduce((sum, value) => sum + value.inputTokens, 0),
+      outputTokens: values.reduce((sum, value) => sum + value.outputTokens, 0),
+      cacheReadTokens: values.reduce((sum, value) => sum + (value.cacheReadTokens ?? 0), 0),
+      cacheWriteTokens: values.some((value) => value.cacheWriteTokens !== void 0) ? values.reduce((sum, value) => sum + (value.cacheWriteTokens ?? 0), 0) : void 0,
+      reasoningTokens: values.reduce((sum, value) => sum + (value.reasoningTokens ?? 0), 0)
+    });
+    textFromBlocks = (blocks, type) => blocks.flatMap((block) => block.type === type ? [block.text] : []).join("");
+    validateText = (text, code) => {
+      if (!text.trim() || Buffer.byteLength(text, "utf8") > MAX_RESULT_BYTES2) throw new Error(code);
+      return text;
+    };
+    createDeadlineBoundary = (source, deadlineAtMs) => {
+      const controller = new AbortController();
+      const relayAbort = () => controller.abort(source?.reason);
+      source?.addEventListener("abort", relayAbort, { once: true });
+      if (source?.aborted) controller.abort(source.reason);
+      const timeout = setTimeout(
+        () => controller.abort(new Error("deadline_exceeded")),
+        Math.max(1, deadlineAtMs - Date.now())
+      );
+      timeout.unref();
+      return {
+        signal: controller.signal,
+        cleanup: () => {
+          clearTimeout(timeout);
+          source?.removeEventListener("abort", relayAbort);
+        }
+      };
+    };
+    nonDispatchedError = (message, category, code, retryable = false) => new CodexAppServerError({
+      message,
+      category,
+      code,
+      retryable,
+      dispatchOutcome: "not_dispatched"
+    });
+    proxyDispatchOutcome = (proxy) => {
+      if (proxy.unansweredUpstreamRequest) return "outcome_unknown";
+      if (proxy.providerResponseObserved) return "confirmed_dispatched";
+      return proxy.upstreamRequestStarted ? "outcome_unknown" : "not_dispatched";
+    };
+    mapDeepSeekFailure = (options) => {
+      if (options.error instanceof CodexAppServerError) return options.error;
+      if (options.cancelled || options.deadline) {
+        return new CodexAppServerError({
+          message: options.cancelled ? "DeepSeek Harness request was cancelled." : "DeepSeek Harness request exceeded its deadline.",
+          category: options.cancelled ? "cancelled" : "timeout",
+          code: options.cancelled ? "cancelled" : "deadline_exceeded",
+          retryable: false,
+          dispatchOutcome: options.dispatchOutcome,
+          cause: options.error
+        });
+      }
+      if (options.error instanceof LlmError) {
+        const failure = options.error.failure;
+        const auth = ["AUTH", "INVALID_CREDENTIAL", "MISSING_CREDENTIAL"].includes(failure.code);
+        const quota = failure.code === "QUOTA" || failure.status === 402;
+        const rateLimit = failure.code === "RATE_LIMIT";
+        const clientError = failure.status !== void 0 && failure.status >= 400 && failure.status < 500;
+        const model = !auth && !quota && !rateLimit && clientError || [
+          "CONTEXT_WINDOW_EXCEEDED",
+          "INVALID_REQUEST",
+          "UNSUPPORTED_CONTENT",
+          "UNSUPPORTED_REASONING_EFFORT"
+        ].includes(failure.code);
+        const transport = [
+          "EMPTY_RESPONSE",
+          "MALFORMED_RESPONSE",
+          "SERVER",
+          "STREAM_CLOSED",
+          "TIMEOUT",
+          "TRANSPORT"
+        ].includes(failure.code) || failure.code.startsWith("HTTP_") && !clientError;
+        const code = auth ? "deepseek_auth_failed" : quota ? "quota_exceeded" : rateLimit ? "provider_rate_limited" : model ? `deepseek_${failure.code.toLowerCase()}` : transport ? `deepseek_${failure.code.toLowerCase()}` : "deepseek_harness_adapter_failure";
+        return new CodexAppServerError({
+          message: failure.message,
+          category: auth ? "auth" : model || quota || rateLimit ? "model" : transport ? "transport" : "adapter",
+          code,
+          retryable: transport && !quota,
+          dispatchOutcome: options.dispatchOutcome,
+          httpStatusCode: failure.status ?? null,
+          retryAtMs: failure.providerRetryAfterMs === void 0 ? null : Date.now() + failure.providerRetryAfterMs,
+          cause: options.error
+        });
+      }
+      return new CodexAppServerError({
+        message: options.error instanceof Error ? options.error.message : "DeepSeek Harness adapter failed.",
+        category: "adapter",
+        code: "deepseek_harness_adapter_failure",
+        retryable: false,
+        dispatchOutcome: options.dispatchOutcome,
+        cause: options.error
+      });
+    };
+    createPrivateWorkspace2 = async () => {
+      const path = await mkdtemp3(join6(tmpdir4(), "vtx-deepseek-harness-"));
+      return { path, cleanup: async () => {
+        await rm5(path, { recursive: true, force: true });
+      } };
+    };
+    directAdapter = (proxy, model, effort) => {
+      const connection = resolveAdapterOptions({
+        apiKeyEnv: "VTX_DSH_LOOPBACK_TOKEN",
+        baseURL: proxy.baseUrl,
+        reasoningEffort: effort,
+        thinking: "enabled",
+        models: [{ id: model }],
+        retryPolicy: { mode: "normal", maxRetries: 0 }
+      });
+      return new DeepSeekAdapter({
+        options: () => connection,
+        resolveApiKey: async () => "vtx-loopback-only",
+        resolveUserId: () => "vtx-macro"
+      });
+    };
+    normalizeJsonValue = (value) => JSON.parse(JSON.stringify(value));
+    DeepSeekHarnessAdapter = class {
+      constructor(dependencies) {
+        this.agentWorkspaces = /* @__PURE__ */ new Map();
+        this.closing = false;
+        this.dependencies = dependencies;
+      }
+      async preflight(signal) {
+        if (!isSupportedNodeVersion(this.dependencies.nodeVersion ?? process.version)) {
+          throw new CodexAppServerError({
+            message: "DeepSeek Harness requires Node 22.19 or newer in the Node 22 line, or Node 24+.",
+            category: "adapter",
+            code: "deepseek_harness_node_version_unsupported",
+            retryable: false
+          });
+        }
+        const credential = await this.dependencies.credentialStore.read(signal);
+        if (!credential) {
+          throw new CodexAppServerError({
+            message: "Import a DeepSeek API key with vtx inference-host deepseek-login first.",
+            category: "auth",
+            code: "deepseek_harness_credential_required",
+            retryable: false
+          });
+        }
+        const response = await (this.dependencies.fetch ?? fetch)(
+          `${this.dependencies.apiBaseUrl ?? DEEPSEEK_API_BASE_URL}/models`,
+          { headers: { authorization: `Bearer ${credential.apiKey}` }, signal }
+        );
+        if (!response.ok) {
+          throw new CodexAppServerError({
+            message: `DeepSeek model catalog request failed with HTTP ${response.status}.`,
+            category: response.status === 401 || response.status === 403 ? "auth" : "transport",
+            code: "deepseek_harness_model_catalog_failed",
+            retryable: false
+          });
+        }
+        const payload = await response.json();
+        const live = new Set((payload.data ?? []).map((item) => String(item.id ?? "")));
+        const models = DEEPSEEK_MODELS.filter((model) => live.has(model));
+        if (models.length === 0) {
+          throw new CodexAppServerError({
+            message: "DeepSeek returned no VTX-supported Harness models.",
+            category: "model",
+            code: "deepseek_harness_model_catalog_empty",
+            retryable: false
+          });
+        }
+        return {
+          adapterId: "deepseek-harness",
+          runtimeVersion: DEEPSEEK_HARNESS_VERSION,
+          authenticatedAccountIdentity: null,
+          authenticatedAccountEmail: null,
+          authenticatedAccountPlan: null,
+          modelCapabilities: models.map((model, index) => ({
+            id: model,
+            model,
+            displayName: model === "deepseek-v4-flash" ? "DeepSeek V4 Flash" : "DeepSeek V4 Pro",
+            hidden: false,
+            supportedReasoningEfforts: [...supportedEfforts(model)],
+            defaultReasoningEffort: "high",
+            isDefault: index === 0
+          })),
+          rateLimits: null,
+          sameAttemptRecovery: false
+        };
+      }
+      async runAttempt(input) {
+        const startedAt = (this.dependencies.now ?? Date.now)();
+        if (Date.now() >= input.deadlineAtMs) {
+          throw nonDispatchedError(
+            "DeepSeek Harness attempt exceeded its deadline.",
+            "timeout",
+            "deadline_exceeded"
+          );
+        }
+        if (!DEEPSEEK_MODELS.includes(input.requestedModel)) {
+          throw nonDispatchedError(
+            "The requested DeepSeek Harness model is unsupported.",
+            "model",
+            "deepseek_model_unsupported"
+          );
+        }
+        if (!supportedEfforts(input.requestedModel).includes(input.requestedReasoningEffort)) {
+          throw nonDispatchedError(
+            "The requested DeepSeek Harness reasoning effort is unsupported.",
+            "model",
+            "deepseek_reasoning_effort_unsupported"
+          );
+        }
+        const effort = effortForHarness(input.requestedReasoningEffort);
+        const boundary = createDeadlineBoundary(input.signal, input.deadlineAtMs);
+        let credential;
+        try {
+          credential = await this.dependencies.credentialStore.read(boundary.signal);
+          if (!credential) {
+            throw nonDispatchedError(
+              "Import a DeepSeek API key with vtx inference-host deepseek-login first.",
+              "auth",
+              "deepseek_harness_credential_required"
+            );
+          }
+        } catch (error48) {
+          const cancelled = input.signal?.aborted === true;
+          const deadline = !cancelled && boundary.signal.aborted;
+          boundary.cleanup();
+          if (error48 instanceof CodexAppServerError) throw error48;
+          throw nonDispatchedError(
+            cancelled ? "DeepSeek Harness attempt was cancelled." : deadline ? "DeepSeek Harness attempt exceeded its deadline." : "DeepSeek Harness could not read its local credential.",
+            cancelled ? "cancelled" : deadline ? "timeout" : "auth",
+            cancelled ? "cancelled" : deadline ? "deadline_exceeded" : "deepseek_harness_credential_read_failed"
+          );
+        }
+        const proxy = new DeepSeekTransportProxy(
+          credential.apiKey,
+          input.requestedModel,
+          effort,
+          this.dependencies.apiBaseUrl ?? DEEPSEEK_API_BASE_URL,
+          this.dependencies.fetch ?? fetch
+        );
+        try {
+          boundary.signal.throwIfAborted();
+          await proxy.start();
+          const adapter = directAdapter(proxy, input.requestedModel, effort);
+          const blocks = [];
+          let usage = null;
+          let finish = null;
+          for await (const chunk of adapter.stream({
+            provider: "deepseek-official",
+            model: input.requestedModel,
+            reasoningEffort: effort,
+            system: `${input.systemPrompt}
+
+Return only one JSON value matching this JSON Schema exactly:
+${input.outputSchemaJson}`,
+            messages: [createUserMessage({
+              content: [{ type: "text", text: input.userPrompt }],
+              source: { kind: "user" }
+            })],
+            tools: [],
+            signal: boundary.signal
+          })) {
+            if (chunk.type === "block-end") blocks.push(chunk.block);
+            if (chunk.type === "usage") usage = chunk.usage;
+            if (chunk.type === "finish") finish = chunk;
+          }
+          const receipts = proxy.receipts;
+          if (receipts.length !== 1 || !usage || finish?.type !== "finish" || finish.reason.kind !== "stop") {
+            throw new Error("deepseek_harness_terminal_receipt_invalid");
+          }
+          const text = validateText(textFromBlocks(blocks, "text"), "deepseek_harness_result_invalid");
+          return {
+            text,
+            reasoningContent: textFromBlocks(blocks, "reasoning") || null,
+            reasoningSummary: null,
+            requestedModel: input.requestedModel,
+            effectiveModel: receipts[0].model,
+            requestedReasoningEffort: input.requestedReasoningEffort,
+            effectiveReasoningEffort: input.requestedReasoningEffort,
+            adapterRequestId: receipts[0].id,
+            adapterResponseId: receipts[0].id,
+            usage: toVtxUsage(usage),
+            latencyMs: Math.max(0, (this.dependencies.now ?? Date.now)() - startedAt),
+            timeToFirstTokenMs: null,
+            terminalStatus: "completed"
+          };
+        } catch (error48) {
+          const cancelled = input.signal?.aborted === true;
+          const deadline = !cancelled && boundary.signal.aborted;
+          throw mapDeepSeekFailure({
+            error: error48,
+            cancelled,
+            deadline,
+            dispatchOutcome: proxyDispatchOutcome(proxy)
+          });
+        } finally {
+          boundary.cleanup();
+          await proxy.close();
+        }
+      }
+      async runTurn(input) {
+        if (this.closing) {
+          throw nonDispatchedError(
+            "DeepSeek Harness Agent adapter is closing.",
+            "transport",
+            "transport_closed",
+            true
+          );
+        }
+        if (Date.now() >= input.deadlineAtMs) {
+          throw nonDispatchedError(
+            "DeepSeek Harness Agent turn exceeded its deadline.",
+            "timeout",
+            "deadline_exceeded"
+          );
+        }
+        if (!DEEPSEEK_MODELS.includes(input.requestedModel)) {
+          throw nonDispatchedError(
+            "The requested DeepSeek Harness model is unsupported.",
+            "model",
+            "deepseek_model_unsupported"
+          );
+        }
+        if (input.dataContract.length === 0 || !supportedEfforts(input.requestedModel).includes(input.requestedReasoningEffort)) {
+          throw nonDispatchedError(
+            "DeepSeek Harness Agent turn input is invalid.",
+            "schema",
+            "invalid_agent_turn_input"
+          );
+        }
+        const startedAt = (this.dependencies.now ?? Date.now)();
+        const effort = effortForHarness(input.requestedReasoningEffort);
+        const boundary = createDeadlineBoundary(input.signal, input.deadlineAtMs);
+        let credential;
+        try {
+          credential = await this.dependencies.credentialStore.read(boundary.signal);
+          if (!credential) {
+            throw nonDispatchedError(
+              "Import a DeepSeek API key with vtx inference-host deepseek-login first.",
+              "auth",
+              "deepseek_harness_credential_required"
+            );
+          }
+        } catch (error48) {
+          const cancelled = input.signal?.aborted === true;
+          const deadline = !cancelled && boundary.signal.aborted;
+          boundary.cleanup();
+          if (error48 instanceof CodexAppServerError) throw error48;
+          throw nonDispatchedError(
+            cancelled ? "DeepSeek Harness Agent turn was cancelled." : deadline ? "DeepSeek Harness Agent turn exceeded its deadline." : "DeepSeek Harness could not read its local credential.",
+            cancelled ? "cancelled" : deadline ? "timeout" : "auth",
+            cancelled ? "cancelled" : deadline ? "deadline_exceeded" : "deepseek_harness_credential_read_failed"
+          );
+        }
+        const owned = input.durableThread ? null : await (this.dependencies.createWorkspace ?? createPrivateWorkspace2)();
+        const rootPath = input.durableThread?.threadPath ?? owned.path;
+        if (owned) this.agentWorkspaces.set(rootPath, owned.cleanup);
+        const proxy = new DeepSeekTransportProxy(
+          credential.apiKey,
+          input.requestedModel,
+          effort,
+          this.dependencies.apiBaseUrl ?? DEEPSEEK_API_BASE_URL,
+          this.dependencies.fetch ?? fetch
+        );
+        const ctx = new Context();
+        const loopbackEnvName = `VTX_DSH_LOOPBACK_TOKEN_${randomUUID2().replaceAll("-", "").toUpperCase()}`;
+        process.env[loopbackEnvName] = "vtx-loopback-only";
+        let durableCheckpointed = input.durableThread !== null;
+        let cleanupUnpublishedWorkspace = false;
+        let removeAgentAbortListener = () => void 0;
+        let cancelAgentTurn = () => void 0;
+        let releaseAgentDispatch = () => void 0;
+        let permitAgentDispatch = false;
+        try {
+          await proxy.start();
+          await ctx.plugin(AgentSpine, {
+            agents: [],
+            maxParallelToolCalls: 1,
+            includeHarnessIdentity: false,
+            includeRuntimeContext: false,
+            persona: `${input.systemPrompt}
+
+Return only one JSON value matching this JSON Schema exactly:
+${JSON.stringify(input.outputSchema)}`,
+            tools: { mode: "native" },
+            workspaceContext: false,
+            skills: { enabled: false },
+            toolBash: false,
+            toolJobs: false,
+            goals: false
+          });
+          await ctx.plugin(JsonlSessionPersistence, { root: rootPath, compression: "none" });
+          await ctx.plugin(SessionCheckpointPolicy);
+          await ctx.plugin(LlmDeepSeek, {
+            apiKeyEnv: loopbackEnvName,
+            baseURL: proxy.baseUrl,
+            reasoningEffort: effort,
+            thinking: "enabled",
+            models: [{ id: input.requestedModel }],
+            retryPolicy: { mode: "normal", maxRetries: 0 }
+          });
+          const evidence = [];
+          const setup = (agentCtx) => {
+            const definitions = [
+              {
+                name: "vtx_get_data",
+                description: "Request assignment-scoped VTX data.",
+                parameters: { oneOf: input.dataContract.map((entry) => ({
+                  type: "object",
+                  additionalProperties: false,
+                  required: ["capability", "arguments"],
+                  properties: { capability: { const: entry.id }, arguments: entry.input_schema }
+                })) }
+              },
+              {
+                name: "vtx_submit_decision",
+                description: "Submit one VTX structured trading decision candidate.",
+                parameters: { type: "object", additionalProperties: false, required: ["candidate"], properties: { candidate: input.decisionSchema } }
+              },
+              {
+                name: "vtx_decision_status",
+                description: "Resolve the durable status of a decision operation.",
+                parameters: { type: "object", additionalProperties: false, required: ["operation_id"], properties: { operation_id: { type: "string", minLength: 1 } } }
+              }
+            ];
+            for (const definition of definitions) {
+              agentCtx.tools.register({
+                ...definition,
+                output: {
+                  schema: {},
+                  render: (_arguments, value) => [{ type: "text", text: JSON.stringify(value) }]
+                },
+                execute: async (argumentsValue) => {
+                  const argumentsRecord = argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue) ? argumentsValue : {};
+                  const callId = randomUUID2();
+                  const result2 = await input.executeTool({ callId, tool: definition.name, arguments: argumentsRecord });
+                  evidence.push({ callId, tool: definition.name, arguments: argumentsRecord, success: result2.success });
+                  return normalizeJsonValue(result2.success ? result2.value : { error: result2.value });
+                }
+              });
+            }
+          };
+          const sessionId = input.durableThread ? SessionId(input.durableThread.threadId) : SessionId(`vtx-${randomUUID2()}`);
+          const handle = input.durableThread ? await ctx.agents.resume({
+            resumeSessionId: sessionId,
+            agentOptions: { provider: "deepseek-official", model: input.requestedModel, reasoningEffort: effort },
+            signal: boundary.signal,
+            setup
+          }) : await ctx.agents.create({
+            sessionId,
+            meta: { cwd: rootPath },
+            agentOptions: { provider: "deepseek-official", model: input.requestedModel, reasoningEffort: effort },
+            signal: boundary.signal,
+            setup
+          });
+          const onAbort = () => handle.agent.cancel({ kind: "user" });
+          cancelAgentTurn = onAbort;
+          boundary.signal.addEventListener("abort", onAbort, { once: true });
+          removeAgentAbortListener = () => boundary.signal.removeEventListener("abort", onAbort);
+          if (boundary.signal.aborted) onAbort();
+          boundary.signal.throwIfAborted();
+          let checkpointReached = false;
+          let resolveCheckpoint;
+          const checkpoint = new Promise((resolve6) => {
+            resolveCheckpoint = resolve6;
+          });
+          const dispatchGate = new Promise((resolve6) => {
+            releaseAgentDispatch = resolve6;
+          });
+          ctx.on("llm/stream", (options, next) => {
+            if (String(options.sessionId ?? "") !== String(sessionId)) return next();
+            return (async function* () {
+              await ctx.sessions.flush(handle.agent.session);
+              checkpointReached = true;
+              resolveCheckpoint();
+              await dispatchGate;
+              boundary.signal.throwIfAborted();
+              if (!permitAgentDispatch) throw new Error("deepseek_agent_publication_not_committed");
+              yield* next();
+            })();
+          });
+          const thread = {
+            threadId: String(sessionId),
+            threadPath: rootPath,
+            effectiveModel: input.requestedModel,
+            effectiveReasoningEffort: input.requestedReasoningEffort
+          };
+          const startSeq = handle.agent.session.seq;
+          handle.agent.followup(createUserMessage({
+            content: [{ type: "text", text: input.userPrompt }],
+            source: { kind: "user" }
+          }));
+          const idle = handle.agent.whenIdle();
+          await Promise.race([
+            checkpoint,
+            idle.then(() => {
+              if (!checkpointReached) throw new Error("deepseek_agent_checkpoint_not_reached");
+            })
+          ]);
+          boundary.signal.throwIfAborted();
+          if (input.onThreadReady) {
+            await input.onThreadReady(thread);
+            durableCheckpointed = true;
+          }
+          boundary.signal.throwIfAborted();
+          permitAgentDispatch = true;
+          releaseAgentDispatch();
+          releaseAgentDispatch = () => void 0;
+          await idle;
+          const events = handle.agent.session.events.slice(startSeq);
+          const assistantEvents = events.filter((event) => event.type === "assistant/message");
+          const turnEnd = [...events].reverse().find((event) => event.type === "turn/end");
+          if (!turnEnd || turnEnd.type !== "turn/end" || turnEnd.data.reason.kind !== "completed") {
+            if (turnEnd?.type === "turn/end" && turnEnd.data.reason.kind === "error") {
+              const failure = turnEnd.data.reason.error;
+              throw new LlmError(failure.message, failure.code, {
+                ...failure.status === void 0 ? {} : { status: failure.status },
+                ...failure.providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: failure.providerRetryAfterMs }
+              });
+            }
+            const reason = turnEnd?.type === "turn/end" ? turnEnd.data.reason : { kind: "missing" };
+            throw new Error(`deepseek_harness_agent_turn_incomplete:${JSON.stringify(reason)}`);
+          }
+          const last = assistantEvents.at(-1);
+          if (!last || last.type !== "assistant/message" || last.data.interrupted) {
+            throw new Error("deepseek_harness_agent_result_missing");
+          }
+          const usages = assistantEvents.flatMap((event) => event.type === "assistant/message" && event.data.usage ? [event.data.usage] : []);
+          if (usages.length === 0 || proxy.receipts.length !== usages.length) {
+            throw new Error("deepseek_harness_agent_receipt_missing");
+          }
+          const text = validateText(textFromBlocks(last.data.message.content, "text"), "deepseek_harness_agent_result_invalid");
+          const receipts = proxy.receipts;
+          await handle.dispose();
+          return {
+            thread,
+            turn: {
+              text,
+              reasoningContent: textFromBlocks(last.data.message.content, "reasoning") || null,
+              reasoningSummary: null,
+              requestedModel: input.requestedModel,
+              effectiveModel: receipts.at(-1).model,
+              requestedReasoningEffort: input.requestedReasoningEffort,
+              effectiveReasoningEffort: input.requestedReasoningEffort,
+              adapterRequestId: receipts[0].id,
+              adapterResponseId: receipts.at(-1).id,
+              usage: sumUsage(usages),
+              latencyMs: Math.max(0, (this.dependencies.now ?? Date.now)() - startedAt),
+              timeToFirstTokenMs: null,
+              terminalStatus: "completed",
+              toolCalls: evidence,
+              webSearches: []
+            }
+          };
+        } catch (error48) {
+          cancelAgentTurn();
+          releaseAgentDispatch();
+          releaseAgentDispatch = () => void 0;
+          if (!durableCheckpointed && owned) {
+            cleanupUnpublishedWorkspace = true;
+          }
+          throw mapDeepSeekFailure({
+            error: error48,
+            cancelled: input.signal?.aborted === true,
+            deadline: input.signal?.aborted !== true && boundary.signal.aborted,
+            dispatchOutcome: proxyDispatchOutcome(proxy)
+          });
+        } finally {
+          removeAgentAbortListener();
+          boundary.cleanup();
+          await ctx.fiber.dispose().catch(() => void 0);
+          await proxy.close();
+          if (cleanupUnpublishedWorkspace && owned) {
+            await owned.cleanup().catch(() => void 0);
+            this.agentWorkspaces.delete(rootPath);
+          }
+          delete process.env[loopbackEnvName];
+        }
+      }
+      async releaseThread(thread) {
+        const cleanup = this.agentWorkspaces.get(thread.threadPath);
+        if (cleanup) {
+          await cleanup();
+          this.agentWorkspaces.delete(thread.threadPath);
+          return;
+        }
+        const resolved = await realpath4(thread.threadPath);
+        const temporaryRoot = await realpath4(tmpdir4());
+        if (dirname4(resolved) !== temporaryRoot || !basename(resolved).startsWith("vtx-deepseek-harness-")) throw new Error("deepseek_harness_thread_path_not_owned");
+        await rm5(resolved, { recursive: true, force: true });
+      }
+      async close() {
+        this.closing = true;
+      }
+    };
+  }
+});
+
+// lib/inference-host/deepseek-credential-store.ts
+import { createHash as createHash5 } from "node:crypto";
+var DEEPSEEK_CREDENTIAL_NAMESPACE, MAX_API_KEY_BYTES, validateApiKey, credentialIdentity, parseCredential, serializeCredential, platformCommands, createDeepSeekHarnessCredentialStore;
+var init_deepseek_credential_store = __esm({
+  "lib/inference-host/deepseek-credential-store.ts"() {
+    "use strict";
+    init_config();
+    init_credential_store();
+    DEEPSEEK_CREDENTIAL_NAMESPACE = "vtxmacro-deepseek-harness";
+    MAX_API_KEY_BYTES = 512;
+    validateApiKey = (raw) => {
+      const apiKey = raw.trim();
+      if (apiKey.length < 16 || Buffer.byteLength(apiKey, "utf8") > MAX_API_KEY_BYTES || /[\s\u0000-\u001f\u007f]/u.test(apiKey)) {
+        throw new Error("DeepSeek API key is invalid. Provide one private key through stdin.");
+      }
+      return apiKey;
+    };
+    credentialIdentity = (apiKey) => `deepseek-key-${createHash5("sha256").update(apiKey).digest("hex").slice(0, 24)}`;
+    parseCredential = (raw) => {
+      let value;
+      try {
+        value = JSON.parse(raw);
+      } catch {
+        throw new Error("Stored DeepSeek Harness credential is invalid JSON.");
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Stored DeepSeek Harness credential is invalid.");
+      }
+      const record2 = value;
+      const apiKey = validateApiKey(String(record2.api_key ?? ""));
+      const identity = credentialIdentity(apiKey);
+      if (record2.schema_version !== 1 || record2.adapter !== "deepseek-harness" || record2.identity !== identity || Object.keys(record2).sort().join(",") !== "adapter,api_key,identity,schema_version") {
+        throw new Error("Stored DeepSeek Harness credential failed validation.");
+      }
+      return { apiKey, identity };
+    };
+    serializeCredential = (apiKey) => {
+      const validated = validateApiKey(apiKey);
+      return `${JSON.stringify({
+        schema_version: 1,
+        adapter: "deepseek-harness",
+        api_key: validated,
+        identity: credentialIdentity(validated)
+      })}
+`;
+    };
+    platformCommands = (env, platform) => {
+      if (platform === "win32") return windowsInferenceCredentialCommands;
+      if (platform === "linux" && String(env.WSL_INTEROP || "").trim()) {
+        return windowsInferenceCredentialCommands;
+      }
+      if (platform === "linux") return linuxSecretServiceInferenceCredentialCommands;
+      if (platform === "darwin") return macosKeychainInferenceCredentialCommands;
+      return null;
+    };
+    createDeepSeekHarnessCredentialStore = (config2, dependencies = {}) => {
+      const accountKey = `deepseek-harness:${config2.instanceName}`;
+      const path = `${config2.statePath}.deepseek-harness-secret.json`;
+      const env = dependencies.env ?? process.env;
+      const platform = dependencies.platform ?? process.platform;
+      const commands = dependencies.commands === void 0 ? platformCommands(env, platform) : dependencies.commands;
+      const runner = dependencies.commandRunner ?? runCredentialCommand;
+      if (config2.credentialStoreMode === "os") {
+        if (!commands) {
+          throw new Error("OS credential storage is unavailable for the DeepSeek API key.");
+        }
+        return {
+          read: async (signal) => {
+            const command = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            const result2 = await runner(command, { stdin: null, signal });
+            if ((command.notFoundExitCodes ?? []).includes(result2.exitCode)) return null;
+            if (result2.exitCode !== 0) throw new Error("DeepSeek OS credential lookup failed.");
+            return parseCredential(result2.stdout);
+          },
+          write: async (apiKey, signal) => {
+            const serialized = serializeCredential(apiKey);
+            const priorLookup = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            const priorResult = await runner(priorLookup, { stdin: null, signal });
+            const prior = (priorLookup.notFoundExitCodes ?? []).includes(priorResult.exitCode) ? null : priorResult.exitCode === 0 ? parseCredential(priorResult.stdout) : void 0;
+            if (prior === void 0) throw new Error("DeepSeek OS credential lookup failed before write.");
+            const command = commands.store(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            if (command.args.some((value) => value.includes(validateApiKey(apiKey)))) {
+              throw new Error("DeepSeek API key must never be passed in command arguments.");
+            }
+            try {
+              const result2 = await runner(command, { stdin: serialized, signal });
+              if (result2.exitCode !== 0) throw new Error("DeepSeek OS credential write failed.");
+              const retainedCommand = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+              const retained = await runner(retainedCommand, { stdin: null, signal });
+              if (retained.exitCode !== 0) {
+                throw new Error("DeepSeek OS credential write could not be verified.");
+              }
+              const expected = parseCredential(serialized);
+              const observed = parseCredential(retained.stdout);
+              if (observed.identity !== expected.identity || observed.apiKey !== expected.apiKey) {
+                throw new Error("DeepSeek OS credential write could not be verified.");
+              }
+              return observed;
+            } catch (error48) {
+              const rollback = prior ? commands.store(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey) : commands.remove(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+              const rollbackResult = await runner(rollback, {
+                stdin: prior ? serializeCredential(prior.apiKey) : null
+              });
+              if (rollbackResult.exitCode !== 0 && !(rollback.notFoundExitCodes ?? []).includes(rollbackResult.exitCode)) {
+                throw new Error("DeepSeek OS credential write failed and rollback failed.", {
+                  cause: error48
+                });
+              }
+              const verifyCommand = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+              const verified = await runner(verifyCommand, { stdin: null });
+              const absent = (verifyCommand.notFoundExitCodes ?? []).includes(verified.exitCode);
+              const restored = prior && verified.exitCode === 0 ? parseCredential(verified.stdout) : null;
+              if (prior === null && !absent || prior !== null && (!restored || restored.identity !== prior.identity || restored.apiKey !== prior.apiKey)) {
+                throw new Error("DeepSeek OS credential write failed and rollback could not be verified.", {
+                  cause: error48
+                });
+              }
+              throw error48;
+            }
+          },
+          remove: async (signal) => {
+            const command = commands.remove(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            const result2 = await runner(command, { stdin: null, signal });
+            if (result2.exitCode !== 0 && !(command.notFoundExitCodes ?? []).includes(result2.exitCode)) throw new Error("DeepSeek OS credential removal failed.");
+            const retainedCommand = commands.lookup(DEEPSEEK_CREDENTIAL_NAMESPACE, accountKey);
+            const retained = await runner(retainedCommand, { stdin: null });
+            if (!(retainedCommand.notFoundExitCodes ?? []).includes(retained.exitCode)) {
+              throw new Error("DeepSeek OS credential removal could not be verified.");
+            }
+          }
+        };
+      }
+      return {
+        read: async () => {
+          const raw = await readInferencePrivateFile(path, "DeepSeek Harness credential file");
+          return raw === null ? null : parseCredential(raw);
+        },
+        write: async (apiKey) => {
+          const serialized = serializeCredential(apiKey);
+          await writeAtomicInferencePrivateFile(path, serialized);
+          const retained = await readInferencePrivateFile(path, "DeepSeek Harness credential file");
+          if (retained !== serialized) throw new Error("DeepSeek credential write could not be verified.");
+          return parseCredential(serialized);
+        },
+        remove: async () => {
+          await clearInferencePrivateFile(path, "DeepSeek Harness credential file");
+        }
+      };
+    };
+  }
+});
+
 // lib/inference-host/durable-adapter.ts
 var DURABLE_INFERENCE_ADAPTER_IDS, isDurableInferenceAdapterId, durableAdapterDisplayName;
 var init_durable_adapter = __esm({
@@ -24729,12 +25823,14 @@ var init_durable_adapter = __esm({
     "use strict";
     DURABLE_INFERENCE_ADAPTER_IDS = [
       "codex",
-      "copilot"
+      "copilot",
+      "deepseek-harness"
     ];
     isDurableInferenceAdapterId = (value) => DURABLE_INFERENCE_ADAPTER_IDS.includes(value);
     durableAdapterDisplayName = (adapter) => ({
       codex: "Codex",
-      copilot: "GitHub Copilot"
+      copilot: "GitHub Copilot",
+      "deepseek-harness": "DeepSeek Harness"
     })[adapter];
   }
 });
@@ -24743,13 +25839,13 @@ var init_durable_adapter = __esm({
 import {
   createCipheriv,
   createDecipheriv,
-  createHash as createHash5,
+  createHash as createHash6,
   createPrivateKey,
   createPublicKey,
   diffieHellman,
   generateKeyPairSync,
   hkdfSync,
-  randomBytes as randomBytes4
+  randomBytes as randomBytes5
 } from "node:crypto";
 var ENVELOPE_SUITE, JOB_KEY_PAYLOAD_SCHEMA_VERSION, WRAP_HKDF_INFO, PAYLOAD_HKDF_INFO, X25519_PKCS8_PREFIX, X25519_SPKI_PREFIX, ExternalInferenceEnvelopeError, canonicalize, canonicalEnvelopeAadBytes, externalInferenceSha256, decodeCanonicalBase64Url, rawPrivateKey, rawPublicKey, rawPublicBytes, aesGcmDecrypt, aesGcmEncrypt, assertIdentity, validatePlaintext, generateExternalInferenceEnvelopeKeyPair, externalInferenceEnvelopePublicKey, deriveKey, deriveExternalInferencePayloadKey, unwrapExternalInferenceJobKey, decryptExternalInferenceJobInput, decryptExternalInferenceClaim, sealExternalInferenceCandidate;
 var init_crypto = __esm({
@@ -24782,7 +25878,7 @@ var init_crypto = __esm({
       const aad = envelopeAadSchema.parse(input);
       return Buffer.from(JSON.stringify(canonicalize(aad)), "utf8");
     };
-    externalInferenceSha256 = (value) => createHash5("sha256").update(value).digest("hex");
+    externalInferenceSha256 = (value) => createHash6("sha256").update(value).digest("hex");
     decodeCanonicalBase64Url = (value, fieldName, expectedBytes) => {
       if (!/^[A-Za-z0-9_-]+$/u.test(value)) {
         throw new ExternalInferenceEnvelopeError("invalid_encoding", `${fieldName} is invalid.`);
@@ -24881,7 +25977,7 @@ var init_crypto = __esm({
       return Buffer.from(hkdfSync(
         "sha256",
         root,
-        createHash5("sha256").update(aadBytes).digest(),
+        createHash6("sha256").update(aadBytes).digest(),
         info,
         32
       ));
@@ -25023,7 +26119,7 @@ var init_crypto = __esm({
           "External inference candidate must not be empty."
         );
       }
-      const nonce = options.nonce ? Buffer.from(options.nonce) : randomBytes4(12);
+      const nonce = options.nonce ? Buffer.from(options.nonce) : randomBytes5(12);
       if (nonce.length !== 12) {
         throw new ExternalInferenceEnvelopeError(
           "invalid_nonce",
@@ -31295,7 +32391,7 @@ var require_ajv = __commonJS({
 });
 
 // lib/inference-host/runner.ts
-import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
 function createDefaultInferenceHostRunnerDependencies(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
   return {
@@ -31330,7 +32426,7 @@ function createDefaultInferenceHostRunnerDependencies(options) {
     envelopePublicKey: options.envelopePublicKey
   };
 }
-var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createInferenceAgentControlClient, INFERENCE_AGENT_SYSTEM_PROMPT, INFERENCE_AGENT_WAKE_SCHEMA, parseInferenceAgentWake, InferenceAgentRuntime;
+var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS, DEFAULT_AGENT_QUOTA_COOLDOWN_MS, DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createInferenceAgentControlClient, INFERENCE_AGENT_SYSTEM_PROMPT, INFERENCE_AGENT_WAKE_SCHEMA, parseInferenceAgentWake, InferenceAgentRuntime;
 var init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -31356,6 +32452,9 @@ var init_runner = __esm({
     MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS = 1e4;
     HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR = 3;
     DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS = 5 * 60 * 1e3;
+    DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS = 6e4;
+    DEFAULT_AGENT_QUOTA_COOLDOWN_MS = 5 * 60 * 1e3;
+    DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS = 5e3;
     MIN_CLAIM_START_WINDOW_MS = 5e3;
     MAX_ATTEMPT_START_RETRY_DELAY_MS = 15e3;
     UNBOUNDED_AVAILABLE_SLOTS = Number.MAX_SAFE_INTEGER;
@@ -31622,7 +32721,7 @@ var init_runner = __esm({
         attempts
       };
     };
-    sha256 = (value) => createHash6("sha256").update(value, "utf8").digest("hex");
+    sha256 = (value) => createHash7("sha256").update(value, "utf8").digest("hex");
     stableOperationId = (kind, parts) => `${kind}_${sha256(JSON.stringify(parts)).slice(0, 48)}`;
     buildAttemptStartRequest = (claim, attemptId, startedAt) => attemptStartRequestSchema.parse({
       schema_version: "external_inference_attempt_start_v1",
@@ -31895,7 +32994,7 @@ var init_runner = __esm({
     membershipFailureDisposition = (failure) => {
       if (failure.dispatchOutcome === "outcome_unknown") return "quarantine_ambiguous";
       if (failure.category === "auth" || ["auth_expired", "managed_chatgpt_auth_required", "invalid_account_metadata"].includes(failure.code)) return "cascade_disable";
-      if (failure.category === "quota" || ["quota_exceeded", "codex_rate_limited"].includes(failure.code)) return "cascade_cooldown";
+      if (failure.category === "quota" || ["quota_exceeded", "codex_rate_limited", "provider_rate_limited"].includes(failure.code)) return "cascade_cooldown";
       if (failure.retryable && (["adapter", "network", "transport"].includes(failure.category) || failure.code === "rpc_timeout")) return "retry_same_host";
       if (["model_unavailable", "reasoning_effort_unavailable"].includes(failure.code)) return "cascade_cooldown";
       if ([
@@ -32169,6 +33268,43 @@ var init_runner = __esm({
             const agentRuntimeSettings = settings.agentRuntime;
             agentLoop = (async () => {
               while (!agentAbort.signal.aborted) {
+                const existingFence = await readInferenceAgentFailureFence(
+                  agentRuntimeSettings.statePath
+                );
+                if (existingFence) {
+                  if (existingFence.adapter_id !== settings.adapterId || existingFence.host_id !== localState.host_id) {
+                    throw new InferenceHostRecoveryRequiredError(
+                      "Inference Agent failure fence belongs to another host or adapter."
+                    );
+                  }
+                  if (existingFence.retry_at === null) {
+                    emitDiagnostic("agent_runtime_quarantined", {
+                      assignment_id: existingFence.assignment_id,
+                      failure_category: existingFence.failure_category,
+                      failure_code: existingFence.failure_code,
+                      dispatch_outcome: existingFence.dispatch_outcome
+                    });
+                    return;
+                  }
+                  const retryAtMs = Date.parse(existingFence.retry_at);
+                  if (retryAtMs > now()) {
+                    emitDiagnostic("agent_runtime_cooldown", {
+                      assignment_id: existingFence.assignment_id,
+                      failure_category: existingFence.failure_category,
+                      failure_code: existingFence.failure_code,
+                      dispatch_outcome: existingFence.dispatch_outcome,
+                      cooldown_until: existingFence.retry_at
+                    });
+                    if (this.options.once) return;
+                    try {
+                      await sleep4(Math.max(MIN_SLEEP_MS, retryAtMs - now()), agentAbort.signal);
+                    } catch {
+                      return;
+                    }
+                    continue;
+                  }
+                  await clearInferenceAgentFailureFence(agentRuntimeSettings.statePath);
+                }
                 const agentRuntime = new InferenceAgentRuntime({
                   adapterId: settings.adapterId,
                   hostId: localState.host_id,
@@ -32189,6 +33325,51 @@ var init_runner = __esm({
                     requestDrain("authority_lost");
                     return;
                   }
+                  if (error48 instanceof CodexAppServerError) {
+                    const failure = classifyFailure(error48);
+                    const providerLimited = failure.category === "auth" || failure.category === "quota" || ["quota_exceeded", "codex_rate_limited", "provider_rate_limited"].includes(failure.code);
+                    const deepSeekTransient = settings.adapterId === "deepseek-harness" && failure.retryable;
+                    if (failure.dispatchOutcome === "outcome_unknown" || providerLimited || deepSeekTransient) {
+                      const runtimeState = await readInferenceAgentRuntimeState(
+                        agentRuntimeSettings.statePath
+                      );
+                      const retryAtMs = failure.dispatchOutcome === "outcome_unknown" || failure.category === "auth" && settings.adapterId === "deepseek-harness" ? null : error48.retryAtMs !== null && error48.retryAtMs > now() ? error48.retryAtMs : now() + (failure.category === "quota" || failure.code === "quota_exceeded" ? DEFAULT_AGENT_QUOTA_COOLDOWN_MS : failure.category === "auth" ? DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS : failure.code === "provider_rate_limited" || failure.code === "codex_rate_limited" ? DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS : DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS);
+                      await writeInferenceAgentFailureFence(agentRuntimeSettings.statePath, {
+                        schema_version: "vtx_inference_agent_failure_fence_v1",
+                        adapter_id: settings.adapterId,
+                        host_id: localState.host_id,
+                        assignment_id: runtimeState?.schema_version === "vtx_inference_agent_runtime_v3" ? runtimeState.assignment.assignment_id : null,
+                        failure_category: safeFailureCode(failure.category, "adapter"),
+                        failure_code: safeFailureCode(failure.code, "adapter_failure"),
+                        dispatch_outcome: failure.dispatchOutcome,
+                        retry_at: retryAtMs === null ? null : isoAt(retryAtMs),
+                        created_at: isoAt(now())
+                      });
+                      if (failure.dispatchOutcome !== "outcome_unknown") {
+                        try {
+                          await agentRuntime.releaseAfterProviderFailure(failure.code);
+                        } catch {
+                        }
+                      }
+                      emitDiagnostic(
+                        retryAtMs === null ? "agent_runtime_quarantined" : "agent_runtime_cooldown",
+                        {
+                          assignment_id: runtimeState?.schema_version === "vtx_inference_agent_runtime_v3" ? runtimeState.assignment.assignment_id : null,
+                          failure_category: failure.category,
+                          failure_code: failure.code,
+                          dispatch_outcome: failure.dispatchOutcome,
+                          cooldown_until: retryAtMs === null ? null : isoAt(retryAtMs)
+                        }
+                      );
+                      if (this.options.once || retryAtMs === null) return;
+                      try {
+                        await sleep4(Math.max(MIN_SLEEP_MS, retryAtMs - now()), agentAbort.signal);
+                      } catch {
+                        return;
+                      }
+                      continue;
+                    }
+                  }
                   emitDiagnostic("agent_runtime_retry", {
                     error_code: error48 && typeof error48 === "object" && "code" in error48 ? String(error48.code) : "agent_runtime_error"
                   });
@@ -32201,7 +33382,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;
@@ -32284,6 +33471,7 @@ var init_runner = __esm({
             }
             throw lastError;
           };
+          let advertisementHandoff = null;
           const publishAdvertisement = async (health, forceAdvance, retryRemote = true, allowDefinitiveReseed = true) => {
             let advertisement = receipt.pending_advertisement;
             if (!advertisement) {
@@ -32332,6 +33520,11 @@ var init_runner = __esm({
             }
             const tool = receipt.registered ? "inference.host.advertise" : "inference.host.register";
             let result2;
+            let releaseAdvertisementHandoff;
+            const currentAdvertisementHandoff = new Promise((resolve6) => {
+              releaseAdvertisementHandoff = resolve6;
+            });
+            advertisementHandoff = currentAdvertisementHandoff;
             try {
               const advertiseOperation = () => mcp.callTool(
                 tool,
@@ -32339,6 +33532,15 @@ var init_runner = __esm({
                 { signal: this.options.signal }
               );
               result2 = retryRemote ? await retryExact(advertiseOperation, { signal: this.options.signal }) : await advertiseOperation();
+              assertAdvertisementResult(advertisement, result2);
+              await mutateReceipt((current) => ({
+                ...current,
+                registered: true,
+                advertisement_generation: result2.host.advertisement_generation,
+                advertisement_expires_at: advertisement.expires_at,
+                pending_advertisement: current.pending_advertisement?.operation_id === advertisement.operation_id ? null : current.pending_advertisement,
+                updated_at: isoAt(now())
+              }));
             } catch (error48) {
               const definitivelyNotApplied = error48 instanceof ExternalInferenceMcpError ? error48.definitivelyNotApplied : Boolean(error48 && typeof error48 === "object" && error48.definitivelyNotApplied === true);
               const expectedGeneration = receipt.registered ? receipt.advertisement_generation + 1 : receipt.advertisement_generation;
@@ -32351,16 +33553,12 @@ var init_runner = __esm({
                 return await publishAdvertisement(health, forceAdvance, retryRemote, false);
               }
               throw error48;
+            } finally {
+              releaseAdvertisementHandoff();
+              if (advertisementHandoff === currentAdvertisementHandoff) {
+                advertisementHandoff = null;
+              }
             }
-            assertAdvertisementResult(advertisement, result2);
-            await mutateReceipt((current) => ({
-              ...current,
-              registered: true,
-              advertisement_generation: result2.host.advertisement_generation,
-              advertisement_expires_at: advertisement.expires_at,
-              pending_advertisement: current.pending_advertisement?.operation_id === advertisement.operation_id ? null : current.pending_advertisement,
-              updated_at: isoAt(now())
-            }));
           };
           const wasRegistered = receipt.registered;
           await publishAdvertisement("healthy", wasRegistered);
@@ -32475,10 +33673,24 @@ var init_runner = __esm({
               if (drainRequested || hostHeartbeatAbort.signal.aborted) return;
               const heartbeatStartedAt = now();
               observeHostHeartbeatGap(heartbeatStartedAt);
+              const pendingAdvertisementHandoff = advertisementHandoff;
+              if (pendingAdvertisementHandoff !== null) {
+                try {
+                  await Promise.race([
+                    pendingAdvertisementHandoff,
+                    sleep4(settings.hostHeartbeatMs, hostHeartbeatAbort.signal)
+                  ]);
+                } catch (error48) {
+                  if (hostHeartbeatAbort.signal.aborted || drainRequested) return;
+                  throw error48;
+                }
+              }
+              if (drainRequested || hostHeartbeatAbort.signal.aborted) return;
+              const heartbeatAttemptedAt = now();
               const attemptedAdvertisementGeneration = receipt.advertisement_generation;
               try {
                 const expiresAt = receipt.advertisement_expires_at ? Date.parse(receipt.advertisement_expires_at) : 0;
-                const refreshPendingAcrossExpiry = receipt.pending_advertisement !== null && expiresAt <= heartbeatStartedAt;
+                const refreshPendingAcrossExpiry = receipt.pending_advertisement !== null && expiresAt <= heartbeatAttemptedAt;
                 await hostHeartbeat(
                   "healthy",
                   { signal: hostHeartbeatAbort.signal },
@@ -33379,10 +34591,10 @@ var init_runner = __esm({
           if (error48 instanceof InferenceHostRunnerError && error48.code === "terminal_outcome_unconfirmed") {
             throw error48;
           }
-          if (error48 instanceof CodexAppServerError && error48.retryAtMs !== null && ["quota_exceeded", "codex_rate_limited"].includes(error48.code)) {
+          if (error48 instanceof CodexAppServerError && error48.retryAtMs !== null && ["quota_exceeded", "codex_rate_limited", "provider_rate_limited"].includes(error48.code)) {
             options.onProviderCooldown?.({
               retryAtMs: error48.retryAtMs,
-              reason: error48.code === "quota_exceeded" ? "quota_exceeded" : "codex_rate_limited",
+              reason: error48.code === "quota_exceeded" ? "quota_exceeded" : error48.code === "provider_rate_limited" ? "provider_rate_limited" : "codex_rate_limited",
               rateLimits: error48.rateLimits
             });
           }
@@ -33597,6 +34809,9 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
       stop() {
         this.stopped = true;
       }
+      async releaseAfterProviderFailure(reasonCode) {
+        await this.releaseForHostStop(safeFailureCode(reasonCode, "provider_failure"));
+      }
       async run(signal) {
         let exitedNormally = false;
         try {
@@ -33613,10 +34828,14 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
       }
       async runSingle(signal) {
+        let exitedNormally = false;
         try {
           await this.runOnce(signal);
+          exitedNormally = true;
         } finally {
-          await this.releaseForHostStop();
+          if (exitedNormally || this.stopped || signal?.aborted) {
+            await this.releaseForHostStop();
+          }
         }
       }
       async runOnce(signal) {
@@ -33662,7 +34881,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
         if (!state) {
           const assignment2 = await this.options.controlClient.nextAssignment({
-            operation_id: randomUUID2(),
+            operation_id: randomUUID3(),
             host_id: this.options.hostId,
             requested_at: nowIso()
           }, { signal });
@@ -33695,7 +34914,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         state = await this.resolvePendingDecision(state, signal);
         let assignment = state.assignment;
         const preTurnHeartbeat = await this.options.controlClient.heartbeat({
-          operation_id: randomUUID2(),
+          operation_id: randomUUID3(),
           host_id: this.options.hostId,
           assignment_id: assignment.assignment_id,
           assignment_generation: assignment.assignment_generation,
@@ -33720,7 +34939,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         const heartbeatTask = (async () => {
           while (!heartbeatStopped && !turnAbort.signal.aborted) {
             const heartbeat = await this.options.controlClient.heartbeat({
-              operation_id: randomUUID2(),
+              operation_id: randomUUID3(),
               host_id: this.options.hostId,
               assignment_id: assignment.assignment_id,
               assignment_generation: assignment.assignment_generation,
@@ -33777,7 +34996,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   return { success: false, value: { error: "invalid_data_request" } };
                 }
                 const value = await this.options.controlClient.dataCall({
-                  operation_id: randomUUID2(),
+                  operation_id: randomUUID3(),
                   host_id: this.options.hostId,
                   assignment_id: assignment.assignment_id,
                   assignment_generation: assignment.assignment_generation,
@@ -33801,7 +35020,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   return { success: false, value: { error: "decision_outcome_unresolved" } };
                 }
                 const pending = {
-                  operation_id: randomUUID2(),
+                  operation_id: randomUUID3(),
                   candidate,
                   observed_at: nowIso(),
                   provenance: {
@@ -33875,7 +35094,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           const nextWakeAtMs = this.now() + wakeSeconds * 1e3;
           const scheduledWakeAt = new Date(nextWakeAtMs).toISOString();
           const wakeHeartbeat = await this.options.controlClient.heartbeat({
-            operation_id: randomUUID2(),
+            operation_id: randomUUID3(),
             host_id: this.options.hostId,
             assignment_id: assignment.assignment_id,
             assignment_generation: assignment.assignment_generation,
@@ -33993,7 +35212,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           if (state?.schema_version !== "vtx_inference_agent_runtime_v3" || state.adapter_id !== this.options.adapterId) return "cancelled";
           const requestedAt = new Date(this.now()).toISOString();
           const heartbeat = await this.options.controlClient.heartbeat({
-            operation_id: randomUUID2(),
+            operation_id: randomUUID3(),
             host_id: this.options.hostId,
             assignment_id: state.assignment.assignment_id,
             assignment_generation: state.assignment.assignment_generation,
@@ -34014,7 +35233,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
         return this.stopped || signal?.aborted ? "stopped" : "ready";
       }
-      async releaseForHostStop() {
+      async releaseForHostStop(reasonCode = "host_stopped") {
         const recovered = await readInferenceAgentRuntimeState(this.options.statePath);
         if (!recovered) return;
         let state;
@@ -34040,11 +35259,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
         if (state.pending_decision) return;
         await this.options.controlClient.releaseAssignment({
-          operation_id: randomUUID2(),
+          operation_id: randomUUID3(),
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
           assignment_generation: state.assignment.assignment_generation,
-          reason_code: "host_stopped",
+          reason_code: reasonCode,
           requested_at: new Date(this.now()).toISOString()
         }, {});
         if (state.thread) await this.options.adapter.releaseThread(state.thread);
@@ -34056,11 +35275,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
 
 // lib/inference-host/service.ts
 import { spawn as spawn6 } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { createWriteStream, readFileSync } from "node:fs";
-import { access as access3, chmod as chmod3, mkdir as mkdir3, readFile as readFile5, rm as rm5, writeFile as writeFile2 } from "node:fs/promises";
+import { access as access3, chmod as chmod3, mkdir as mkdir3, readFile as readFile5, rm as rm6, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname4, join as join6, resolve as resolve4 } from "node:path";
+import { dirname as dirname5, join as join7, resolve as resolve4 } from "node:path";
 var SERVICE_NAME, SYSTEMD_UNIT, LAUNCHD_LABEL, SERVICE_COOPERATIVE_STOP_SECONDS, INFERENCE_HOST_SERVICE_DRAIN_COMMAND, inferenceHostServiceChildEnvironment, isWindowsSubsystemForLinux, inferenceHostServiceManifestPath, inferenceHostServiceDesiredPath, inferenceHostServiceLogPath, inferenceHostServiceRuntimePath, xmlEscape, plistEscape, systemdQuote, defaultRunCommand, managerName, assertRuntimeEnvironment, withoutConcurrencyLimit, assertServicePath, manifestGeneration, assertWorker, assertManifest, assertServiceRuntimeState, assertDesiredState, readInferenceHostServiceManifest, readManifestAcrossAtomicReplacement, readInferenceHostServiceRuntime, readRuntimeAcrossAtomicReplacement, readInferenceHostServiceDesired, readDesiredAcrossAtomicReplacement, writeDesired, runtimeEnvironment, serviceArguments, windowsOwnedCommandLine, vbScriptString, windowsServiceLauncher, windowsTaskXml, systemdUnit, launchAgentPlist, sameWorker, sameServiceDefinition, sameWorkerSet, InferenceHostServiceManager, appendServiceLog, spawnInferenceHostServiceChild, runInferenceHostServiceSupervisor;
 var init_service = __esm({
   "lib/inference-host/service.ts"() {
@@ -34529,8 +35748,8 @@ WantedBy=default.target
       }
       definitionPath() {
         if (this.platform === "win32") return `${this.config.supervisorStatePath}.service-task.xml`;
-        if (this.platform === "darwin") return join6(this.home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-        return join6(this.home, ".config", "systemd", "user", SYSTEMD_UNIT);
+        if (this.platform === "darwin") return join7(this.home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+        return join7(this.home, ".config", "systemd", "user", SYSTEMD_UNIT);
       }
       windowsLauncherPath() {
         return `${this.config.supervisorStatePath}.service-launcher.vbs`;
@@ -34581,7 +35800,7 @@ WantedBy=default.target
         const previousRuntimeUpdatedAt = previousRuntime?.manifest_generation === manifest.generation ? Date.parse(previousRuntime.updated_at) : Number.NaN;
         const restoredManifest = preserveGeneration ? manifest : assertManifest({
           ...manifest,
-          generation: randomUUID3(),
+          generation: randomUUID4(),
           installed_at: this.now().toISOString()
         });
         await writeAtomicInferencePrivateFile(
@@ -34663,7 +35882,7 @@ ${result2.stderr}`)) {
           await writeAtomicInferencePrivateFile(this.manifestPath(), `${JSON.stringify(manifest, null, 2)}
 `);
           await writeDesired(this.desiredPath(), desiredRunning, this.now());
-          await mkdir3(dirname4(this.definitionPath()), { recursive: true, mode: 448 });
+          await mkdir3(dirname5(this.definitionPath()), { recursive: true, mode: 448 });
           if (this.platform === "win32") {
             await writeAtomicInferencePrivateFile(
               this.windowsLauncherPath(),
@@ -34712,13 +35931,13 @@ ${cleanup.stderr}`)) {
               );
             }
           }
-          await rm5(this.definitionPath(), { force: true }).catch(() => void 0);
+          await rm6(this.definitionPath(), { force: true }).catch(() => void 0);
           if (this.platform === "win32") {
-            await rm5(this.windowsLauncherPath(), { force: true }).catch(() => void 0);
+            await rm6(this.windowsLauncherPath(), { force: true }).catch(() => void 0);
           }
-          await rm5(this.manifestPath(), { force: true }).catch(() => void 0);
-          await rm5(this.desiredPath(), { force: true }).catch(() => void 0);
-          await rm5(this.runtimePath(), { force: true }).catch(() => void 0);
+          await rm6(this.manifestPath(), { force: true }).catch(() => void 0);
+          await rm6(this.desiredPath(), { force: true }).catch(() => void 0);
+          await rm6(this.runtimePath(), { force: true }).catch(() => void 0);
           if (this.platform === "linux") {
             await this.runCommand("systemctl", ["--user", "daemon-reload"]).catch(() => void 0);
           }
@@ -34867,7 +36086,7 @@ ${cleanup.stderr}`)) {
         ].sort((left, right) => left.instance_name.localeCompare(right.instance_name));
         const manifest = assertManifest({
           schema_version: "vtx_inference_service_v3",
-          generation: randomUUID3(),
+          generation: randomUUID4(),
           installed_at: this.now().toISOString(),
           executable: this.executable,
           script: this.script,
@@ -35081,7 +36300,7 @@ ${result2.stderr}`)) {
           if (remaining.length === 0) return await this.uninstallUnlocked();
           return await this.replaceManifestUnlocked({
             ...manifest,
-            generation: randomUUID3(),
+            generation: randomUUID4(),
             installed_at: this.now().toISOString(),
             workers: remaining
           }, await readInferenceHostServiceDesired(this.desiredPath()));
@@ -35104,12 +36323,12 @@ ${result2.stderr}`)) {
 ${result2.stderr}`)) {
           throw new Error(`Background service uninstall failed: ${result2.stderr.trim()}`);
         }
-        await rm5(this.definitionPath(), { force: true });
-        if (this.platform === "win32") await rm5(this.windowsLauncherPath(), { force: true });
+        await rm6(this.definitionPath(), { force: true });
+        if (this.platform === "win32") await rm6(this.windowsLauncherPath(), { force: true });
         if (this.platform === "linux") await this.runCommand("systemctl", ["--user", "daemon-reload"]);
-        await rm5(this.manifestPath(), { force: true });
-        await rm5(this.desiredPath(), { force: true });
-        await rm5(this.runtimePath(), { force: true });
+        await rm6(this.manifestPath(), { force: true });
+        await rm6(this.desiredPath(), { force: true });
+        await rm6(this.runtimePath(), { force: true });
         return {
           installed: false,
           desired_running: false,
@@ -35123,7 +36342,7 @@ ${result2.stderr}`)) {
       }
     };
     appendServiceLog = async (path, event, fields = {}) => {
-      await mkdir3(dirname4(path), { recursive: true, mode: 448 });
+      await mkdir3(dirname5(path), { recursive: true, mode: 448 });
       const stream = createWriteStream(path, { flags: "a", mode: 384 });
       await new Promise((resolvePromise, reject) => {
         stream.once("error", reject);
@@ -35471,11 +36690,11 @@ __export(cli_exports, {
   registerInferenceHostServiceControlInput: () => registerInferenceHostServiceControlInput,
   runInferenceHostCli: () => runInferenceHostCli
 });
-import { createHash as createHash7, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID5 } from "node:crypto";
 import { spawn as spawn7 } from "node:child_process";
-import { lstat as lstat4, realpath as realpath4, rm as rm6 } from "node:fs/promises";
+import { lstat as lstat4, realpath as realpath5, rm as rm7 } from "node:fs/promises";
 import { hostname as osHostname } from "node:os";
-import { join as join7, resolve as resolve5 } from "node:path";
+import { join as join8, resolve as resolve5 } from "node:path";
 async function runInferenceHostCli(argv2, env = process.env, dependencies = {}) {
   const warnings = [];
   try {
@@ -35505,6 +36724,9 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     if (parsed.command === "codex-login") {
       return await codexLogin(config2, parsed, env, dependencies);
     }
+    if (parsed.command === "deepseek-login") {
+      return await deepSeekLogin(config2, parsed, dependencies);
+    }
     if (parsed.command === "run") {
       return await runHost(config2, parsed, env, dependencies, warnings);
     }
@@ -35597,11 +36819,14 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     if (parsed.command === "codex-logout") {
       return await codexLogout(config2, parsed, env, dependencies);
     }
+    if (parsed.command === "deepseek-logout") {
+      return await deepSeekLogout(config2, parsed, dependencies);
+    }
     if (parsed.command === "revoke") {
       return await cleanupLogin(config2, parsed, dependencies, warnings, true);
     }
     throw new Error(
-      "Usage: vtx inference-host <login|codex-login|run|agent-connect|agent-run|agent-next|agent-complete|agent-fail|agent-assignment-next|agent-assignment-heartbeat|agent-data-call|agent-decision-submit|agent-decision-status|agent-assignment-release|service|status|doctor|logout|codex-logout|revoke> [--json]"
+      "Usage: vtx inference-host <login|codex-login|deepseek-login|run|agent-connect|agent-run|agent-next|agent-complete|agent-fail|agent-assignment-next|agent-assignment-heartbeat|agent-data-call|agent-decision-submit|agent-decision-status|agent-assignment-release|service|status|doctor|logout|codex-logout|deepseek-logout|revoke> [--json]"
     );
   } catch (error48) {
     return {
@@ -35612,7 +36837,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     };
   }
 }
-var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, credentialLifecycleLockPath, serviceRecoveryCommandLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, resolveDurableServiceDisplayName, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, preparePortableDurableAdapter, defaultRunPortableDurableAdapter, login, codexLogin, codexLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, parseOptionalAgentStdin, agentOperationId, agentSession, agentConnect, foregroundAgentControlState, requireForegroundAgentState, assignmentFromClaim, foregroundAssignmentNext, foregroundAssignmentHeartbeat, foregroundDataCall, foregroundDecisionStatusRequest, foregroundAssignmentLeaseEnded, handleForegroundCancelledAssignment, foregroundDecisionStatus, foregroundDecisionSubmit, foregroundAssignmentRelease, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, recoveryBackupPath, serviceRecoveryTransactionPath, readServiceRecoveryTransaction, assertResumableCodexRecoveryEvidence, recoverInstalledCodexService, serviceCommand, hasExplicitCredentialStoreConfiguration, credentialEnvironmentForIdentity, commandRequiresRetainedCredentialStore, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
+var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, credentialLifecycleLockPath, serviceRecoveryCommandLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, resolveDurableServiceDisplayName, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, preparePortableDurableAdapter, defaultRunPortableDurableAdapter, login, codexLogin, codexLogout, deepSeekCredentialStore, deepSeekLogin, deepSeekLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, parseOptionalAgentStdin, agentOperationId, agentSession, agentConnect, foregroundAgentControlState, requireForegroundAgentState, assignmentFromClaim, foregroundAssignmentNext, foregroundAssignmentHeartbeat, foregroundDataCall, foregroundDecisionStatusRequest, foregroundAssignmentLeaseEnded, handleForegroundCancelledAssignment, foregroundDecisionStatus, foregroundDecisionSubmit, foregroundAssignmentRelease, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, recoveryBackupPath, serviceRecoveryTransactionPath, readServiceRecoveryTransaction, assertResumableCodexRecoveryEvidence, recoverInstalledCodexService, serviceCommand, hasExplicitCredentialStoreConfiguration, credentialEnvironmentForIdentity, commandRequiresRetainedCredentialStore, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
 var init_cli = __esm({
   "lib/inference-host/cli.ts"() {
     "use strict";
@@ -35623,6 +36848,8 @@ var init_cli = __esm({
     init_codex_adapter();
     init_codex_recovery_process();
     init_copilot_adapter();
+    init_deepseek_harness_adapter();
+    init_deepseek_credential_store();
     init_durable_adapter();
     init_codex_app_server();
     init_codex_binary();
@@ -35706,6 +36933,7 @@ var init_cli = __esm({
 Commands:
   login           Authorize the isolated VTX insights:inference grant
   codex-login     Sign the automated Codex host into a ChatGPT subscription
+  deepseek-login  Import a DeepSeek API key privately from stdin
   run             Run a supported durable inference adapter in the foreground
   agent-connect   Advertise a model from a compatible agent harness
   agent-run       Keep an agent-driven host online in the foreground
@@ -35724,11 +36952,12 @@ Commands:
   logout          Remove local VTX host state without revoking the grant
   revoke          Revoke the VTX grant and remove local host state
   codex-logout    Remove the automated host's dedicated Codex login
+  deepseek-logout Remove the locally stored DeepSeek API key
 
 Common options:
   --json           Emit machine-readable JSON
   --instance NAME  Target an isolated local subscription instance (default: default)
-  --adapter ID     Durable adapter: codex or copilot
+  --adapter ID     Durable adapter: codex, copilot, or deepseek-harness
   --max-concurrency N  Optional positive-integer local slot limit (default: unlimited)
   --help, -h       Show this help
 
@@ -35744,6 +36973,8 @@ Durable service:
   vtx inference-host codex-login --instance codex-2
   vtx inference-host service install --instance codex-2
   vtx inference-host service install --adapter copilot --instance copilot-1
+  vtx inference-host deepseek-login --instance deepseek-1 < /private/path/deepseek.key
+  vtx inference-host service install --adapter deepseek-harness --instance deepseek-1
   vtx inference-host service uninstall --instance codex-2
   vtx inference-host service recover --instance codex-1 --force-recovery
   vtx inference-host service <start|stop|status|logs|recover|uninstall>
@@ -35850,7 +37081,7 @@ Durable service:
       if (command === "agent-connect" && !displayNameExplicit) {
         displayName = "Agent-driven inference host";
       } else if (adapter && isDurableInferenceAdapterId(adapter) && !displayNameExplicit) {
-        displayName = `${durableAdapterDisplayName(adapter)} subscription host`;
+        displayName = `${durableAdapterDisplayName(adapter)} host`;
       }
       return {
         command,
@@ -36007,10 +37238,10 @@ Durable service:
       return raw !== null;
     };
     inspectCodexAuthentication = async (config2) => {
-      const path = join7(config2.codexHomePath, "auth.json");
+      const path = join8(config2.codexHomePath, "auth.json");
       try {
         const before = await lstat4(path);
-        const canonical = await realpath4(path);
+        const canonical = await realpath5(path);
         const isPrivate = before.isFile() && !before.isSymbolicLink() && canonical === resolve5(path) && before.size <= 8 * 1024 * 1024 && (process.platform === "win32" || (before.mode & 63) === 0 && (typeof process.getuid !== "function" || before.uid === process.getuid()));
         return { present: true, private: isPrivate };
       } catch (error48) {
@@ -36025,7 +37256,7 @@ Durable service:
         runtimeReceiptPath(config2),
         "Inference host runtime receipt file"
       );
-      await rm6(codexGuardianReceiptRoot(config2), { recursive: true, force: true });
+      await rm7(codexGuardianReceiptRoot(config2), { recursive: true, force: true });
       await clearInferencePrivateFile(
         codexRecoveryPath(config2),
         "Codex attempt recovery file"
@@ -36034,6 +37265,7 @@ Durable service:
       await clearInferenceAgentNextState(config2.statePath);
       await clearInferenceForegroundAgentControlState(config2.statePath);
       await clearCodexAgentRuntimeState(config2.statePath);
+      await clearInferenceAgentFailureFence(config2.statePath);
       await clearInferenceHostLocalState(config2.statePath);
     };
     assertDurableServiceUninstalled = async (config2) => {
@@ -36062,7 +37294,8 @@ Durable service:
       const agentNextRecoveryPresent = await readInferenceAgentNextState(config2.statePath) !== null;
       const foregroundAgentControlPresent = await readInferenceForegroundAgentControlState(config2.statePath) !== null;
       const codexAgentRuntimePresent = await readCodexAgentRuntimeState(config2.statePath) !== null;
-      if (pendingAttempts > 0 || codexRecoveryPresent || serviceRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent || foregroundAgentControlPresent || codexAgentRuntimePresent) {
+      const agentFailureFencePresent = await readInferenceAgentFailureFence(config2.statePath) !== null;
+      if (pendingAttempts > 0 || codexRecoveryPresent || serviceRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent || foregroundAgentControlPresent || codexAgentRuntimePresent || agentFailureFencePresent) {
         throw new Error(
           "Inference host logout refused because attempt recovery is still pending (Codex, Provider, Agent-control, or revocation recovery). Reconcile or release the exact active operation before retrying logout, or resume revoke."
         );
@@ -36132,8 +37365,10 @@ Durable service:
         signal: options.signal
       }).run();
     };
-    preparePortableDurableAdapter = async (adapterId, signal) => {
-      const adapter = new CopilotSubscriptionAdapter();
+    preparePortableDurableAdapter = async (adapterId, config2, signal) => {
+      const adapter = adapterId === "copilot" ? new CopilotSubscriptionAdapter() : new DeepSeekHarnessAdapter({
+        credentialStore: createDeepSeekHarnessCredentialStore(config2)
+      });
       return { adapter, preflight: await adapter.preflight(signal) };
     };
     defaultRunPortableDurableAdapter = async (options) => {
@@ -36215,7 +37450,7 @@ Durable service:
         await writeInferenceHostCredentialContextTransition(config2, previousCredentialContext);
         await writeInferenceHostCredentialContext(config2);
         const keyPair = generateExternalInferenceEnvelopeKeyPair();
-        const hostId = randomUUID4();
+        const hostId = randomUUID5();
         const beginLogin = dependencies.beginLogin ?? beginInferenceOAuthLogin;
         const loginStore = {
           kind: store.kind,
@@ -36413,6 +37648,53 @@ Waiting for approval...
         cancellation.unregister();
       }
     };
+    deepSeekCredentialStore = (config2, dependencies) => dependencies.createDeepSeekCredentialStore?.(config2) ?? createDeepSeekHarnessCredentialStore(config2);
+    deepSeekLogin = async (config2, parsed, dependencies) => {
+      await assertDurableServiceUninstalled(config2);
+      if (!dependencies.readStdin && process.stdin.isTTY) {
+        throw new Error("DeepSeek API key must be supplied through stdin, never as an argument.");
+      }
+      const cancellation = lifecycleCancellation(dependencies);
+      let lock2 = null;
+      try {
+        lock2 = await acquireInferenceHostProcessLock(config2.processLockPath);
+        const raw = await (dependencies.readStdin ?? defaultReadStdin)();
+        const credential = await deepSeekCredentialStore(config2, dependencies).write(
+          raw,
+          cancellation.signal
+        );
+        const failureFence = await readInferenceAgentFailureFence(config2.statePath);
+        if (failureFence?.adapter_id === "deepseek-harness" && failureFence.failure_category === "auth") {
+          await clearInferenceAgentFailureFence(config2.statePath);
+        }
+        return {
+          exitCode: 0,
+          stdout: render({
+            status: "deepseek_api_key_imported",
+            identity: credential.identity,
+            credential_store: config2.credentialStoreMode
+          }, parsed.json),
+          stderr: ""
+        };
+      } finally {
+        await lock2?.release();
+        cancellation.unregister();
+      }
+    };
+    deepSeekLogout = async (config2, parsed, dependencies) => {
+      await assertDurableServiceUninstalled(config2);
+      const lock2 = await acquireInferenceHostProcessLock(config2.processLockPath);
+      try {
+        await deepSeekCredentialStore(config2, dependencies).remove();
+        return {
+          exitCode: 0,
+          stdout: render({ status: "deepseek_api_key_removed" }, parsed.json),
+          stderr: ""
+        };
+      } finally {
+        await lock2.release();
+      }
+    };
     localStatus = async (config2, parsed, dependencies, warnings) => {
       const codexAuthentication = await inspectCodexAuthentication(config2);
       const state = await readInferenceHostLocalState(config2.statePath);
@@ -36457,6 +37739,7 @@ Waiting for approval...
       );
       const agentAttempt = await readInferenceAgentAttemptState(config2.statePath);
       const agentNextRecoveryPresent = await readInferenceAgentNextState(config2.statePath) !== null;
+      const agentFailureFence = await readInferenceAgentFailureFence(config2.statePath);
       return {
         exitCode: 0,
         stdout: render({
@@ -36482,6 +37765,13 @@ Waiting for approval...
             deadline_at: agentAttempt.deadline_at
           } : null,
           agent_next_recovery_present: agentNextRecoveryPresent,
+          agent_failure_fence: agentFailureFence ? {
+            adapter: agentFailureFence.adapter_id,
+            failure_category: agentFailureFence.failure_category,
+            failure_code: agentFailureFence.failure_code,
+            dispatch_outcome: agentFailureFence.dispatch_outcome,
+            retry_at: agentFailureFence.retry_at
+          } : null,
           codex_recovery_present: recoveryPresent,
           service_recovery_present: serviceRecoveryPresent,
           codex_auth: codexAuthentication,
@@ -36500,6 +37790,12 @@ Waiting for approval...
         ok: state !== null,
         detail: state ? "valid" : "missing"
       });
+      const agentFailureFence = await readInferenceAgentFailureFence(config2.statePath);
+      checks.push({
+        name: "agent_runtime_fence",
+        ok: agentFailureFence === null,
+        detail: agentFailureFence === null ? "clear" : `${agentFailureFence.failure_code}:${agentFailureFence.dispatch_outcome}`
+      });
       checks.push({
         name: "revocation_recovery",
         ok: revocationCheckpoint === null,
@@ -36538,7 +37834,8 @@ Waiting for approval...
       } else if (adapterId !== "codex") {
         try {
           const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
-            adapterId
+            adapterId,
+            config2
           );
           checks.push({
             name: "provider_runtime",
@@ -36796,6 +38093,7 @@ Waiting for approval...
         if (adapterId !== "codex") {
           const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
             adapterId,
+            config2,
             cancellation.signal
           );
           const summary = await (dependencies.runPortableDurableAdapter ?? defaultRunPortableDurableAdapter)({
@@ -36915,7 +38213,7 @@ Waiting for approval...
       }
       return record2;
     };
-    agentOperationId = (kind) => `${kind}-${randomUUID4()}`;
+    agentOperationId = (kind) => `${kind}-${randomUUID5()}`;
     agentSession = async (config2, dependencies, warnings, signal) => {
       if (await readRevocationCheckpoint(config2)) {
         throw new Error("Inference host revocation recovery must finish first.");
@@ -37932,7 +39230,7 @@ Waiting for approval...
         if (recoveryRaw === null && existingTransaction?.phase !== "reconciled") {
           throw new Error("Codex recovery evidence changed before service recovery began.");
         }
-        const transactionId = existingTransaction?.transaction_id ?? randomUUID4();
+        const transactionId = existingTransaction?.transaction_id ?? randomUUID5();
         const backupPath = existingTransaction?.recovery_backup_path ?? recoveryBackupPath(config2, transactionId);
         if (!existingTransaction) {
           await writeAtomicInferencePrivateFile(backupPath, recoveryRaw);
@@ -37941,7 +39239,7 @@ Waiting for approval...
           backupPath,
           "Codex service recovery backup"
         );
-        const backupSha256 = backupRaw === null ? null : createHash7("sha256").update(backupRaw).digest("hex");
+        const backupSha256 = backupRaw === null ? null : createHash8("sha256").update(backupRaw).digest("hex");
         if (backupSha256 === null || existingTransaction && backupSha256 !== existingTransaction.recovery_backup_sha256) {
           throw new Error("Codex service recovery backup is missing or changed.");
         }
@@ -37952,7 +39250,7 @@ Waiting for approval...
           existingTransaction?.cleanup_confirmed_attempt_ids ?? [],
           existingTransaction?.phase ?? "prepared"
         );
-        const recoverySha256 = recoveryRaw === null ? null : createHash7("sha256").update(recoveryRaw).digest("hex");
+        const recoverySha256 = recoveryRaw === null ? null : createHash8("sha256").update(recoveryRaw).digest("hex");
         const unresolvedAttemptIds = Object.keys(backupAttempts).filter((attemptId) => !existingTransaction?.cleanup_confirmed_attempt_ids.includes(attemptId) && !initialAttempts[attemptId]?.cleanupConfirmed);
         const binary = unresolvedAttemptIds.length > 0 ? await (dependencies.resolveBinary ?? resolvePinnedCodexBinary)(env) : null;
         let activeTransaction = existingTransaction;
@@ -37991,7 +39289,7 @@ Waiting for approval...
                   codexRecoveryPath(config2),
                   "Codex attempt recovery file"
                 );
-                if (currentRaw === null || recoverySha256 === null || createHash7("sha256").update(currentRaw).digest("hex") !== recoverySha256) {
+                if (currentRaw === null || recoverySha256 === null || createHash8("sha256").update(currentRaw).digest("hex") !== recoverySha256) {
                   throw new Error("Codex recovery evidence changed while the service was stopping.");
                 }
                 const proof = await (dependencies.proveCodexQuiescence ?? proveCodexSameBootQuiescence)({
@@ -38080,7 +39378,7 @@ Waiting for approval...
               serviceRecoveryTransactionPath(config2),
               "Inference-host service recovery transaction"
             );
-            await rm6(backupPath, { force: true });
+            await rm7(backupPath, { force: true });
           }
         }
       } finally {
@@ -38161,7 +39459,8 @@ Waiting for approval...
           const displayName = resolveDurableServiceDisplayName(parsed, dependencies);
           if (adapter !== "codex") {
             const prepared = await (dependencies.prepareDurableAdapter ?? preparePortableDurableAdapter)(
-              adapter
+              adapter,
+              config2
             );
             try {
               const status2 = await manager.install({
@@ -38348,11 +39647,11 @@ Waiting for approval...
 });
 
 // lib/agent-core/config.ts
-import { mkdir as mkdir5, readFile as readFile6, rm as rm7, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname5, join as join8 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile6, rm as rm8, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname6, join as join9 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function defaultBaseDir() {
-  return join8(homedir3(), ".vtx");
+  return join9(homedir3(), ".vtx");
 }
 function resolveAgentCliConfig(env = process.env) {
   const baseDir = String(env.VTX_HOME || "").trim() || defaultBaseDir();
@@ -38360,8 +39659,8 @@ function resolveAgentCliConfig(env = process.env) {
   const parsedProfile = rawProfile ? Number(rawProfile) : NaN;
   return {
     apiUrl: String(env.VTX_API_URL || "http://localhost:8000").replace(/\/+$/, ""),
-    tokenPath: String(env.VTX_TOKEN_PATH || "").trim() || join8(baseDir, "token.json"),
-    statePath: String(env.VTX_RUNTIME_STATE_PATH || "").trim() || join8(baseDir, "runtime-state.json"),
+    tokenPath: String(env.VTX_TOKEN_PATH || "").trim() || join9(baseDir, "token.json"),
+    statePath: String(env.VTX_RUNTIME_STATE_PATH || "").trim() || join9(baseDir, "runtime-state.json"),
     runtimeDeviceId: String(env.VTX_RUNTIME_DEVICE_ID || "").trim() || null,
     activeProfileId: Number.isFinite(parsedProfile) && parsedProfile > 0 ? parsedProfile : null,
     outputJson: String(env.VTX_OUTPUT || "").trim().toLowerCase() === "json"
@@ -38387,12 +39686,12 @@ async function readStoredAgentAuth(path) {
   }
 }
 async function writeStoredAgentAuth(path, auth) {
-  await mkdir5(dirname5(path), { recursive: true });
+  await mkdir5(dirname6(path), { recursive: true });
   await writeFile3(path, `${JSON.stringify(auth, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 async function clearStoredAgentAuth(path) {
-  await rm7(path, { force: true });
+  await rm8(path, { force: true });
 }
 async function readRuntimeState(path) {
   try {
@@ -38422,12 +39721,12 @@ async function readRuntimeState(path) {
   }
 }
 async function writeRuntimeState(path, state) {
-  await mkdir5(dirname5(path), { recursive: true });
+  await mkdir5(dirname6(path), { recursive: true });
   await writeFile3(path, `${JSON.stringify(state, null, 2)}
 `, { encoding: "utf8", mode: 384 });
 }
 async function clearRuntimeState(path) {
-  await rm7(path, { force: true });
+  await rm8(path, { force: true });
 }
 var init_config2 = __esm({
   "lib/agent-core/config.ts"() {
@@ -38453,7 +39752,7 @@ var init_types = __esm({
 });
 
 // lib/agent-core/client.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function normalizeApiUrl(value) {
   const parsed = String(value || "").trim();
   if (!parsed) {
@@ -38715,7 +40014,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/decision", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -38724,7 +40023,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/trade-sync", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -38733,7 +40032,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/error", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -38745,7 +40044,7 @@ var init_client = __esm({
         return this.request("/trading/market-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38753,7 +40052,7 @@ var init_client = __esm({
         return this.request("/trading/limit-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38761,7 +40060,7 @@ var init_client = __esm({
         return this.request("/trading/cancel-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38780,7 +40079,7 @@ var init_client = __esm({
         return this.request("/trading/ai/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38788,7 +40087,7 @@ var init_client = __esm({
         return this.request("/trading/ai/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: {}
         });
       }
@@ -38796,7 +40095,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: {}
         });
       }
@@ -38804,7 +40103,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: {}
         });
       }
@@ -38812,7 +40111,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/session/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38823,7 +40122,7 @@ var init_client = __esm({
           return this.request("/trading/ai/runtime/session/stop", {
             method: "POST",
             profileId,
-            idempotencyKey: randomUUID5(),
+            idempotencyKey: randomUUID6(),
             body: payload
           });
         }
@@ -38840,7 +40139,7 @@ var init_client = __esm({
         }).request("/trading/ai/runtime/session/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID5(),
+          idempotencyKey: randomUUID6(),
           body: payload
         });
       }
@@ -38857,8 +40156,8 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { dirname as dirname6 } from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { dirname as dirname7 } from "node:path";
 var parseStoredValues, FileBackedProtectionStorage, clientRuntimeProtectionStatePath;
 var init_protection_storage = __esm({
   "lib/agent-core/protection-storage.ts"() {
@@ -38911,10 +40210,10 @@ var init_protection_storage = __esm({
         }
       }
       writeValues(values) {
-        mkdirSync(dirname6(this.path), { recursive: true, mode: 448 });
+        mkdirSync(dirname7(this.path), { recursive: true, mode: 448 });
         const serialized = `${JSON.stringify(values)}
 `;
-        const temporaryPath = `${this.path}.${process.pid}.${randomUUID6()}.tmp`;
+        const temporaryPath = `${this.path}.${process.pid}.${randomUUID7()}.tmp`;
         try {
           writeFileSync(temporaryPath, serialized, {
             encoding: "utf8",
@@ -38941,7 +40240,7 @@ var init_protection_storage = __esm({
 });
 
 // lib/agent-core/headless-runtime.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 function objectOrNull2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -39039,8 +40338,8 @@ async function runAndReportLocalWorkCycle(options, state, leaseToken, context) {
   return Boolean(result2.decision || tradeSync || result2.afterDecision);
 }
 async function startHeadlessRuntime(options) {
-  const runtimeSessionId = randomUUID7();
-  const deviceId = String(options.deviceId || "").trim() || randomUUID7();
+  const runtimeSessionId = randomUUID8();
+  const deviceId = String(options.deviceId || "").trim() || randomUUID8();
   const startResponse = await options.client.startRuntime(options.profileId, {
     session_id: runtimeSessionId,
     device_id: deviceId,
@@ -43725,8 +45024,8 @@ var init_rlp_encode = __esm({
 });
 
 // node_modules/ethers/lib.esm/utils/uuid.js
-function uuidV4(randomBytes8) {
-  const bytes3 = getBytes(randomBytes8, "randomBytes");
+function uuidV4(randomBytes9) {
+  const bytes3 = getBytes(randomBytes9, "randomBytes");
   bytes3[6] = bytes3[6] & 15 | 64;
   bytes3[8] = bytes3[8] & 63 | 128;
   const value = hexlify(bytes3);
@@ -43760,7 +45059,7 @@ var init_utils = __esm({
 });
 
 // node_modules/ethers/lib.esm/crypto/crypto.js
-import { createHash as createHash8, createHmac, pbkdf2Sync, randomBytes as randomBytes5 } from "crypto";
+import { createHash as createHash9, createHmac, pbkdf2Sync, randomBytes as randomBytes6 } from "crypto";
 var init_crypto2 = __esm({
   "node_modules/ethers/lib.esm/crypto/crypto.js"() {
   }
@@ -44414,7 +45713,7 @@ var init_pbkdf2 = __esm({
 });
 
 // node_modules/ethers/lib.esm/crypto/random.js
-function randomBytes6(length) {
+function randomBytes7(length) {
   return __randomBytes(length);
 }
 var locked5, _randomBytes, __randomBytes;
@@ -44423,20 +45722,20 @@ var init_random = __esm({
     init_crypto2();
     locked5 = false;
     _randomBytes = function(length) {
-      return new Uint8Array(randomBytes5(length));
+      return new Uint8Array(randomBytes6(length));
     };
     __randomBytes = _randomBytes;
-    randomBytes6._ = _randomBytes;
-    randomBytes6.lock = function() {
+    randomBytes7._ = _randomBytes;
+    randomBytes7.lock = function() {
       locked5 = true;
     };
-    randomBytes6.register = function(func) {
+    randomBytes7.register = function(func) {
       if (locked5) {
         throw new Error("randomBytes is locked");
       }
       __randomBytes = func;
     };
-    Object.freeze(randomBytes6);
+    Object.freeze(randomBytes7);
   }
 });
 
@@ -44974,10 +46273,10 @@ var init_sha22 = __esm({
     init_crypto2();
     init_utils();
     _sha256 = function(data) {
-      return createHash8("sha256").update(data).digest();
+      return createHash9("sha256").update(data).digest();
     };
     _sha512 = function(data) {
-      return createHash8("sha512").update(data).digest();
+      return createHash9("sha512").update(data).digest();
     };
     __sha256 = _sha256;
     __sha512 = _sha512;
@@ -45084,7 +46383,7 @@ function wrapConstructor2(hashCons) {
   hashC.create = () => hashCons();
   return hashC;
 }
-function randomBytes7(bytesLength = 32) {
+function randomBytes8(bytesLength = 32) {
   if (crypto2 && typeof crypto2.getRandomValues === "function") {
     return crypto2.getRandomValues(new Uint8Array(bytesLength));
   }
@@ -46623,7 +47922,7 @@ function weierstrass(curveDef) {
   function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
     if (["recovered", "canonical"].some((k) => k in opts))
       throw new Error("sign() legacy options not supported");
-    const { hash: hash4, randomBytes: randomBytes8 } = CURVE;
+    const { hash: hash4, randomBytes: randomBytes9 } = CURVE;
     let { lowS, prehash, extraEntropy: ent } = opts;
     if (lowS == null)
       lowS = true;
@@ -46634,7 +47933,7 @@ function weierstrass(curveDef) {
     const d = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d), int2octets(h1int)];
     if (ent != null) {
-      const e = ent === true ? randomBytes8(Fp2.BYTES) : ent;
+      const e = ent === true ? randomBytes9(Fp2.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e));
     }
     const seed = concatBytes2(...seedArgs);
@@ -46871,7 +48170,7 @@ function getHash(hash4) {
   return {
     hash: hash4,
     hmac: (key, ...msgs) => hmac2(hash4, key, concatBytes(...msgs)),
-    randomBytes: randomBytes7
+    randomBytes: randomBytes8
   };
 }
 function createCurve(curveDef, defHash) {
@@ -50845,7 +52144,7 @@ async function decryptKeystoreJson(json2, _password, progress) {
   return getAccount(data, key);
 }
 function getEncryptKdfParams(options) {
-  const salt = options.salt != null ? getBytes(options.salt, "options.salt") : randomBytes6(32);
+  const salt = options.salt != null ? getBytes(options.salt, "options.salt") : randomBytes7(32);
   let N2 = 1 << 17, r = 8, p = 1;
   if (options.scrypt) {
     if (options.scrypt.N) {
@@ -50865,9 +52164,9 @@ function getEncryptKdfParams(options) {
 }
 function _encryptKeystore(key, kdf, account, options) {
   const privateKey = getBytes(account.privateKey, "privateKey");
-  const iv = options.iv != null ? getBytes(options.iv, "options.iv") : randomBytes6(16);
+  const iv = options.iv != null ? getBytes(options.iv, "options.iv") : randomBytes7(16);
   assertArgument(iv.length === 16, "invalid options.iv length", "options.iv", options.iv);
-  const uuidRandom = options.uuid != null ? getBytes(options.uuid, "options.uuid") : randomBytes6(16);
+  const uuidRandom = options.uuid != null ? getBytes(options.uuid, "options.uuid") : randomBytes7(16);
   assertArgument(uuidRandom.length === 16, "invalid options.uuid length", "options.uuid", options.iv);
   const derivedKey = key.slice(0, 16);
   const macPrefix = key.slice(16, 32);
@@ -50901,7 +52200,7 @@ function _encryptKeystore(key, kdf, account, options) {
     const locale = account.mnemonic.locale || "en";
     const mnemonicKey = key.slice(32, 64);
     const entropy = getBytes(account.mnemonic.entropy, "account.mnemonic.entropy");
-    const mnemonicIv = randomBytes6(16);
+    const mnemonicIv = randomBytes7(16);
     const mnemonicAesCtr = new CTR(mnemonicKey, mnemonicIv);
     const mnemonicCiphertext = getBytes(mnemonicAesCtr.encrypt(entropy));
     const now = /* @__PURE__ */ new Date();
@@ -51239,7 +52538,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);
       }
       /**
@@ -52661,11 +53960,11 @@ var init_error_surface_contract = __esm({
       );
       let message;
       if (resolvedReason === "private_node_stale") {
-        message = `\u26A0\uFE0F The ${orderLabel} was not sent: Hyperliquid private account data was too stale to validate the signing key.`;
+        message = `\u26A0\uFE0F The ${orderLabel} was not sent: VTX could not verify this profile's signing-key authorization because required Hyperliquid account data was stale. No order was submitted, and the signing key was not rejected. VTX will try again automatically if the trader is running; no action is required.`;
       } else if (resolvedReason === "signer_validation_unavailable") {
-        message = `\u26A0\uFE0F The ${orderLabel} was not sent: Hyperliquid's private account service could not validate the signing key.`;
+        message = `\u26A0\uFE0F The ${orderLabel} was not sent: VTX could not verify this profile's signing-key authorization because required Hyperliquid account data was temporarily unavailable. No order was submitted, and the signing key was not rejected. VTX will try again automatically if the trader is running; no action is required.`;
       } else if (resolvedReason === "wallet_not_authorized") {
-        message = `\u26A0\uFE0F The ${orderLabel} was not sent: the signing key is not authorized for the configured wallet.`;
+        message = `\u26A0\uFE0F The ${orderLabel} was not sent: Hyperliquid confirmed that the signing key is not authorized for the configured wallet. No order was submitted. Stop the trader, then reconnect the correct wallet and signing key in System.`;
       } else if (resolvedReason === "credentials_missing") {
         message = `\u26A0\uFE0F The ${orderLabel} was not sent: a wallet address and authorized signing key are required for trading.`;
       } else if (resolvedReason === "local_safety_block") {
@@ -53586,13 +54885,28 @@ var init_hyperliquid_client = __esm({
         throw new Error("Malformed Hyperliquid userRole response.");
       }
       const response = payload;
-      const role = String(response.role || "").trim();
-      if (!role) {
+      const role = response.role;
+      if (typeof role !== "string" || !["missing", "user", "agent", "vault", "subAccount"].includes(role)) {
+        throw new Error("Malformed Hyperliquid userRole response.");
+      }
+      const rawData = response.data;
+      if (["missing", "user", "vault"].includes(role)) {
+        if (rawData !== void 0 && rawData !== null) {
+          throw new Error("Malformed Hyperliquid userRole response.");
+        }
+        return { role, data: null };
+      }
+      if (!rawData || typeof rawData !== "object" || Array.isArray(rawData)) {
+        throw new Error("Malformed Hyperliquid userRole response.");
+      }
+      const data = rawData;
+      const addressKey = role === "agent" ? "user" : "master";
+      if (typeof data[addressKey] !== "string" || !/^0x[0-9a-f]{40}$/i.test(data[addressKey])) {
         throw new Error("Malformed Hyperliquid userRole response.");
       }
       return {
         role,
-        data: response.data && typeof response.data === "object" && !Array.isArray(response.data) ? response.data : null
+        data
       };
     };
     fetchBrowserAccountState2 = async (input) => {
@@ -54691,7 +56005,7 @@ var init_hyperliquid_signer_binding = __esm({
       } catch (error48) {
         if (input.signal?.aborted) throw error48;
         throw new RuntimeExecutionError(
-          "Hyperliquid's private account service could not validate the signing key.",
+          "VTX could not verify this profile's signing-key authorization because required Hyperliquid account data was temporarily unavailable. The signing key was not rejected. Try again later; reconnecting is not required.",
           "signer_validation_unavailable"
         );
       }
@@ -54706,7 +56020,7 @@ var init_hyperliquid_signer_binding = __esm({
       if (signerRole === "agent") {
         const masterWallet = extractRoleAddress(
           roleResponse.data,
-          ["user", "master", "masterAddress", "master_address"]
+          ["user"]
         );
         if (masterWallet === walletAddress) {
           return {
@@ -61592,7 +62906,7 @@ var headless_local_worker_exports = {};
 __export(headless_local_worker_exports, {
   createHeadlessLocalWorker: () => createHeadlessLocalWorker
 });
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function objectOrNull3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -62009,7 +63323,7 @@ function createHeadlessLocalWorker(options) {
       const statusMatch = errorText.match(/\b([45]\d{2})\b/);
       const statusCode = statusMatch ? Number(statusMatch[1]) : null;
       const failedInvocation = normalizeAiInvocationTelemetry({
-        client_invocation_id: randomUUID8(),
+        client_invocation_id: randomUUID9(),
         use_case: "trader",
         role: "primary",
         attempt_index: 0,
@@ -62065,7 +63379,7 @@ function createHeadlessLocalWorker(options) {
       billable_cached_input_tokens: normalizedUsage.cached_input_tokens
     };
     const invocation = normalizeAiInvocationTelemetry({
-      client_invocation_id: randomUUID8(),
+      client_invocation_id: randomUUID9(),
       use_case: "trader",
       role: "primary",
       attempt_index: 0,
@@ -62284,7 +63598,7 @@ var vtx_exports = {};
 __export(vtx_exports, {
   runVtxCli: () => runVtxCli
 });
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { spawn as spawn8 } from "node:child_process";
 function render2(value, json2) {
   if (json2) {
@@ -62698,8 +64012,8 @@ async function runVtxCli(argv2, env = process.env) {
         });
         return { exitCode: 0, stdout: render2(redactCliOutput(response2), json2), stderr: "" };
       }
-      const runtimeSessionId = randomUUID9();
-      const deviceId = config2.runtimeDeviceId ?? randomUUID9();
+      const runtimeSessionId = randomUUID10();
+      const deviceId = config2.runtimeDeviceId ?? randomUUID10();
       const response = await client.startRuntime(profileId, {
         session_id: runtimeSessionId,
         device_id: deviceId,