@bitkyc08/opencodex 2.70.0 → 2.71.0

package/src/generated/compatibility-version.json

@@ -10,7 +10,7 @@
     },
     {
       "path": "package.json",
-      "sha256": "544d263f4160f9c44005c7dda17cfb0cf9215dbb9d6d6d6210d94a46ffebcea0"
+      "sha256": "94fb6ebefca26ab1c618600b5c9e836bf562f88e442cad127562d862d024cada"
     },
     {
       "path": "scripts/model-metadata.source.json",
@@ -38,7 +38,7 @@
     },
     {
       "path": "src/adapters/anthropic-model-contract.ts",
-      "sha256": "2fb5952cd82c506674802a44531853ffde6eff68aec7f4251aa0fe3e4e9ec428"
+      "sha256": "6cca852818694d3a1676c5fe89d9fb69c08a32bc857f56b9dda94bec468f3b81"
     },
     {
       "path": "src/adapters/anthropic-output-schema.ts",
@@ -46,7 +46,7 @@
     },
     {
       "path": "src/adapters/anthropic.ts",
-      "sha256": "52c8ce671984580840932732b4f7d97abc69a38c8d74c52731d1beb620803b1a"
+      "sha256": "9a01a71b8e5e97b1ae76bc26e284665e629de94ee9fa0efa087c2d09c7fd96b8"
     },
     {
       "path": "src/adapters/anthropic/beta-allowlist.ts",
@@ -578,7 +578,7 @@
     },
     {
       "path": "src/adapters/openai-chat/summary-budget.ts",
-      "sha256": "18d3f6897d1e1927370ccf8e58dcfc0cf6c76af2ca444201fcfc132d32433845"
+      "sha256": "1c96b651a6683a2b3df5089ac26e2df9e1e02612ccd09e666562345c8bfc6733"
     },
     {
       "path": "src/adapters/openai-chat/tool-call-id-remint.ts",
@@ -830,7 +830,7 @@
     },
     {
       "path": "src/claude/desktop-picker.ts",
-      "sha256": "485c1c015f3fac66fe7e915963ae0b2bafd9b203a234141205d3cb80a42f7f9b"
+      "sha256": "d10d6826b572f12f8f6b27facaa80fac7c0d98812ebb4e658f8978d10f12a687"
     },
     {
       "path": "src/claude/desktop-policy.ts",
@@ -910,7 +910,7 @@
     },
     {
       "path": "src/claude/intercept/local-ca.ts",
-      "sha256": "01a6861c05d960dcf05d5aedc295ece601c71158c76e325eaf97aac2c01c9277"
+      "sha256": "5344c5e90053515dfd8f6efe04180f0f96f66fadd1d4d20e96568a0592070919"
     },
     {
       "path": "src/claude/intercept/model-bindings.ts",
@@ -926,7 +926,7 @@
     },
     {
       "path": "src/claude/intercept/picker-ca.ts",
-      "sha256": "85dbc70a3eb84a7858c516a793ffd927f463d9a3cef3ae90be73b6b9df087e4e"
+      "sha256": "4afa56ccad7adf07082dbf49ac0c46b8f75a678b50f28bcbb5e5237a812c6c93"
     },
     {
       "path": "src/claude/intercept/picker-listener.ts",
@@ -1038,7 +1038,7 @@
     },
     {
       "path": "src/cli/capabilities.ts",
-      "sha256": "ad6781db0122e20a81f28704c3f5faf165582fc5282f813627b1c35830a2a70a"
+      "sha256": "f475daacc68ae84f891d6a1642d5accd572e797a771d176a2a54272e05abbe9b"
     },
     {
       "path": "src/cli/catalog-prewarm.ts",
@@ -1054,7 +1054,7 @@
     },
     {
       "path": "src/cli/claude-desktop.ts",
-      "sha256": "043af2fd6ca07d4993604ba5fe30ba1f078b9badf686ed89e47426b04c04ee04"
+      "sha256": "2a66d4d53877026f33185340dc2086345e1ac893575d55d57d51f72c01663efd"
     },
     {
       "path": "src/cli/claude.ts",
@@ -1098,7 +1098,7 @@
     },
     {
       "path": "src/cli/cross-home-owner.ts",
-      "sha256": "798e888ccc682cd20133591e80d77b1def832e860307032077c8acea2f040aa7"
+      "sha256": "706c4eb6706c67ad05e1c6a4c1ef4e79850ac073b492cca4202f29687bc2e006"
     },
     {
       "path": "src/cli/debug.ts",
@@ -1142,7 +1142,7 @@
     },
     {
       "path": "src/cli/index.ts",
-      "sha256": "f164658417c8a125815694fe1becdfc47d78485d5018344f4f09b7f5111ae966"
+      "sha256": "34af92d38d0ad171884ab83954043ff4d1752c0aa22c54cfed81cd72c4cb74d4"
     },
     {
       "path": "src/cli/init.ts",
@@ -1590,7 +1590,7 @@
     },
     {
       "path": "src/codex/catalog-auto-refresh.ts",
-      "sha256": "34fb5bd01876b96bc51b2f9ea2a6b9a4cb177ab94cfe6d6387ffb683db4957ee"
+      "sha256": "6c700d85818802a8d87b7b718d74a2e0da9e7bbe3e7b50eccf8a3558d7256f2c"
     },
     {
       "path": "src/codex/catalog-refresh-status.ts",
@@ -2488,6 +2488,10 @@
       "path": "src/config/openai-tier-backup.ts",
       "sha256": "dcd1ecb3020c3ff30b661121a515df27d09f750bebdd3369aa5bc0e8c95bc4e6"
     },
