@vtxmacro/cli 2026.9.68 → 2026.10.1

package/bin/vtx.js

@@ -77,7 +77,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.68",
+      package_version: "2026.10.1",
       codex_package_name: "@openai/codex",
       codex_version: "0.155.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -17607,9 +17607,9 @@ var init_mcp_transport_config = __esm({
 import { randomBytes } from "node:crypto";
 import { spawn } from "node:child_process";
 import { constants } from "node:fs";
-import { lstat, mkdir, open, readFile, realpath, rename, rm } from "node:fs/promises";
+import { lstat, mkdir, open, readdir, readFile, realpath, rename, rm } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, isAbsolute as isAbsolute2, join, relative, resolve, win32 as windowsPath } from "node:path";
+import { basename, dirname, isAbsolute as isAbsolute2, join, relative, resolve, win32 as windowsPath } from "node:path";
 function inferenceBaseDir(env) {
   const configured = String(env.VTX_INFERENCE_HOST_HOME || "").trim();
   return configured || join(homedir(), ".vtx", "inference-host");
@@ -18012,146 +18012,65 @@ async function acquireInferenceHostProcessLock(path, dependencies = {}) {
   const directory2 = dirname(path);
   await ensureInferencePrivateDirectory(directory2);
   const ownerToken = randomBytes(24).toString("base64url");
-  const observeIdentity = dependencies.processIdentity ?? defaultProcessIdentity;
-  const currentBootIdentity = dependencies.currentBootIdentity ?? (() => readInferenceSystemBootIdentity());
-  const isProcessAlive = dependencies.processAlive ?? ((pid) => {
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch (error48) {
-      if (error48.code === "ESRCH") return false;
-      throw error48;
-    }
-  });
-  let handle;
-  for (let acquisition = 0; acquisition < 2; acquisition += 1) {
-    try {
-      handle = await open(
-        path,
-        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
-        384
-      );
-      break;
-    } catch (error48) {
-      if (error48.code !== "EEXIST") throw error48;
-      if (acquisition > 0) {
-        throw new InferenceHostProcessLockBusyError();
-      }
-      let before;
+  const probes = {
+    currentBootIdentity: dependencies.currentBootIdentity ?? (() => readInferenceSystemBootIdentity()),
+    observeIdentity: dependencies.processIdentity ?? defaultProcessIdentity,
+    isProcessAlive: dependencies.processAlive ?? ((pid) => {
       try {
-        before = await lstat(path);
-      } catch (error49) {
-        if (error49.code === "ENOENT") continue;
-        throw error49;
-      }
-      if (before.isSymbolicLink() || !before.isFile() || process.platform !== "win32" && (before.mode & 63) !== 0 || typeof process.getuid === "function" && before.uid !== process.getuid()) {
-        throw new Error("Inference host process lock is unsafe.");
-      }
-      const reclaimPublicationResidue = async () => {
-        let current2;
-        try {
-          current2 = await lstat(path);
-        } catch (error49) {
-          if (error49.code === "ENOENT") return false;
-          throw error49;
-        }
-        if (current2.isSymbolicLink() || !current2.isFile() || current2.dev !== before.dev || current2.ino !== before.ino || process.platform !== "win32" && (current2.mode & 63) !== 0 || typeof process.getuid === "function" && current2.uid !== process.getuid()) {
-          throw new Error("Inference host process lock publication residue changed or is unsafe.");
-        }
-        try {
-          await rm(path);
-        } catch (error49) {
-          if (error49.code === "ENOENT") return false;
-          throw error49;
-        }
-        processLockObservationCache.delete(resolve(path));
-        await syncInferenceDirectory(directory2);
+        process.kill(pid, 0);
         return true;
-      };
-      try {
-        await secureExistingWindowsPath(path, "file");
-      } catch (error49) {
-        if (error49.code === "ENOENT") continue;
-        throw error49;
+      } catch (error48) {
+        if (error48.code === "ESRCH") return false;
+        throw error48;
       }
-      let staleOwner;
+    })
+  };
+  const [ownerIdentity, bootIdentity] = await Promise.all([
+    (dependencies.currentProcessIdentity ?? defaultCurrentProcessIdentity)(),
+    probes.currentBootIdentity()
+  ]);
+  const ownerRecord = (token) => `${JSON.stringify({
+    schema_version: 2,
+    pid: process.pid,
+    owner_token: token,
+    process_identity: ownerIdentity,
+    boot_identity: bootIdentity
+  })}
+`;
+  let handle = await openExclusiveProcessLockFile(path);
+  if (!handle) {
+    const inspection = await inspectProcessLockFile(path, PROCESS_LOCK_LABEL, probes);
+    if (inspection.state === "busy") throw new InferenceHostProcessLockBusyError();
+    if (inspection.state === "stale") {
+      await inspection.handle.close();
+      const guard = await acquireProcessLockReclaimGuard(path, ownerRecord, probes);
       try {
-        staleOwner = JSON.parse(await readFile(path, "utf8"));
-      } catch (error49) {
-        if (error49.code === "ENOENT") continue;
-        if (Date.now() - before.mtimeMs < 1e4) {
-          throw new InferenceHostProcessLockBusyError();
-        }
-        await reclaimPublicationResidue();
-        continue;
-      }
-      if (staleOwner.schema_version !== 2 || !Number.isSafeInteger(staleOwner.pid) || Number(staleOwner.pid) < 1 || typeof staleOwner.owner_token !== "string" || !staleOwner.owner_token || typeof staleOwner.process_identity !== "string" || !staleOwner.process_identity || typeof staleOwner.boot_identity !== "string" || !staleOwner.boot_identity) {
-        if (Date.now() - before.mtimeMs < 1e4) {
-          throw new InferenceHostProcessLockBusyError();
+        const guarded = await inspectProcessLockFile(path, PROCESS_LOCK_LABEL, probes);
+        if (guarded.state === "busy") throw new InferenceHostProcessLockBusyError();
+        if (guarded.state === "stale") {
+          await removeVerifiedStaleProcessLockFile(path, guarded, guard.assertHeld);
         }
-        await reclaimPublicationResidue();
-        continue;
-      }
-      const stalePid = Number(staleOwner.pid);
-      const bootIdentity2 = await currentBootIdentity();
-      if (bootIdentity2 === staleOwner.boot_identity && isProcessAlive(stalePid)) {
-        const cached2 = processLockObservationCache.get(resolve(path));
-        const observedIdentity = cached2 && cached2.dev === before.dev && cached2.ino === before.ino && cached2.pid === stalePid && cached2.storedIdentity === staleOwner.process_identity && Date.now() - cached2.observedAtMs < 5e3 ? cached2.observedIdentity : await observeIdentity(stalePid);
-        if (!observedIdentity) {
-          throw new Error("Inference host could not verify the existing lock owner identity.");
-        }
-        processLockObservationCache.set(resolve(path), {
-          dev: before.dev,
-          ino: before.ino,
-          pid: stalePid,
-          storedIdentity: staleOwner.process_identity,
-          observedIdentity,
-          observedAtMs: Date.now()
-        });
-        if (inferenceProcessIdentitiesMatch(staleOwner.process_identity, observedIdentity)) {
-          throw new InferenceHostProcessLockBusyError();
-        }
-      }
-      let current;
-      try {
-        current = await lstat(path);
-      } catch (error49) {
-        if (error49.code === "ENOENT") continue;
-        throw error49;
-      }
-      if (current.dev !== before.dev || current.ino !== before.ino) {
-        throw new Error("Inference host process lock ownership changed.");
+        handle = await openExclusiveProcessLockFile(path);
+      } finally {
+        await guard.release();
       }
-      await rm(path);
-      processLockObservationCache.delete(resolve(path));
-      await syncInferenceDirectory(directory2);
+    } else {
+      handle = await openExclusiveProcessLockFile(path);
     }
+    if (!handle) throw new InferenceHostProcessLockBusyError();
   }
-  if (!handle) throw new Error("Inference host process lock could not be acquired.");
-  let ownerIdentity;
-  let bootIdentity;
   try {
-    [ownerIdentity, bootIdentity] = await Promise.all([
-      (dependencies.currentProcessIdentity ?? defaultCurrentProcessIdentity)(),
-      currentBootIdentity()
-    ]);
+    await handle.writeFile(ownerRecord(ownerToken), "utf8");
+    await handle.sync();
   } catch (error48) {
+    const created = await handle.stat().catch(() => null);
     await handle.close().catch(() => void 0);
-    await rm(path, { force: true }).catch(() => void 0);
+    const current = await lstat(path).catch(() => null);
+    if (created && current && current.dev === created.dev && current.ino === created.ino) {
+      await rm(path, { force: true }).catch(() => void 0);
+    }
     throw error48;
   }
-  await handle.writeFile(
-    `${JSON.stringify({
-      schema_version: 2,
-      pid: process.pid,
-      owner_token: ownerToken,
-      process_identity: ownerIdentity,
-      boot_identity: bootIdentity
-    })}
-`,
-    "utf8"
-  );
-  await handle.sync();
   await handle.close();
   await secureWindowsPrivatePath(path, "file", "harden");
   await syncInferenceDirectory(directory2);
@@ -18176,7 +18095,7 @@ async function acquireInferenceHostProcessLock(path, dependencies = {}) {
     }
   };
 }
-var loadInferenceReceiptDurabilityTimeoutMs, loadInferenceAgentDataRequestTimeoutMs, loadInferenceAgentCommandLockPolicy, InferenceHostProcessLockBusyError, INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS, WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS, SMALL_IDENTITY_COMMAND_TIMEOUT_MS, windowsPowerShellEnvironment, windowsPrivateAclBrokerInvocation, WindowsPrivateAclBroker, defaultWindowsPrivateAclBroker, runWindowsPrivateAcl, windowsAclCache, windowsAclIdentity, aclCacheKey, secureWindowsPrivatePath, invalidateWindowsAclCache, rebindHardenedWindowsAclAfterRename, rebindHardenedWindowsDirectoryAfterOwnedMutation, isDefaultWindowsPrivatePath, secureExistingWindowsPath, linuxProcessIdentity, windowsProcessIdentityInvocation, windowsBootIdentityInvocation, windowsProcessIdentity, darwinProcessIdentity, runSmallIdentityCommand, cachedSystemBootIdentity, readInferenceSystemBootIdentity, defaultProcessIdentity, defaultCurrentProcessIdentity, readInferenceHostProcessLockStatus, processLockObservationCache, inferenceProcessIdentitiesMatch, DEFAULT_INFERENCE_HOST_INSTANCE, SAFE_INFERENCE_HOST_INSTANCE, requireNamedInstancePath, credentialStoreIdentity, inferenceHostCredentialContextPath, inferenceHostCredentialContextTransitionPath, credentialContextForConfig, WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES;
+var loadInferenceReceiptDurabilityTimeoutMs, loadInferenceAgentDataRequestTimeoutMs, loadInferenceAgentCommandLockPolicy, InferenceHostProcessLockBusyError, INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS, WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS, SMALL_IDENTITY_COMMAND_TIMEOUT_MS, windowsPowerShellEnvironment, windowsPrivateAclBrokerInvocation, WindowsPrivateAclBroker, defaultWindowsPrivateAclBroker, runWindowsPrivateAcl, windowsAclCache, windowsAclIdentity, aclCacheKey, secureWindowsPrivatePath, invalidateWindowsAclCache, rebindHardenedWindowsAclAfterRename, rebindHardenedWindowsDirectoryAfterOwnedMutation, isDefaultWindowsPrivatePath, secureExistingWindowsPath, linuxProcessIdentity, windowsProcessIdentityInvocation, windowsBootIdentityInvocation, windowsProcessIdentity, darwinProcessIdentity, runSmallIdentityCommand, cachedSystemBootIdentity, readInferenceSystemBootIdentity, defaultProcessIdentity, cachedCurrentProcessIdentity, defaultCurrentProcessIdentity, readInferenceHostProcessLockStatus, processLockObservationCache, inferenceProcessIdentitiesMatch, DEFAULT_INFERENCE_HOST_INSTANCE, SAFE_INFERENCE_HOST_INSTANCE, requireNamedInstancePath, credentialStoreIdentity, inferenceHostCredentialContextPath, inferenceHostCredentialContextTransitionPath, credentialContextForConfig, WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES, PROCESS_LOCK_PUBLICATION_GRACE_MS, PROCESS_LOCK_MAX_RECORD_BYTES, PROCESS_LOCK_GUARD_ELECTION_LEASE_MS, PROCESS_LOCK_GUARD_ELECTION_STALE_MS, PROCESS_LOCK_GUARD_ELECTION_ATTEMPTS, PROCESS_LOCK_GUARD_ELECTION_BACKOFF_MS, PROCESS_LOCK_LABEL, PROCESS_LOCK_GUARD_LABEL, sameProcessLockFile, openExclusiveProcessLockFile, inspectProcessLockFile, removeVerifiedStaleProcessLockFile, removeStaleProcessLockReclaimGuard, acquireProcessLockReclaimGuard;
 var init_config = __esm({
   "lib/inference-host/config.ts"() {
     "use strict";
@@ -18770,10 +18689,22 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
       if (process.platform === "darwin") return await darwinProcessIdentity(pid);
       return null;
     };
+    cachedCurrentProcessIdentity = null;
     defaultCurrentProcessIdentity = async () => {
-      const identity2 = await defaultProcessIdentity(process.pid);
-      if (!identity2) throw new Error("Inference host could not establish its process-start identity.");
-      return identity2;
+      if (!cachedCurrentProcessIdentity) {
+        cachedCurrentProcessIdentity = (async () => {
+          const identity2 = await defaultProcessIdentity(process.pid);
+          if (!identity2) throw new Error("Inference host could not establish its process-start identity.");
+          return identity2;
+        })();
+      }
+      const pending3 = cachedCurrentProcessIdentity;
+      try {
+        return await pending3;
+      } catch (error48) {
+        if (cachedCurrentProcessIdentity === pending3) cachedCurrentProcessIdentity = null;
+        throw error48;
+      }
     };
     readInferenceHostProcessLockStatus = async (path) => {
       const raw = await readInferencePrivateFile(path, "Inference host process lock");
@@ -18836,6 +18767,242 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
       "ENOTEMPTY",
       "EPERM"
     ]);
+    PROCESS_LOCK_PUBLICATION_GRACE_MS = 1e4;
+    PROCESS_LOCK_MAX_RECORD_BYTES = 64 * 1024;
+    PROCESS_LOCK_GUARD_ELECTION_LEASE_MS = 5e3;
+    PROCESS_LOCK_GUARD_ELECTION_STALE_MS = 3e4;
+    PROCESS_LOCK_GUARD_ELECTION_ATTEMPTS = 8;
+    PROCESS_LOCK_GUARD_ELECTION_BACKOFF_MS = 10;
+    PROCESS_LOCK_LABEL = "Inference host process lock";
+    PROCESS_LOCK_GUARD_LABEL = "Inference host process lock reclamation guard";
+    sameProcessLockFile = (left, right) => left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+    openExclusiveProcessLockFile = async (path) => {
+      try {
+        return await open(
+          path,
+          constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+          384
+        );
+      } catch (error48) {
+        if (error48.code === "EEXIST") return null;
+        throw error48;
+      }
+    };
+    inspectProcessLockFile = async (path, label, probes) => {
+      let before;
+      try {
+        before = await lstat(path);
+      } catch (error48) {
+        if (error48.code === "ENOENT") return { state: "missing" };
+        throw error48;
+      }
+      if (before.isSymbolicLink() || !before.isFile() || process.platform !== "win32" && (before.mode & 63) !== 0 || typeof process.getuid === "function" && before.uid !== process.getuid()) {
+        throw new Error(`${label} is unsafe.`);
+      }
+      let handle;
+      try {
+        await secureExistingWindowsPath(path, "file");
+        handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+      } catch (error48) {
+        if (error48.code === "ENOENT") return { state: "missing" };
+        throw error48;
+      }
+      let stale = false;
+      try {
+        const opened = await handle.stat();
+        if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) {
+          return { state: "busy" };
+        }
+        const raw = opened.size > PROCESS_LOCK_MAX_RECORD_BYTES ? "" : await handle.readFile("utf8");
+        const stat = await handle.stat();
+        if (!sameProcessLockFile(opened, stat)) return { state: "busy" };
+        let record5 = null;
+        try {
+          const parsed = JSON.parse(raw);
+          if (parsed && typeof parsed === "object") record5 = parsed;
+        } catch {
+          record5 = null;
+        }
+        if (!record5 || record5.schema_version !== 2 || !Number.isSafeInteger(record5.pid) || Number(record5.pid) < 1 || typeof record5.owner_token !== "string" || !record5.owner_token || typeof record5.process_identity !== "string" || !record5.process_identity || typeof record5.boot_identity !== "string" || !record5.boot_identity) {
+          if (Date.now() - stat.mtimeMs < PROCESS_LOCK_PUBLICATION_GRACE_MS) return { state: "busy" };
+          stale = true;
+          return { state: "stale", handle, stat };
+        }
+        const ownerPid = Number(record5.pid);
+        const storedIdentity = record5.process_identity;
+        const cacheKey = resolve(path);
+        if (await probes.currentBootIdentity() === record5.boot_identity && probes.isProcessAlive(ownerPid)) {
+          const cached2 = processLockObservationCache.get(cacheKey);
+          const observedIdentity = cached2 && cached2.dev === stat.dev && cached2.ino === stat.ino && cached2.pid === ownerPid && cached2.storedIdentity === storedIdentity && Date.now() - cached2.observedAtMs < 5e3 ? cached2.observedIdentity : await probes.observeIdentity(ownerPid);
+          if (!observedIdentity) {
+            throw new Error("Inference host could not verify the existing lock owner identity.");
+          }
+          processLockObservationCache.set(cacheKey, {
+            dev: stat.dev,
+            ino: stat.ino,
+            pid: ownerPid,
+            storedIdentity,
+            observedIdentity,
+            observedAtMs: Date.now()
+          });
+          if (inferenceProcessIdentitiesMatch(storedIdentity, observedIdentity)) {
+            return { state: "busy" };
+          }
+        }
+        stale = true;
+        return { state: "stale", handle, stat };
+      } finally {
+        if (!stale) await handle.close().catch(() => void 0);
+      }
+    };
+    removeVerifiedStaleProcessLockFile = async (path, inspection, assertExclusive) => {
+      try {
+        await assertExclusive();
+        let current;
+        try {
+          current = await lstat(path);
+        } catch (error48) {
+          if (error48.code === "ENOENT") return;
+          throw error48;
+        }
+        const opened = await inspection.handle.stat();
+        if (current.isSymbolicLink() || !sameProcessLockFile(current, opened) || !sameProcessLockFile(opened, inspection.stat)) {
+          throw new InferenceHostProcessLockBusyError();
+        }
+        if (process.platform === "win32") await inspection.handle.close();
+        try {
+          await rm(path);
+        } catch (error48) {
+          if (error48.code !== "ENOENT") throw error48;
+        }
+      } finally {
+        await inspection.handle.close().catch(() => void 0);
+      }
+      processLockObservationCache.delete(resolve(path));
+      invalidateWindowsAclCache(path);
+      await syncInferenceDirectory(dirname(path));
+    };
+    removeStaleProcessLockReclaimGuard = async (lockPath, guardPath, inspection) => {
+      const directory2 = dirname(lockPath);
+      const prefix = `${basename(lockPath)}.reclaim-ballot.`;
+      try {
+        for (let attempt = 0; attempt < PROCESS_LOCK_GUARD_ELECTION_ATTEMPTS; attempt += 1) {
+          if (attempt > 0) {
+            await new Promise((resolvePromise) => setTimeout(
+              resolvePromise,
+              Math.floor(Math.random() * PROCESS_LOCK_GUARD_ELECTION_BACKOFF_MS * 2 ** Math.min(attempt, 4))
+            ));
+            let current;
+            try {
+              current = await lstat(guardPath);
+            } catch (error48) {
+              if (error48.code === "ENOENT") return;
+              throw error48;
+            }
+            if (!sameProcessLockFile(current, inspection.stat)) return;
+          }
+          const ballotName = `${prefix}${randomBytes(16).toString("hex")}`;
+          const ballotPath = join(directory2, ballotName);
+          const ballot = await openExclusiveProcessLockFile(ballotPath);
+          if (!ballot) continue;
+          await ballot.close();
+          const electedAt = performance.now();
+          try {
+            let contested = false;
+            for (const name of await readdir(directory2)) {
+              if (!name.startsWith(prefix) || name === ballotName) continue;
+              const otherPath = join(directory2, name);
+              let other;
+              try {
+                other = await lstat(otherPath);
+              } catch (error48) {
+                if (error48.code === "ENOENT") continue;
+                throw error48;
+              }
+              if (!other.isDirectory() && Date.now() - other.mtimeMs > PROCESS_LOCK_GUARD_ELECTION_STALE_MS) {
+                await rm(otherPath, { force: true });
+                continue;
+              }
+              contested = true;
+            }
+            if (contested) continue;
+            await removeVerifiedStaleProcessLockFile(guardPath, inspection, async () => {
+              if (performance.now() - electedAt > PROCESS_LOCK_GUARD_ELECTION_LEASE_MS) {
+                throw new InferenceHostProcessLockBusyError();
+              }
+            });
+            return;
+          } finally {
+            await rm(ballotPath, { force: true }).catch(() => void 0);
+          }
+        }
+        throw new InferenceHostProcessLockBusyError();
+      } finally {
+        await inspection.handle.close().catch(() => void 0);
+      }
+    };
+    acquireProcessLockReclaimGuard = async (lockPath, ownerRecord, probes) => {
+      const guardPath = `${lockPath}.reclaim`;
+      const guardToken = randomBytes(24).toString("base64url");
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        const handle = await openExclusiveProcessLockFile(guardPath);
+        if (handle) {
+          try {
+            await handle.writeFile(ownerRecord(guardToken), "utf8");
+          } catch (error48) {
+            await handle.close().catch(() => void 0);
+            await rm(guardPath, { force: true }).catch(() => void 0);
+            throw error48;
+          }
+          await handle.close();
+          await secureWindowsPrivatePath(guardPath, "file", "harden");
+          const isHeld = async () => {
+            let reader;
+            try {
+              reader = await open(guardPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+            } catch (error48) {
+              if (error48.code === "ENOENT") return false;
+              throw error48;
+            }
+            try {
+              const [opened, current] = await Promise.all([reader.stat(), lstat(guardPath)]);
+              if (current.isSymbolicLink() || current.dev !== opened.dev || current.ino !== opened.ino) {
+                return false;
+              }
+              const parsed = JSON.parse(await reader.readFile("utf8"));
+              return parsed.owner_token === guardToken;
+            } catch {
+              return false;
+            } finally {
+              await reader.close().catch(() => void 0);
+            }
+          };
+          return {
+            assertHeld: async () => {
+              if (!await isHeld()) throw new InferenceHostProcessLockBusyError();
+            },
+            // Best effort: a guard left behind carries this live process identity
+            // and becomes reclaimable once this process exits.
+            release: async () => {
+              try {
+                if (!await isHeld()) return;
+                await rm(guardPath);
+                processLockObservationCache.delete(resolve(guardPath));
+                invalidateWindowsAclCache(guardPath);
+              } catch {
+              }
+            }
+          };
+        }
+        if (attempt > 0) break;
+        const inspection = await inspectProcessLockFile(guardPath, PROCESS_LOCK_GUARD_LABEL, probes);
+        if (inspection.state === "busy") break;
+        if (inspection.state === "stale") {
+          await removeStaleProcessLockReclaimGuard(lockPath, guardPath, inspection);
+        }
+      }
+      throw new InferenceHostProcessLockBusyError();
+    };
   }
 });
 
