@vtxmacro/cli 2026.8.52 → 2026.8.53

package/bin/vtx.js

@@ -47,7 +47,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.8.52",
+      package_version: "2026.8.53",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -19695,32 +19695,60 @@ var init_agent_client = __esm({
 });
 
 // lib/inference-host/agent-state.ts
-async function readCodexAgentRuntimeState(statePath) {
+async function readInferenceAgentRuntimeState(statePath) {
   const raw = await readInferencePrivateFile(
-    codexAgentRuntimeStatePath(statePath),
-    "Codex Agent runtime recovery state"
+    inferenceAgentRuntimeStatePath(statePath),
+    "Inference Agent runtime recovery state"
   );
   if (raw === null) return null;
   try {
-    return assertCodexAgentRuntimeState(JSON.parse(raw));
+    return assertInferenceAgentRuntimeState(JSON.parse(raw));
   } catch (error48) {
     if (error48 instanceof SyntaxError) {
-      throw new Error("Codex Agent runtime recovery state is not valid JSON.");
+      throw new Error("Inference Agent runtime recovery state is not valid JSON.");
     }
     throw error48;
   }
 }
-async function writeCodexAgentRuntimeState(statePath, value) {
+async function writeInferenceAgentRuntimeState(statePath, value) {
   await writeAtomicInferencePrivateFile(
-    codexAgentRuntimeStatePath(statePath),
-    `${JSON.stringify(assertCodexAgentRuntimeState(value), null, 2)}
+    inferenceAgentRuntimeStatePath(statePath),
+    `${JSON.stringify(assertInferenceAgentRuntimeState(value), null, 2)}
 `
   );
 }
-async function clearCodexAgentRuntimeState(statePath) {
+async function clearInferenceAgentRuntimeState(statePath) {
   await clearInferencePrivateFile(
-    codexAgentRuntimeStatePath(statePath),
-    "Codex Agent runtime recovery state"
+    inferenceAgentRuntimeStatePath(statePath),
+    "Inference Agent runtime recovery state"
+  );
+}
+async function readInferenceForegroundAgentControlState(statePath) {
+  const raw = await readInferencePrivateFile(
+    foregroundAgentControlStatePath(statePath),
+    "Foreground Agent control recovery state"
+  );
+  if (raw === null) return null;
+  try {
+    return assertForegroundAgentControlState(JSON.parse(raw));
+  } catch (error48) {
+    if (error48 instanceof SyntaxError) {
+      throw new Error("Foreground Agent control recovery state is not valid JSON.");
+    }
+    throw error48;
+  }
+}
+async function writeInferenceForegroundAgentControlState(statePath, value) {
+  await writeAtomicInferencePrivateFile(
+    foregroundAgentControlStatePath(statePath),
+    `${JSON.stringify(assertForegroundAgentControlState(value), null, 2)}
+`
+  );
+}
+async function clearInferenceForegroundAgentControlState(statePath) {
+  await clearInferencePrivateFile(
+    foregroundAgentControlStatePath(statePath),
+    "Foreground Agent control recovery state"
   );
 }
 async function readInferenceAgentAttemptState(statePath) {
@@ -19779,7 +19807,7 @@ async function clearInferenceAgentNextState(statePath) {
     "Agent-driven inference next recovery state"
   );
 }
-var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, codexAgentRuntimeStatePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertCodexAgentRuntimeState, assertNextState, assertAttemptState;
+var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, inferenceAgentRuntimeStatePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
 var init_agent_state = __esm({
   "lib/inference-host/agent-state.ts"() {
     "use strict";
@@ -19787,18 +19815,20 @@ var init_agent_state = __esm({
     init_external_inference_contract();
     inferenceAgentAttemptStatePath = (statePath) => `${statePath}.agent-attempt.json`;
     inferenceAgentNextStatePath = (statePath) => `${statePath}.agent-next.json`;
-    codexAgentRuntimeStatePath = (statePath) => `${statePath}.codex-agent-runtime.json`;
+    inferenceAgentRuntimeStatePath = (statePath) => `${statePath}.codex-agent-runtime.json`;
     isIsoTimestamp = (value) => typeof value === "string" && Number.isFinite(Date.parse(value));
     assertPlainObject = (value, message) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(message);
       return value;
     };
     hasExactKeys = (record2, keys) => Object.keys(record2).sort().join("\0") === [...keys].sort().join("\0");
-    assertCodexAgentRuntimeState = (value) => {
-      const message = "Codex Agent runtime recovery state is invalid.";
+    assertInferenceAgentRuntimeState = (value) => {
+      const message = "Inference Agent runtime recovery state is invalid.";
       const state = assertPlainObject(value, message);
+      const generic = state.schema_version === "vtx_inference_agent_runtime_v3";
       if (!hasExactKeys(state, [
         "schema_version",
+        ...generic ? ["adapter_id"] : [],
         "host_id",
         "assignment",
         "thread",
@@ -19807,9 +19837,13 @@ var init_agent_state = __esm({
         "updated_at"
       ])) throw new Error(message);
       const assignment = assertPlainObject(state.assignment, message);
-      if (!["vtx_codex_agent_runtime_v1", "vtx_codex_agent_runtime_v2"].includes(
+      if (![
+        "vtx_codex_agent_runtime_v1",
+        "vtx_codex_agent_runtime_v2",
+        "vtx_inference_agent_runtime_v3"
+      ].includes(
         String(state.schema_version)
-      ) || typeof state.host_id !== "string" || !state.host_id || !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at) || !hasExactKeys(
+      ) || generic && (typeof state.adapter_id !== "string" || !/^[a-z0-9][a-z0-9._-]{0,63}$/u.test(state.adapter_id)) || typeof state.host_id !== "string" || !state.host_id || !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at) || !hasExactKeys(
         assignment,
         [
           "assignment_id",
@@ -19823,10 +19857,10 @@ var init_agent_state = __esm({
           "minimum_wake_seconds",
           "maximum_wake_seconds",
           "lease_expires_at",
-          ...state.schema_version === "vtx_codex_agent_runtime_v2" ? ["data_contract"] : []
+          ...state.schema_version !== "vtx_codex_agent_runtime_v1" ? ["data_contract"] : []
         ]
       ) || typeof assignment.assignment_id !== "string" || !assignment.assignment_id || !Number.isSafeInteger(assignment.assignment_generation) || Number(assignment.assignment_generation) < 1 || typeof assignment.model_id !== "string" || !assignment.model_id || typeof assignment.reasoning_effort !== "string" || !assignment.reasoning_effort || !["trader", "assistant"].includes(String(assignment.bot_mode)) || !["server", "client"].includes(String(assignment.execution_mode)) || !Array.isArray(assignment.allowed_symbols) || assignment.allowed_symbols.some((symbol2) => typeof symbol2 !== "string" || !symbol2) || !assignment.output_schema || typeof assignment.output_schema !== "object" || Array.isArray(assignment.output_schema) || !Number.isSafeInteger(assignment.minimum_wake_seconds) || Number(assignment.minimum_wake_seconds) < 1 || !Number.isSafeInteger(assignment.maximum_wake_seconds) || Number(assignment.maximum_wake_seconds) < Number(assignment.minimum_wake_seconds) || !isIsoTimestamp(assignment.lease_expires_at)) throw new Error(message);
-      if (state.schema_version === "vtx_codex_agent_runtime_v2") {
+      if (state.schema_version !== "vtx_codex_agent_runtime_v1") {
         if (!Array.isArray(assignment.data_contract) || assignment.data_contract.length === 0) {
           throw new Error(message);
         }
@@ -19865,6 +19899,76 @@ var init_agent_state = __esm({
       }
       return state;
     };
+    readCodexAgentRuntimeState = readInferenceAgentRuntimeState;
+    clearCodexAgentRuntimeState = clearInferenceAgentRuntimeState;
+    foregroundAgentControlStatePath = (statePath) => `${statePath}.foreground-agent-control.json`;
+    assertRuntimeAssignment = (value, message) => {
+      const assignment = assertPlainObject(value, message);
+      if (!hasExactKeys(assignment, [
+        "assignment_id",
+        "assignment_generation",
+        "model_id",
+        "reasoning_effort",
+        "bot_mode",
+        "execution_mode",
+        "allowed_symbols",
+        "output_schema",
+        "data_contract",
+        "minimum_wake_seconds",
+        "maximum_wake_seconds",
+        "lease_expires_at"
+      ]) || typeof assignment.assignment_id !== "string" || !assignment.assignment_id || !Number.isSafeInteger(assignment.assignment_generation) || Number(assignment.assignment_generation) < 1 || typeof assignment.model_id !== "string" || !assignment.model_id || typeof assignment.reasoning_effort !== "string" || !assignment.reasoning_effort || !["trader", "assistant"].includes(String(assignment.bot_mode)) || !["server", "client"].includes(String(assignment.execution_mode)) || !Array.isArray(assignment.allowed_symbols) || assignment.allowed_symbols.some((symbol2) => typeof symbol2 !== "string" || !symbol2) || !assignment.output_schema || typeof assignment.output_schema !== "object" || Array.isArray(assignment.output_schema) || !Array.isArray(assignment.data_contract) || assignment.data_contract.length === 0 || !Number.isSafeInteger(assignment.minimum_wake_seconds) || Number(assignment.minimum_wake_seconds) < 1 || !Number.isSafeInteger(assignment.maximum_wake_seconds) || Number(assignment.maximum_wake_seconds) < Number(assignment.minimum_wake_seconds) || !isIsoTimestamp(assignment.lease_expires_at)) throw new Error(message);
+      const ids = assignment.data_contract.map((value2) => {
+        const descriptor = assertPlainObject(value2, message);
+        if (!hasExactKeys(descriptor, [
+          "id",
+          "title",
+          "description",
+          "input_schema",
+          "input_schema_sha256"
+        ]) || typeof descriptor.id !== "string" || !descriptor.id || typeof descriptor.title !== "string" || !descriptor.title || typeof descriptor.description !== "string" || !descriptor.description || !descriptor.input_schema || typeof descriptor.input_schema !== "object" || Array.isArray(descriptor.input_schema) || typeof descriptor.input_schema_sha256 !== "string" || !/^[0-9a-f]{64}$/u.test(descriptor.input_schema_sha256)) throw new Error(message);
+        return descriptor.id;
+      });
+      if (new Set(ids).size !== ids.length) throw new Error(message);
+      return assignment;
+    };
+    assertForegroundAgentControlState = (value) => {
+      const message = "Foreground Agent control recovery state is invalid.";
+      const state = assertPlainObject(value, message);
+      if (!hasExactKeys(state, [
+        "schema_version",
+        "host_id",
+        "assignment",
+        "pending_next",
+        "pending_decision",
+        "next_wake_at",
+        "updated_at"
+      ]) || state.schema_version !== "vtx_foreground_agent_control_v1" || typeof state.host_id !== "string" || !state.host_id || state.next_wake_at !== null && !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at)) throw new Error(message);
+      if (state.assignment !== null) assertRuntimeAssignment(state.assignment, message);
+      if (state.pending_next !== null) {
+        const pending = assertPlainObject(state.pending_next, message);
+        if (!hasExactKeys(pending, ["operation_id", "requested_at"]) || typeof pending.operation_id !== "string" || !pending.operation_id || !isIsoTimestamp(pending.requested_at)) throw new Error(message);
+      }
+      if (state.pending_decision !== null) {
+        if (state.assignment === null) throw new Error(message);
+        const pending = assertPlainObject(state.pending_decision, message);
+        if (!hasExactKeys(pending, [
+          "request",
+          "first_transmit_at",
+          "last_status_check_at"
+        ])) throw new Error(message);
+        const request = assertPlainObject(pending.request, message);
+        if (!hasExactKeys(request, [
+          "assignment_id",
+          "assignment_generation",
+          "operation_id",
+          "candidate",
+          "observed_at",
+          "provenance"
+        ]) || request.assignment_id !== state.assignment.assignment_id || request.assignment_generation !== state.assignment.assignment_generation || typeof request.operation_id !== "string" || !request.operation_id || !request.candidate || typeof request.candidate !== "object" || Array.isArray(request.candidate) || !isIsoTimestamp(request.observed_at) || !request.provenance || typeof request.provenance !== "object" || Array.isArray(request.provenance) || pending.first_transmit_at !== null && !isIsoTimestamp(pending.first_transmit_at) || pending.last_status_check_at !== null && !isIsoTimestamp(pending.last_status_check_at)) throw new Error(message);
+      }
+      return state;
+    };
     assertNextState = (value) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error("Agent-driven inference next recovery state is invalid.");
@@ -24019,15 +24123,17 @@ $items = @(Get-CimInstance Win32_Process | Where-Object { $_.Name -in @('node.ex
 });
 
 // lib/inference-host/copilot-adapter.ts
+import { randomUUID } from "node:crypto";
 import { mkdtemp as mkdtemp2, rm as rm4 } from "node:fs/promises";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join5 } from "node:path";
 import {
   CopilotClient,
-  RuntimeConnection
+  RuntimeConnection,
+  defineTool
 } from "@github/copilot-sdk";
-var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, resolveRuntimePackage, copilotRuntimePackageCandidates, resolvePinnedCopilotCliPath, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, CopilotSubscriptionAdapter;
+var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, resolveRuntimePackage, copilotRuntimePackageCandidates, resolvePinnedCopilotCliPath, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, copilotAgentToolDefinitions, CopilotSubscriptionAdapter;
 var init_copilot_adapter = __esm({
   "lib/inference-host/copilot-adapter.ts"() {
     "use strict";
@@ -24123,9 +24229,66 @@ var init_copilot_adapter = __esm({
       }
       return Number(value);
     };
+    copilotAgentToolDefinitions = (input, evidence) => {
+      const execute = async (tool, argumentsValue) => {
+        const argumentsRecord = argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue) ? argumentsValue : {};
+        const callId = randomUUID();
+        const result2 = await input.executeTool({
+          callId,
+          tool,
+          arguments: argumentsRecord
+        });
+        evidence.push({ callId, tool, arguments: argumentsRecord, success: result2.success });
+        return result2.success ? result2.value : { error: result2.value };
+      };
+      return [
+        defineTool("vtx_get_data", {
+          description: "Request assignment-scoped VTX data using one exact canonical capability schema.",
+          parameters: {
+            oneOf: input.dataContract.map((descriptor) => ({
+              type: "object",
+              additionalProperties: false,
+              required: ["capability", "arguments"],
+              description: descriptor.description,
+              properties: {
+                capability: { type: "string", const: descriptor.id, title: descriptor.title },
+                arguments: descriptor.input_schema
+              }
+            }))
+          },
+          skipPermission: true,
+          handler: async (args) => await execute("vtx_get_data", args)
+        }),
+        defineTool("vtx_submit_decision", {
+          description: "Submit one VTX structured trading decision candidate.",
+          parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["candidate"],
+            properties: { candidate: input.decisionSchema }
+          },
+          skipPermission: true,
+          handler: async (args) => await execute("vtx_submit_decision", args)
+        }),
+        defineTool("vtx_decision_status", {
+          description: "Resolve the durable status of a previously attempted decision operation.",
+          parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["operation_id"],
+            properties: { operation_id: { type: "string", minLength: 1 } }
+          },
+          skipPermission: true,
+          handler: async (args) => await execute("vtx_decision_status", args)
+        })
+      ];
+    };
     CopilotSubscriptionAdapter = class {
       constructor(dependencies = {}) {
         this.inFlight = /* @__PURE__ */ new Map();
+        this.agentConnection = null;
+        this.agentWorkspaceCleanups = /* @__PURE__ */ new Map();
+        this.closing = false;
         this.dependencies = dependencies;
       }
       async preflight(signal) {
@@ -24337,6 +24500,224 @@ ${input.outputSchemaJson}`
           await workspace.cleanup();
         }
       }
+      async runTurn(input) {
+        if (this.closing) {
+          throw new CodexAppServerError({
+            message: "Copilot Agent adapter is closing.",
+            category: "transport",
+            code: "transport_closed",
+            retryable: true
+          });
+        }
+        input.signal?.throwIfAborted();
+        if (Date.now() >= input.deadlineAtMs || input.dataContract.length === 0) {
+          throw new CodexAppServerError({
+            message: "Copilot Agent turn input is invalid or expired.",
+            category: Date.now() >= input.deadlineAtMs ? "timeout" : "schema",
+            code: Date.now() >= input.deadlineAtMs ? "deadline_exceeded" : "invalid_agent_turn_input",
+            retryable: false
+          });
+        }
+        const startedAt = (this.dependencies.now ?? Date.now)();
+        const ownedWorkspace = input.durableThread ? null : await (this.dependencies.createAgentWorkspace ?? this.dependencies.createWorkspace ?? createPrivateWorkspace)();
+        const workspacePath = input.durableThread?.threadPath ?? ownedWorkspace.path;
+        if (ownedWorkspace) this.agentWorkspaceCleanups.set(workspacePath, ownedWorkspace.cleanup);
+        const client = (this.dependencies.createClient ?? defaultClient)(workspacePath);
+        let session = null;
+        let durableCheckpointed = input.durableThread !== null;
+        let dispatchEntered = false;
+        const toolEvidence = [];
+        try {
+          await client.start();
+          const tools = copilotAgentToolDefinitions(input, toolEvidence);
+          const sessionConfig = {
+            clientName: "@vtxmacro/cli durable Copilot Agent host",
+            model: input.requestedModel,
+            ...input.requestedReasoningEffort === "none" ? {} : { reasoningEffort: input.requestedReasoningEffort },
+            systemMessage: {
+              mode: "replace",
+              content: `${input.systemPrompt}
+
+Return only one JSON value matching this JSON Schema exactly:
+${JSON.stringify(input.outputSchema)}`
+            },
+            tools,
+            availableTools: tools.map((tool) => tool.name),
+            enableConfigDiscovery: false,
+            streaming: true,
+            workingDirectory: workspacePath,
+            infiniteSessions: { enabled: true }
+          };
+          session = input.durableThread ? await client.resumeSession(input.durableThread.threadId, sessionConfig) : await client.createSession(sessionConfig);
+          this.agentConnection = {
+            client,
+            session,
+            workspacePath,
+            cleanup: ownedWorkspace?.cleanup ?? null
+          };
+          const thread = {
+            threadId: session.sessionId,
+            threadPath: workspacePath,
+            effectiveModel: input.requestedModel,
+            effectiveReasoningEffort: input.requestedReasoningEffort
+          };
+          if (input.onThreadReady) {
+            await input.onThreadReady(thread);
+            durableCheckpointed = true;
+          }
+          const usageEvents = [];
+          session.on((event) => {
+            if (event.type === "assistant.usage" && !event.agentId) usageEvents.push(event);
+          });
+          const onAbort = () => {
+            void session?.abort().catch(() => void 0);
+          };
+          input.signal?.addEventListener("abort", onAbort, { once: true });
+          dispatchEntered = true;
+          let response;
+          try {
+            response = await session.sendAndWait(
+              { prompt: input.userPrompt },
+              Math.max(1, input.deadlineAtMs - Date.now())
+            );
+          } finally {
+            input.signal?.removeEventListener("abort", onAbort);
+          }
+          if (!response?.data.content || Buffer.byteLength(response.data.content, "utf8") > MAX_RESULT_BYTES) {
+            throw new Error("copilot_agent_invalid_result");
+          }
+          const observedModels = /* @__PURE__ */ new Set();
+          const observedEfforts = /* @__PURE__ */ new Set();
+          let inputTokens = 0;
+          let cachedInputTokens = 0;
+          let outputTokens = 0;
+          let reasoningOutputTokens = 0;
+          let cacheWriteInputTokens = 0;
+          let cacheWriteSupported = false;
+          let timeToFirstTokenMs = null;
+          let providerCallId = null;
+          for (const event of usageEvents) {
+            if (event.type !== "assistant.usage") continue;
+            observedModels.add(event.data.model);
+            if (event.data.reasoningEffort) observedEfforts.add(event.data.reasoningEffort);
+            inputTokens += requiredUsageInteger(event.data.inputTokens, "input_tokens");
+            cachedInputTokens += optionalUsageInteger(event.data.cacheReadTokens, "cache_read_tokens");
+            outputTokens += requiredUsageInteger(event.data.outputTokens, "output_tokens");
+            reasoningOutputTokens += optionalUsageInteger(event.data.reasoningTokens, "reasoning_tokens");
+            if (event.data.cacheWriteTokens !== void 0) {
+              cacheWriteSupported = true;
+              cacheWriteInputTokens += optionalUsageInteger(event.data.cacheWriteTokens, "cache_write_tokens");
+            }
+            if (timeToFirstTokenMs === null && Number.isSafeInteger(event.data.timeToFirstTokenMs)) {
+              timeToFirstTokenMs = Number(event.data.timeToFirstTokenMs);
+            }
+            providerCallId = event.data.providerCallId ?? event.data.apiCallId ?? providerCallId;
+          }
+          if (usageEvents.length === 0) throw new Error("copilot_agent_usage_receipt_missing");
+          if (response.data.model) observedModels.add(response.data.model);
+          if (observedModels.size !== 1 || !observedModels.has(input.requestedModel)) {
+            throw new Error("copilot_agent_effective_model_mismatch");
+          }
+          const effectiveEffort = input.requestedReasoningEffort === "none" ? observedEfforts.size === 0 ? "none" : observedEfforts.size === 1 ? [...observedEfforts][0] : null : observedEfforts.size === 1 ? [...observedEfforts][0] : null;
+          if (effectiveEffort !== input.requestedReasoningEffort) {
+            throw new Error("copilot_agent_effective_effort_mismatch");
+          }
+          const usage = {
+            inputTokens,
+            cachedInputTokens: Math.min(cachedInputTokens, inputTokens),
+            outputTokens,
+            reasoningOutputTokens: Math.min(reasoningOutputTokens, outputTokens),
+            totalTokens: inputTokens + outputTokens,
+            cacheWriteInputTokens: cacheWriteSupported ? cacheWriteInputTokens : null,
+            cacheWriteSupported
+          };
+          return {
+            thread,
+            turn: {
+              text: response.data.content,
+              reasoningContent: response.data.reasoningText ?? null,
+              reasoningSummary: null,
+              requestedModel: input.requestedModel,
+              effectiveModel: input.requestedModel,
+              requestedReasoningEffort: input.requestedReasoningEffort,
+              effectiveReasoningEffort: effectiveEffort,
+              adapterRequestId: providerCallId ?? response.data.requestId ?? response.data.messageId,
+              adapterResponseId: response.data.serviceRequestId ?? response.data.messageId,
+              usage,
+              latencyMs: Math.max(0, (this.dependencies.now ?? Date.now)() - startedAt),
+              timeToFirstTokenMs,
+              terminalStatus: "completed",
+              toolCalls: toolEvidence,
+              webSearches: []
+            }
+          };
+        } catch (error48) {
+          if (error48 instanceof CodexAppServerError) throw error48;
+          const cancelled = input.signal?.aborted === true;
+          const deadline = Date.now() >= input.deadlineAtMs;
+          if (dispatchEntered) await session?.abort().catch(() => void 0);
+          if (session && !durableCheckpointed) {
+            const abandonedSession = session;
+            session = null;
+            if (this.agentConnection?.session === abandonedSession) this.agentConnection = null;
+            await abandonedSession.disconnect().catch(() => void 0);
+            await client.deleteSession(abandonedSession.sessionId).catch(() => void 0);
+            const cleanup = this.agentWorkspaceCleanups.get(workspacePath);
+            if (cleanup) {
+              await cleanup().catch(() => void 0);
+              this.agentWorkspaceCleanups.delete(workspacePath);
+            }
+          }
+          throw new CodexAppServerError({
+            message: cancelled ? "Copilot Agent turn was cancelled." : deadline ? "Copilot Agent turn exceeded its deadline." : error48 instanceof Error ? error48.message : "Copilot Agent adapter failed.",
+            category: cancelled ? "cancelled" : deadline ? "timeout" : "adapter",
+            code: cancelled ? "cancelled" : deadline ? "deadline_exceeded" : "copilot_agent_adapter_failure",
+            retryable: false,
+            dispatchOutcome: dispatchEntered ? "confirmed_dispatched" : "not_dispatched",
+            cause: error48
+          });
+        } finally {
+          await session?.disconnect().catch(() => void 0);
+          await client.stop().catch(async () => {
+            await client.forceStop();
+          });
+          if (this.agentConnection?.session === session) this.agentConnection = null;
+        }
+      }
+      async releaseThread(thread) {
+        const active = this.agentConnection;
+        if (active?.session.sessionId === thread.threadId) {
+          await active.session.disconnect().catch(() => void 0);
+          await active.client.stop().catch(async () => {
+            await active.client.forceStop();
+          });
+          this.agentConnection = null;
+        }
+        const client = (this.dependencies.createClient ?? defaultClient)(thread.threadPath);
+        await client.start();
+        try {
+          await client.deleteSession(thread.threadId);
+        } finally {
+          await client.stop().catch(async () => {
+            await client.forceStop();
+          });
+        }
+        const cleanup = this.agentWorkspaceCleanups.get(thread.threadPath);
+        if (cleanup) {
+          await cleanup();
+          this.agentWorkspaceCleanups.delete(thread.threadPath);
+        }
+      }
+      async close() {
+        this.closing = true;
+        const active = this.agentConnection;
+        this.agentConnection = null;
+        if (!active) return;
+        await active.session.disconnect().catch(() => void 0);
+        await active.client.stop().catch(async () => {
+          await active.client.forceStop();
+        });
+      }
     };
   }
 });