+    {
+      "path": "src/config/owner-registry.ts",
+      "sha256": "0d0f97d81db4cbe2ac029a79938e83119be4c76340abd8dd3c823332bad3419b"
+    },
     {
       "path": "src/config/paths.ts",
       "sha256": "37f6b7f0c9e078d7fe79e2aaf54ba2961aa4cbeb281d84b3d950e89846bfaf3f"
@@ -2514,7 +2518,7 @@
     },
     {
       "path": "src/config/process-state.ts",
-      "sha256": "7ba3e4f2df630dddaf13c3fba654b567680339580a75e9bbcb442be26376020a"
+      "sha256": "a0be3e7c31894b1cc4a23c430bc22fa300ccf95a2880364dcb7280bdb7ba16a5"
     },
     {
       "path": "src/config/provider-name.ts",
@@ -2702,12 +2706,16 @@
     },
     {
       "path": "src/integrations/cursor-detect.ts",
-      "sha256": "ec3c7c03cb7652bd7c89eee4a285fefd0c2c0fa4c641238fda91b977ac12f02c"
+      "sha256": "5218146125d92d9d5fa7f51743b85618ab84ecdbb8710d0e85d58baf62c41821"
     },
     {
       "path": "src/integrations/cursor-effort-table.ts",
       "sha256": "34b27afb34f2169c042354998e4af91616075f27bd6b086457ae50be8d6194d4"
     },
+    {
+      "path": "src/integrations/cursor-local-installer.ts",
+      "sha256": "a771e3ace879f3b8dae8f9b9fa58046e43845e2539edafa31c521dc6fe2894ab"
+    },
     {
       "path": "src/integrations/cursor-seen.ts",
       "sha256": "ed100257d59585f2f42c46157f844a44f0f53ec66f82cbd267675baef798e231"
@@ -5142,7 +5150,7 @@
     },
     {
       "path": "src/server/management/cursor-integration-routes.ts",
-      "sha256": "b277f6f26c89d9ba993767258b61a879fb693747e2455bcb8b39f0df90c7c14b"
+      "sha256": "767a0c404c3c3c30cc4610749a21008570abfcdda8304a158a2b3267e97527bf"
     },
     {
       "path": "src/server/management/grok-coupon-routes.ts",
@@ -5230,7 +5238,7 @@
     },
     {
       "path": "src/server/management/route-registry.ts",
-      "sha256": "6a1f07048c2e5e3d5ada58d0ec481443857f283fec7c982b98aa36b370804b0c"
+      "sha256": "0ab475d125edf34c9f0617980289f992db73fba000e3a3080818730151d2d2e9"
     },
     {
       "path": "src/server/management/routing-analytics-routes.ts",
@@ -5326,7 +5334,7 @@
     },
     {
       "path": "src/server/port-reclaim.ts",
-      "sha256": "e661479d0a1d5ec8e088c76c9c592cccab523c9fb0a791641a8ba14cd9613bf0"
+      "sha256": "e020d6243d94e77b97977ab5db7b5601123d8d9e1382dbbcc2bb4f88d5ba694b"
     },
     {
       "path": "src/server/ports.ts",
@@ -5334,7 +5342,7 @@
     },
     {
       "path": "src/server/proxy-liveness.ts",
-      "sha256": "dc9f452951c0544ff70e1a905d17d0eed7711ee8eab24eae4d3584fc00af6d65"
+      "sha256": "33f225eb0132bf2b5e2f6f3415613e034c149a7ada4dd578925c5dddeb427390"
     },
     {
       "path": "src/server/readiness.ts",
@@ -5916,6 +5924,10 @@
       "path": "src/service/windows-ops.ts",
       "sha256": "fd1343ec88bc57fbec24a90e7662567cbb5e8883133826038caca643198d3e50"
     },