@@ -21111,6 +21278,7 @@ var init_mcp_client = __esm({
     agentDecisionTimingSchema = external_exports.strictObject({
       analysis_started_at: timestampSchema2,
       model_latency_ms: external_exports.number().int().nonnegative().nullable(),
+      analysis_duration_ms: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).nullable().optional(),
       model_latency_source: external_exports.literal("harness_invocation").nullable()
     }).refine((timing) => timing.model_latency_ms === null === (timing.model_latency_source === null), {
       message: "Model latency and its measurement source must be supplied together."
@@ -21123,7 +21291,7 @@ var init_mcp_client = __esm({
       observed_at: timestampSchema2,
       timing: agentDecisionTimingSchema.optional(),
       provenance: jsonObjectSchema.nullable().optional()
-    }).refine((request) => !request.timing || Date.parse(request.timing.analysis_started_at) <= Date.parse(request.observed_at), {
+    }).refine((request) => !request.timing || Date.parse(request.timing.analysis_started_at) <= Date.parse(request.observed_at) && (request.timing.analysis_duration_ms == null || request.timing.analysis_duration_ms <= Date.parse(request.observed_at) - Date.parse(request.timing.analysis_started_at)), {
       message: "Analysis start must precede decision observation."
     });
     agentDecisionSubmitResultSchema = external_exports.strictObject({
@@ -21477,6 +21645,7 @@ var init_mcp_client = __esm({
       #initialized = false;
       #providerQuotaRecoverySupported = false;
       #providerCreditsSupported = false;
+      #agentAnalysisDurationSupported = false;
       #runtimeRecoveryDiagnosticsSupported = false;
       #providerHttpStatusTools = /* @__PURE__ */ new Set();
       #grokToolValidationTools = /* @__PURE__ */ new Set();
@@ -21523,6 +21692,18 @@ var init_mcp_client = __esm({
       supportsRuntimeRecoveryDiagnostics() {
         return this.#runtimeRecoveryDiagnosticsSupported;
       }
+      supportsAgentAnalysisDuration() {
+        return this.#agentAnalysisDurationSupported;
+      }
+      async refreshAgentAnalysisDurationSupport(options = {}) {
+        if (this.supportsAgentAnalysisDuration()) return true;
+        try {
+          await this.initialize(options);
+        } catch {
+          return false;
+        }
+        return this.supportsAgentAnalysisDuration();
+      }
       supportsProviderCredits() {
         return this.#providerCreditsSupported;
       }
@@ -21603,6 +21784,20 @@ var init_mcp_client = __esm({
           return Array.isArray(node.anyOf) && node.anyOf.some((branch) => advertisesCredits(branch, depth + 1));
         };
         this.#providerCreditsSupported = advertisesCredits(hostHeartbeatSchema?.properties?.provider_weekly_quota);
+        const decisionSchema = listed.tools.find(
+          (tool) => tool.name === "inference.agent.decision.submit"
+        )?.inputSchema;
+        const advertisesAnalysisDuration = (value, depth = 0) => {
+          if (depth > 4 || !value || typeof value !== "object" || Array.isArray(value)) return false;
+          const node = value;
+          if (node.properties && typeof node.properties === "object" && Object.hasOwn(node.properties, "analysis_duration_ms")) return true;
+          if (typeof node.$ref === "string" && /^#\/\$defs\/[^/]+$/u.test(node.$ref)) {
+            const definition = node.$ref.slice("#/$defs/".length).replace(/~1/gu, "/").replace(/~0/gu, "~");
+            return advertisesAnalysisDuration(decisionSchema?.$defs?.[definition], depth + 1);
+          }
+          return Array.isArray(node.anyOf) && node.anyOf.some((branch) => advertisesAnalysisDuration(branch, depth + 1));
+        };
+        this.#agentAnalysisDurationSupported = advertisesAnalysisDuration(decisionSchema?.properties?.timing);
         this.#grokToolValidationTools.clear();
         if (advertisesFields("inference.job.fail", ["grok_tool_validation"])) {
           this.#grokToolValidationTools.add("inference.job.fail");
@@ -30901,7 +31096,7 @@ async function clearInferenceAgentNextState(statePath) {
     "Agent-driven inference next recovery state"
   );
 }
-var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, assertDecisionTiming, inferenceAgentRuntimeStatePath, inferenceAgentFailureFencePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentFailureFence, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
+var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, measureAgentReviewTiming, assertDecisionTiming, inferenceAgentRuntimeStatePath, inferenceAgentFailureFencePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentFailureFence, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
 var init_agent_state = __esm({
   "lib/inference-host/agent-state.ts"() {
     "use strict";
@@ -30912,9 +31107,20 @@ var init_agent_state = __esm({
     init_external_inference_contract();
     inferenceAgentAttemptStatePath = (statePath) => `${statePath}.agent-attempt.json`;
     inferenceAgentNextStatePath = (statePath) => `${statePath}.agent-next.json`;
+    measureAgentReviewTiming = (analysisStartedAt, observedAt, measureDuration = true) => ({
+      analysis_started_at: analysisStartedAt,
+      model_latency_ms: null,
+      model_latency_source: null,
+      ...measureDuration ? { analysis_duration_ms: Date.parse(observedAt) - Date.parse(analysisStartedAt) } : {}
+    });
     assertDecisionTiming = (value, observedAt, message) => {
       const timing = assertPlainObject(value, message);
-      if (!hasExactKeys(timing, ["analysis_started_at", "model_latency_ms", "model_latency_source"]) || !isIsoTimestamp(timing.analysis_started_at) || Date.parse(timing.analysis_started_at) > Date.parse(String(observedAt)) || (timing.model_latency_ms === null ? timing.model_latency_source !== null : !Number.isSafeInteger(timing.model_latency_ms) || Number(timing.model_latency_ms) < 0 || timing.model_latency_source !== "harness_invocation")) throw new Error(message);
+      if (!hasExactKeys(timing, [
+        "analysis_started_at",
+        "model_latency_ms",
+        "model_latency_source",
+        ..."analysis_duration_ms" in timing ? ["analysis_duration_ms"] : []
+      ]) || !isIsoTimestamp(timing.analysis_started_at) || Date.parse(timing.analysis_started_at) > Date.parse(String(observedAt)) || timing.analysis_duration_ms != null && (!Number.isSafeInteger(timing.analysis_duration_ms) || Number(timing.analysis_duration_ms) < 0 || Number(timing.analysis_duration_ms) > Date.parse(String(observedAt)) - Date.parse(timing.analysis_started_at)) || (timing.model_latency_ms === null ? timing.model_latency_source !== null : !Number.isSafeInteger(timing.model_latency_ms) || Number(timing.model_latency_ms) < 0 || timing.model_latency_source !== "harness_invocation")) throw new Error(message);
     };
     inferenceAgentRuntimeStatePath = (statePath) => `${statePath}.codex-agent-runtime.json`;
     inferenceAgentFailureFencePath = (statePath) => `${statePath}.agent-failure-fence.json`;
@@ -34609,6 +34815,7 @@ var init_runner = __esm({
       }
     };
     createInferenceAgentControlClient = (mcp) => ({
+      supportsAgentAnalysisDuration: async (options = {}) => mcp.supportsAgentAnalysisDuration?.() === true || await mcp.refreshAgentAnalysisDurationSupport?.(options) === true,
       supportsProviderHttpStatusDiagnostics: async (options = {}) => mcp.supportsProviderHttpStatusDiagnostics?.("inference.agent.assignment.heartbeat") === true || await mcp.refreshProviderHttpStatusSupport?.("inference.agent.assignment.heartbeat", options) === true,
       supportsGrokResponseIdentityDiagnostics: async (options = {}) => mcp.supportsGrokResponseIdentityDiagnostics?.("inference.agent.assignment.heartbeat") === true || await mcp.refreshGrokResponseIdentitySupport?.("inference.agent.assignment.heartbeat", options) === true,
       supportsGrokToolValidationDiagnostics: async (options = {}) => mcp.supportsGrokToolValidationDiagnostics?.("inference.agent.assignment.heartbeat") === true || await mcp.refreshGrokToolValidationSupport?.("inference.agent.assignment.heartbeat", options) === true,
@@ -35028,15 +35235,19 @@ var init_runner = __esm({
                 if (state.pending_decision) {
                   return { success: false, value: { error: "decision_outcome_unresolved" } };
                 }
+                const measureDuration = state.pending_turn.decision_operation_ids.length === 0 && await this.options.controlClient.supportsAgentAnalysisDuration?.({ signal: turnAbort.signal }) === true;
+                const observedAt = nowIso();
                 const pending3 = {
                   operation_id: randomUUID(),
                   candidate,
-                  observed_at: nowIso(),
-                  timing: {
-                    analysis_started_at: state.pending_turn.started_at,
-                    model_latency_ms: null,
-                    model_latency_source: null
-                  },
+                  observed_at: observedAt,
+                  // A later decision in the same turn has no independent review
+                  // boundary. Do not report the whole turn again as its duration.
+                  timing: measureAgentReviewTiming(
+                    state.pending_turn.started_at,
+                    observedAt,
+                    measureDuration
+                  ),
                   provenance: {
                     source: "external_agent",
                     agent_run_id: liveThread.threadId,
@@ -35920,7 +36131,7 @@ import {
   lstat as lstat3,
   mkdir as mkdir2,
   mkdtemp,
-  readdir,
+  readdir as readdir2,
   readFile as readFile4,
   realpath as realpath3,
   rm as rm3
@@ -36358,7 +36569,7 @@ var init_codex_adapter = __esm({
         if (!directoryState.isDirectory() || directoryState.isSymbolicLink() || typeof process.getuid === "function" && directoryState.uid !== process.getuid()) {
           throw new Error("Codex recovery home contains an unsafe directory.");
         }
-        const entries = await readdir(current.path, { withFileTypes: true });
+        const entries = await readdir2(current.path, { withFileTypes: true });
         for (const entry of entries) {
           entriesSeen += 1;
           if (entriesSeen > 2e4) {
@@ -38453,7 +38664,7 @@ var init_deepseek_transport_proxy = __esm({
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { mkdtemp as mkdtemp3, realpath as realpath4, rm as rm5 } from "node:fs/promises";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename, dirname as dirname4, join as join6 } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join6 } from "node:path";
 import { Context } from "@deepseek-ai/cordis";
 import * as AgentSpine from "@deepseek-ai/dsh-agent-spine-demo";
 import {
@@ -39111,7 +39322,7 @@ ${JSON.stringify(input.outputSchema)}`,
         }
         const resolved = await realpath4(thread.threadPath);
         const temporaryRoot = await realpath4(tmpdir4());
-        if (dirname4(resolved) !== temporaryRoot || !basename(resolved).startsWith("vtx-deepseek-harness-")) throw new Error("deepseek_harness_thread_path_not_owned");
+        if (dirname4(resolved) !== temporaryRoot || !basename2(resolved).startsWith("vtx-deepseek-harness-")) throw new Error("deepseek_harness_thread_path_not_owned");
         await rm5(resolved, { recursive: true, force: true });
       }
       async close() {
@@ -39317,8 +39528,8 @@ var init_pi_transport = __esm({
 
 // lib/inference-host/pi-adapter.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { lstat as lstat4, realpath as realpath5, rm as rm6, readdir as readdir2 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname5, join as join7, resolve as resolve4 } from "node:path";
+import { lstat as lstat4, realpath as realpath5, rm as rm6, readdir as readdir3 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname5, join as join7, resolve as resolve4 } from "node:path";
 import {
   createAgentSession,
   DefaultResourceLoader,
@@ -39481,7 +39692,7 @@ var init_pi_adapter = __esm({
       async ownedThread(thread) {
         const root = await realpath5(this.dependencies.stateRoot);
         const supplied = resolve4(thread.threadPath);
-        if (dirname5(supplied) !== root || basename2(supplied) !== `agent-${thread.threadId}` || !/^[a-f0-9-]{36}$/u.test(thread.threadId)) throw fail("pi_thread_not_owned");
+        if (dirname5(supplied) !== root || basename3(supplied) !== `agent-${thread.threadId}` || !/^[a-f0-9-]{36}$/u.test(thread.threadId)) throw fail("pi_thread_not_owned");
         const info = await lstat4(supplied);
         if (info.isSymbolicLink() || !info.isDirectory()) throw fail("pi_thread_not_owned");
         if (await realpath5(supplied) !== supplied) throw fail("pi_thread_not_owned");
@@ -39564,7 +39775,7 @@ var init_pi_adapter = __esm({
             const selection = manager.buildSessionContext().model;
             if (!selection || selection.provider !== model.provider || selection.modelId !== model.id) throw fail("pi_thread_binding_changed", "model");
           } else if (agent) {
-            const initial = SessionManager.inMemory(cwd, { id: basename2(cwd).slice("agent-".length) });
+            const initial = SessionManager.inMemory(cwd, { id: basename3(cwd).slice("agent-".length) });
             await writeAtomicInferencePrivateFile(sessionFile, `${JSON.stringify(initial.getHeader())}
 `);
             manager = SessionManager.open(sessionFile, cwd, cwd);
@@ -39635,7 +39846,7 @@ var init_pi_adapter = __esm({
           if (created.modelFallbackMessage || session.model?.id !== model.id || session.model.provider !== model.provider || session.thinkingLevel !== thinkingLevel) throw fail("pi_effective_selection_mismatch", "model");
           if (session.getActiveToolNames().sort().join(",") !== (agent ? [...CODEX_AGENT_DYNAMIC_TOOLS].sort().join(",") : "")) throw fail("pi_tool_isolation_failed");
           if (agent) {
-            const threadId = basename2(cwd).slice("agent-".length);
+            const threadId = basename3(cwd).slice("agent-".length);
             thread = { threadId, threadPath: cwd, effectiveModel: input.requestedModel, effectiveReasoningEffort: input.requestedReasoningEffort };
             await agent.onThreadReady?.(thread);
             published = true;
@@ -39830,11 +40041,11 @@ var init_pi_adapter = __esm({
       if (metadata.isSymbolicLink() || !metadata.isDirectory()) throw fail("pi_state_not_owned");
       await ensureInferencePrivateDirectory(stateRoot);
       const root = await realpath5(stateRoot);
-      const entries = await readdir2(root, { withFileTypes: true });
+      const entries = await readdir3(root, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isSymbolicLink() || !entry.isDirectory() || entry.name !== "provider" && !/^agent-[a-f0-9-]{36}$/u.test(entry.name)) throw fail("pi_state_not_owned");
         const path = join7(root, entry.name);
-        for (const child of await readdir2(path, { withFileTypes: true })) {
+        for (const child of await readdir3(path, { withFileTypes: true })) {
           if (child.isSymbolicLink() || !child.isFile() || entry.name === "provider" || child.name !== "session.jsonl") throw fail("pi_state_not_owned");
           const contents = await readInferencePrivateFile(join7(path, child.name), "Pi session");
           const header = contents === null ? null : object2(JSON.parse(contents.split("\n", 1)[0]));
@@ -40815,8 +41026,8 @@ var init_grok_runtime = __esm({
 
 // lib/inference-host/grok-state.ts
 import { constants as constants2 } from "node:fs";
-import { lstat as lstat7, mkdtemp as mkdtemp4, open as open3, readdir as readdir3, realpath as realpath6, rm as rm9, rmdir, unlink, writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname8, join as join10, resolve as resolve6 } from "node:path";
+import { lstat as lstat7, mkdtemp as mkdtemp4, open as open3, readdir as readdir4, realpath as realpath6, rm as rm9, rmdir, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname8, join as join10, resolve as resolve6 } from "node:path";
 var markerName, ownedName, invalid, missing, sessionIdValid, directory, nativeDirectory, roots, owner, nativeFile, encodedCwd, nativeSession, removeEmptyNativeGroup, createGrokOwnedWorkspace, bindGrokOwnedSession, validateGrokOwnedThread, releaseGrokOwnedWorkspace, cleanupGrokOwnedState;
 var init_grok_state = __esm({
   "lib/inference-host/grok-state.ts"() {
@@ -40853,7 +41064,7 @@ var init_grok_state = __esm({
     };
     owner = async (options, workspace) => {
       const scope = await roots(options);
-      if (workspace !== resolve6(workspace) || dirname8(workspace) !== scope.workspaceRoot || !ownedName.test(basename3(workspace))) throw invalid();
+      if (workspace !== resolve6(workspace) || dirname8(workspace) !== scope.workspaceRoot || !ownedName.test(basename4(workspace))) throw invalid();
       await directory(scope.workspaceRoot);
       await directory(workspace);
       const raw = await readInferencePrivateFile(join10(workspace, markerName), "Grok workspace owner");
@@ -40896,7 +41107,7 @@ var init_grok_state = __esm({
       if (encoded.length <= 255) groups = [join10(sessions, encoded)];
       else {
         groups = [];
-        for (const entry of await readdir3(sessions, { withFileTypes: true })) {
+        for (const entry of await readdir4(sessions, { withFileTypes: true })) {
           if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
           const group = join10(sessions, entry.name);
           if (await realpath6(group) !== resolve6(group)) throw invalid();
@@ -40943,7 +41154,7 @@ var init_grok_state = __esm({
         if (missing(error48)) return;
         throw error48;
       }
-      const entries = await readdir3(group);
+      const entries = await readdir4(group);
       let cwdMarker = null;
       if (entries.length === 1 && entries[0] === ".cwd") {
         cwdMarker = await nativeFile(join10(group, ".cwd"), 32768);
@@ -41003,7 +41214,7 @@ var init_grok_state = __esm({
     };
     releaseGrokOwnedWorkspace = async (options, workspace, expectedSessionId) => {
       const scope = await roots(options);
-      if (workspace !== resolve6(workspace) || dirname8(workspace) !== scope.workspaceRoot || !ownedName.test(basename3(workspace))) throw invalid();
+      if (workspace !== resolve6(workspace) || dirname8(workspace) !== scope.workspaceRoot || !ownedName.test(basename4(workspace))) throw invalid();
       await directory(scope.workspaceRoot);
       try {
         await lstat7(workspace);
@@ -41037,7 +41248,7 @@ var init_grok_state = __esm({
         if (missing(error48)) return;
         throw error48;
       }
-      for (const entry of await readdir3(scope.workspaceRoot, { withFileTypes: true })) {
+      for (const entry of await readdir4(scope.workspaceRoot, { withFileTypes: true })) {
         if (!ownedName.test(entry.name)) continue;
         const workspace = join10(scope.workspaceRoot, entry.name);
         try {
@@ -41606,8 +41817,8 @@ var init_grok_auth = __esm({
 import { spawn as spawn9 } from "node:child_process";
 import { randomUUID as randomUUID9, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import { createServer as createServer5 } from "node:http";
-import { access as access3, lstat as lstat8, readdir as readdir4, realpath as realpath7, rm as rm10 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname9, join as join12, resolve as resolve7 } from "node:path";
+import { access as access3, lstat as lstat8, readdir as readdir5, realpath as realpath7, rm as rm10 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname9, join as join12, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var import_ajv3, failure, object4, validModel, receiptUsage, assertOwnedRuntime, cleanupExoOwnedState, ExoForegroundAdapter;
 var init_exo_adapter = __esm({
@@ -41663,7 +41874,7 @@ var init_exo_adapter = __esm({
       }
       await ensureInferencePrivateDirectory(stateRoot);
       const root = await realpath7(stateRoot);
-      for (const entry of await readdir4(root, { withFileTypes: true })) {
+      for (const entry of await readdir5(root, { withFileTypes: true })) {
         const match = /^(?:agent|attempt)-([a-f0-9-]{36})$/u.exec(entry.name);
         if (!match || !entry.isDirectory() || entry.isSymbolicLink()) throw failure("exo_state_not_owned");
         await assertOwnedRuntime(join12(root, entry.name), match[1]);
@@ -41777,7 +41988,7 @@ var init_exo_adapter = __esm({
       async ownedRoot(thread) {
         const parent = await realpath7(this.options.stateRoot);
         const root = resolve7(thread.threadPath);
-        if (!/^[a-f0-9-]{36}$/u.test(thread.threadId) || dirname9(root) !== parent || basename4(root) !== `agent-${thread.threadId}`) throw failure("exo_thread_not_owned");
+        if (!/^[a-f0-9-]{36}$/u.test(thread.threadId) || dirname9(root) !== parent || basename5(root) !== `agent-${thread.threadId}`) throw failure("exo_thread_not_owned");
         await assertOwnedRuntime(root, thread.threadId);
         return root;
       }
@@ -46806,11 +47017,11 @@ Waiting for approval...
               operation_id: agentOperationId("agent-decision-submit"),
               candidate: input.candidate,
               observed_at: observedAt,
-              ...state.review ? { timing: {
-                analysis_started_at: state.review.analysis_started_at,
-                model_latency_ms: null,
-                model_latency_source: null
-              } } : {},
+              ...state.review ? { timing: measureAgentReviewTiming(
+                state.review.analysis_started_at,
+                observedAt,
+                session.client.supportsAgentAnalysisDuration?.() === true
+              ) } : {},
               provenance: input.provenance
             },
             first_transmit_at: null,
@@ -48121,7 +48332,8 @@ async function parseError(response, fallback) {
     detail = null;
   }
   const rawDetail = detail && typeof detail === "object" && "detail" in detail ? detail.detail : detail;
-  const message = typeof rawDetail === "string" ? rawDetail : fallback;
+  const detailMessage = rawDetail && typeof rawDetail === "object" && typeof rawDetail.message === "string" ? String(rawDetail.message).trim() : "";
+  const message = typeof rawDetail === "string" ? rawDetail : detailMessage || fallback;
   const code = rawDetail && typeof rawDetail === "object" && "code" in rawDetail ? String(rawDetail.code || "") : void 0;
   return new AgentClientError({
     status: response.status,
@@ -52490,6 +52702,28 @@ var init_client_host_commands = __esm({
   }
 });
 
+// lib/api/insights-access-center.ts
+var init_insights_access_center = __esm({
+  "lib/api/insights-access-center.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    init_shared();
+  }
+});
+
+// lib/api/updates.ts
+var init_updates = __esm({
+  "lib/api/updates.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    init_shared();
+  }
+});
+
 // lib/runtime/server-runtime-lease.ts
 var CLIENT_RUNTIME_SERVER_LEASE_STORAGE_KEY, canUseStorage, normalizeProfileId, normalizeLeaseGeneration, parseLeaseRecord, readPersistedLeaseMap, writePersistedLeaseMap, isLeaseExpired, getPersistedClientRuntimeServerLease, persistExistingClientRuntimeServerLease, persistClientRuntimeServerLease, clearPersistedClientRuntimeServerLease;
 var init_server_runtime_lease = __esm({
@@ -53199,6 +53433,8 @@ var init_api2 = __esm({
     init_market_data();
     init_screener();
     init_client_host_commands();
+    init_insights_access_center();
+    init_updates();
     init_server_runtime_lease();
     preferencesWriteQueue = Promise.resolve();
     CLIENT_SUPPORTED_PROMPT_CONTRACT_VERSION = String(
@@ -71102,8 +71338,8 @@ var init_network = __esm({
        *  Gets a list of all plugins that match %%name%%, with otr without
        *  a fragment.
        */
-      getPlugins(basename5) {
-        return this.plugins.filter((p) => p.name.split("#")[0] === basename5);
+      getPlugins(basename6) {
+        return this.plugins.filter((p) => p.name.split("#")[0] === basename6);
       }
       /**
        *  Create a copy of this Network.
@@ -86693,7 +86929,7 @@ var init_openai_compatible_capabilities = __esm({
 });
 
 // lib/local-ai.ts
-var LOCAL_CONTEXT_CACHE_TTL_MS, LOCAL_AI_SERVER_TYPE_ALIASES, normalizeLocalAiServerType;
+var LOCAL_CONTEXT_CACHE_TTL_MS, LOCAL_AI_SERVER_TYPE_ALIASES, normalizeLocalAiServerType, endpointOrigin, sameEndpointOriginKey;
 var init_local_ai = __esm({
   "lib/local-ai.ts"() {
     "use strict";
@@ -86717,6 +86953,17 @@ var init_local_ai = __esm({
       }
       return Object.prototype.hasOwnProperty.call(LOCAL_AI_SERVER_TYPE_ALIASES, normalized) ? "openai-compatible" : null;
     };
+    endpointOrigin = (value) => {
+      try {
+        return value ? new URL(value).origin : null;
+      } catch {
+        return null;
+      }
+    };
+    sameEndpointOriginKey = (saved, targetBaseUrl) => {
+      const savedOrigin = endpointOrigin(saved?.baseUrl);
+      return savedOrigin !== null && savedOrigin === endpointOrigin(targetBaseUrl) ? saved?.apiKey || void 0 : void 0;
+    };
   }
 });
 
@@ -87086,7 +87333,10 @@ var init_vault = __esm({
         serverType: localNormalized?.localAi?.serverType ?? remoteNormalized?.localAi?.serverType
       }) : normalizeLocalAiSecrets({
         baseUrl: remoteNormalized?.localAi?.baseUrl,
-        apiKey: remoteNormalized?.localAi?.apiKey ?? localNormalized?.localAi?.apiKey,
+        apiKey: remoteNormalized?.localAi?.apiKey ?? sameEndpointOriginKey(
+          localNormalized?.localAi,
+          remoteNormalized?.localAi?.baseUrl
+        ),
         serverType: remoteNormalized?.localAi?.serverType ?? localNormalized?.localAi?.serverType
       });
       const mergedOpenAiCompatible = storage2.byok === "device" ? normalizeOpenAiCompatibleSecrets({
@@ -87094,7 +87344,10 @@ var init_vault = __esm({
         apiKey: localNormalized?.openaiCompatible?.apiKey
       }) : normalizeOpenAiCompatibleSecrets({
         baseUrl: remoteNormalized?.openaiCompatible?.baseUrl,
-        apiKey: remoteNormalized?.openaiCompatible?.apiKey ?? localNormalized?.openaiCompatible?.apiKey
+        apiKey: remoteNormalized?.openaiCompatible?.apiKey ?? sameEndpointOriginKey(
+          localNormalized?.openaiCompatible,
+          remoteNormalized?.openaiCompatible?.baseUrl
+        )
       });
       return validateDeviceSecrets({
         hyperliquidSigningKey: storage2.hyperliquid === "device" ? localNormalized?.hyperliquidSigningKey : remoteNormalized?.hyperliquidSigningKey,
@@ -87113,8 +87366,15 @@ var init_vault = __esm({
         return null;
       }
       const storage2 = normalizeDeviceSecretStorage(normalized.storage);
-      const localAi = storage2.byok === "device" ? normalizeLocalAiSecrets(normalized.localAi) : normalizeLocalAiSecrets({ apiKey: normalized.localAi?.apiKey, serverType: normalized.localAi?.serverType });
-      const openaiCompatible = storage2.byok === "device" ? normalizeOpenAiCompatibleSecrets(normalized.openaiCompatible) : normalizeOpenAiCompatibleSecrets({ apiKey: normalized.openaiCompatible?.apiKey });
+      const localAi = storage2.byok === "device" ? normalizeLocalAiSecrets(normalized.localAi) : normalizeLocalAiSecrets({
+        apiKey: normalized.localAi?.apiKey,
+        baseUrl: normalized.localAi?.apiKey ? normalized.localAi?.baseUrl : void 0,
+        serverType: normalized.localAi?.serverType
+      });
+      const openaiCompatible = storage2.byok === "device" ? normalizeOpenAiCompatibleSecrets(normalized.openaiCompatible) : normalizeOpenAiCompatibleSecrets({
+        apiKey: normalized.openaiCompatible?.apiKey,
+        baseUrl: normalized.openaiCompatible?.apiKey ? normalized.openaiCompatible?.baseUrl : void 0
+      });
       return validateDeviceSecrets({
         hyperliquidSigningKey: storage2.hyperliquid === "device" ? normalized.hyperliquidSigningKey : void 0,
         providerKeys: storage2.byok === "device" ? { ...normalized.providerKeys } : {},
@@ -88065,7 +88325,7 @@ var init_execution_guard_contract = __esm({
 });
 
 // lib/runtime/runtime-execution.ts
-var executionReadPriority, fetchClientRuntimeOpenOrders, createRuntimeId, _extractOrderId, _toExecutionMetadata, _extractClientMutationId, trailingStopMemory, protectiveGroupMemory, protectiveGroupReadFailures, windowHandoffCleanupAttempts, clientRuntimeProtectionStorage, resolveClientRuntimeProtectionStorage, setClientRuntimeProtectionStorage, trailingStopStorageKey, readTrackedTrailingStops, writeTrackedTrailingStops, rememberTrailingStop, protectiveGroupStorageKey, readClientProtectiveGroups, writeClientProtectiveGroups, hasClientProtectiveGroupReadFailure, readFreshClientProtectiveGroups, stableProtectionSnapshot, exactClientProtectiveGroupSnapshot, exactClientProtectiveGroupSetSnapshot, replaceExactClientProtectiveGroup, replaceExactClientProtectiveGroupSet, isClientRuntimeLeaseOwnershipError, hasClientRuntimeProtectionState, clearClientRuntimeVetoedProtectiveIntent, rethrowWindowHandoffAfterProtectiveReplacementVeto, canPersistClientProtectiveGroups, removeTrackedTrailingStop, replaceTrackedTrailingStop, replaceProtectiveLeg, replacementJournalEntryOrderId, buildProtectiveReplacementJournalGroup, isProtectiveReplacementJournalGroup, reserveProtectiveLegReplacement, ensureProtectiveReplacementJournalCompanion, buildVetoedProtectiveReplacementCleanup, assertExactProtectiveReplacementDispatchAuthority, transitionProtectiveReplacementAcknowledgement, transitionTerminalProtectiveReplacement, pendingProtectiveReplacementReport, toPositiveNumber, resolveRiskPct, buildTriggerPrice, isConfiguredProtectionRequested, protectiveAction, isExactClientPositionTpslPair, hasAmbiguousClientPositionTpslAuthority, protectiveStableShapeMatches, protectiveLiveShapeMatches, protectiveTerminalShapeMatches, cancelClientProtectiveLeg, buildPendingProtectivePlan, attachClientProtectivePlan, resolveJournaledAttachmentContinuity, recoverJournaledClientProtectiveAttachments, recoverPendingClientProtectiveGroups, recoverPendingProtectiveReplacements, reconcileClientProtectiveGroups, cancelAllClientProtectiveGroups, tightenClientTrailingStops, throwIfAborted2, sleep3, roundAssetSize, resolvePositionSize, resolveCurrentPositionSize, buildPositionSnapshot, signedRemainingExposureAfterConfirmedReduction, verifyNoLiveClientProtectiveTriggers, clientExecutionMutations, withClientExecutionMutation, executeClientRuntimeDecision, maintainClientRuntimeTrailingStops, executeClientRuntimeDecisionUnlocked;
+var clientProtectiveMutationAuthority, executionReadPriority, fetchClientRuntimeOpenOrders, createRuntimeId, _extractOrderId, _toExecutionMetadata, _extractClientMutationId, trailingStopMemory, protectiveGroupMemory, protectiveGroupReadFailures, windowHandoffCleanupAttempts, clientRuntimeProtectionStorage, resolveClientRuntimeProtectionStorage, setClientRuntimeProtectionStorage, trailingStopStorageKey, readTrackedTrailingStops, writeTrackedTrailingStops, rememberTrailingStop, protectiveGroupStorageKey, readClientProtectiveGroups, writeClientProtectiveGroups, hasClientProtectiveGroupReadFailure, readFreshClientProtectiveGroups, stableProtectionSnapshot, exactClientProtectiveGroupSnapshot, exactClientProtectiveGroupSetSnapshot, replaceExactClientProtectiveGroup, replaceExactClientProtectiveGroupSet, isClientRuntimeLeaseOwnershipError, hasClientRuntimeProtectionState, clearClientRuntimeVetoedProtectiveIntent, rethrowWindowHandoffAfterProtectiveReplacementVeto, canPersistClientProtectiveGroups, removeTrackedTrailingStop, replaceTrackedTrailingStop, replaceProtectiveLeg, replacementJournalEntryOrderId, buildProtectiveReplacementJournalGroup, isProtectiveReplacementJournalGroup, reserveProtectiveLegReplacement, ensureProtectiveReplacementJournalCompanion, buildVetoedProtectiveReplacementCleanup, assertExactProtectiveReplacementDispatchAuthority, transitionProtectiveReplacementAcknowledgement, transitionTerminalProtectiveReplacement, pendingProtectiveReplacementReport, toPositiveNumber, resolveRiskPct, buildTriggerPrice, isConfiguredProtectionRequested, protectiveAction, isExactClientPositionTpslPair, hasAmbiguousClientPositionTpslAuthority, protectiveStableShapeMatches, protectiveLiveShapeMatches, protectiveTerminalShapeMatches, cancelClientProtectiveLeg, buildPendingProtectivePlan, persistPendingClientProtectiveGroup, attachClientProtectivePlan, resolveJournaledAttachmentContinuity, recoverJournaledClientProtectiveAttachments, recoverPendingClientProtectiveGroups, recoverPendingProtectiveReplacements, reconcileClientProtectiveGroups, cancelAllClientProtectiveGroups, tightenClientTrailingStops, throwIfAborted2, sleep3, roundAssetSize, resolvePositionSize, resolveCurrentPositionSize, buildPositionSnapshot, signedRemainingExposureAfterConfirmedReduction, verifyNoLiveClientProtectiveTriggers, clientExecutionMutations, withClientExecutionMutation, executeClientRuntimeDecision, maintainClientRuntimeTrailingStops, executeClientRuntimeDecisionUnlocked;
 var init_runtime_execution = __esm({
   "lib/runtime/runtime-execution.ts"() {
     "use strict";
@@ -88081,6 +88341,12 @@ var init_runtime_execution = __esm({
     init_runtime_redaction();
     init_error_surface_contract();
     init_runtime_handoff();
+    clientProtectiveMutationAuthority = (request) => request.mutationAuthority === "manual_session" ? {} : {
+      runtimeSessionId: request.sessionId || "__missing_runtime_session__",
+      runtimeLeaseToken: request.runtimeLeaseToken,
+      runtimeDeviceId: request.runtimeDeviceId,
+      schedulerInstanceId: request.schedulerInstanceId
+    };
     executionReadPriority = (input) => {
       const context = input.executionContext;
       const classified = classifyExecutionIntent(
@@ -89094,10 +89360,7 @@ var init_runtime_execution = __esm({
         await executeClientCancelOrder({
           publicRequestPriority: "trading_reduce",
           profileId: request.profileId,
-          runtimeSessionId: request.sessionId || "__missing_runtime_session__",
-          runtimeLeaseToken: request.runtimeLeaseToken,
-          runtimeDeviceId: request.runtimeDeviceId,
-          schedulerInstanceId: request.schedulerInstanceId,
+          ...clientProtectiveMutationAuthority(request),
           walletAddress: request.executionContext.walletAddress,
           config: request.config ?? null,
           signal: request.signal,
@@ -89130,24 +89393,58 @@ var init_runtime_execution = __esm({
         };
       }
     };
-    buildPendingProtectivePlan = (request, input) => ({
+    buildPendingProtectivePlan = (settings, input) => ({
       ...input,
       stopLoss: {
-        enabled: request.executionContext.stopLossEnabled !== false,
-        mode: request.executionContext.stopLossMode === "usdc" ? "usdc" : "percent",
+        enabled: settings.stopLossEnabled !== false,
+        mode: settings.stopLossMode === "usdc" ? "usdc" : "percent",
         value: toPositiveNumber(
-          request.executionContext.stopLossMode === "usdc" ? request.executionContext.stopLossUsdc : request.executionContext.stopLossPct
+          settings.stopLossMode === "usdc" ? settings.stopLossUsdc : settings.stopLossPct
         ),
-        isTrailing: request.executionContext.stopLossType === "trailing"
+        isTrailing: settings.stopLossType === "trailing"
       },
       takeProfit: {
-        enabled: request.executionContext.takeProfitEnabled !== false,
-        mode: request.executionContext.takeProfitMode === "usdc" ? "usdc" : "percent",
+        enabled: settings.takeProfitEnabled !== false,
+        mode: settings.takeProfitMode === "usdc" ? "usdc" : "percent",
         value: toPositiveNumber(
-          request.executionContext.takeProfitMode === "usdc" ? request.executionContext.takeProfitUsdc : request.executionContext.takeProfitPct
+          settings.takeProfitMode === "usdc" ? settings.takeProfitUsdc : settings.takeProfitPct
         )
       }
     });
+    persistPendingClientProtectiveGroup = (input) => {
+      const { profileId, symbol: symbol2 } = input;
+      const group = {
+        version: 2,
+        profileId,
+        symbol: symbol2.trim().toUpperCase(),
+        walletAddress: String(input.walletAddress || "").trim().toLowerCase(),
+        entryOrderId: input.entryClientOrderId,
+        isLong: input.entrySide === "buy",
+        legs: [],
+        pendingEntry: buildPendingProtectivePlan(input.settings, {
+          entryMutationId: input.entryMutationId,
+          entryClientOrderId: input.entryClientOrderId,
+          entrySide: input.entrySide,
+          requestedSize: input.requestedSize
+        })
+      };
+      const cleanup = {
+        kind: "vetoed_protective_intent",
+        profileId,
+        symbol: symbol2,
+        entryOrderId: group.entryOrderId,
+        pendingGroupSnapshot: exactClientProtectiveGroupSnapshot(group)
+      };
+      const existingGroups = readFreshClientProtectiveGroups(profileId, symbol2);
+      const nextGroups = [...existingGroups, group];
+      const persistenceFailed = hasClientProtectiveGroupReadFailure(profileId, symbol2) || !replaceExactClientProtectiveGroupSet(
+        profileId,
+        symbol2,
+        existingGroups,
+        nextGroups
+      );
+      return { group, cleanup, persistedGroupSet: persistenceFailed ? null : nextGroups };
+    };
     attachClientProtectivePlan = async (request, group, fill) => {
       const reports = [];
       const plan = group.pendingEntry;
@@ -89211,8 +89508,7 @@ var init_runtime_execution = __esm({
         "trading_reduce"
       );
       const livePositionSize = Number(snapshot.size);
-      const directionMatches = Number.isFinite(livePositionSize) && (isLong ? livePositionSize > 0 : livePositionSize < 0);
-      if (!directionMatches) {
+      if (!Number.isFinite(livePositionSize)) {
         reports.push({
           order_id: fill.orderId,
           symbol: symbol2,
@@ -89222,6 +89518,26 @@ var init_runtime_execution = __esm({
         });
         return reports;
       }
+      const directionMatches = isLong ? livePositionSize > 0 : livePositionSize < 0;
+      if (!directionMatches) {
+        const flat = livePositionSize === 0;
+        const retired = replaceExactClientProtectiveGroupSet(
+          profileId,
+          symbol2,
+          observedGroups,
+          existingGroups
+        );
+        reports.push({
+          order_id: fill.orderId,
+          symbol: symbol2,
+          action: "PROTECTIVE_RECONCILIATION",
+          status: "failed",
+          execution_metadata: {
+            reason_code: !retired ? "protective_lifecycle_persistence_failed" : flat ? "protective_position_flat" : "protective_position_drift"
+          }
+        });
+        return reports;
+      }
       const liveExposure = Math.abs(livePositionSize);
       const allocatedCandidates = planned.flatMap((candidate) => {
         const allocated = existingGroups.flatMap((existing) => existing.legs).filter((leg) => leg.kind === candidate.kind).reduce((total, leg) => total + leg.size, 0);
@@ -89229,7 +89545,22 @@ var init_runtime_execution = __esm({
           Math.min(fill.filledSize, Math.max(0, liveExposure - allocated)),
           request.executionContext.sizeDecimals
         );
-        if (!Number.isFinite(size) || size <= 0) return [];
+        if (!Number.isFinite(size) || size <= 0) {
+          reports.push({
+            order_id: null,
+            symbol: symbol2,
+            action: candidate.kind === "sl" ? "AUTO_SL" : "AUTO_TP",
+            status: "blocked",
+            execution_metadata: {
+              reason_code: "protective_exposure_already_covered",
+              entry_order_id: fill.orderId,
+              entry_filled_size: fill.filledSize,
+              entry_average_price: fill.averagePrice,
+              live_position_size: livePositionSize
+            }
+          });
+          return [];
+        }
         const triggerPrice = buildTriggerPrice(
           fill.averagePrice,
           resolveRiskPct(
@@ -89271,7 +89602,7 @@ var init_runtime_execution = __esm({
         (candidate) => candidate.triggerPrice <= 0
       );
       if (invalidCandidates.length > 0) {
-        for (const candidate of invalidCandidates) {
+        for (const candidate of allocatedCandidates) {
           reports.push({
             order_id: fill.orderId,
             symbol: symbol2,
@@ -89279,6 +89610,7 @@ var init_runtime_execution = __esm({
             status: "failed",
             execution_metadata: {
               reason_code: "protective_trigger_invalid",
+              ...candidate.triggerPrice > 0 ? { invalid_sibling: true } : {},
               entry_filled_size: fill.filledSize,
               entry_average_price: fill.averagePrice
             }
@@ -89496,10 +89828,7 @@ var init_runtime_execution = __esm({
         if (positionTpsl) {
           response = await executeClientOrderBatch({
             profileId: request.profileId,
-            runtimeSessionId: request.sessionId || "__missing_runtime_session__",
-            runtimeLeaseToken: request.runtimeLeaseToken,
-            runtimeDeviceId: request.runtimeDeviceId,
-            schedulerInstanceId: request.schedulerInstanceId,
+            ...clientProtectiveMutationAuthority(request),
             walletAddress: request.executionContext.walletAddress,
             config: request.config ?? null,
             signal: request.signal,
@@ -89529,10 +89858,7 @@ var init_runtime_execution = __esm({
           const candidate = candidates[0];
           response = await executeClientTriggerOrder({
             profileId: request.profileId,
-            runtimeSessionId: request.sessionId || "__missing_runtime_session__",
-            runtimeLeaseToken: request.runtimeLeaseToken,
-            runtimeDeviceId: request.runtimeDeviceId,
-            schedulerInstanceId: request.schedulerInstanceId,
+            ...clientProtectiveMutationAuthority(request),
             walletAddress: request.executionContext.walletAddress,
             config: request.config ?? null,
             signal: request.signal,
@@ -89605,14 +89931,15 @@ var init_runtime_execution = __esm({
         return acknowledgement == null ? null : [acknowledgement];
       })();
       if (acknowledgements == null) {
-        return candidates.map((candidate) => ({
+        reports.push(...candidates.map((candidate) => ({
           order_id: null,
           client_mutation_id: candidate.mutationId,
           symbol: symbol2,
           action: candidate.kind === "sl" ? "AUTO_SL" : "AUTO_TP",
           status: "blocked",
           execution_metadata: { reason_code: "protective_trigger_ack_unresolved" }
-        }));
+        })));
+        return reports;
       }
       const acknowledgedLegs = acknowledgements.map((acknowledgement, index) => ({
         ...provisionalLegs[index],
@@ -92570,41 +92897,19 @@ var init_runtime_execution = __esm({
       if (shouldAttachSlTp) {
         entryMutationId = createRuntimeId().toLowerCase();
         entryClientOrderId = `0x${entryMutationId.replaceAll("-", "")}`;
-        const profileId2 = String(input.profileId).trim();
-        pendingProtectiveGroup = {
-          version: 2,
-          profileId: profileId2,
-          symbol: input.executionContext.symbol.trim().toUpperCase(),
-          walletAddress: String(input.executionContext.walletAddress || "").trim().toLowerCase(),
-          entryOrderId: entryClientOrderId,
-          isLong: classified.side === "buy",
-          legs: [],
-          pendingEntry: buildPendingProtectivePlan(input, {
-            entryMutationId,
-            entryClientOrderId,
-            entrySide: classified.side,
-            requestedSize: sizeAsset
-          })
-        };
-        pendingProtectiveCleanup = {
-          kind: "vetoed_protective_intent",
-          profileId: profileId2,
+        const pendingProtection = persistPendingClientProtectiveGroup({
+          profileId: String(input.profileId).trim(),
           symbol: input.executionContext.symbol,
-          entryOrderId: pendingProtectiveGroup.entryOrderId,
-          pendingGroupSnapshot: exactClientProtectiveGroupSnapshot(pendingProtectiveGroup)
-        };
-        const existingGroups = readFreshClientProtectiveGroups(
-          profileId2,
-          input.executionContext.symbol
-        );
-        const nextGroups = [...existingGroups, pendingProtectiveGroup];
-        const persistenceFailed = hasClientProtectiveGroupReadFailure(profileId2, input.executionContext.symbol) || !replaceExactClientProtectiveGroupSet(
-          profileId2,
-          input.executionContext.symbol,
-          existingGroups,
-          nextGroups
-        );
-        if (persistenceFailed) {
+          walletAddress: input.executionContext.walletAddress,
+          settings: input.executionContext,
+          entryMutationId,
+          entryClientOrderId,
+          entrySide: classified.side,
+          requestedSize: sizeAsset
+        });
+        pendingProtectiveGroup = pendingProtection.group;
+        pendingProtectiveCleanup = pendingProtection.cleanup;
+        if (pendingProtection.persistedGroupSet == null) {
           const cleanupComplete = clearClientRuntimeVetoedProtectiveIntent(
             pendingProtectiveCleanup
           );
@@ -92635,7 +92940,7 @@ var init_runtime_execution = __esm({
             executionSnapshotCapturedAt
           };
         }
-        persistedProtectiveGroupSet = nextGroups;
+        persistedProtectiveGroupSet = pendingProtection.persistedGroupSet;
       }
       let marketOrderResponse;
       let entryDispatchBoundaryPassed = false;
@@ -95013,8 +95318,34 @@ function parseMarketOrderPayload(args) {
   if (estimatedPriceTimestampMs) {
     payload.estimated_price_timestamp_ms = parsePositiveInt(estimatedPriceTimestampMs, "--estimated-price-timestamp-ms");
   }
+  if (args.includes("--reduce-only")) {
+    payload.reduce_only = true;
+  }
+  const protection = parseMarketOrderProtection(args);
+  if (protection) {
+    payload.protection = protection;
+  }
   return payload;
 }
+function parseMarketOrderProtection(args) {
+  const leg = (name) => {
+    const percent = optionalValue(args, `--${name}-percent`);
+    const usdc = optionalValue(args, `--${name}-usdc`);
+    if (percent && usdc) {
+      throw new Error(`Use either --${name}-percent or --${name}-usdc, not both`);
+    }
+    if (percent) return { mode: "percent", value: parsePositiveNumber(percent, `--${name}-percent`) };
+    if (usdc) return { mode: "usdc", value: parsePositiveNumber(usdc, `--${name}-usdc`) };
+    return null;
+  };
+  const takeProfit = leg("take-profit");
+  const stopLoss = leg("stop-loss");
+  if (!takeProfit && !stopLoss) return null;
+  return {
+    ...takeProfit ? { take_profit: takeProfit } : {},
+    ...stopLoss ? { stop_loss: { ...stopLoss, stop_type: "fixed" } } : {}
+  };
+}
 function parseLimitOrderPayload(args) {
   return {
     symbol: normalizeHyperliquidMarketSymbol(requireValue(args, "--symbol")),
@@ -95373,6 +95704,17 @@ Common commands:
   runtime events             Read recent runtime events and errors
   inference-host --help      Set up an automated or agent-driven inference host
 
+Trading commands (Server Mode profiles):
+  trade market-order --symbol <s> --side buy|sell --size <n>
+      [--slippage <fraction>] [--estimated-price <n>] [--reduce-only]
+      [--take-profit-percent <n> | --take-profit-usdc <n>]
+      [--stop-loss-percent <n> | --stop-loss-usdc <n>]
+                             Fixed TP/SL as reduce-only market triggers from the
+                             average fill, within the AI page's Auto SL/TP limits;
+                             not allowed with --reduce-only; no trailing stops
+  trade limit-order --symbol <s> --side buy|sell --size <n> --limit-price <n> [--reduce-only]
+  trade cancel-order --symbol <s> --oid <n>
+
 Global options:
   --json                     Emit machine-readable JSON
   --profile <id>             Select one VTX profile