@vtxmacro/cli 2026.9.69 → 2026.10.2

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.69",
+      package_version: "2026.10.2",
       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();
-        }
-        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();
+        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);
         }
+        handle = await openExclusiveProcessLockFile(path);
+      } finally {
+        await guard.release();
       }
-      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.");
-      }
-      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();
+    };
   }
 });
 
@@ -35964,7 +36131,7 @@ import {
   lstat as lstat3,
   mkdir as mkdir2,
   mkdtemp,
-  readdir,
+  readdir as readdir2,
   readFile as readFile4,
   realpath as realpath3,
   rm as rm3
@@ -36402,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) {
@@ -38497,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 {
@@ -39155,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() {
@@ -39361,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,
@@ -39525,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");
@@ -39608,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);
@@ -39679,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;
@@ -39874,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]));
@@ -40859,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"() {
@@ -40897,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");
@@ -40940,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();
@@ -40987,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);
@@ -41047,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);
@@ -41081,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 {
@@ -41650,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({
@@ -41707,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]);
@@ -41821,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;
       }
@@ -48165,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,
@@ -50153,7 +50321,7 @@ var init_hyperliquid_account_mode_contract = __esm({
 });
 
 // lib/runtime/hyperliquid-account-contract.ts
-var toNumber, firstNumber, roundTo, normalizeSpotBalancesFromInfoResponse, sumBalanceHoldUsd, sumPositionUnrealizedPnl, resolveTotalUnrealizedPnl, approximatelyEqualAccountValues, buildAccountSummaryFromInfoResponses;
+var toNumber, firstNumber, roundTo, STABLE_SPOT_SYMBOLS, spotBalanceValueUsd, normalizeSpotBalancesFromInfoResponse, sumBalanceHoldUsd, sumPositionUnrealizedPnl, resolveTotalUnrealizedPnl, approximatelyEqualAccountValues, buildAccountSummaryFromInfoResponses;
 var init_hyperliquid_account_contract = __esm({
   "lib/runtime/hyperliquid-account-contract.ts"() {
     "use strict";
@@ -50178,6 +50346,14 @@ var init_hyperliquid_account_contract = __esm({
       return fallback;
     };
     roundTo = (value, digits = 12) => Number(value.toFixed(digits));
+    STABLE_SPOT_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USD", "USDT"]);
+    spotBalanceValueUsd = (balance, coin, total) => {
+      const explicit = firstNumber([balance?.value_usd, balance?.usdValue, balance?.usdcValue], Number.NaN);
+      if (Number.isFinite(explicit)) {
+        return explicit;
+      }
+      return STABLE_SPOT_SYMBOLS.has(coin) ? total : 0;
+    };
     normalizeSpotBalancesFromInfoResponse = (spotResponse) => {
       const containers = [];
       if (spotResponse && typeof spotResponse === "object") {
@@ -50196,7 +50372,7 @@ var init_hyperliquid_account_contract = __esm({
         const total = toNumber(balance?.total, 0);
         const hold = toNumber(balance?.hold, 0);
         const available = roundTo(Math.max(0, total - hold));
-        const value_usd = toNumber(balance?.value_usd, total);
+        const value_usd = spotBalanceValueUsd(balance, coin, total);
         return {
           coin,
           total,
@@ -50358,7 +50534,7 @@ var init_hyperliquid_active_asset_contract = __esm({
 });
 
 // lib/runtime/server-prompt-rescue-account-contract.ts
-var STABLE_SYMBOLS, toNumber2, firstNumber2, firstTruthy, spotContainers, extractCanonicalSpotMetrics, sumBalanceValueUsd, approximatelyEqual, balancesMirrorUnifiedAccountValue, computeEffectiveAccountValue, equityFormula, buildServerPromptRescueAccountSummary;
+var toNumber2, firstNumber2, firstTruthy, spotContainers, extractCanonicalSpotMetrics, sumBalanceValueUsd, approximatelyEqual, balancesMirrorUnifiedAccountValue, computeEffectiveAccountValue, equityFormula, buildServerPromptRescueAccountSummary;
 var init_server_prompt_rescue_account_contract = __esm({
   "lib/runtime/server-prompt-rescue-account-contract.ts"() {
     "use strict";
@@ -50366,7 +50542,7 @@ var init_server_prompt_rescue_account_contract = __esm({
     init_define_VTX_GROK_POLICY();
     init_define_VTX_PI_MODEL_POLICY();
     init_hyperliquid_account_mode_contract();
-    STABLE_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USD", "USDT"]);
+    init_hyperliquid_account_contract();
     toNumber2 = (value, fallback = 0) => {
       const numeric2 = Number(value);
       return Number.isFinite(numeric2) ? numeric2 : fallback;
@@ -50437,14 +50613,14 @@ var init_server_prompt_rescue_account_contract = __esm({
               toNumber2(firstTruthy([entry.available, entry.free, total - hold], "0"))
             );
             let valueUsd = toNumber2(firstTruthy([entry.usdValue, entry.usdcValue], "0"));
-            if (valueUsd <= 0 && STABLE_SYMBOLS.has(coin)) {
+            if (valueUsd <= 0 && STABLE_SPOT_SYMBOLS.has(coin)) {
               valueUsd = available > 0 ? available : total;
             }
             balances.push({ coin, total, hold, available, value_usd: valueUsd });
             const entryValue = valueUsd > 0 ? valueUsd : total;
             if (entryValue > 0) {
               anyTotal += entryValue;
-              if (STABLE_SYMBOLS.has(coin)) stableTotal += entryValue;
+              if (STABLE_SPOT_SYMBOLS.has(coin)) stableTotal += entryValue;
             }
           }
           if (accountValue <= 0) {
@@ -50458,7 +50634,7 @@ var init_server_prompt_rescue_account_contract = __esm({
     };
     sumBalanceValueUsd = (balances) => balances.reduce((total, balance) => {
       let valueUsd = toNumber2(balance.value_usd);
-      if (valueUsd <= 0 && STABLE_SYMBOLS.has(String(balance.coin || "").trim().toUpperCase())) {
+      if (valueUsd <= 0 && STABLE_SPOT_SYMBOLS.has(String(balance.coin || "").trim().toUpperCase())) {
         valueUsd = toNumber2(balance.total);
       }
       return total + Math.max(valueUsd, 0);
@@ -50870,7 +51046,13 @@ var init_hyperliquid_account_state_adapter = __esm({
         }
         const parsedProviderRowCount = Number(parsed?.providerRowCount);
         const providerRowCount = Number.isInteger(parsedProviderRowCount) && parsedProviderRowCount >= rawFills.length ? parsedProviderRowCount : rawFills.length;
-        const entry = { fetchedAtMs, rawFills, providerRowCount };
+        const parsedOldestFillTimeMs = Number(parsed?.oldestFillTimeMs);
+        const entry = {
+          fetchedAtMs,
+          rawFills,
+          providerRowCount,
+          oldestFillTimeMs: Number.isSafeInteger(parsedOldestFillTimeMs) && parsedOldestFillTimeMs > 0 ? parsedOldestFillTimeMs : null
+        };
         browserUserFillsCache.set(cacheKey, entry);
         return entry;
       } catch {
@@ -51763,6 +51945,7 @@ var init_hyperliquid_account_state_adapter = __esm({
             fetchedAtMs: cached2.fetchedAtMs,
             providerRowCount: cached2.providerRowCount,
             providerPageCap: HYPERLIQUID_USER_FILLS_PROVIDER_PAGE_CAP,
+            oldestFillTimeMs: cached2.oldestFillTimeMs ?? null,
             exactTerminalFillEvidenceComplete: false
           }
         };
@@ -51778,12 +51961,14 @@ var init_hyperliquid_account_state_adapter = __esm({
             fetchedAtMs: cached2.fetchedAtMs,
             providerRowCount: cached2.providerRowCount,
             providerPageCap: HYPERLIQUID_USER_FILLS_PROVIDER_PAGE_CAP,
+            oldestFillTimeMs: cached2.oldestFillTimeMs ?? null,
             exactTerminalFillEvidenceComplete: false
           }
         };
       }
       let rawWalletFills;
       let providerRowCount = 0;
+      let oldestFillTimeMs = null;
       let evidenceSource = "live";
       let fetchedAtMs = now;
       const olderInFlight = browserUserFillsInFlight.get(cacheKey);
@@ -51812,12 +51997,15 @@ var init_hyperliquid_account_state_adapter = __esm({
         ).then((payload) => {
           const providerRowCount2 = Array.isArray(payload) ? payload.length : 0;
           const rawFills2 = Array.isArray(payload) ? payload.filter(isPerpFill).map((fill) => ({ ...fill })) : [];
-          writeBrowserUserFillsCache(cacheKey, {
+          const fillTimes = Array.isArray(payload) ? payload.map((fill) => Number(fill?.time)).filter((time3) => Number.isSafeInteger(time3) && time3 > 0) : [];
+          const entry = {
             fetchedAtMs: Date.now(),
             rawFills: rawFills2,
-            providerRowCount: providerRowCount2
-          });
-          return { fetchedAtMs: Date.now(), rawFills: rawFills2, providerRowCount: providerRowCount2 };
+            providerRowCount: providerRowCount2,
+            oldestFillTimeMs: fillTimes.length > 0 ? Math.min(...fillTimes) : null
+          };
+          writeBrowserUserFillsCache(cacheKey, entry);
+          return entry;
         }).finally(() => {
           if (browserUserFillsInFlight.get(cacheKey)?.promise === freshRequest) {
             browserUserFillsInFlight.delete(cacheKey);
@@ -51831,6 +52019,7 @@ var init_hyperliquid_account_state_adapter = __esm({
         rawWalletFills = liveResult.rawFills;
         providerRowCount = liveResult.providerRowCount;
         fetchedAtMs = liveResult.fetchedAtMs;
+        oldestFillTimeMs = liveResult.oldestFillTimeMs ?? null;
       } catch (error48) {
         const staleCache = readBrowserUserFillsCache(cacheKey);
         if (isRateLimitError(error48) && !input.forceRefresh) {
@@ -51838,6 +52027,7 @@ var init_hyperliquid_account_state_adapter = __esm({
           rawWalletFills = staleCache && Date.now() - staleCache.fetchedAtMs <= staleIf429MaxAgeMs ? staleCache.rawFills : [];
           providerRowCount = staleCache?.providerRowCount ?? 0;
           fetchedAtMs = staleCache?.fetchedAtMs ?? Date.now();
+          oldestFillTimeMs = staleCache?.oldestFillTimeMs ?? null;
         } else {
           throw error48;
         }
@@ -51852,6 +52042,7 @@ var init_hyperliquid_account_state_adapter = __esm({
           fetchedAtMs,
           providerRowCount,
           providerPageCap: HYPERLIQUID_USER_FILLS_PROVIDER_PAGE_CAP,
+          oldestFillTimeMs,
           exactTerminalFillEvidenceComplete: evidenceSource === "live" && providerRowCount < HYPERLIQUID_USER_FILLS_PROVIDER_PAGE_CAP
         }
       };
@@ -52534,6 +52725,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({
@@ -53243,6 +53456,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(
@@ -71146,8 +71361,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.
@@ -84477,7 +84692,7 @@ var init_hyperliquid_signer = __esm({
 });
 
 // lib/runtime/hyperliquid-client.ts
-var HyperliquidExchangeRejectionError, durableMutationAuthorityArgs, assertFreshPreparedExecutionContext, HYPERLIQUID_TERMINAL_ORDER_STATUSES, normalizeSymbol, HYPERLIQUID_NONCE_STORAGE_KEY, HYPERLIQUID_NONCE_LOCK_NAME, lastGeneratedNonce, readBrowserStoredHyperliquidNonce, writeBrowserStoredHyperliquidNonce, browserNonceCoordinator, allocateHyperliquidNonce, generateHyperliquidNonce, roundToSigFigs, normalizeDecimalString, toPlainDecimalString, roundDirectionalDecimalString, formatHyperliquidPerpPriceWire, formatHyperliquidTriggerPriceWire, countSignificantDigits, countDecimalPlaces, validateHyperliquidPerpPriceWire, validateHyperliquidSizeWire, formatSizeWire, inferApiUrl, inferIsTestnet, postHyperliquidInfo, toFiniteNumber, OPEN_ORDER_NUMERIC_STRING, OPEN_ORDER_ID_STRING, parseCanonicalOpenOrderId, parseOpenOrderFiniteNumber, parseOpenOrderPositiveNumber, parseOpenOrderPresentationNumber, readOpenOrderField, firstFiniteNumber2, parseFundingUsdcFromInfoPosition2, isExchangeIsolatedOnly, computeHip3AssetId, getPerpDexIndexMap, buildAssetInfosFromMetaResponse, requireWalletAddress2, assertPositiveInteger, assertPositiveNumber, normalizeOrderSide, normalizeHyperliquidClientOrderId, resolveAssets, findResolvedAsset, normalizeExecutionAssetMetadata, resolveHyperliquidAsset, resolveHyperliquidAssetIndex, fetchBrowserAvailableAssets, fetchBrowserAllMids, fetchBrowserSymbolMidPrice, fetchBrowserOpenOrders, parseCanonicalHyperliquidOrderStatusEvidence, fetchBrowserOrderStatusEvidence, fetchBrowserUserRole, fetchBrowserAccountState2, fetchBrowserPosition, buildHyperliquidOrderWire, buildHyperliquidTriggerOrderWire, signHyperliquidPayload, buildHyperliquidCancelPayload, buildHyperliquidUpdateLeveragePayload, buildHyperliquidMarketOrderPayload, buildHyperliquidTriggerOrderPayload, buildHyperliquidOrderBatchPayload, buildHyperliquidModifyOrderPayload, extractHyperliquidExchangeError, isDefinitiveHyperliquidExchangeResponse, extractDefinitiveHyperliquidOrderId, CANONICAL_POSITIVE_DECIMAL_PATTERN, extractCanonicalHyperliquidOrderStateAcknowledgement, extractCanonicalHyperliquidOrderStateAcknowledgements, extractCanonicalHyperliquidFilledOrderAcknowledgement, extractDefinitiveHyperliquidOrderMemberResults, buildHyperliquidOrderDiagnostics, loadClientExecutionReferenceEvidence, sha256Hex, extractSignedPayloadClientOrderId, extractSignedPayloadMutationCorrelation, assertDurableMutationMatchesSignedAction, exchangeRejectionReason, exchangeActionPriority, submitHyperliquidExchangePayload;
+var HyperliquidExchangeRejectionError, durableMutationAuthorityArgs, assertFreshPreparedExecutionContext, HYPERLIQUID_TERMINAL_ORDER_STATUSES, normalizeSymbol, HYPERLIQUID_NONCE_STORAGE_KEY, HYPERLIQUID_NONCE_LOCK_NAME, lastGeneratedNonce, readBrowserStoredHyperliquidNonce, writeBrowserStoredHyperliquidNonce, browserNonceCoordinator, allocateHyperliquidNonce, generateHyperliquidNonce, roundToSigFigs, normalizeDecimalString, toPlainDecimalString, roundDirectionalDecimalString, formatHyperliquidPerpPriceWire, formatHyperliquidTriggerPriceWire, countSignificantDigits, countDecimalPlaces, validateHyperliquidPerpPriceWire, validateHyperliquidSizeWire, formatSizeWire, inferApiUrl, inferIsTestnet, postHyperliquidInfo, toFiniteNumber, OPEN_ORDER_NUMERIC_STRING, OPEN_ORDER_ID_STRING, parseCanonicalOpenOrderId, parseOpenOrderFiniteNumber, parseOpenOrderPositiveNumber, parseOpenOrderPresentationNumber, readOpenOrderField, firstFiniteNumber2, parseFundingUsdcFromInfoPosition2, isExchangeIsolatedOnly, computeHip3AssetId, getPerpDexIndexMap, buildAssetInfosFromMetaResponse, requireWalletAddress2, assertPositiveInteger, assertPositiveNumber, normalizeOrderSide, normalizeHyperliquidClientOrderId, resolveAssets, findResolvedAsset, normalizeExecutionAssetMetadata, resolveHyperliquidAsset, resolveHyperliquidAssetIndex, fetchBrowserAvailableAssets, fetchBrowserAllMids, fetchBrowserSymbolMidPrice, fetchBrowserOpenOrders, parseCanonicalHyperliquidOrderStatusEvidence, fetchBrowserOrderStatusEvidence, fetchBrowserUserRole, fetchBrowserAccountState2, fetchBrowserPosition, buildHyperliquidOrderWire, buildHyperliquidTriggerOrderWire, signHyperliquidPayload, buildHyperliquidCancelPayload, buildHyperliquidUpdateLeveragePayload, buildHyperliquidMarketOrderPayload, buildHyperliquidTriggerOrderPayload, buildHyperliquidOrderBatchPayload, buildHyperliquidModifyOrderPayload, extractHyperliquidExchangeError, resolveHyperliquidTriggerAcknowledgements, isDefinitiveHyperliquidExchangeResponse, extractDefinitiveHyperliquidOrderId, CANONICAL_POSITIVE_DECIMAL_PATTERN, extractCanonicalHyperliquidOrderStateAcknowledgement, extractCanonicalHyperliquidOrderStateAcknowledgements, extractCanonicalHyperliquidFilledOrderAcknowledgement, extractDefinitiveHyperliquidOrderMemberResults, buildHyperliquidOrderDiagnostics, loadClientExecutionReferenceEvidence, sha256Hex, extractSignedPayloadClientOrderId, extractSignedPayloadMutationCorrelation, assertDurableMutationMatchesSignedAction, exchangeRejectionReason, exchangeActionPriority, submitHyperliquidExchangePayload;
 var init_hyperliquid_client = __esm({
   "lib/runtime/hyperliquid-client.ts"() {
     "use strict";
@@ -85713,6 +85928,40 @@ var init_hyperliquid_client = __esm({
       }
       return null;
     };
+    resolveHyperliquidTriggerAcknowledgements = async (payload, action, lookup) => {
+      if (action.type !== "order" || action.grouping !== "normalTpsl" && action.grouping !== "positionTpsl" || !Array.isArray(action.orders) || payload == null || typeof payload !== "object" || Array.isArray(payload)) {
+        return payload;
+      }
+      const root = payload;
+      const response = root.response;
+      const data4 = response && typeof response === "object" ? response.data : void 0;
+      const statuses = data4 && typeof data4 === "object" && Array.isArray(data4.statuses) ? data4.statuses : null;
+      if (root.status !== "ok" || response?.type !== "order" || statuses == null || statuses.length !== action.orders.length || !statuses.includes("waitingForTrigger")) {
+        return payload;
+      }
+      const resolved = [...statuses];
+      for (let index = 0; index < statuses.length; index += 1) {
+        if (statuses[index] !== "waitingForTrigger") continue;
+        const order = action.orders[index];
+        const trigger = order && typeof order === "object" ? order.t : void 0;
+        const clientOrderId = String(order?.c ?? "").trim().toLowerCase();
+        if (!trigger || typeof trigger !== "object" || !("trigger" in trigger) || !/^0x[0-9a-f]{32}$/.test(clientOrderId)) {
+          return payload;
+        }
+        let evidence;
+        try {
+          evidence = await lookup(clientOrderId);
+        } catch {
+          return payload;
+        }
+        const orderId = Number(evidence.orderId);
+        if (!evidence.responseValid || !evidence.orderMatches || evidence.orderStatus !== "open" || evidence.isTrigger !== true || !Number.isSafeInteger(orderId) || orderId <= 0) {
+          return payload;
+        }
+        resolved[index] = { resting: { oid: orderId, cloid: clientOrderId } };
+      }
+      return { ...root, response: { ...response, data: { ...data4, statuses: resolved } } };
+    };
     isDefinitiveHyperliquidExchangeResponse = (payload, action) => {
       if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
         return false;
@@ -86419,6 +86668,18 @@ var init_hyperliquid_client = __esm({
                 "outcome_unknown"
               );
             }
+            const triggerWallet = String(input.triggerAcknowledgementWalletAddress ?? "").trim();
+            if (triggerWallet) {
+              payload = await resolveHyperliquidTriggerAcknowledgements(
+                payload,
+                input.payload.action,
+                (clientOrderId) => fetchBrowserOrderStatusEvidence({
+                  ...input,
+                  walletAddress: triggerWallet,
+                  orderId: clientOrderId
+                })
+              );
+            }
             const exchangeError = extractHyperliquidExchangeError(payload);
             if (exchangeError) {
               await settleDurableMutation(
@@ -86737,7 +86998,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";
@@ -86761,6 +87022,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;
+    };
   }
 });
 
@@ -87130,7 +87402,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({
@@ -87138,7 +87413,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,
@@ -87157,8 +87435,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 } : {},
@@ -87744,7 +88029,8 @@ var init_browser_trading = __esm({
           symbol: input.symbol,
           clientOrderIds: input.members.map((member) => member.clientOrderId),
           onExchangeOrderDispatched: input.onExchangeOrderDispatched
-        }
+        },
+        triggerAcknowledgementWalletAddress: input.walletAddress ?? null
       });
     };
     executeClientModifyOrder = async (input) => {
@@ -88109,7 +88395,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";
@@ -88125,6 +88411,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(
@@ -89138,10 +89430,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,
@@ -89174,24 +89463,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;
@@ -89255,8 +89578,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,
@@ -89266,6 +89588,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);
@@ -89273,7 +89615,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(
@@ -89315,7 +89672,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,
@@ -89323,6 +89680,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
             }
@@ -89540,10 +89898,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,
@@ -89573,10 +89928,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,
@@ -89649,14 +90001,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],
@@ -90452,7 +90805,9 @@ var init_runtime_execution = __esm({
                 execution_metadata: {
                   reason_code: "protective_replacement_terminal_reconciled",
                   previous_order_id: replacement.previousOrderId,
-                  order_status: evidence.orderStatus
+                  order_status: evidence.orderStatus,
+                  protected_size: replacementLeg.size,
+                  position_tpsl: replacementLeg.positionTpsl === true
                 }
               });
               continue;
@@ -90508,7 +90863,8 @@ var init_runtime_execution = __esm({
                   reason_code: exactLivePositionTpsl ? "protective_replacement_reconciled_for_cleanup" : "protective_replacement_reconciled",
                   previous_order_id: replacement.previousOrderId,
                   trigger_price: replacement.triggerPrice,
-                  protected_size: replacement.size
+                  protected_size: replacement.size,
+                  position_tpsl: recoveredLeg.positionTpsl === true
                 }
               });
               continue;
@@ -90553,7 +90909,8 @@ var init_runtime_execution = __esm({
                   reason_code: "protective_replacement_fulfilled_reconciled",
                   previous_order_id: replacement.previousOrderId,
                   trigger_price: replacement.triggerPrice,
-                  protected_size: replacement.size
+                  protected_size: replacement.size,
+                  position_tpsl: leg.positionTpsl === true
                 }
               });
               continue;
@@ -90656,7 +91013,8 @@ var init_runtime_execution = __esm({
                     reason_code: acknowledgement.state === "fulfilled" ? "protective_replacement_fulfilled_reconciled" : "protective_replacement_reconciled",
                     previous_order_id: replacement.previousOrderId,
                     trigger_price: replacement.triggerPrice,
-                    protected_size: replacement.size
+                    protected_size: replacement.size,
+                    position_tpsl: effectiveLeg.positionTpsl === true
                   }
                 });
                 continue;
@@ -90694,7 +91052,8 @@ var init_runtime_execution = __esm({
                 reason_code: "protective_replacement_reconciled",
                 previous_order_id: replacement.previousOrderId,
                 trigger_price: replacement.triggerPrice,
-                protected_size: replacement.size
+                protected_size: replacement.size,
+                position_tpsl: canonicalReplacementLeg.positionTpsl === true
               }
             });
           } catch (error48) {
@@ -90770,7 +91129,9 @@ var init_runtime_execution = __esm({
               status: "executed",
               execution_metadata: {
                 reason_code: "protective_replacement_terminal_reconciled",
-                order_status: evidence.orderStatus
+                order_status: evidence.orderStatus,
+                protected_size: journalLeg.size,
+                position_tpsl: journalLeg.positionTpsl === true || evidence.isPositionTpsl === true
               }
             });
             continue;
@@ -91394,7 +91755,8 @@ var init_runtime_execution = __esm({
               execution_metadata: {
                 reason_code: "protective_resized_to_live_exposure",
                 previous_order_id: leg.orderId,
-                protected_size: allowedSize
+                protected_size: allowedSize,
+                position_tpsl: replacementLeg.positionTpsl === true
               }
             });
             if (fulfilledDuringResize) {
@@ -91857,7 +92219,9 @@ var init_runtime_execution = __esm({
             execution_metadata: {
               trigger_price: replacementTriggerPrice,
               previous_trigger_price: record5.triggerPrice,
-              previous_order_id: record5.orderId
+              previous_order_id: record5.orderId,
+              protected_size: effectiveSize,
+              position_tpsl: record5.positionTpsl === true
             }
           });
         } catch (error48) {
@@ -92614,41 +92978,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
           );
@@ -92679,7 +93021,7 @@ var init_runtime_execution = __esm({
             executionSnapshotCapturedAt
           };
         }
-        persistedProtectiveGroupSet = nextGroups;
+        persistedProtectiveGroupSet = pendingProtection.persistedGroupSet;
       }
       let marketOrderResponse;
       let entryDispatchBoundaryPassed = false;
@@ -93089,6 +93431,7 @@ var init_runtime_execution = __esm({
                 is_take_profit: triggerInput.isTakeProfit,
                 entry_filled_size: protectionSize,
                 protected_size: legSize,
+                position_tpsl: leg.positionTpsl === true,
                 entry_average_price: protectionEntryPrice,
                 ..._toExecutionMetadata(triggerResponse)
               }
@@ -95057,8 +95400,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")),
@@ -95417,6 +95786,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