@@ -30914,7 +31295,7 @@ var require_ajv = __commonJS({
 });
 
 // lib/inference-host/runner.ts
-import { createHash as createHash6, randomUUID } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
 function createDefaultInferenceHostRunnerDependencies(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
   return {
@@ -30949,7 +31330,7 @@ function createDefaultInferenceHostRunnerDependencies(options) {
     envelopePublicKey: options.envelopePublicKey
   };
 }
-var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createCodexAgentControlClient, CODEX_AGENT_SYSTEM_PROMPT, CODEX_AGENT_WAKE_SCHEMA, parseCodexAgentWake, CodexAgentRuntime;
+var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, 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";
@@ -31333,7 +31714,7 @@ var init_runner = __esm({
           adapterId,
           options.structuredOutput ?? adapterId === "codex",
           options.sameAttemptRecovery ?? adapterId === "codex",
-          options.agentRuntime && adapterId === "codex" ? ["provider", "agent"] : ["provider"]
+          options.agentRuntime ? ["provider", "agent"] : ["provider"]
         ),
         maxConcurrency: options.maxConcurrency === null || options.maxConcurrency === void 0 ? null : finitePositiveOption(options.maxConcurrency, 1, "Maximum concurrency"),
         advertisementTtlMs,
@@ -31788,10 +32169,11 @@ var init_runner = __esm({
             const agentRuntimeSettings = settings.agentRuntime;
             agentLoop = (async () => {
               while (!agentAbort.signal.aborted) {
-                const agentRuntime = new CodexAgentRuntime({
+                const agentRuntime = new InferenceAgentRuntime({
+                  adapterId: settings.adapterId,
                   hostId: localState.host_id,
                   statePath: agentRuntimeSettings.statePath,
-                  controlClient: createCodexAgentControlClient(mcp),
+                  controlClient: createInferenceAgentControlClient(mcp),
                   adapter: agentRuntimeSettings.adapter
                 });
                 try {
@@ -33129,7 +33511,7 @@ var init_runner = __esm({
         }
       }
     };
-    createCodexAgentControlClient = (mcp) => ({
+    createInferenceAgentControlClient = (mcp) => ({
       nextAssignment: async (request, options) => {
         const result2 = await mcp.callTool("inference.agent.assignment.next", {
           ...request,
@@ -33172,9 +33554,9 @@ var init_runner = __esm({
         await mcp.callTool("inference.agent.assignment.release", request, options);
       }
     });
-    CODEX_AGENT_SYSTEM_PROMPT = `You autonomously control one running VTX bot.
+    INFERENCE_AGENT_SYSTEM_PROMPT = `You autonomously control one running VTX bot.
 VTX supplies no trading prompt or prepared market context. At your own cadence, request zero, some, or all assignment-scoped data with vtx_get_data and independently use web search when useful. Submit trading instructions only through vtx_submit_decision, using the assignment's exact decision schema. VTX remains responsible for validating and executing the same structured decision used by normal Server and Client modes. You have no shell, filesystem-write, app, plugin, browser-control, or subagent authority.`;
-    CODEX_AGENT_WAKE_SCHEMA = {
+    INFERENCE_AGENT_WAKE_SCHEMA = {
       type: "object",
       additionalProperties: false,
       required: ["next_wake_seconds", "summary"],
@@ -33183,29 +33565,29 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         summary: { type: "string", minLength: 1, maxLength: 2e3 }
       }
     };
-    parseCodexAgentWake = (text, assignment) => {
+    parseInferenceAgentWake = (text, assignment) => {
       let value;
       try {
         value = JSON.parse(text);
       } catch {
         throw new InferenceHostRunnerError(
           "invalid_agent_wake",
-          "Codex Agent returned invalid wake JSON."
+          "Inference Agent returned invalid wake JSON."
         );
       }
       if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new InferenceHostRunnerError("invalid_agent_wake", "Codex Agent wake is invalid.");
+        throw new InferenceHostRunnerError("invalid_agent_wake", "Inference Agent wake is invalid.");
       }
       const seconds = value.next_wake_seconds;
       if (!Number.isSafeInteger(seconds) || Number(seconds) < 1) {
-        throw new InferenceHostRunnerError("invalid_agent_wake", "Codex Agent wake is invalid.");
+        throw new InferenceHostRunnerError("invalid_agent_wake", "Inference Agent wake is invalid.");
       }
       return Math.max(
         assignment.minimum_wake_seconds,
         Math.min(assignment.maximum_wake_seconds, Number(seconds))
       );
     };
-    CodexAgentRuntime = class {
+    InferenceAgentRuntime = class {
       constructor(options) {
         this.options = options;
         this.stopped = false;
@@ -33239,29 +33621,55 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
       }
       async runOnce(signal) {
         const nowIso = () => new Date(this.now()).toISOString();
-        const recoveredState = await readCodexAgentRuntimeState(this.options.statePath);
+        const recoveredState = await readInferenceAgentRuntimeState(this.options.statePath);
         if (recoveredState && recoveredState.host_id !== this.options.hostId) {
           throw new InferenceHostRunnerError(
             "agent_recovery_scope_mismatch",
-            "Codex Agent recovery state belongs to another host."
+            "Inference Agent recovery state belongs to another host."
           );
         }
         let state;
         if (recoveredState?.schema_version === "vtx_codex_agent_runtime_v1") {
+          if (this.options.adapterId !== "codex") {
+            throw new InferenceHostRunnerError(
+              "agent_recovery_adapter_mismatch",
+              "Legacy Codex Agent recovery state cannot be opened by another adapter."
+            );
+          }
           state = await this.upgradeLegacyRuntimeState(recoveredState, signal);
           if (!state) return this.now() + (this.options.idlePollMs ?? 5e3);
+        } else if (recoveredState?.schema_version === "vtx_codex_agent_runtime_v2") {
+          if (this.options.adapterId !== "codex") {
+            throw new InferenceHostRunnerError(
+              "agent_recovery_adapter_mismatch",
+              "Legacy Codex Agent recovery state cannot be opened by another adapter."
+            );
+          }
+          state = {
+            ...recoveredState,
+            schema_version: "vtx_inference_agent_runtime_v3",
+            adapter_id: "codex"
+          };
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
         } else {
           state = recoveredState ?? null;
+          if (state && state.adapter_id !== this.options.adapterId) {
+            throw new InferenceHostRunnerError(
+              "agent_recovery_adapter_mismatch",
+              "Inference Agent recovery state belongs to another adapter."
+            );
+          }
         }
         if (!state) {
           const assignment2 = await this.options.controlClient.nextAssignment({
-            operation_id: randomUUID(),
+            operation_id: randomUUID2(),
             host_id: this.options.hostId,
             requested_at: nowIso()
           }, { signal });
           if (!assignment2) return this.now() + (this.options.idlePollMs ?? 5e3);
           state = {
-            schema_version: "vtx_codex_agent_runtime_v2",
+            schema_version: "vtx_inference_agent_runtime_v3",
+            adapter_id: this.options.adapterId,
             host_id: this.options.hostId,
             assignment: assignment2,
             thread: null,
@@ -33269,7 +33677,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             pending_decision: null,
             updated_at: nowIso()
           };
-          await writeCodexAgentRuntimeState(this.options.statePath, state);
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
         } else {
           const persistedWakeAtMs = Date.parse(state.next_wake_at);
           if (persistedWakeAtMs > this.now()) {
@@ -33277,8 +33685,8 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             if (wakeOutcome !== "ready") {
               return this.now() + (this.options.idlePollMs ?? 5e3);
             }
-            const rereadState = await readCodexAgentRuntimeState(this.options.statePath);
-            if (rereadState?.schema_version !== "vtx_codex_agent_runtime_v2") {
+            const rereadState = await readInferenceAgentRuntimeState(this.options.statePath);
+            if (rereadState?.schema_version !== "vtx_inference_agent_runtime_v3" || rereadState.adapter_id !== this.options.adapterId) {
               return this.now() + (this.options.idlePollMs ?? 5e3);
             }
             state = rereadState;
@@ -33287,7 +33695,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         state = await this.resolvePendingDecision(state, signal);
         let assignment = state.assignment;
         const preTurnHeartbeat = await this.options.controlClient.heartbeat({
-          operation_id: randomUUID(),
+          operation_id: randomUUID2(),
           host_id: this.options.hostId,
           assignment_id: assignment.assignment_id,
           assignment_generation: assignment.assignment_generation,
@@ -33302,7 +33710,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           lease_expires_at: preTurnHeartbeat.lease_expires_at
         };
         state = { ...state, assignment, updated_at: nowIso() };
-        await writeCodexAgentRuntimeState(this.options.statePath, state);
+        await writeInferenceAgentRuntimeState(this.options.statePath, state);
         const turnAbort = new AbortController();
         const relayAbort = () => turnAbort.abort();
         signal?.addEventListener("abort", relayAbort, { once: true });
@@ -33312,7 +33720,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         const heartbeatTask = (async () => {
           while (!heartbeatStopped && !turnAbort.signal.aborted) {
             const heartbeat = await this.options.controlClient.heartbeat({
-              operation_id: randomUUID(),
+              operation_id: randomUUID2(),
               host_id: this.options.hostId,
               assignment_id: assignment.assignment_id,
               assignment_generation: assignment.assignment_generation,
@@ -33336,7 +33744,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           const deadlineAtMs = this.now() + (this.options.turnTimeoutMs ?? 10 * 6e4);
           const result2 = await this.options.adapter.runTurn({
             durableThread: state.thread,
-            systemPrompt: CODEX_AGENT_SYSTEM_PROMPT,
+            systemPrompt: INFERENCE_AGENT_SYSTEM_PROMPT,
             userPrompt: JSON.stringify({
               assignment_id: assignment.assignment_id,
               assignment_generation: assignment.assignment_generation,
@@ -33350,7 +33758,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                 maximum: assignment.maximum_wake_seconds
               }
             }),
-            outputSchema: CODEX_AGENT_WAKE_SCHEMA,
+            outputSchema: INFERENCE_AGENT_WAKE_SCHEMA,
             dataContract: assignment.data_contract,
             decisionSchema: assignment.output_schema,
             requestedModel: assignment.model_id,
@@ -33359,7 +33767,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             signal: turnAbort.signal,
             onThreadReady: async (thread) => {
               state = { ...state, thread, updated_at: nowIso() };
-              await writeCodexAgentRuntimeState(this.options.statePath, state);
+              await writeInferenceAgentRuntimeState(this.options.statePath, state);
             },
             executeTool: async (call) => {
               if (call.tool === "vtx_get_data") {
@@ -33369,7 +33777,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   return { success: false, value: { error: "invalid_data_request" } };
                 }
                 const value = await this.options.controlClient.dataCall({
-                  operation_id: randomUUID(),
+                  operation_id: randomUUID2(),
                   host_id: this.options.hostId,
                   assignment_id: assignment.assignment_id,
                   assignment_generation: assignment.assignment_generation,
@@ -33393,12 +33801,12 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   return { success: false, value: { error: "decision_outcome_unresolved" } };
                 }
                 const pending = {
-                  operation_id: randomUUID(),
+                  operation_id: randomUUID2(),
                   candidate,
                   observed_at: nowIso(),
                   provenance: {
-                    source: "codex_agent",
-                    codex_thread_id: liveThread.threadId,
+                    source: "external_agent",
+                    agent_run_id: liveThread.threadId,
                     requested_model: assignment.model_id,
                     effective_model: liveThread.effectiveModel,
                     requested_reasoning_effort: assignment.reasoning_effort,
@@ -33408,13 +33816,13 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   last_status_check_at: null
                 };
                 state = { ...state, pending_decision: pending, updated_at: nowIso() };
-                await writeCodexAgentRuntimeState(this.options.statePath, state);
+                await writeInferenceAgentRuntimeState(this.options.statePath, state);
                 state = {
                   ...state,
                   pending_decision: { ...pending, first_transmit_at: nowIso() },
                   updated_at: nowIso()
                 };
-                await writeCodexAgentRuntimeState(this.options.statePath, state);
+                await writeInferenceAgentRuntimeState(this.options.statePath, state);
                 let submitStatus;
                 try {
                   submitStatus = await this.options.controlClient.submitDecision({
@@ -33431,7 +33839,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                 }
                 if (submitStatus.status === "applied" || submitStatus.status === "not_applied") {
                   state = { ...state, pending_decision: null, updated_at: nowIso() };
-                  await writeCodexAgentRuntimeState(this.options.statePath, state);
+                  await writeInferenceAgentRuntimeState(this.options.statePath, state);
                 }
                 return {
                   success: submitStatus.status === "applied",
@@ -33455,7 +33863,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   pending_decision: null,
                   updated_at: nowIso()
                 };
-                await writeCodexAgentRuntimeState(this.options.statePath, state);
+                await writeInferenceAgentRuntimeState(this.options.statePath, state);
               }
               return {
                 success: status.status === "applied" || status.status === "not_applied",
@@ -33463,11 +33871,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
               };
             }
           });
-          const wakeSeconds = parseCodexAgentWake(result2.turn.text, assignment);
+          const wakeSeconds = parseInferenceAgentWake(result2.turn.text, assignment);
           const nextWakeAtMs = this.now() + wakeSeconds * 1e3;
           const scheduledWakeAt = new Date(nextWakeAtMs).toISOString();
           const wakeHeartbeat = await this.options.controlClient.heartbeat({
-            operation_id: randomUUID(),
+            operation_id: randomUUID2(),
             host_id: this.options.hostId,
             assignment_id: assignment.assignment_id,
             assignment_generation: assignment.assignment_generation,
@@ -33477,7 +33885,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           if (wakeHeartbeat.directive === "cancel") {
             if (state.pending_decision) return this.now() + (this.options.idlePollMs ?? 5e3);
             await this.options.adapter.releaseThread(result2.thread).catch(() => void 0);
-            await clearCodexAgentRuntimeState(this.options.statePath);
+            await clearInferenceAgentRuntimeState(this.options.statePath);
             return this.now() + (this.options.idlePollMs ?? 5e3);
           }
           latestLeaseExpiry = wakeHeartbeat.lease_expires_at;
@@ -33488,7 +33896,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             next_wake_at: scheduledWakeAt,
             updated_at: nowIso()
           };
-          await writeCodexAgentRuntimeState(this.options.statePath, state);
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
           return nextWakeAtMs;
         } catch (error48) {
           if (!cancelled) throw error48;
@@ -33507,7 +33915,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         if (state.thread) {
           await this.options.adapter.releaseThread(state.thread).catch(() => void 0);
         }
-        await clearCodexAgentRuntimeState(this.options.statePath);
+        await clearInferenceAgentRuntimeState(this.options.statePath);
         return null;
       }
       async resolveLegacyPendingDecision(state, signal) {
@@ -33519,7 +33927,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: { ...pending, last_status_check_at: checkedAt },
           updated_at: checkedAt
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, checking);
+        await writeInferenceAgentRuntimeState(this.options.statePath, checking);
         const status = await this.options.controlClient.decisionStatus({
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
@@ -33532,7 +33940,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: null,
           updated_at: new Date(this.now()).toISOString()
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, resolved);
+        await writeInferenceAgentRuntimeState(this.options.statePath, resolved);
         return resolved;
       }
       async resolvePendingDecision(state, signal) {
@@ -33544,7 +33952,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: { ...pending, last_status_check_at: checkedAt },
           updated_at: checkedAt
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, checking);
+        await writeInferenceAgentRuntimeState(this.options.statePath, checking);
         const status = await this.options.controlClient.decisionStatus({
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
@@ -33557,7 +33965,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: null,
           updated_at: new Date(this.now()).toISOString()
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, resolved);
+        await writeInferenceAgentRuntimeState(this.options.statePath, resolved);
         return resolved;
       }
       async handleCancelledAssignment(state, signal) {
@@ -33573,7 +33981,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         if (current.thread) {
           await this.options.adapter.releaseThread(current.thread).catch(() => void 0);
         }
-        await clearCodexAgentRuntimeState(this.options.statePath);
+        await clearInferenceAgentRuntimeState(this.options.statePath);
       }
       async waitUntilWake(nextWakeAtMs, signal) {
         const heartbeatIntervalMs = this.options.heartbeatIntervalMs ?? 3e3;
@@ -33581,11 +33989,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           await this.sleep(Math.min(heartbeatIntervalMs, nextWakeAtMs - this.now()), signal);
           if (this.stopped || signal?.aborted) return "stopped";
           if (this.now() >= nextWakeAtMs) return "ready";
-          const state = await readCodexAgentRuntimeState(this.options.statePath);
-          if (state?.schema_version !== "vtx_codex_agent_runtime_v2") return "cancelled";
+          const state = await readInferenceAgentRuntimeState(this.options.statePath);
+          if (state?.schema_version !== "vtx_inference_agent_runtime_v3" || state.adapter_id !== this.options.adapterId) return "cancelled";
           const requestedAt = new Date(this.now()).toISOString();
           const heartbeat = await this.options.controlClient.heartbeat({
-            operation_id: randomUUID(),
+            operation_id: randomUUID2(),
             host_id: this.options.hostId,
             assignment_id: state.assignment.assignment_id,
             assignment_generation: state.assignment.assignment_generation,
@@ -33595,7 +34003,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             await this.handleCancelledAssignment(state, signal);
             return "cancelled";
           }
-          await writeCodexAgentRuntimeState(this.options.statePath, {
+          await writeInferenceAgentRuntimeState(this.options.statePath, {
             ...state,
             assignment: {
               ...state.assignment,
@@ -33607,8 +34015,24 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         return this.stopped || signal?.aborted ? "stopped" : "ready";
       }
       async releaseForHostStop() {
-        let state = await readCodexAgentRuntimeState(this.options.statePath);
-        if (!state) return;
+        const recovered = await readInferenceAgentRuntimeState(this.options.statePath);
+        if (!recovered) return;
+        let state;
+        if (recovered.schema_version === "vtx_codex_agent_runtime_v1") {
+          if (this.options.adapterId !== "codex") return;
+          state = recovered;
+        } else if (recovered.schema_version === "vtx_codex_agent_runtime_v2") {
+          if (this.options.adapterId !== "codex") return;
+          state = {
+            ...recovered,
+            schema_version: "vtx_inference_agent_runtime_v3",
+            adapter_id: "codex"
+          };
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
+        } else {
+          if (recovered.adapter_id !== this.options.adapterId) return;
+          state = recovered;
+        }
         try {
           state = state.schema_version === "vtx_codex_agent_runtime_v1" ? await this.resolveLegacyPendingDecision(state) : await this.resolvePendingDecision(state);
         } catch {
@@ -33616,7 +34040,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
         if (state.pending_decision) return;
         await this.options.controlClient.releaseAssignment({
-          operation_id: randomUUID(),
+          operation_id: randomUUID2(),
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
           assignment_generation: state.assignment.assignment_generation,
@@ -33624,7 +34048,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           requested_at: new Date(this.now()).toISOString()
         }, {});
         if (state.thread) await this.options.adapter.releaseThread(state.thread);
-        await clearCodexAgentRuntimeState(this.options.statePath);
+        await clearInferenceAgentRuntimeState(this.options.statePath);
       }
     };
   }
@@ -33632,7 +34056,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
 
 // lib/inference-host/service.ts
 import { spawn as spawn6 } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } 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 { homedir as homedir2 } from "node:os";
@@ -34157,7 +34581,7 @@ WantedBy=default.target
         const previousRuntimeUpdatedAt = previousRuntime?.manifest_generation === manifest.generation ? Date.parse(previousRuntime.updated_at) : Number.NaN;
         const restoredManifest = preserveGeneration ? manifest : assertManifest({
           ...manifest,
-          generation: randomUUID2(),
+          generation: randomUUID3(),
           installed_at: this.now().toISOString()
         });
         await writeAtomicInferencePrivateFile(
@@ -34443,7 +34867,7 @@ ${cleanup.stderr}`)) {
         ].sort((left, right) => left.instance_name.localeCompare(right.instance_name));
         const manifest = assertManifest({
           schema_version: "vtx_inference_service_v3",
-          generation: randomUUID2(),
+          generation: randomUUID3(),
           installed_at: this.now().toISOString(),
           executable: this.executable,
           script: this.script,
@@ -34657,7 +35081,7 @@ ${result2.stderr}`)) {
           if (remaining.length === 0) return await this.uninstallUnlocked();
           return await this.replaceManifestUnlocked({
             ...manifest,
-            generation: randomUUID2(),
+            generation: randomUUID3(),
             installed_at: this.now().toISOString(),
             workers: remaining
           }, await readInferenceHostServiceDesired(this.desiredPath()));
@@ -35047,7 +35471,7 @@ __export(cli_exports, {
   registerInferenceHostServiceControlInput: () => registerInferenceHostServiceControlInput,
   runInferenceHostCli: () => runInferenceHostCli
 });
-import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID4 } 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 { hostname as osHostname } from "node:os";
@@ -35111,6 +35535,42 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
         async () => await agentFail(config2, parsed, dependencies, warnings)
       );
     }
+    if (parsed.command === "agent-assignment-next") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundAssignmentNext(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-assignment-heartbeat") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundAssignmentHeartbeat(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-data-call") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundDataCall(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-decision-submit") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundDecisionSubmit(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-decision-status") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundDecisionStatus(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-assignment-release") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundAssignmentRelease(config2, parsed, dependencies, warnings)
+      );
+    }
     if (parsed.command === "service") {
       const mutationActions = /* @__PURE__ */ new Set(["install", "start", "stop", "recover", "uninstall"]);
       if (!parsed.serviceAction || !mutationActions.has(parsed.serviceAction)) {
@@ -35141,7 +35601,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
       return await cleanupLogin(config2, parsed, dependencies, warnings, true);
     }
     throw new Error(
-      "Usage: vtx inference-host <login|codex-login|run|agent-connect|agent-run|agent-next|agent-complete|agent-fail|service|status|doctor|logout|codex-logout|revoke> [--json]"
+      "Usage: vtx inference-host <login|codex-login|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]"
     );
   } catch (error48) {
     return {
@@ -35152,7 +35612,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     };
   }
 }
-var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, credentialLifecycleLockPath, serviceRecoveryCommandLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, resolveDurableServiceDisplayName, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, preparePortableDurableAdapter, defaultRunPortableDurableAdapter, login, codexLogin, codexLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, agentOperationId, agentSession, agentConnect, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, recoveryBackupPath, serviceRecoveryTransactionPath, readServiceRecoveryTransaction, assertResumableCodexRecoveryEvidence, recoverInstalledCodexService, serviceCommand, hasExplicitCredentialStoreConfiguration, credentialEnvironmentForIdentity, commandRequiresRetainedCredentialStore, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
+var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, credentialLifecycleLockPath, serviceRecoveryCommandLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, resolveDurableServiceDisplayName, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, preparePortableDurableAdapter, defaultRunPortableDurableAdapter, login, codexLogin, codexLogout, 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";
@@ -35252,6 +35712,12 @@ Commands:
   agent-next      Claim the next exact VTX inference request
   agent-complete  Submit one completed agent result from stdin
   agent-fail      Submit one truthful agent failure from stdin
+  agent-assignment-next       Claim the assigned Main bot for Agent control
+  agent-assignment-heartbeat  Renew the current Agent assignment
+  agent-data-call             Request allowed assignment-scoped VTX data
+  agent-decision-submit       Submit the normal structured trading decision
+  agent-decision-status       Resolve an uncertain Agent decision submission
+  agent-assignment-release    Release the current Agent assignment
   service         Install and control the durable background host
   status          Inspect local host and credential state
   doctor          Verify credentials, provider runtime, and private state
@@ -35566,6 +36032,7 @@ Durable service:
       );
       await clearInferenceAgentAttemptState(config2.statePath);
       await clearInferenceAgentNextState(config2.statePath);
+      await clearInferenceForegroundAgentControlState(config2.statePath);
       await clearCodexAgentRuntimeState(config2.statePath);
       await clearInferenceHostLocalState(config2.statePath);
     };
@@ -35593,10 +36060,11 @@ Durable service:
       const revocationCheckpointPresent = await readRevocationCheckpoint(config2) !== null;
       const agentAttemptPresent = await readInferenceAgentAttemptState(config2.statePath) !== null;
       const agentNextRecoveryPresent = await readInferenceAgentNextState(config2.statePath) !== null;
+      const foregroundAgentControlPresent = await readInferenceForegroundAgentControlState(config2.statePath) !== null;
       const codexAgentRuntimePresent = await readCodexAgentRuntimeState(config2.statePath) !== null;
-      if (pendingAttempts > 0 || codexRecoveryPresent || serviceRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent || codexAgentRuntimePresent) {
+      if (pendingAttempts > 0 || codexRecoveryPresent || serviceRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent || foregroundAgentControlPresent || codexAgentRuntimePresent) {
         throw new Error(
-          "Inference host logout refused because attempt recovery is still pending (Codex, agent-driven, or revocation recovery). Rerun agent-next, complete or fail the active attempt, run the automated host to reconcile it, or resume revoke."
+          "Inference host logout refused because attempt recovery is still pending (Codex, Provider, Agent-control, or revocation recovery). Reconcile or release the exact active operation before retrying logout, or resume revoke."
         );
       }
     };
@@ -35669,6 +36137,12 @@ Durable service:
       return { adapter, preflight: await adapter.preflight(signal) };
     };
     defaultRunPortableDurableAdapter = async (options) => {
+      const agentAdapter = options.adapter;
+      if (typeof agentAdapter.runTurn !== "function" || typeof agentAdapter.releaseThread !== "function" || typeof agentAdapter.close !== "function") {
+        throw new Error(
+          `${options.preflight.adapterId} does not implement the durable Agent-control contract.`
+        );
+      }
       const dependencies = createDefaultInferenceHostRunnerDependencies({
         apiUrl: options.config.apiUrl,
         statePath: options.config.statePath,
@@ -35704,6 +36178,10 @@ Durable service:
         maxConcurrency: options.maxConcurrency,
         once: options.once,
         emitDiagnosticEvent: options.emitDiagnosticEvent,
+        agentRuntime: {
+          statePath: options.config.statePath,
+          adapter: agentAdapter
+        },
         signal: options.signal
       }).run();
     };
@@ -35737,7 +36215,7 @@ Durable service:
         await writeInferenceHostCredentialContextTransition(config2, previousCredentialContext);
         await writeInferenceHostCredentialContext(config2);
         const keyPair = generateExternalInferenceEnvelopeKeyPair();
-        const hostId = randomUUID3();
+        const hostId = randomUUID4();
         const beginLogin = dependencies.beginLogin ?? beginInferenceOAuthLogin;
         const loginStore = {
           kind: store.kind,
@@ -36417,7 +36895,27 @@ Waiting for approval...
       }
       return record2;
     };
-    agentOperationId = (kind) => `${kind}-${randomUUID3()}`;
+    parseOptionalAgentStdin = async (dependencies, allowedKeys) => {
+      if (!dependencies.readStdin && process.stdin.isTTY) return {};
+      const raw = await (dependencies.readStdin ?? defaultReadStdin)();
+      if (!raw.trim()) return {};
+      let value;
+      try {
+        value = JSON.parse(raw);
+      } catch {
+        throw new Error("Agent-driven inference stdin must be one JSON object.");
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Agent-driven inference stdin must be one JSON object.");
+      }
+      const record2 = value;
+      const unexpected = Object.keys(record2).filter((key) => !allowedKeys.includes(key));
+      if (unexpected.length > 0) {
+        throw new Error(`Unsupported agent-driven inference fields: ${unexpected.join(", ")}.`);
+      }
+      return record2;
+    };
+    agentOperationId = (kind) => `${kind}-${randomUUID4()}`;
     agentSession = async (config2, dependencies, warnings, signal) => {
       if (await readRevocationCheckpoint(config2)) {
         throw new Error("Inference host revocation recovery must finish first.");
@@ -36461,11 +36959,419 @@ Waiting for approval...
           reasoning_effort: result2.reasoning_effort,
           lanes: ["main", "review", "screener"],
           response_modes: ["provider_response", "decision_candidate"],
+          control_modes: ["provider", "agent"],
           execution_modes: ["client", "server"],
           next_command: "vtx inference-host agent-next --wait-seconds 50 --json",
+          agent_next_command: "vtx inference-host agent-assignment-next --wait-seconds 50 --json",
           keeper_command: "vtx inference-host agent-run"
         }, parsed.json),
         stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundAgentControlState = (hostId, updatedAt) => ({
+      schema_version: "vtx_foreground_agent_control_v1",
+      host_id: hostId,
+      assignment: null,
+      pending_next: null,
+      pending_decision: null,
+      next_wake_at: null,
+      updated_at: updatedAt
+    });
+    requireForegroundAgentState = async (config2, hostId) => {
+      const state = await readInferenceForegroundAgentControlState(config2.statePath);
+      if (!state?.assignment) {
+        throw new Error("No active foreground Agent assignment. Run agent-assignment-next first.");
+      }
+      if (state.host_id !== hostId) {
+        throw new Error("Foreground Agent assignment belongs to another inference host.");
+      }
+      return state;
+    };
+    assignmentFromClaim = (result2) => ({
+      assignment_id: result2.assignment_id,
+      assignment_generation: result2.assignment_generation,
+      model_id: result2.model_id,
+      reasoning_effort: result2.reasoning_effort,
+      bot_mode: result2.bot_mode,
+      execution_mode: result2.execution_mode,
+      allowed_symbols: result2.allowed_symbols,
+      data_contract: result2.data_contract,
+      output_schema: result2.output_schema,
+      minimum_wake_seconds: result2.minimum_wake_seconds,
+      maximum_wake_seconds: result2.maximum_wake_seconds,
+      lease_expires_at: result2.lease_expires_at
+    });
+    foregroundAssignmentNext = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+      const sleep4 = dependencies.sleep ?? (async (milliseconds) => {
+        await new Promise((resolve6) => setTimeout(resolve6, milliseconds));
+      });
+      const stopAt = now().getTime() + parsed.waitSeconds * 1e3;
+      let state = await readInferenceForegroundAgentControlState(config2.statePath) ?? foregroundAgentControlState(session.localState.host_id, now().toISOString());
+      if (state.host_id !== session.localState.host_id) {
+        throw new Error("Foreground Agent recovery state belongs to another inference host.");
+      }
+      if (state.pending_decision) {
+        throw new Error("Resolve the pending Agent decision before claiming another assignment.");
+      }
+      while (true) {
+        if (!state.pending_next) {
+          const requestedAt = now().toISOString();
+          state = {
+            ...state,
+            pending_next: {
+              operation_id: agentOperationId("agent-assignment-next"),
+              requested_at: requestedAt
+            },
+            updated_at: requestedAt
+          };
+          await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        }
+        const pending = state.pending_next;
+        let result2;
+        try {
+          result2 = await session.client.callTool("inference.agent.assignment.next", {
+            operation_id: pending.operation_id,
+            host_id: session.localState.host_id,
+            requested_at: pending.requested_at,
+            contract_version: "agent_assignment_v2",
+            ...state.assignment ? {
+              assignment_id: state.assignment.assignment_id,
+              assignment_generation: state.assignment.assignment_generation
+            } : {}
+          });
+        } catch (error48) {
+          if (error48 && typeof error48 === "object" && error48.definitivelyNotApplied === true) {
+            state = { ...state, pending_next: null, updated_at: now().toISOString() };
+            await writeInferenceForegroundAgentControlState(config2.statePath, state);
+          }
+          throw error48;
+        }
+        if (result2.claim_state === "claimed") {
+          const assignment = assignmentFromClaim(result2);
+          state = {
+            ...state,
+            assignment,
+            pending_next: null,
+            next_wake_at: null,
+            updated_at: now().toISOString()
+          };
+          await writeInferenceForegroundAgentControlState(config2.statePath, state);
+          return {
+            exitCode: 0,
+            stdout: render({
+              ...result2,
+              instructions: "VTX supplied no trading prompt or prepared context. Choose your own cadence; use agent-data-call zero or more times, submit the exact output_schema through agent-decision-submit, then record the next wake with agent-assignment-heartbeat. Keep agent-run open for liveness.",
+              data_command: "vtx inference-host agent-data-call --json",
+              decision_command: "vtx inference-host agent-decision-submit --json",
+              decision_input: {
+                candidate: "<object matching output_schema>",
+                provenance: {
+                  source: "external_agent",
+                  agent_run_id: "<stable harness run id>",
+                  requested_model: result2.model_id,
+                  effective_model: "<actual model used>",
+                  requested_reasoning_effort: result2.reasoning_effort,
+                  effective_reasoning_effort: "<actual reasoning effort used>"
+                }
+              },
+              heartbeat_command: "vtx inference-host agent-assignment-heartbeat --json",
+              release_command: "vtx inference-host agent-assignment-release --json"
+            }, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
+        state = { ...state, pending_next: null, updated_at: now().toISOString() };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        const remaining = stopAt - now().getTime();
+        if (remaining <= 0 || parsed.waitSeconds === 0) {
+          return {
+            exitCode: 0,
+            stdout: render(result2, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
+        await sleep4(Math.min(remaining, Math.max(50, result2.retry_after_ms)));
+      }
+    };
+    foregroundAssignmentHeartbeat = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const state = await requireForegroundAgentState(
+        config2,
+        session.localState.host_id
+      );
+      const input = await parseOptionalAgentStdin(dependencies, ["next_wake_at"]);
+      const nextWakeAt = input.next_wake_at;
+      if (nextWakeAt !== void 0 && (typeof nextWakeAt !== "string" || !Number.isFinite(Date.parse(nextWakeAt)))) {
+        throw new Error("next_wake_at must be an ISO timestamp.");
+      }
+      const requestedAt = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+      const result2 = await session.client.callTool("inference.agent.assignment.heartbeat", {
+        operation_id: agentOperationId("agent-assignment-heartbeat"),
+        host_id: session.localState.host_id,
+        assignment_id: state.assignment.assignment_id,
+        assignment_generation: state.assignment.assignment_generation,
+        requested_at: requestedAt,
+        ...nextWakeAt === void 0 ? {} : { next_wake_at: nextWakeAt }
+      });
+      if (result2.directive === "cancel") {
+        await handleForegroundCancelledAssignment(config2, session, state, requestedAt);
+      } else {
+        await writeInferenceForegroundAgentControlState(config2.statePath, {
+          ...state,
+          assignment: { ...state.assignment, lease_expires_at: result2.lease_expires_at },
+          next_wake_at: result2.next_wake_at ?? state.next_wake_at,
+          updated_at: requestedAt
+        });
+      }
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundDataCall = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const state = await requireForegroundAgentState(config2, session.localState.host_id);
+      const input = await parseAgentStdin(dependencies, ["capability", "arguments"]);
+      const capability = typeof input.capability === "string" ? input.capability.trim() : "";
+      if (!capability || !state.assignment.data_contract.some((item) => item.id === capability)) {
+        throw new Error("Agent data capability is not allowed by the current assignment.");
+      }
+      if (!input.arguments || typeof input.arguments !== "object" || Array.isArray(input.arguments)) {
+        throw new Error("Agent data arguments must be one JSON object.");
+      }
+      const result2 = await session.client.callTool("inference.agent.data.call", {
+        operation_id: agentOperationId("agent-data-call"),
+        host_id: session.localState.host_id,
+        assignment_id: state.assignment.assignment_id,
+        assignment_generation: state.assignment.assignment_generation,
+        capability,
+        arguments: input.arguments,
+        requested_at: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+      });
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundDecisionStatusRequest = (hostId, state) => ({
+      operation_id: state.pending_decision.request.operation_id,
+      host_id: hostId,
+      assignment_id: state.assignment.assignment_id,
+      assignment_generation: state.assignment.assignment_generation
+    });
+    foregroundAssignmentLeaseEnded = (state, now) => Boolean(state.assignment) && Date.parse(state.assignment.lease_expires_at) <= now.getTime();
+    handleForegroundCancelledAssignment = async (config2, session, state, requestedAt, signal) => {
+      if (!state.pending_decision) {
+        await clearInferenceForegroundAgentControlState(config2.statePath);
+        return;
+      }
+      const cancelledState = {
+        ...state,
+        assignment: {
+          ...state.assignment,
+          lease_expires_at: requestedAt
+        },
+        pending_decision: {
+          ...state.pending_decision,
+          last_status_check_at: requestedAt
+        },
+        next_wake_at: null,
+        updated_at: requestedAt
+      };
+      await writeInferenceForegroundAgentControlState(config2.statePath, cancelledState);
+      try {
+        await session.client.callTool(
+          "inference.agent.decision.status",
+          foregroundDecisionStatusRequest(session.localState.host_id, cancelledState),
+          { signal }
+        );
+      } catch {
+        return;
+      }
+      await clearInferenceForegroundAgentControlState(config2.statePath);
+    };
+    foregroundDecisionStatus = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      let state = await requireForegroundAgentState(config2, session.localState.host_id);
+      if (!state.pending_decision) {
+        throw new Error("No uncertain foreground Agent decision requires status recovery.");
+      }
+      const checkedAt = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+      state = {
+        ...state,
+        pending_decision: { ...state.pending_decision, last_status_check_at: checkedAt },
+        updated_at: checkedAt
+      };
+      await writeInferenceForegroundAgentControlState(config2.statePath, state);
+      const result2 = await session.client.callTool(
+        "inference.agent.decision.status",
+        foregroundDecisionStatusRequest(session.localState.host_id, state)
+      );
+      const assignmentLeaseEnded = foregroundAssignmentLeaseEnded(state, new Date(checkedAt));
+      if (result2.found || assignmentLeaseEnded) {
+        if (assignmentLeaseEnded) {
+          await clearInferenceForegroundAgentControlState(config2.statePath);
+        } else {
+          await writeInferenceForegroundAgentControlState(config2.statePath, {
+            ...state,
+            pending_decision: null,
+            updated_at: checkedAt
+          });
+        }
+      }
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundDecisionSubmit = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+      let state = await requireForegroundAgentState(config2, session.localState.host_id);
+      if (!state.pending_decision) {
+        const input = await parseAgentStdin(dependencies, ["candidate", "provenance"]);
+        if (!input.candidate || typeof input.candidate !== "object" || Array.isArray(input.candidate)) {
+          throw new Error("Agent decision candidate must be one JSON object.");
+        }
+        if (!input.provenance || typeof input.provenance !== "object" || Array.isArray(input.provenance)) {
+          throw new Error("Agent decision provenance must be one JSON object.");
+        }
+        const observedAt = now().toISOString();
+        state = {
+          ...state,
+          pending_decision: {
+            request: {
+              assignment_id: state.assignment.assignment_id,
+              assignment_generation: state.assignment.assignment_generation,
+              operation_id: agentOperationId("agent-decision-submit"),
+              candidate: input.candidate,
+              observed_at: observedAt,
+              provenance: input.provenance
+            },
+            first_transmit_at: null,
+            last_status_check_at: null
+          },
+          updated_at: observedAt
+        };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+      } else {
+        const checkedAt = now().toISOString();
+        state = {
+          ...state,
+          pending_decision: { ...state.pending_decision, last_status_check_at: checkedAt },
+          updated_at: checkedAt
+        };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        const status = await session.client.callTool(
+          "inference.agent.decision.status",
+          foregroundDecisionStatusRequest(session.localState.host_id, state)
+        );
+        if (status.found) {
+          await writeInferenceForegroundAgentControlState(config2.statePath, {
+            ...state,
+            pending_decision: null,
+            updated_at: checkedAt
+          });
+          return {
+            exitCode: 0,
+            stdout: render({ ...status, recovered: true }, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
+      }
+      const transmittedAt = now().toISOString();
+      state = {
+        ...state,
+        pending_decision: {
+          ...state.pending_decision,
+          first_transmit_at: state.pending_decision.first_transmit_at ?? transmittedAt
+        },
+        updated_at: transmittedAt
+      };
+      await writeInferenceForegroundAgentControlState(config2.statePath, state);
+      try {
+        const result2 = await session.client.callTool(
+          "inference.agent.decision.submit",
+          state.pending_decision.request
+        );
+        await writeInferenceForegroundAgentControlState(config2.statePath, {
+          ...state,
+          pending_decision: null,
+          updated_at: now().toISOString()
+        });
+        return {
+          exitCode: 0,
+          stdout: render(result2, parsed.json),
+          stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+        };
+      } catch (error48) {
+        const checkedAt = now().toISOString();
+        state = {
+          ...state,
+          pending_decision: { ...state.pending_decision, last_status_check_at: checkedAt },
+          updated_at: checkedAt
+        };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        try {
+          const status = await session.client.callTool(
+            "inference.agent.decision.status",
+            foregroundDecisionStatusRequest(session.localState.host_id, state)
+          );
+          if (status.found) {
+            await writeInferenceForegroundAgentControlState(config2.statePath, {
+              ...state,
+              pending_decision: null,
+              updated_at: checkedAt
+            });
+            return {
+              exitCode: 0,
+              stdout: render({ ...status, recovered: true }, parsed.json),
+              stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+            };
+          }
+        } catch {
+        }
+        throw error48;
+      }
+    };
+    foregroundAssignmentRelease = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const state = await requireForegroundAgentState(config2, session.localState.host_id);
+      if (state.pending_decision) {
+        throw new Error("Resolve the pending Agent decision before releasing its assignment.");
+      }
+      const input = await parseOptionalAgentStdin(dependencies, ["reason_code"]);
+      const reasonCode = input.reason_code === void 0 ? "agent_released" : input.reason_code;
+      if (typeof reasonCode !== "string" || !/^[a-z0-9][a-z0-9._-]{0,95}$/u.test(reasonCode)) {
+        throw new Error("reason_code must be a safe lowercase code.");
+      }
+      const result2 = await session.client.callTool("inference.agent.assignment.release", {
+        operation_id: agentOperationId("agent-assignment-release"),
+        host_id: session.localState.host_id,
+        assignment_id: state.assignment.assignment_id,
+        assignment_generation: state.assignment.assignment_generation,
+        reason_code: reasonCode,
+        requested_at: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+      });
+      await clearInferenceForegroundAgentControlState(config2.statePath);
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
 ` : ""
       };
     };
@@ -36473,6 +37379,7 @@ Waiting for approval...
       const cancellation = lifecycleCancellation(dependencies);
       let keeperLock = null;
       let heartbeatCount = 0;
+      let assignmentHeartbeatCount = 0;
       try {
         keeperLock = await acquireInferenceHostProcessLock(foregroundHostLockPath(config2));
         const store = configuredCredentialStore(config2, dependencies, (message) => {
@@ -36506,6 +37413,7 @@ Waiting for approval...
           }
           if (commandLock) {
             let heartbeatSuppressed = false;
+            let assignmentHeartbeatComplete = true;
             try {
               const active = await readInferenceAgentAttemptState(config2.statePath);
               const pendingNext = await readInferenceAgentNextState(config2.statePath);
@@ -36565,10 +37473,65 @@ Waiting for approval...
                   }
                 }
               }
+              const control = await readInferenceForegroundAgentControlState(config2.statePath);
+              if (control && control.host_id !== session.localState.host_id) {
+                throw new Error("Foreground Agent control state belongs to another inference host.");
+              }
+              if (control?.assignment) {
+                assignmentHeartbeatComplete = false;
+                try {
+                  const requestedAt = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+                  const result2 = await session.client.callTool(
+                    "inference.agent.assignment.heartbeat",
+                    {
+                      operation_id: agentOperationId("agent-assignment-heartbeat"),
+                      host_id: session.localState.host_id,
+                      assignment_id: control.assignment.assignment_id,
+                      assignment_generation: control.assignment.assignment_generation,
+                      requested_at: requestedAt
+                    },
+                    { signal: cancellation.signal }
+                  );
+                  assignmentHeartbeatComplete = true;
+                  assignmentHeartbeatCount += 1;
+                  if (result2.directive === "cancel") {
+                    await handleForegroundCancelledAssignment(
+                      config2,
+                      session,
+                      control,
+                      requestedAt,
+                      cancellation.signal
+                    );
+                  } else {
+                    await writeInferenceForegroundAgentControlState(config2.statePath, {
+                      ...control,
+                      assignment: {
+                        ...control.assignment,
+                        lease_expires_at: result2.lease_expires_at
+                      },
+                      updated_at: requestedAt
+                    });
+                  }
+                } catch (error48) {
+                  if (cancellation.signal.aborted) break;
+                  if (!retryableAgentHeartbeatError(error48)) throw error48;
+                  consecutiveHeartbeatFailures += 1;
+                  retryDelayMs = Math.min(
+                    AGENT_HEARTBEAT_INTERVAL_MS * 2 ** Math.max(0, consecutiveHeartbeatFailures - 1),
+                    AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS
+                  );
+                  emitStderr(parsed.json ? `${JSON.stringify({
+                    status: "assignment_heartbeat_retry",
+                    retry_after_ms: retryDelayMs
+                  })}
+` : `Foreground Agent assignment heartbeat was temporarily unavailable; retrying in ${retryDelayMs}ms.
+`);
+                }
+              }
             } finally {
               await commandLock.release();
             }
-            if (parsed.once && (heartbeatCount > 0 || heartbeatSuppressed)) break;
+            if (parsed.once && (heartbeatCount > 0 || heartbeatSuppressed) && assignmentHeartbeatComplete) break;
           }
           if (parsed.once && !commandLock) break;
           await (dependencies.sleep ?? (async (milliseconds) => {
@@ -36577,7 +37540,11 @@ Waiting for approval...
         }
         return {
           exitCode: 0,
-          stdout: render({ status: "stopped", heartbeats: heartbeatCount }, parsed.json),
+          stdout: render({
+            status: "stopped",
+            heartbeats: heartbeatCount,
+            assignment_heartbeats: assignmentHeartbeatCount
+          }, parsed.json),
           stderr: warnings.length > 0 ? `${warnings.join("\n")}
 ` : ""
         };
@@ -36965,7 +37932,7 @@ Waiting for approval...
         if (recoveryRaw === null && existingTransaction?.phase !== "reconciled") {
           throw new Error("Codex recovery evidence changed before service recovery began.");
         }
-        const transactionId = existingTransaction?.transaction_id ?? randomUUID3();
+        const transactionId = existingTransaction?.transaction_id ?? randomUUID4();
         const backupPath = existingTransaction?.recovery_backup_path ?? recoveryBackupPath(config2, transactionId);
         if (!existingTransaction) {
           await writeAtomicInferencePrivateFile(backupPath, recoveryRaw);
@@ -37486,7 +38453,7 @@ var init_types = __esm({
 });
 
 // lib/agent-core/client.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 function normalizeApiUrl(value) {
   const parsed = String(value || "").trim();
   if (!parsed) {
@@ -37748,7 +38715,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/decision", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -37757,7 +38724,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/trade-sync", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -37766,7 +38733,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/error", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -37778,7 +38745,7 @@ var init_client = __esm({
         return this.request("/trading/market-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37786,7 +38753,7 @@ var init_client = __esm({
         return this.request("/trading/limit-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37794,7 +38761,7 @@ var init_client = __esm({
         return this.request("/trading/cancel-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37813,7 +38780,7 @@ var init_client = __esm({
         return this.request("/trading/ai/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37821,7 +38788,7 @@ var init_client = __esm({
         return this.request("/trading/ai/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: {}
         });
       }
@@ -37829,7 +38796,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: {}
         });
       }
@@ -37837,7 +38804,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: {}
         });
       }
@@ -37845,7 +38812,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/session/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37856,7 +38823,7 @@ var init_client = __esm({
           return this.request("/trading/ai/runtime/session/stop", {
             method: "POST",
             profileId,
-            idempotencyKey: randomUUID4(),
+            idempotencyKey: randomUUID5(),
             body: payload
           });
         }
@@ -37873,7 +38840,7 @@ var init_client = __esm({
         }).request("/trading/ai/runtime/session/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37890,7 +38857,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { dirname as dirname6 } from "node:path";
 var parseStoredValues, FileBackedProtectionStorage, clientRuntimeProtectionStatePath;
 var init_protection_storage = __esm({
@@ -37947,7 +38914,7 @@ var init_protection_storage = __esm({
         mkdirSync(dirname6(this.path), { recursive: true, mode: 448 });
         const serialized = `${JSON.stringify(values)}
 `;
-        const temporaryPath = `${this.path}.${process.pid}.${randomUUID5()}.tmp`;
+        const temporaryPath = `${this.path}.${process.pid}.${randomUUID6()}.tmp`;
         try {
           writeFileSync(temporaryPath, serialized, {
             encoding: "utf8",
@@ -37974,7 +38941,7 @@ var init_protection_storage = __esm({
 });
 
 // lib/agent-core/headless-runtime.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 function objectOrNull2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -38072,8 +39039,8 @@ async function runAndReportLocalWorkCycle(options, state, leaseToken, context) {
   return Boolean(result2.decision || tradeSync || result2.afterDecision);
 }
 async function startHeadlessRuntime(options) {
-  const runtimeSessionId = randomUUID6();
-  const deviceId = String(options.deviceId || "").trim() || randomUUID6();
+  const runtimeSessionId = randomUUID7();
+  const deviceId = String(options.deviceId || "").trim() || randomUUID7();
   const startResponse = await options.client.startRuntime(options.profileId, {
     session_id: runtimeSessionId,
     device_id: deviceId,
@@ -60625,7 +61592,7 @@ var headless_local_worker_exports = {};
 __export(headless_local_worker_exports, {
   createHeadlessLocalWorker: () => createHeadlessLocalWorker
 });
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 function objectOrNull3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -61042,7 +62009,7 @@ function createHeadlessLocalWorker(options) {
       const statusMatch = errorText.match(/\b([45]\d{2})\b/);
       const statusCode = statusMatch ? Number(statusMatch[1]) : null;
       const failedInvocation = normalizeAiInvocationTelemetry({
-        client_invocation_id: randomUUID7(),
+        client_invocation_id: randomUUID8(),
         use_case: "trader",
         role: "primary",
         attempt_index: 0,
@@ -61098,7 +62065,7 @@ function createHeadlessLocalWorker(options) {
       billable_cached_input_tokens: normalizedUsage.cached_input_tokens
     };
     const invocation = normalizeAiInvocationTelemetry({
-      client_invocation_id: randomUUID7(),
+      client_invocation_id: randomUUID8(),
       use_case: "trader",
       role: "primary",
       attempt_index: 0,
@@ -61317,7 +62284,7 @@ var vtx_exports = {};
 __export(vtx_exports, {
   runVtxCli: () => runVtxCli
 });
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { spawn as spawn8 } from "node:child_process";
 function render2(value, json2) {
   if (json2) {
@@ -61731,8 +62698,8 @@ async function runVtxCli(argv2, env = process.env) {
         });
         return { exitCode: 0, stdout: render2(redactCliOutput(response2), json2), stderr: "" };
       }
-      const runtimeSessionId = randomUUID8();
-      const deviceId = config2.runtimeDeviceId ?? randomUUID8();
+      const runtimeSessionId = randomUUID9();
+      const deviceId = config2.runtimeDeviceId ?? randomUUID9();
       const response = await client.startRuntime(profileId, {
         session_id: runtimeSessionId,
         device_id: deviceId,