+    {
+      "path": "src/service/windows-process-priority.ts",
+      "sha256": "59d3f6685f884fc11e6d2e1a0f3edd729c4c01355aa01a26d202b7ea89520e05"
+    },
     {
       "path": "src/service/windows-scheduler.ts",
       "sha256": "bc47a79ea9427d27eb6b127f63b7be80efc05d355bac2fb7762250c9d222256f"
@@ -6350,7 +6362,7 @@
     },
     {
       "path": "src/vision/anthropic-describe.ts",
-      "sha256": "c5045ffe5348fe61c4a0cde1d4a1d9684b9b8903e8c606e6a481a144d5e867fe"
+      "sha256": "b696ff4e1deaf7b00a03487902776dc7da9a237f61590ff70fbcc8dd10500fed"
     },
     {
       "path": "src/vision/backends.ts",
@@ -6394,7 +6406,7 @@
     },
     {
       "path": "src/web-search/anthropic-executor.ts",
-      "sha256": "bc1deeffae45b62714e8d30e9cebad2333f795fa8db9768d54007f6da7b770c0"
+      "sha256": "de002f4ba40b28f94e014a3cf39e37dcaf920d9f612addd6c449d24a4fef51a3"
     },
     {
       "path": "src/web-search/backends.ts",

package/src/integrations/cursor-detect.ts

@@ -91,8 +91,9 @@ export function cursorProductJsonCandidates(deps: CursorDetectDeps): Array<{ roo
     return out;
   }
   // Linux: AppImages carry product.json only once extracted, so this covers the tarball /
-  // package layouts and stays best-effort.
-  for (const dir of ["/opt", join(deps.homedir, ".local", "share")]) {
+  // package layouts and stays best-effort. /usr/share covers distro-style installs of the
+  // tarball (e.g. /usr/share/cursor), which is where the Private Inference .deb lands.
+  for (const dir of ["/opt", "/usr/share", join(deps.homedir, ".local", "share")]) {
     for (const entry of deps.listDir(dir)) {
       if (!/^cursor/i.test(entry)) continue;
       const root = join(dir, entry);

package/src/integrations/cursor-local-installer.ts

@@ -0,0 +1,150 @@
+/**
+ * The `cursor-local` update channel is how Cursor now distributes Private Inference: a
+ * same-version installer advertised through the regular install's own update endpoint
+ * (Cursor 3.21.18+). Regular Cursor users were previously told "not found" with no path
+ * forward; the channel manifest is the path forward, surfaced read-only.
+ *
+ * This module never downloads, launches, or installs anything: it formats one URL the
+ * dashboard shows the user. The manifest request is a plain GET of a public endpoint and
+ * its failure degrades to `available: false` with the reason recorded — the update
+ * endpoint is undocumented and can change shape or vanish without notice.
+ *
+ * The lookup runs only on an explicit dashboard action, never from the polled status route. The
+ * answer is cached per update host and platform (successes for 30 minutes, failures for 5) and
+ * concurrent lookups share one request: repeated presses against a slow or unreachable channel
+ * cost at most one bounded wait per failure window.
+ */
+const DEFAULT_UPDATE_HOST = "https://api2.cursor.sh";
+
+const UPDATE_MANIFEST_TIMEOUT_MS = 4_000;
+const CACHE_TTL_OK_MS = 30 * 60_000;
+const CACHE_TTL_FAILED_MS = 5 * 60_000;
+
+/** Channel segments for the builds Cursor ships; Windows uses the per-user installer. */
+const PLATFORMS = ["win32-x64-user", "win32-arm64-user", "darwin-x64", "darwin-arm64", "linux-x64", "linux-arm64"] as const;
+
+export type CursorLocalPlatform = (typeof PLATFORMS)[number];
+
+export interface CursorLocalInstallerHint {
+  /** Whether the channel advertised an installer the dashboard can name. */
+  available: boolean;
+  /** The download URL from the manifest, when one was advertised. */
+  url: string | null;
+  /** The advertised installer version, when the manifest carried one. */
+  version: string | null;
+  /**
+   * Why nothing was advertised: no regular install, a host Cursor ships no build for,
+   * an unreachable manifest, or an unusable answer.
+   */
+  reason: "no-regular-install" | "unsupported-platform" | "unreachable" | "unusable-response" | null;
+}
+
+interface CursorLocalManifest {
+  version?: unknown;
+  url?: unknown;
+  productVersion?: unknown;
+  /** The macOS manifests carry the version only here. */
+  name?: unknown;
+}
+
+interface CursorLocalHintDeps {
+  platform: string;
+  /** `process.arch` values; the installer is architecture-specific. */
+  arch: string;
+  fetchJson(url: string, timeoutMs: number): Promise<unknown>;
+  /** Clock for the cache; defaults to `Date.now`. */
+  now?(): number;
+}
+
+export function realCursorLocalHintDeps(): CursorLocalHintDeps {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    fetchJson: async (url, timeoutMs) => {
+      const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      return response.json();
+    },
+  };
+}
+
+/**
+ * The channel segment for this host, or null when Cursor ships no build for it. The installer
+ * is architecture-specific, so only `x64` and `arm64` map; any other CPU (ia32, arm, riscv64…)
+ * or OS gets no link rather than another machine's build.
+ */
+export function platformForHost(os: string, arch: string): CursorLocalPlatform | null {
+  if (arch !== "x64" && arch !== "arm64") return null;
+  switch (os) {
+    case "win32": return arch === "arm64" ? "win32-arm64-user" : "win32-x64-user";
+    case "darwin": return arch === "arm64" ? "darwin-arm64" : "darwin-x64";
+    case "linux": return arch === "arm64" ? "linux-arm64" : "linux-x64";
+    default: return null;
+  }
+}
+
+function parseManifest(raw: unknown): { version: string; url: string } | null {
+  if (!raw || typeof raw !== "object") return null;
+  const record = raw as CursorLocalManifest;
+  if (typeof record.url !== "string" || !/^https:\/\/downloads\.cursor\.com\/local-mode\//.test(record.url)) {
+    return null;
+  }
+  // Windows and Linux manifests carry `version`/`productVersion`; the Darwin ones return only
+  // `{ url, name }`, with the version in `name`.
+  const candidate = typeof record.version === "string" ? record.version
+    : typeof record.productVersion === "string" ? record.productVersion
+      : typeof record.name === "string" ? record.name : "";
+  const version = candidate.trim();
+  if (version === "") return null;
+  // The Linux channel advertises the AppImage's zsync delta metadata (what the in-app updater
+  // consumes); the installer a person downloads is the sibling AppImage at the same path.
+  return { version, url: record.url.replace(/\.AppImage\.zsync$/, ".AppImage") };
+}
+
+type ResolvedHint = Omit<CursorLocalInstallerHint, "reason"> & { reason: "unreachable" | "unusable-response" | null };
+
+async function resolveInstaller(deps: CursorLocalHintDeps, updateHost: string, platform: CursorLocalPlatform): Promise<ResolvedHint> {
+  const manifestUrl = `${updateHost}/updates/api/update/${platform}/cursor-local/0.0.0/manual-check/stable`;
+  let raw: unknown;
+  try {
+    raw = await deps.fetchJson(manifestUrl, UPDATE_MANIFEST_TIMEOUT_MS);
+  } catch {
+    return { available: false, url: null, version: null, reason: "unreachable" };
+  }
+  const installer = parseManifest(raw);
+  if (!installer) return { available: false, url: null, version: null, reason: "unusable-response" };
+  return { available: true, url: installer.url, version: installer.version, reason: null };
+}
+
+const cache = new Map<string, { expiresAt: number; value: Promise<ResolvedHint> }>();
+
+export function resetCursorLocalInstallerCacheForTests(): void {
+  cache.clear();
+}
+
+/**
+ * Build the installer hint for the dashboard's Cursor card. The hint is only resolved
+ * when a regular install exists but Private Inference does not — the exact "not found"
+ * state the card could previously do nothing about.
+ */
+export async function buildCursorLocalInstallerHint(
+  installs: { regularInstalled: boolean; privateInferenceInstalled: boolean },
+  deps: CursorLocalHintDeps = realCursorLocalHintDeps(),
+  updateHost: string = DEFAULT_UPDATE_HOST,
+): Promise<CursorLocalInstallerHint> {
+  if (installs.privateInferenceInstalled || !installs.regularInstalled) {
+    return { available: false, url: null, version: null, reason: installs.privateInferenceInstalled ? null : "no-regular-install" };
+  }
+  const platform = platformForHost(deps.platform, deps.arch);
+  if (!platform) return { available: false, url: null, version: null, reason: "unsupported-platform" };
+  const now = deps.now ?? Date.now;
+  const key = `${updateHost} ${platform}`;
+  const cached = cache.get(key);
+  if (cached && cached.expiresAt > now()) return cached.value;
+  const value = resolveInstaller(deps, updateHost, platform);
+  // The in-flight promise is shared immediately; its lifetime is settled once it answers.
+  cache.set(key, { expiresAt: Number.POSITIVE_INFINITY, value });
+  const settled = await value;
+  cache.set(key, { expiresAt: now() + (settled.available ? CACHE_TTL_OK_MS : CACHE_TTL_FAILED_MS), value });
+  return settled;
+}

package/src/server/management/cursor-integration-routes.ts

@@ -12,6 +12,7 @@ import { readRuntimePort } from "../../config/process-state";
 import { filterCatalogVisibleModels, nativeContextLimits, nativeOpenAiContextTier, nativeReasoningEfforts, uniqueCatalogModelsForRawPublicList, visibleNativeSlugs } from "../../codex/catalog";
 import { cursorLastSeen, type CursorSeen } from "../../integrations/cursor-seen";
 import { detectCursorInstalls, type CursorInstall } from "../../integrations/cursor-detect";
+import { buildCursorLocalInstallerHint, type CursorLocalInstallerHint } from "../../integrations/cursor-local-installer";
 import { loadCursorEffortTable } from "../../integrations/cursor-effort-table";
 import { configuredApiAuthToken, isApiAuthRequired, jsonResponse } from "../auth-cors";
 import { localInferenceDestination } from "../../lib/local-destinations";
@@ -127,10 +128,29 @@ export async function buildCursorIntegrationStatus(
   };
 }
 
+/**
+ * The cursor-local installer the update channel advertises (#5679), resolved only on an explicit
+ * user action. The status route above is polled while the Cursor tab is open and must stay
+ * local, so the remote channel lookup lives behind its own route the dashboard calls from a
+ * button, never on page load.
+ */
+export function resolveCursorLocalInstaller(
+  installs: CursorInstall[] = detectCursorInstalls(),
+  deps?: Parameters<typeof buildCursorLocalInstallerHint>[1],
+): Promise<CursorLocalInstallerHint> {
+  return buildCursorLocalInstallerHint({
+    regularInstalled: pick(installs, "regular") !== undefined,
+    privateInferenceInstalled: pick(installs, "private-inference") !== undefined,
+  }, deps);
+}
+
 export async function handleCursorIntegrationRoutes(ctx: ManagementContext): Promise<Response | null> {
   const { req, url } = ctx;
   if (url.pathname === "/api/native-integrations/cursor" && req.method === "GET") {
     return jsonResponse(await buildCursorIntegrationStatus(ctx));
   }
+  if (url.pathname === "/api/native-integrations/cursor/local-installer" && req.method === "GET") {
+    return jsonResponse(await resolveCursorLocalInstaller());
+  }
   return null;
 }

package/src/server/management/route-registry.ts

@@ -289,6 +289,7 @@ export const MANAGEMENT_ROUTES: readonly ManagementRoute[] = [
   { method: "PUT", path: "/api/native-integrations/grok", module: "server/management/native-integration-routes", mutates: true },
   // server/management/cursor-integration-routes
   { method: "GET", path: "/api/native-integrations/cursor", module: "server/management/cursor-integration-routes", mutates: false },
+  { method: "GET", path: "/api/native-integrations/cursor/local-installer", module: "server/management/cursor-integration-routes", mutates: false },
   // server/management/oauth-account-routes
   { method: "DELETE", path: "/api/keys", module: "server/management/oauth-account-routes", mutates: true },
   { method: "DELETE", path: "/api/keys/rotate", module: "server/management/oauth-account-routes", mutates: true },

package/src/server/port-reclaim.ts

@@ -148,10 +148,58 @@ export function parseListenPidsFromNetstat(output: string, port: number): number
   return [...new Set(parseListenEntriesFromNetstat(output, port).map(entry => entry.pid))];
 }
 
+/**
+ * Field names `ss -p` is known to emit inside a `users:` tuple. comm names are printed
+ * unescaped and are attacker-controlled, but bounded to 15 bytes (TASK_COMM_LEN - 1):
+ * a forged complete tuple needs `",pid=N,fd=N),("` — closing one tuple and opening the
+ * next leaves no room for a nonempty name — and a forged in-tuple field needs a key
+ * outside this list to stay under the bound, so it trips the grammar check instead.
+ */
+const SS_OWNER_FIELD_KEYS = new Set(["fd", "ino", "sk", "v6only"]);
+
+/**
+ * Strictly parse a `users:(("name",pid=N,fd=N)[,("name2",...)])` column, returning every
+ * attributed PID, or null when the column deviates from the grammar anywhere — a row that
+ * cannot be trusted must not attribute an owner at all. Every accepted tuple must carry
+ * its own `fd=`: a forged tuple fragment emitted inside a comm (a 15-byte comm has room
+ * for `a",pid=N),("b` but never for a full tuple plus `fd=`) supplies only `pid=`, so
+ * its PID must never reach the owner list.
+ */
+function parseSsOwnerPids(field: string): number[] | null {
+  if (!field.startsWith("users:(")) return null;
+  const pids: number[] = [];
+  let at = "users:(".length;
+  while (field.startsWith("(", at)) {
+    at += 1;
+    // ss prints comm raw between quotes with no escaping; a quote inside the name
+    // therefore ends it early and the rest of the name lands in field position.
+    const name = /^"[^"\n]*"/.exec(field.slice(at));
+    if (name === null || name[0] === `""`) return null;
+    at += name[0].length;
+    const pid = /^,pid=(\d+)/.exec(field.slice(at));
+    if (pid === null) return null;
+    at += pid[0].length;
+    let hasFd = false;
+    for (;;) {
+      const kv = /^,([a-z_]+)=([^,"()\s]+)/.exec(field.slice(at));
+      if (kv === null) break;
+      if (!SS_OWNER_FIELD_KEYS.has(kv[1]!)) return null;
+      if (kv[1] === "fd") hasFd = true;
+      at += kv[0].length;
+    }
+    if (field[at] !== ")" || !hasFd) return null;
+    pids.push(Number(pid[1]));
+    at += 1;
+    if (field.startsWith(",(", at)) at += 1;
+  }
+  return field[at] === ")" && field.slice(at + 1).trim() === "" ? pids : null;
+}
+
 /**
  * Parse `ss -Hltnp` rows for a port, keeping each distinct PID/address pair. A row
- * without a `pid=` attribution (another user's socket) is dropped rather than
- * reported unverifiable. Exported for unit tests.
+ * without a `pid=` attribution (another user's socket), or whose `users:` column
+ * does not parse cleanly, is dropped rather than reported unverifiable. Exported
+ * for unit tests.
  */
 export function parseListenEntriesFromSs(output: string, port: number): ListenEntry[] {
   const entries = new Map<string, ListenEntry>();
@@ -163,11 +211,13 @@ export function parseListenEntriesFromSs(output: string, port: number): ListenEn
     // LISTEN <recv-q> <send-q> <local-addr:port> <peer-addr:port> users:(...)
     const localIdx = parts.findIndex(part => part.endsWith(portSuffix) || part.endsWith(`]:${port}`));
     if (localIdx < 0) continue;
-    const pidMatch = /pid=(\d+)/.exec(line);
-    const pid = pidMatch ? Number(pidMatch[1]) : NaN;
-    if (Number.isSafeInteger(pid) && pid > 0) {
-      const address = normalizeListenAddress(parts[localIdx]);
-      entries.set(`${pid}|${address}`, { pid, address });
+    const usersIdx = line.indexOf("users:(");
+    if (usersIdx < 0) continue;
+    const ownerPids = parseSsOwnerPids(line.slice(usersIdx));
+    if (ownerPids === null) continue;
+    const address = normalizeListenAddress(parts[localIdx]);
+    for (const pid of ownerPids) {
+      if (Number.isSafeInteger(pid) && pid > 0) entries.set(`${pid}|${address}`, { pid, address });
     }
   }
   return [...entries.values()];

package/src/server/proxy-liveness.ts

@@ -185,9 +185,17 @@ export interface LiveProxy {
 /**
  * A /healthz identity proves only that a proxy holds the port. Before a destructive orphan stop,
  * require that listener to prove possession of this home's runtime-record secret as well.
+ *
+ * The verdict is three-valued on purpose. "proven" is the only answer that authorizes the
+ * caller's action; "refuted" means the answer was definitive (no record, a pid/port
+ * mismatch, or a failed proof); "indeterminate" means transport, deadline, or an
+ * unattestable record left the question open, which a shared-write decision must treat
+ * the same as a live owner it simply could not verify (#6198).
  */
-export async function proveLiveProxyOwnedByHome(live: LiveProxy, io: LivenessIo = {}): Promise<boolean> {
-  if (live.pid === null) return false;
+export type HomeOwnershipProof = "proven" | "refuted" | "indeterminate";
+
+export async function proveLiveProxyOwnedByHome(live: LiveProxy, io: LivenessIo = {}): Promise<HomeOwnershipProof> {
+  if (live.pid === null) return "indeterminate";
   return attestFencedIdentity(
     `http://${probeHostname(live.hostname)}:${live.port}/healthz`,
     live.port,
@@ -258,31 +266,50 @@ async function attestFencedIdentity(
   io: LivenessIo,
   fetchFn: LivenessFetch,
   timeoutMs: number,
-): Promise<boolean> {
+): Promise<HomeOwnershipProof> {
   const readRuntimeFn = io.readRuntimeFn ?? readRuntimePort;
   let record: ReturnType<NonNullable<LivenessIo["readRuntimeFn"]>>;
   try {
     record = readRuntimeFn(pid);
   } catch {
-    return false;
+    return "indeterminate";
   }
   // The typed seam omits the secret; the production record (readRuntimePort) carries it.
   const secret: unknown = record ? Reflect.get(record, "attestationSecret") : undefined;
-  if (!record || record.pid !== pid || record.port !== port || typeof secret !== "string") return false;
+  if (!record || record.pid !== pid || record.port !== port) return "refuted";
+  if (typeof secret !== "string" || secret.length === 0) return "indeterminate";
   const challenge = (io.createChallengeFn ?? createLocalAttestationChallenge)();
-  try {
-    const res = await fetchFn(url, {
-      headers: { [LOCAL_ATTESTATION_CHALLENGE_HEADER]: challenge },
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    const body = (await res.json().catch(() => null)) as HealthzIdentity | null;
-    // The second answer must still be the same fenced (or by now healthy) process.
-    if (!isOpencodexHealthz(body) && !isPackageTreeFencedHealthz(body)) return false;
-    if (body?.pid !== pid) return false;
-    return verifyLocalAttestationProof(secret, challenge, pid, port, res.headers.get(LOCAL_ATTESTATION_PROOF_HEADER));
-  } catch {
-    return false;
+  // One proof failure is definitive and never retried; a transport failure only means
+  // the listener did not answer yet, so it gets the same bounded retry the identity
+  // probe uses — "did not answer" is not "not ours" (#6198). The challenge is minted
+  // once: a retried attempt proves the same fresh nonce, not a replayed proof.
+  const sleepFn = io.sleepFn ?? ((ms: number) => new Promise<void>(r => setTimeout(r, ms)));
+  const nowFn = io.nowFn ?? Date.now;
+  const requestedAttempts = Math.trunc(io.attempts ?? 1);
+  const attempts = Number.isNaN(requestedAttempts)
+    ? 1
+    : Math.max(1, Math.min(requestedAttempts, 5));
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const remainingMs = io.deadlineAt === undefined ? timeoutMs : Math.min(timeoutMs, io.deadlineAt - nowFn());
+    if (remainingMs <= 0) return "indeterminate";
+    try {
+      const res = await fetchFn(url, {
+        headers: { [LOCAL_ATTESTATION_CHALLENGE_HEADER]: challenge },
+        signal: AbortSignal.timeout(remainingMs),
+      });
+      const body = (await res.json().catch(() => null)) as HealthzIdentity | null;
+      // The second answer must still be the same fenced (or by now healthy) process.
+      if (!isOpencodexHealthz(body) && !isPackageTreeFencedHealthz(body)) return "refuted";
+      if (body?.pid !== pid) return "refuted";
+      return verifyLocalAttestationProof(secret, challenge, pid, port, res.headers.get(LOCAL_ATTESTATION_PROOF_HEADER))
+        ? "proven"
+        : "refuted";
+    } catch {
+      if (attempt >= attempts) return "indeterminate";
+      await sleepFn(100);
+    }
   }
+  return "indeterminate";
 }
 
 /** A bounded version string safe to carry beyond the untrusted health response. */
@@ -317,7 +344,7 @@ export function isConnectionRefused(error: unknown): boolean {
   return visit(error, 0);
 }
 
-async function classifyHealthz(
+export async function classifyHealthz(
   url: string,
   fetchFn: LivenessFetch,
   timeoutMs: number,
@@ -391,7 +418,7 @@ export async function proxyIdentityAt(
         if (opts.expectedPid !== undefined && fencedPid !== opts.expectedPid) return null;
         const attestMs = io.deadlineAt === undefined ? baseTimeoutMs : Math.min(baseTimeoutMs, io.deadlineAt - nowFn());
         if (attestMs <= 0) return null;
-        if (!(await attestFencedIdentity(url, port, fencedPid, io, fetchFn, attestMs))) return null;
+        if ((await attestFencedIdentity(url, port, fencedPid, io, fetchFn, attestMs)) !== "proven") return null;
         const fencedVersion = isHealthzVersion(fenced?.version) ? fenced!.version as string : undefined;
         return {
           pid: fencedPid,

package/src/service/windows-process-priority.ts

@@ -0,0 +1,39 @@
+import { constants as osConstants, setPriority } from "node:os";
+
+/**
+ * Windows proxy scheduling priority.
+ *
+ * The Task Scheduler definition runs the proxy at NORMAL (task XML `<Priority>4</Priority>`,
+ * #3682). On a host saturated by unrelated NORMAL-priority work (Defender scans, encoders,
+ * emulators), the proxy's main thread can sit runnable-but-unscheduled for seconds, so
+ * `/healthz` misses the 750 ms CLI liveness ceiling and every verb reports "Proxy not
+ * reachable" while the listener is up. ABOVE_NORMAL lets the Windows scheduler pick the
+ * mostly idle proxy ahead of that work without HIGH's ability to starve the desktop.
+ *
+ * Best-effort and never fatal: a refused priority change leaves the process at NORMAL.
+ * Processes the proxy spawns do not inherit ABOVE_NORMAL; Windows only propagates IDLE and
+ * BELOW_NORMAL classes to children. `OCX_DISABLE_PRIORITY_BOOST=1` opts out.
+ */
+export interface ProcessPriorityDeps {
+  platform: NodeJS.Platform;
+  disabled: () => boolean;
+  setPriority: (pid: number, priority: number) => void;
+}
+
+const defaults: ProcessPriorityDeps = {
+  platform: process.platform,
+  disabled: () => process.env.OCX_DISABLE_PRIORITY_BOOST === "1",
+  setPriority,
+};
+
+export type ProcessPriorityResult = "raised" | "skipped" | "failed";
+
+export function raiseWindowsProxyPriority(deps: ProcessPriorityDeps = defaults): ProcessPriorityResult {
+  if (deps.platform !== "win32" || deps.disabled()) return "skipped";
+  try {
+    deps.setPriority(0, osConstants.priority.PRIORITY_ABOVE_NORMAL);
+    return "raised";
+  } catch {
+    return "failed";
+  }
+}

package/src/vision/anthropic-describe.ts

@@ -182,7 +182,7 @@ export async function describeImageAnthropic(
   const body = {
     model: settings.model,
     max_tokens: ANTHROPIC_VISION_MAX_TOKENS,
-    thinking: sidecarThinkingOff(settings.model),
+    ...sidecarThinkingOff(settings.model),
     system: [
       { type: "text", text: CLAUDE_CODE_SYSTEM_INSTRUCTION },
       { type: "text", text: DESCRIBE_INSTRUCTION },