overlord-cli 0.2608141252.0 → 0.2608170844.0

package/dist/index.js

@@ -278,16 +278,16 @@ function resolveCommandArgs({
   return parsed;
 }
 function normalizeVersion(raw) {
-  const trimmed7 = raw.trim();
-  if (!trimmed7) {
+  const trimmed8 = raw.trim();
+  if (!trimmed8) {
     throw new CliError({ message: "Received an empty version from npm." });
   }
   try {
-    const parsed = JSON.parse(trimmed7);
+    const parsed = JSON.parse(trimmed8);
     if (typeof parsed === "string" && parsed.trim()) return parsed.trim();
   } catch {
   }
-  return trimmed7.replace(/^"+|"+$/g, "");
+  return trimmed8.replace(/^"+|"+$/g, "");
 }
 function compareVersions(left, right) {
   const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
@@ -1346,11 +1346,11 @@ import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, wr
 import os from "node:os";
 import path3 from "node:path";
 function normalizeBackendUrl(value) {
-  const trimmed7 = value.trim().replace(/\/+$/, "");
-  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed7)) {
-    return trimmed7;
+  const trimmed8 = value.trim().replace(/\/+$/, "");
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed8)) {
+    return trimmed8;
   }
-  return `http://${trimmed7}`;
+  return `http://${trimmed8}`;
 }
 function isLoopbackBackendUrl(backendUrl) {
   try {
@@ -2412,12 +2412,12 @@ function parseConnectorManifestYaml(text) {
   };
   for (const rawLine of text.split("\n")) {
     const line = rawLine.replace(/\r$/, "");
-    const trimmed7 = line.trim();
-    if (trimmed7 === "" || trimmed7.startsWith("#")) continue;
+    const trimmed8 = line.trim();
+    if (trimmed8 === "" || trimmed8.startsWith("#")) continue;
     const indent = line.length - line.trimStart().length;
     if (pending) {
       if (indent > pending.indent) {
-        const container = trimmed7.startsWith("- ") ? [] : {};
+        const container = trimmed8.startsWith("- ") ? [] : {};
         pending.parent[pending.key] = container;
         stack.push({ indent, container });
         pending = null;
@@ -2430,16 +2430,16 @@ function parseConnectorManifestYaml(text) {
       stack.pop();
     }
     const frame = stack[stack.length - 1];
-    if (trimmed7.startsWith("- ")) {
+    if (trimmed8.startsWith("- ")) {
       if (Array.isArray(frame.container)) {
-        frame.container.push(parseScalar(trimmed7.slice(2)));
+        frame.container.push(parseScalar(trimmed8.slice(2)));
       }
       continue;
     }
-    const colon = trimmed7.indexOf(":");
+    const colon = trimmed8.indexOf(":");
     if (colon < 0 || Array.isArray(frame.container)) continue;
-    const key = trimmed7.slice(0, colon).trim();
-    const rest = trimmed7.slice(colon + 1).trim();
+    const key = trimmed8.slice(0, colon).trim();
+    const rest = trimmed8.slice(colon + 1).trim();
     if (rest === "") {
       pending = { parent: frame.container, key, indent };
     } else {
@@ -2633,10 +2633,10 @@ ${managedBlock}
 
 ${after}`;
   }
-  const trimmed7 = existingContent.trimEnd();
-  if (!trimmed7) return `${managedBlock}
+  const trimmed8 = existingContent.trimEnd();
+  if (!trimmed8) return `${managedBlock}
 `;
-  return `${trimmed7}
+  return `${trimmed8}
 
 ${managedBlock}
 `;
@@ -3073,16 +3073,21 @@ function normalizeBaseUrl4(value) {
 function resolveAuthHeaders({ baseUrl }) {
   const fromEnv = process.env.OVERLORD_USER_TOKEN?.trim() || process.env.OVLD_USER_TOKEN?.trim() || process.env.USER_TOKEN?.trim();
   if (fromEnv) {
-    return { headers: { Authorization: `Bearer ${fromEnv}` }, fromStored: false };
+    return {
+      headers: { Authorization: `Bearer ${fromEnv}` },
+      fromStored: false,
+      storedCredentialBackendUrl: null
+    };
   }
   const stored = readStoredAuthCredentials();
-  if (!stored) return { headers: {}, fromStored: false };
+  if (!stored) return { headers: {}, fromStored: false, storedCredentialBackendUrl: null };
   if (normalizeBaseUrl4(stored.backendUrl) !== normalizeBaseUrl4(baseUrl)) {
-    return { headers: {}, fromStored: false };
+    return { headers: {}, fromStored: false, storedCredentialBackendUrl: stored.backendUrl };
   }
   return {
     headers: { Authorization: `Bearer ${stored.token}` },
-    fromStored: true
+    fromStored: true,
+    storedCredentialBackendUrl: null
   };
 }
 async function readResponseJson2(response) {
@@ -3146,6 +3151,12 @@ function createBackendClient() {
   }) {
     const url = `${baseUrl}${path34.startsWith("/") ? path34 : `/${path34}`}`;
     const auth = resolveAuthHeaders({ baseUrl });
+    if (auth.storedCredentialBackendUrl) {
+      throw new CliError({
+        message: `Saved credentials are for ${normalizeBaseUrl4(auth.storedCredentialBackendUrl)}, but this CLI is configured for ${baseUrl}.
+The backend URL may have changed. Run \`ovld auth login\` to sign in to the current backend.`
+      });
+    }
     let response;
     try {
       response = await fetch(url, {
@@ -5555,8 +5566,8 @@ function resolveNativeSessionId({
   env = process.env
 }) {
   if (explicit !== void 0) {
-    const trimmed7 = explicit.trim();
-    return trimmed7 === "null" ? null : trimmed7 || void 0;
+    const trimmed8 = explicit.trim();
+    return trimmed8 === "null" ? null : trimmed8 || void 0;
   }
   const normalizedAgent = agent.toLowerCase();
   if (normalizedAgent === "codex") {
@@ -16324,22 +16335,22 @@ var init_contract = __esm({
 
 // ../packages/contract/dist/agent-launch-flags.js
 function parseAgentLaunchFlagText(text) {
-  const trimmed7 = text.trim();
-  if (!trimmed7)
+  const trimmed8 = text.trim();
+  if (!trimmed8)
     return null;
-  const eqIndex = trimmed7.indexOf("=");
-  if (eqIndex > 0 && trimmed7.startsWith("--")) {
-    const name = trimmed7.slice(0, eqIndex).trim();
-    const value = trimmed7.slice(eqIndex + 1).trim();
+  const eqIndex = trimmed8.indexOf("=");
+  if (eqIndex > 0 && trimmed8.startsWith("--")) {
+    const name = trimmed8.slice(0, eqIndex).trim();
+    const value = trimmed8.slice(eqIndex + 1).trim();
     return name ? { name, value: value.length > 0 ? value : null } : null;
   }
-  const spaceIndex = trimmed7.indexOf(" ");
-  if (spaceIndex > 0 && trimmed7.startsWith("--")) {
-    const name = trimmed7.slice(0, spaceIndex).trim();
-    const value = trimmed7.slice(spaceIndex + 1).trim();
+  const spaceIndex = trimmed8.indexOf(" ");
+  if (spaceIndex > 0 && trimmed8.startsWith("--")) {
+    const name = trimmed8.slice(0, spaceIndex).trim();
+    const value = trimmed8.slice(spaceIndex + 1).trim();
     return name ? { name, value: value.length > 0 ? value : null } : null;
   }
-  return { name: trimmed7 };
+  return { name: trimmed8 };
 }
 function normalizeAgentLaunchFlags(input) {
   if (!Array.isArray(input))
@@ -16490,11 +16501,11 @@ function accessModeToResourcePathPermission({ accessMode, isPrimary = false }) {
   return accessMode === "read" ? "ro" : "rw";
 }
 function formatResourcePathWithPermission({ path: path34, accessMode, isPrimary = false }) {
-  const trimmed7 = path34.trim();
-  if (!trimmed7)
+  const trimmed8 = path34.trim();
+  if (!trimmed8)
     return "";
   const permission = accessModeToResourcePathPermission({ accessMode, isPrimary });
-  return `${trimmed7}:${permission}`;
+  return `${trimmed8}:${permission}`;
 }
 function formatProjectResourcePathsFromManifest(projectResources) {
   if (!Array.isArray(projectResources))
@@ -16632,12 +16643,304 @@ var init_terminal_profile_types2 = __esm({
   }
 });
 
-// ../packages/core/dist/service/latch-launch.js
+// ../packages/core/dist/service/latch-discovery.js
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync14, statSync as statSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import os3 from "node:os";
+import path15 from "node:path";
+function defaultLatchDiscoveryCachePath() {
+  const home = process.env.OVLD_HOME?.trim() || path15.join(os3.homedir(), ".ovld");
+  return path15.join(home, LATCH_DISCOVERY_CACHE_FILENAME);
+}
 function trimmed2(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
+function asBoolean(value) {
+  return value === true;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function parseLatchCapabilitiesReport(raw) {
+  const text = raw.trim();
+  if (!text)
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return null;
+  const cast = parsed;
+  const protocolVersion = typeof cast.protocolVersion === "number" && Number.isFinite(cast.protocolVersion) ? Math.trunc(cast.protocolVersion) : null;
+  const productVersion = trimmed2(cast.productVersion);
+  if (protocolVersion === null || !productVersion)
+    return null;
+  if (!cast.capabilities || typeof cast.capabilities !== "object" || Array.isArray(cast.capabilities)) {
+    return null;
+  }
+  const caps = cast.capabilities;
+  return {
+    protocolVersion,
+    productVersion,
+    capabilities: {
+      create: asBoolean(caps.create),
+      openViewer: asBoolean(caps.openViewer),
+      localAttach: asBoolean(caps.localAttach),
+      cloudAttach: asBoolean(caps.cloudAttach),
+      selfUpdate: asBoolean(caps.selfUpdate),
+      extensions: asStringArray(caps.extensions)
+    }
+  };
+}
+function evaluateLatchCapabilities({ report, executable, resolvedPath, checkedAt = (/* @__PURE__ */ new Date()).toISOString() }) {
+  if (report.protocolVersion !== SUPPORTED_LATCH_PROTOCOL_VERSION) {
+    return {
+      state: "incompatible",
+      executable,
+      resolvedPath,
+      protocolVersion: report.protocolVersion,
+      productVersion: report.productVersion,
+      missingCapability: "protocolVersion",
+      detail: `Latch protocolVersion ${report.protocolVersion} is not supported (need ${SUPPORTED_LATCH_PROTOCOL_VERSION}).`,
+      checkedAt,
+      latchSelectable: false,
+      directSelectable: true
+    };
+  }
+  for (const required of REQUIRED_LATCH_CAPABILITIES) {
+    if (!report.capabilities[required]) {
+      return {
+        state: "incompatible",
+        executable,
+        resolvedPath,
+        protocolVersion: report.protocolVersion,
+        productVersion: report.productVersion,
+        missingCapability: required,
+        detail: `Latch is missing required capability \`${required}\`.`,
+        checkedAt,
+        latchSelectable: false,
+        directSelectable: true
+      };
+    }
+  }
+  return {
+    state: "found",
+    executable,
+    resolvedPath,
+    protocolVersion: report.protocolVersion,
+    productVersion: report.productVersion,
+    capabilities: report.capabilities,
+    checkedAt,
+    latchSelectable: true,
+    directSelectable: true
+  };
+}
+function resolveLatchExecutableOnPath(executable) {
+  try {
+    const found = execFileSync("which", [executable], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return found || null;
+  } catch {
+    return null;
+  }
+}
+function resolveLatchExecutablePathFromEnvironment({ executable, homeDirectory = os3.homedir(), platform: platform2 = process.platform, resolveOnPath = resolveLatchExecutableOnPath, fileExists = existsSync15 }) {
+  const name = trimmed2(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  if (path15.isAbsolute(name) || name.includes("/") || name.includes("\\")) {
+    return fileExists(name) ? path15.resolve(name) : null;
+  }
+  const resolvedOnPath = resolveOnPath(name);
+  if (resolvedOnPath)
+    return resolvedOnPath;
+  const fallbacks = [
+    path15.join(homeDirectory, ".local", "bin", name),
+    ...platform2 === "darwin" ? [`/opt/homebrew/bin/${name}`, `/usr/local/bin/${name}`] : []
+  ];
+  const fallback = fallbacks.find(fileExists);
+  return fallback ? path15.resolve(fallback) : null;
+}
+function resolveLatchExecutablePath(executable) {
+  return resolveLatchExecutablePathFromEnvironment({ executable });
+}
+function notInstalledResult({ executable, checkedAt }) {
+  return {
+    state: "not_installed",
+    executable,
+    installCommand: LATCH_STANDALONE_INSTALL_COMMAND,
+    checkedAt,
+    latchSelectable: false,
+    directSelectable: true
+  };
+}
+function probeLatchCapabilities({ executable = DEFAULT_LATCH_EXECUTABLE, resolvePath = resolveLatchExecutablePath, runCommand: runCommand2 = defaultCommandRunner, now = () => (/* @__PURE__ */ new Date()).toISOString() } = {}) {
+  const exe = trimmed2(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  const checkedAt = now();
+  const resolvedPath = resolvePath(exe);
+  if (!resolvedPath) {
+    return notInstalledResult({ executable: exe, checkedAt });
+  }
+  const ran = runCommand2({ executable: resolvedPath, argv: ["capabilities", "--json"] });
+  if (ran.status === null && ran.stderr === "ENOENT") {
+    return notInstalledResult({ executable: exe, checkedAt });
+  }
+  const report = parseLatchCapabilitiesReport(ran.stdout);
+  if (!report) {
+    return {
+      state: "incompatible",
+      executable: exe,
+      resolvedPath,
+      protocolVersion: null,
+      productVersion: null,
+      missingCapability: "capabilities",
+      detail: ran.status === 0 ? "Latch capabilities output was not valid JSON in the expected shape." : `Latch capabilities failed (exit ${ran.status ?? "null"}).`,
+      checkedAt,
+      latchSelectable: false,
+      directSelectable: true
+    };
+  }
+  return evaluateLatchCapabilities({ report, executable: exe, resolvedPath, checkedAt });
+}
+function latchDiscoveryCacheKey({ executionTargetId, executable }) {
+  const exe = trimmed2(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  return `${executionTargetId}::${exe}`;
+}
+function readBinaryMtimeMs(resolvedPath) {
+  if (!resolvedPath)
+    return null;
+  try {
+    return statSync4(resolvedPath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function isLatchDiscoveryCacheFresh({ entry, resolvePath = resolveLatchExecutablePath }) {
+  const { result } = entry;
+  if (result.state === "not_installed") {
+    return resolvePath(result.executable) === null;
+  }
+  const pathStill = result.resolvedPath;
+  if (!pathStill || !existsSync15(pathStill))
+    return false;
+  const mtime = readBinaryMtimeMs(pathStill);
+  if (mtime === null || entry.binaryMtimeMs === null)
+    return false;
+  return mtime === entry.binaryMtimeMs;
+}
+function readLatchDiscoveryCacheFile(filePath) {
+  if (!existsSync15(filePath))
+    return { version: 1, entries: {} };
+  try {
+    const parsed = JSON.parse(readFileSync14(filePath, "utf8"));
+    if (parsed.version !== 1 || !parsed.entries || typeof parsed.entries !== "object") {
+      return { version: 1, entries: {} };
+    }
+    return { version: 1, entries: parsed.entries };
+  } catch {
+    return { version: 1, entries: {} };
+  }
+}
+function writeLatchDiscoveryCacheFile({ filePath, cache: cache2 }) {
+  mkdirSync8(path15.dirname(filePath), { recursive: true });
+  writeFileSync7(filePath, `${JSON.stringify(cache2, null, 2)}
+`, { mode: 384 });
+}
+function discoverLatchForExecutionTarget({ executionTargetId, executable = DEFAULT_LATCH_EXECUTABLE, cacheFilePath, force = false, resolvePath = resolveLatchExecutablePath, runCommand: runCommand2 = defaultCommandRunner, now = () => (/* @__PURE__ */ new Date()).toISOString() }) {
+  const exe = trimmed2(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  const key = latchDiscoveryCacheKey({ executionTargetId, executable: exe });
+  const cache2 = readLatchDiscoveryCacheFile(cacheFilePath);
+  const existing = cache2.entries[key];
+  if (!force && existing && isLatchDiscoveryCacheFresh({ entry: existing, resolvePath })) {
+    return { ...existing.result, checkedAt: existing.result.checkedAt, directSelectable: true };
+  }
+  const result = probeLatchCapabilities({ executable: exe, resolvePath, runCommand: runCommand2, now });
+  const binaryMtimeMs = result.state === "not_installed" ? null : readBinaryMtimeMs(result.resolvedPath);
+  cache2.entries[key] = {
+    result,
+    binaryMtimeMs,
+    cachedAt: result.checkedAt
+  };
+  writeLatchDiscoveryCacheFile({ filePath: cacheFilePath, cache: cache2 });
+  return result;
+}
+var SUPPORTED_LATCH_PROTOCOL_VERSION, REQUIRED_LATCH_CAPABILITIES, LATCH_STANDALONE_INSTALL_COMMAND, LATCH_DISCOVERY_CACHE_FILENAME, defaultCommandRunner;
+var init_latch_discovery = __esm({
+  "../packages/core/dist/service/latch-discovery.js"() {
+    "use strict";
+    init_latch_environment();
+    init_terminal_profile_types2();
+    SUPPORTED_LATCH_PROTOCOL_VERSION = 1;
+    REQUIRED_LATCH_CAPABILITIES = ["create"];
+    LATCH_STANDALONE_INSTALL_COMMAND = "curl -fsSL https://raw.githubusercontent.com/jchaselubitz/Latch/main/scripts/install-cli.sh | bash";
+    LATCH_DISCOVERY_CACHE_FILENAME = "latch-discovery.json";
+    defaultCommandRunner = ({ executable, argv }) => {
+      try {
+        const stdout = execFileSync(executable, argv, {
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "pipe"],
+          timeout: 5e3,
+          env: latchChildEnvironment()
+        });
+        return { status: 0, stdout: String(stdout), stderr: "" };
+      } catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+          return { status: null, stdout: "", stderr: "ENOENT" };
+        }
+        return {
+          status: typeof err.status === "number" ? err.status : 1,
+          stdout: err.stdout ? String(err.stdout) : "",
+          stderr: err.stderr ? String(err.stderr) : String(error)
+        };
+      }
+    };
+  }
+});
+
+// ../packages/core/dist/service/latch-binary.js
+import { existsSync as existsSync16 } from "node:fs";
+function trimmed3(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function resolveLatchBinaryPath(executable, resolve = resolveLatchExecutablePath) {
+  const name = trimmed3(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  const cached = cache.get(name);
+  if (cached) {
+    if (existsSync16(cached))
+      return cached;
+    cache.delete(name);
+  }
+  const resolved = resolve(name);
+  if (resolved)
+    cache.set(name, resolved);
+  return resolved;
+}
+function latchBinaryMissingMessage(executable) {
+  const name = trimmed3(executable) ?? DEFAULT_LATCH_EXECUTABLE;
+  return `Latch executable "${name}" was not found on this device (checked PATH, ~/.local/bin, and the Homebrew prefixes).`;
+}
+var cache;
+var init_latch_binary = __esm({
+  "../packages/core/dist/service/latch-binary.js"() {
+    "use strict";
+    init_latch_discovery();
+    init_terminal_profile_types2();
+    cache = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../packages/core/dist/service/latch-launch.js
+function trimmed4(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
 function buildLatchCreateManifest({ commandString, shell = process.env.SHELL?.trim() || "/bin/bash", cwd, env, size = DEFAULT_LATCH_TERMINAL_SIZE, title, name, commandLabel, externalRunId }) {
-  const shellPath = trimmed2(shell) ?? "/bin/bash";
+  const shellPath = trimmed4(shell) ?? "/bin/bash";
   const cleanedEnv = {};
   for (const [key, value] of Object.entries(env)) {
     if (key.trim() && typeof value === "string")
@@ -16646,15 +16949,15 @@ function buildLatchCreateManifest({ commandString, shell = process.env.SHELL?.tr
   const display = {
     source: {
       kind: "overlord",
-      ...trimmed2(externalRunId) ? { external_run_id: trimmed2(externalRunId) } : {}
+      ...trimmed4(externalRunId) ? { external_run_id: trimmed4(externalRunId) } : {}
     }
   };
-  if (trimmed2(title))
-    display.title = trimmed2(title);
-  if (trimmed2(name))
-    display.name = trimmed2(name);
-  if (trimmed2(commandLabel))
-    display.command_label = trimmed2(commandLabel);
+  if (trimmed4(title))
+    display.title = trimmed4(title);
+  if (trimmed4(name))
+    display.name = trimmed4(name);
+  if (trimmed4(commandLabel))
+    display.command_label = trimmed4(commandLabel);
   return {
     format_version: LATCH_MANIFEST_FORMAT_VERSION,
     launch: {
@@ -16673,7 +16976,7 @@ function buildLatchCreateManifest({ commandString, shell = process.env.SHELL?.tr
 function parseLatchCreateReport(raw) {
   try {
     const parsed = JSON.parse(raw);
-    const id = trimmed2(parsed.session?.id);
+    const id = trimmed4(parsed.session?.id);
     if (!id)
       return null;
     const protocolVersion = typeof parsed.protocolVersion === "number" && Number.isFinite(parsed.protocolVersion) ? parsed.protocolVersion : LATCH_MANIFEST_FORMAT_VERSION;
@@ -16681,9 +16984,9 @@ function parseLatchCreateReport(raw) {
       protocolVersion,
       session: {
         id,
-        name: trimmed2(parsed.session?.name) ?? id,
-        state: trimmed2(parsed.session?.state) ?? "running",
-        createdAt: trimmed2(parsed.session?.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString()
+        name: trimmed4(parsed.session?.name) ?? id,
+        state: trimmed4(parsed.session?.state) ?? "running",
+        createdAt: trimmed4(parsed.session?.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString()
       }
     };
   } catch {
@@ -16695,28 +16998,28 @@ function toExecutionProviderSession({ createReport, executionTargetId, createdAt
     provider: "latch",
     providerSessionId: createReport.session.id,
     sessionName: createReport.session.name,
-    executionTargetId: trimmed2(executionTargetId),
+    executionTargetId: trimmed4(executionTargetId),
     agentSessionId: null,
     createdAt: createdAt ?? createReport.session.createdAt,
     lastObservedState: createReport.session.state
   };
 }
 function existingLatchProviderSession({ latchSessionId, executionTargetId, createdAt = (/* @__PURE__ */ new Date()).toISOString() }) {
-  const providerSessionId = trimmed2(latchSessionId);
+  const providerSessionId = trimmed4(latchSessionId);
   if (!providerSessionId)
     return null;
   return {
     provider: "latch",
     providerSessionId,
     sessionName: null,
-    executionTargetId: trimmed2(executionTargetId),
+    executionTargetId: trimmed4(executionTargetId),
     agentSessionId: null,
     createdAt,
     lastObservedState: "running"
   };
 }
 function latchViewerFlagForKind(kind) {
-  switch (trimmed2(kind)?.toLowerCase()) {
+  switch (trimmed4(kind)?.toLowerCase()) {
     case "iterm":
     case "iterm2":
       return "iterm";
@@ -16740,7 +17043,7 @@ function compareLatchProductVersions(a, b) {
   return 0;
 }
 function latchSupportsOpenAs(productVersion) {
-  const version = trimmed2(productVersion);
+  const version = trimmed4(productVersion);
   if (!version)
     return false;
   return compareLatchProductVersions(version, LATCH_OPEN_AS_MIN_PRODUCT_VERSION) >= 0;
@@ -16754,10 +17057,10 @@ function buildLatchOpenArgs({ providerSessionId, viewer, openAs, productVersion
   return args;
 }
 function latchAttachCommand({ executable = "latch", providerSessionId }) {
-  return `${trimmed2(executable) ?? "latch"} attach ${providerSessionId}`;
+  return `${trimmed4(executable) ?? "latch"} attach ${providerSessionId}`;
 }
 function shouldUseLatchProvider({ providerKind, latchSelectable }) {
-  return trimmed2(providerKind)?.toLowerCase() === "latch" && latchSelectable === true;
+  return trimmed4(providerKind)?.toLowerCase() === "latch" && latchSelectable === true;
 }
 var LATCH_MANIFEST_FORMAT_VERSION, DEFAULT_LATCH_TERMINAL_SIZE, LATCH_OPEN_AS_MIN_PRODUCT_VERSION;
 var init_latch_launch = __esm({
@@ -16772,11 +17075,11 @@ var init_latch_launch = __esm({
 
 // ../packages/core/dist/service/latch-session.js
 import { spawnSync as spawnSync2 } from "node:child_process";
-function trimmed3(value) {
+function trimmed5(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function parseState(value) {
-  switch (trimmed3(value)) {
+  switch (trimmed5(value)) {
     case "running":
       return "running";
     case "exited":
@@ -16790,7 +17093,10 @@ function parseState(value) {
   }
 }
 function runLatchJson({ executable, args }) {
-  const result = spawnSync2(executable, args, {
+  const binary = resolveLatchBinaryPath(executable);
+  if (!binary)
+    throw new LatchSessionCommandError(latchBinaryMissingMessage(executable));
+  const result = spawnSync2(binary, args, {
     encoding: "utf8",
     shell: false,
     timeout: 1e4,
@@ -16815,11 +17121,11 @@ function runLatchJson({ executable, args }) {
   }
 }
 function inspectLatchSession({ executable = "latch", providerSessionId }) {
-  const sessionId = trimmed3(providerSessionId);
+  const sessionId = trimmed5(providerSessionId);
   if (!sessionId)
     throw new LatchSessionCommandError("A Latch session id is required.");
   const report = runLatchJson({
-    executable: trimmed3(executable) ?? "latch",
+    executable: trimmed5(executable) ?? "latch",
     args: ["inspect", sessionId, "--json"]
   });
   const state = parseState(report.state);
@@ -16827,8 +17133,8 @@ function inspectLatchSession({ executable = "latch", providerSessionId }) {
     throw new LatchSessionCommandError("Latch returned an unsupported session state.");
   const exit = report.exit && typeof report.exit === "object" && !Array.isArray(report.exit) ? report.exit : null;
   return {
-    providerSessionId: trimmed3(report.id) ?? sessionId,
-    name: trimmed3(report.name) ?? sessionId,
+    providerSessionId: trimmed5(report.id) ?? sessionId,
+    name: trimmed5(report.name) ?? sessionId,
     state,
     exitCode: typeof exit?.code === "number" && Number.isFinite(exit.code) ? exit.code : null,
     inspectedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -16836,20 +17142,20 @@ function inspectLatchSession({ executable = "latch", providerSessionId }) {
 }
 function readLatchProductVersion(executable) {
   try {
-    return trimmed3(runLatchJson({ executable, args: ["capabilities", "--json"] }).productVersion);
+    return trimmed5(runLatchJson({ executable, args: ["capabilities", "--json"] }).productVersion);
   } catch {
     return null;
   }
 }
 function openLatchSession({ executable = "latch", providerSessionId, viewerKind, openAs }) {
-  const sessionId = trimmed3(providerSessionId);
+  const sessionId = trimmed5(providerSessionId);
   if (!sessionId)
     throw new LatchSessionCommandError("A Latch session id is required.");
   const viewer = latchViewerFlagForKind(viewerKind);
   if (!viewer) {
     throw new LatchSessionCommandError(`Latch cannot open the configured viewer "${viewerKind}".`);
   }
-  const exe = trimmed3(executable) ?? "latch";
+  const exe = trimmed5(executable) ?? "latch";
   const report = runLatchJson({
     executable: exe,
     args: buildLatchOpenArgs({
@@ -16863,25 +17169,25 @@ function openLatchSession({ executable = "latch", providerSessionId, viewerKind,
     throw new LatchSessionCommandError(`Latch did not open the ${viewer} viewer.`);
   }
   return {
-    providerSessionId: trimmed3(report.id) ?? sessionId,
-    viewer: trimmed3(report.viewer) ?? viewer,
+    providerSessionId: trimmed5(report.id) ?? sessionId,
+    viewer: trimmed5(report.viewer) ?? viewer,
     opened: true,
-    behavior: trimmed3(report.behavior) ? parseViewerOpenAs(report.behavior) : null
+    behavior: trimmed5(report.behavior) ? parseViewerOpenAs(report.behavior) : null
   };
 }
 function stopLatchSession({ executable = "latch", providerSessionId }) {
-  const sessionId = trimmed3(providerSessionId);
+  const sessionId = trimmed5(providerSessionId);
   if (!sessionId)
     throw new LatchSessionCommandError("A Latch session id is required.");
   const report = runLatchJson({
-    executable: trimmed3(executable) ?? "latch",
+    executable: trimmed5(executable) ?? "latch",
     args: ["stop", sessionId, "--json"]
   });
   const state = parseState(report.state);
   if (!state)
     throw new LatchSessionCommandError("Latch returned an unsupported session state.");
   return {
-    providerSessionId: trimmed3(report.id) ?? sessionId,
+    providerSessionId: trimmed5(report.id) ?? sessionId,
     state
   };
 }
@@ -16889,6 +17195,7 @@ var LatchSessionCommandError;
 var init_latch_session = __esm({
   "../packages/core/dist/service/latch-session.js"() {
     "use strict";
+    init_latch_binary();
     init_latch_environment();
     init_latch_launch();
     init_terminal_profile_types2();
@@ -16903,17 +17210,17 @@ var init_latch_session = __esm({
 
 // ../packages/core/dist/service/latch-events.js
 import { spawn as spawn3 } from "node:child_process";
-function trimmed4(value) {
+function trimmed6(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function parseHarnessEvent(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return null;
   const row = value;
-  const type = trimmed4(row.type);
-  const sessionId = trimmed4(row.sessionId);
-  const at = trimmed4(row.at);
-  const harnessVersion = trimmed4(row.harnessVersion);
+  const type = trimmed6(row.type);
+  const sessionId = trimmed6(row.sessionId);
+  const at = trimmed6(row.at);
+  const harnessVersion = trimmed6(row.harnessVersion);
   const connectorEpoch = typeof row.connectorEpoch === "number" && Number.isFinite(row.connectorEpoch) ? row.connectorEpoch : null;
   if (!type || !HARNESS_EVENT_TYPES.has(type) || !sessionId || !at || !harnessVersion)
     return null;
@@ -16924,26 +17231,26 @@ function parseHarnessEvent(value) {
     case "user_message":
     case "assistant_delta":
     case "assistant_message": {
-      const text = trimmed4(row.text);
+      const text = trimmed6(row.text);
       if (!text)
         return null;
       return { ...base, type, text };
     }
     case "tool_started": {
-      const tool = trimmed4(row.tool);
+      const tool = trimmed6(row.tool);
       if (!tool)
         return null;
       return { ...base, type, tool, input: row.input };
     }
     case "tool_finished": {
-      const tool = trimmed4(row.tool);
+      const tool = trimmed6(row.tool);
       if (!tool)
         return null;
       return { ...base, type, tool, output: row.output };
     }
     case "awaiting_input": {
-      const requestId = trimmed4(row.requestId);
-      const kind = trimmed4(row.kind);
+      const requestId = trimmed6(row.requestId);
+      const kind = trimmed6(row.kind);
       const prompt = typeof row.prompt === "string" ? row.prompt : null;
       if (!requestId || kind !== "permission" && kind !== "question" || prompt === null) {
         return null;
@@ -16959,7 +17266,7 @@ function parseHarnessEvent(value) {
       };
     }
     case "status": {
-      const status = trimmed4(row.status);
+      const status = trimmed6(row.status);
       if (!status)
         return null;
       return { ...base, type, status };
@@ -16984,11 +17291,13 @@ function parseHarnessEventNdjson(raw) {
   return events;
 }
 async function collectLatchEvents({ executable = "latch", providerSessionId, from = 0, idleMs = 250, timeoutMs = 8e3 }) {
-  const sessionId = trimmed4(providerSessionId);
+  const sessionId = trimmed6(providerSessionId);
   if (!sessionId)
     throw new LatchSessionCommandError("A Latch session id is required.");
   const fromCursor = Number.isFinite(from) && from > 0 ? Math.floor(from) : 0;
-  const bin = trimmed4(executable) ?? "latch";
+  const bin = resolveLatchBinaryPath(executable);
+  if (!bin)
+    throw new LatchSessionCommandError(latchBinaryMissingMessage(executable));
   return new Promise((resolve, reject) => {
     const child = spawn3(bin, ["events", sessionId, "--json", "--from", String(fromCursor)], {
       stdio: ["ignore", "pipe", "pipe"],
@@ -17056,6 +17365,7 @@ var HARNESS_EVENT_TYPES;
 var init_latch_events = __esm({
   "../packages/core/dist/service/latch-events.js"() {
     "use strict";
+    init_latch_binary();
     init_latch_environment();
     init_latch_session();
     HARNESS_EVENT_TYPES = /* @__PURE__ */ new Set([
@@ -17085,12 +17395,12 @@ var init_util2 = __esm({
 });
 
 // ../packages/core/dist/service/local-target/project-metadata.js
-import { execFileSync } from "node:child_process";
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "node:fs";
-import path15 from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
+import path16 from "node:path";
 function writeIfChanged(filePath, content) {
-  if (!existsSync15(filePath) || readFileSync14(filePath, "utf8") !== content) {
-    writeFileSync7(filePath, content);
+  if (!existsSync17(filePath) || readFileSync15(filePath, "utf8") !== content) {
+    writeFileSync8(filePath, content);
   }
 }
 function replaceManagedBlock(content, block) {
@@ -17101,25 +17411,25 @@ function replaceManagedBlock(content, block) {
 }
 function ensureAgentInstructions(checkoutPath) {
   for (const filename of ["AGENTS.md", "CLAUDE.md"]) {
-    const instructionPath = path15.join(checkoutPath, filename);
-    const existing = existsSync15(instructionPath) ? readFileSync14(instructionPath, "utf8") : "";
+    const instructionPath = path16.join(checkoutPath, filename);
+    const existing = existsSync17(instructionPath) ? readFileSync15(instructionPath, "utf8") : "";
     writeIfChanged(instructionPath, replaceManagedBlock(existing, PROJECT_METADATA_INSTRUCTION));
   }
 }
 function ensureGitignore(checkoutPath) {
-  const gitignorePath = path15.join(checkoutPath, ".gitignore");
-  const existing = existsSync15(gitignorePath) ? readFileSync14(gitignorePath, "utf8") : "";
+  const gitignorePath = path16.join(checkoutPath, ".gitignore");
+  const existing = existsSync17(gitignorePath) ? readFileSync15(gitignorePath, "utf8") : "";
   const existingPatterns = new Set(existing.split(/\r?\n/).map((line) => line.trim().replace(/^\//, "")).filter(Boolean));
   const additions = [".overlord/tmp/", ".overlord/logs/"].filter((pattern) => !existingPatterns.has(pattern));
   if (additions.length === 0)
     return;
   const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
-  writeFileSync7(gitignorePath, `${existing}${separator}${additions.join("\n")}
+  writeFileSync8(gitignorePath, `${existing}${separator}${additions.join("\n")}
 `);
 }
 function resolveGitRoot(directoryPath) {
   try {
-    return execFileSync("git", ["-C", directoryPath, "rev-parse", "--show-toplevel"], {
+    return execFileSync2("git", ["-C", directoryPath, "rev-parse", "--show-toplevel"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
@@ -17176,9 +17486,9 @@ function selectPrimaryProjectEntry(projects) {
   return latestLinkedAt(projects);
 }
 function parseProjectJson(projectJsonPath) {
-  if (!existsSync15(projectJsonPath))
+  if (!existsSync17(projectJsonPath))
     return null;
-  const parsed = JSON.parse(readFileSync14(projectJsonPath, "utf8"));
+  const parsed = JSON.parse(readFileSync15(projectJsonPath, "utf8"));
   const fromArray = Array.isArray(parsed.projects) ? parsed.projects.map((entry) => parseProjectEntry(entry)).filter((entry) => entry !== null) : [];
   const fromTopLevel = parseProjectEntry(parsed);
   const projects = fromArray.length > 0 ? fromArray : fromTopLevel ? [fromTopLevel] : [];
@@ -17245,12 +17555,12 @@ function serializeProjectEntry(entry) {
   };
 }
 function writeProjectJson({ directoryPath, projectId, projectName, resourceId, resourceKey, executionTargetId, isPrimary }) {
-  const overlordDir = path15.join(directoryPath, ".overlord");
-  mkdirSync8(overlordDir, { recursive: true });
-  mkdirSync8(path15.join(overlordDir, "tmp"), { recursive: true });
-  mkdirSync8(path15.join(overlordDir, "logs"), { recursive: true });
+  const overlordDir = path16.join(directoryPath, ".overlord");
+  mkdirSync9(overlordDir, { recursive: true });
+  mkdirSync9(path16.join(overlordDir, "tmp"), { recursive: true });
+  mkdirSync9(path16.join(overlordDir, "logs"), { recursive: true });
   protectProjectMetadata(directoryPath);
-  const projectJsonPath = path15.join(overlordDir, "project.json");
+  const projectJsonPath = path16.join(overlordDir, "project.json");
   const existing = parseProjectJson(projectJsonPath);
   const existingProjects = existing?.projects ?? [];
   const existingEntry = existingProjects.find((entry) => entry.projectId === projectId);
@@ -17277,7 +17587,7 @@ function writeProjectJson({ directoryPath, projectId, projectName, resourceId, r
   ];
   const primary = selectPrimaryProjectEntry(projects) ?? nextEntry;
   const primaryResourceIds = primary.resourceIdsByExecutionTarget ?? {};
-  writeFileSync7(projectJsonPath, `${JSON.stringify({
+  writeFileSync8(projectJsonPath, `${JSON.stringify({
     _warning: PROJECT_JSON_WARNING,
     version: PROJECT_JSON_VERSION,
     projectId: primary.projectId,
@@ -17312,11 +17622,11 @@ ${INSTRUCTION_BLOCK_END}`;
 });
 
 // ../packages/core/dist/repository/git-tree.js
-import { execFileSync as execFileSync2 } from "node:child_process";
-import path16 from "node:path";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import path17 from "node:path";
 function runGit(cwd, args) {
   try {
-    return execFileSync2("git", args, {
+    return execFileSync3("git", args, {
       cwd,
       encoding: "utf8",
       maxBuffer: 10 * 1024 * 1024,
@@ -17336,17 +17646,17 @@ function gitPath(cwd, args) {
   }
 }
 function addDirectoryAncestors(paths, filePath) {
-  let parent = path16.posix.dirname(filePath);
+  let parent = path17.posix.dirname(filePath);
   while (parent !== "." && parent !== "/") {
     paths.add(parent);
-    parent = path16.posix.dirname(parent);
+    parent = path17.posix.dirname(parent);
   }
 }
 function toEntry(entryPath, type) {
-  const parentPath = path16.posix.dirname(entryPath);
+  const parentPath = path17.posix.dirname(entryPath);
   return {
     path: entryPath,
-    name: path16.posix.basename(entryPath),
+    name: path17.posix.basename(entryPath),
     type,
     parentPath: parentPath === "." ? null : parentPath,
     depth: entryPath.split("/").length - 1
@@ -17358,7 +17668,7 @@ function compareEntries(a, b) {
   return a.path < b.path ? -1 : 1;
 }
 function readRepositoryTree(rootPath, options = {}) {
-  const resolvedRoot = path16.resolve(rootPath);
+  const resolvedRoot = path17.resolve(rootPath);
   const gitRoot = gitPath(resolvedRoot, ["rev-parse", "--show-toplevel"]);
   if (!gitRoot) {
     throw new RepositoryReadError("not_git_repository", `${resolvedRoot} is not inside a git repository.`);
@@ -17381,7 +17691,7 @@ function readRepositoryTree(rootPath, options = {}) {
   const truncated = entries.length > maxEntries;
   return {
     rootPath: resolvedRoot,
-    gitRoot: path16.resolve(gitRoot),
+    gitRoot: path17.resolve(gitRoot),
     branch: gitPath(gitRoot, ["branch", "--show-current"]),
     commit: gitPath(gitRoot, ["rev-parse", "--short", "HEAD"]),
     entries: truncated ? entries.slice(0, maxEntries) : entries,
@@ -17403,274 +17713,14 @@ var init_git_tree = __esm({
   }
 });
 
-// ../packages/core/dist/service/latch-discovery.js
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync15, statSync as statSync4, writeFileSync as writeFileSync8 } from "node:fs";
-import os3 from "node:os";
-import path17 from "node:path";
-function defaultLatchDiscoveryCachePath() {
-  const home = process.env.OVLD_HOME?.trim() || path17.join(os3.homedir(), ".ovld");
-  return path17.join(home, LATCH_DISCOVERY_CACHE_FILENAME);
-}
-function trimmed5(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function asBoolean(value) {
-  return value === true;
-}
-function asStringArray(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.filter((entry) => typeof entry === "string");
-}
-function parseLatchCapabilitiesReport(raw) {
-  const text = raw.trim();
-  if (!text)
-    return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return null;
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-    return null;
-  const cast = parsed;
-  const protocolVersion = typeof cast.protocolVersion === "number" && Number.isFinite(cast.protocolVersion) ? Math.trunc(cast.protocolVersion) : null;
-  const productVersion = trimmed5(cast.productVersion);
-  if (protocolVersion === null || !productVersion)
-    return null;
-  if (!cast.capabilities || typeof cast.capabilities !== "object" || Array.isArray(cast.capabilities)) {
-    return null;
-  }
-  const caps = cast.capabilities;
-  return {
-    protocolVersion,
-    productVersion,
-    capabilities: {
-      create: asBoolean(caps.create),
-      openViewer: asBoolean(caps.openViewer),
-      localAttach: asBoolean(caps.localAttach),
-      cloudAttach: asBoolean(caps.cloudAttach),
-      selfUpdate: asBoolean(caps.selfUpdate),
-      extensions: asStringArray(caps.extensions)
-    }
-  };
-}
-function evaluateLatchCapabilities({ report, executable, resolvedPath, checkedAt = (/* @__PURE__ */ new Date()).toISOString() }) {
-  if (report.protocolVersion !== SUPPORTED_LATCH_PROTOCOL_VERSION) {
-    return {
-      state: "incompatible",
-      executable,
-      resolvedPath,
-      protocolVersion: report.protocolVersion,
-      productVersion: report.productVersion,
-      missingCapability: "protocolVersion",
-      detail: `Latch protocolVersion ${report.protocolVersion} is not supported (need ${SUPPORTED_LATCH_PROTOCOL_VERSION}).`,
-      checkedAt,
-      latchSelectable: false,
-      directSelectable: true
-    };
-  }
-  for (const required of REQUIRED_LATCH_CAPABILITIES) {
-    if (!report.capabilities[required]) {
-      return {
-        state: "incompatible",
-        executable,
-        resolvedPath,
-        protocolVersion: report.protocolVersion,
-        productVersion: report.productVersion,
-        missingCapability: required,
-        detail: `Latch is missing required capability \`${required}\`.`,
-        checkedAt,
-        latchSelectable: false,
-        directSelectable: true
-      };
-    }
-  }
-  return {
-    state: "found",
-    executable,
-    resolvedPath,
-    protocolVersion: report.protocolVersion,
-    productVersion: report.productVersion,
-    capabilities: report.capabilities,
-    checkedAt,
-    latchSelectable: true,
-    directSelectable: true
-  };
-}
-function resolveLatchExecutableOnPath(executable) {
-  try {
-    const found = execFileSync3("which", [executable], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    return found || null;
-  } catch {
-    return null;
-  }
-}
-function resolveLatchExecutablePathFromEnvironment({ executable, homeDirectory = os3.homedir(), platform: platform2 = process.platform, resolveOnPath = resolveLatchExecutableOnPath, fileExists = existsSync16 }) {
-  const name = trimmed5(executable) ?? DEFAULT_LATCH_EXECUTABLE;
-  if (path17.isAbsolute(name) || name.includes("/") || name.includes("\\")) {
-    return fileExists(name) ? path17.resolve(name) : null;
-  }
-  const resolvedOnPath = resolveOnPath(name);
-  if (resolvedOnPath)
-    return resolvedOnPath;
-  const fallbacks = [
-    path17.join(homeDirectory, ".local", "bin", name),
-    ...platform2 === "darwin" ? [`/opt/homebrew/bin/${name}`, `/usr/local/bin/${name}`] : []
-  ];
-  const fallback = fallbacks.find(fileExists);
-  return fallback ? path17.resolve(fallback) : null;
-}
-function resolveLatchExecutablePath(executable) {
-  return resolveLatchExecutablePathFromEnvironment({ executable });
-}
-function notInstalledResult({ executable, checkedAt }) {
-  return {
-    state: "not_installed",
-    executable,
-    installCommand: LATCH_STANDALONE_INSTALL_COMMAND,
-    checkedAt,
-    latchSelectable: false,
-    directSelectable: true
-  };
-}
-function probeLatchCapabilities({ executable = DEFAULT_LATCH_EXECUTABLE, resolvePath = resolveLatchExecutablePath, runCommand: runCommand2 = defaultCommandRunner, now = () => (/* @__PURE__ */ new Date()).toISOString() } = {}) {
-  const exe = trimmed5(executable) ?? DEFAULT_LATCH_EXECUTABLE;
-  const checkedAt = now();
-  const resolvedPath = resolvePath(exe);
-  if (!resolvedPath) {
-    return notInstalledResult({ executable: exe, checkedAt });
-  }
-  const ran = runCommand2({ executable: resolvedPath, argv: ["capabilities", "--json"] });
-  if (ran.status === null && ran.stderr === "ENOENT") {
-    return notInstalledResult({ executable: exe, checkedAt });
-  }
-  const report = parseLatchCapabilitiesReport(ran.stdout);
-  if (!report) {
-    return {
-      state: "incompatible",
-      executable: exe,
-      resolvedPath,
-      protocolVersion: null,
-      productVersion: null,
-      missingCapability: "capabilities",
-      detail: ran.status === 0 ? "Latch capabilities output was not valid JSON in the expected shape." : `Latch capabilities failed (exit ${ran.status ?? "null"}).`,
-      checkedAt,
-      latchSelectable: false,
-      directSelectable: true
-    };
-  }
-  return evaluateLatchCapabilities({ report, executable: exe, resolvedPath, checkedAt });
-}
-function latchDiscoveryCacheKey({ executionTargetId, executable }) {
-  const exe = trimmed5(executable) ?? DEFAULT_LATCH_EXECUTABLE;
-  return `${executionTargetId}::${exe}`;
-}
-function readBinaryMtimeMs(resolvedPath) {
-  if (!resolvedPath)
-    return null;
-  try {
-    return statSync4(resolvedPath).mtimeMs;
-  } catch {
-    return null;
-  }
-}
-function isLatchDiscoveryCacheFresh({ entry, resolvePath = resolveLatchExecutablePath }) {
-  const { result } = entry;
-  if (result.state === "not_installed") {
-    return resolvePath(result.executable) === null;
-  }
-  const pathStill = result.resolvedPath;
-  if (!pathStill || !existsSync16(pathStill))
-    return false;
-  const mtime = readBinaryMtimeMs(pathStill);
-  if (mtime === null || entry.binaryMtimeMs === null)
-    return false;
-  return mtime === entry.binaryMtimeMs;
-}
-function readLatchDiscoveryCacheFile(filePath) {
-  if (!existsSync16(filePath))
-    return { version: 1, entries: {} };
-  try {
-    const parsed = JSON.parse(readFileSync15(filePath, "utf8"));
-    if (parsed.version !== 1 || !parsed.entries || typeof parsed.entries !== "object") {
-      return { version: 1, entries: {} };
-    }
-    return { version: 1, entries: parsed.entries };
-  } catch {
-    return { version: 1, entries: {} };
-  }
-}
-function writeLatchDiscoveryCacheFile({ filePath, cache }) {
-  mkdirSync9(path17.dirname(filePath), { recursive: true });
-  writeFileSync8(filePath, `${JSON.stringify(cache, null, 2)}
-`, { mode: 384 });
-}
-function discoverLatchForExecutionTarget({ executionTargetId, executable = DEFAULT_LATCH_EXECUTABLE, cacheFilePath, force = false, resolvePath = resolveLatchExecutablePath, runCommand: runCommand2 = defaultCommandRunner, now = () => (/* @__PURE__ */ new Date()).toISOString() }) {
-  const exe = trimmed5(executable) ?? DEFAULT_LATCH_EXECUTABLE;
-  const key = latchDiscoveryCacheKey({ executionTargetId, executable: exe });
-  const cache = readLatchDiscoveryCacheFile(cacheFilePath);
-  const existing = cache.entries[key];
-  if (!force && existing && isLatchDiscoveryCacheFresh({ entry: existing, resolvePath })) {
-    return { ...existing.result, checkedAt: existing.result.checkedAt, directSelectable: true };
-  }
-  const result = probeLatchCapabilities({ executable: exe, resolvePath, runCommand: runCommand2, now });
-  const binaryMtimeMs = result.state === "not_installed" ? null : readBinaryMtimeMs(result.resolvedPath);
-  cache.entries[key] = {
-    result,
-    binaryMtimeMs,
-    cachedAt: result.checkedAt
-  };
-  writeLatchDiscoveryCacheFile({ filePath: cacheFilePath, cache });
-  return result;
-}
-var SUPPORTED_LATCH_PROTOCOL_VERSION, REQUIRED_LATCH_CAPABILITIES, LATCH_STANDALONE_INSTALL_COMMAND, LATCH_DISCOVERY_CACHE_FILENAME, defaultCommandRunner;
-var init_latch_discovery = __esm({
-  "../packages/core/dist/service/latch-discovery.js"() {
-    "use strict";
-    init_latch_environment();
-    init_terminal_profile_types2();
-    SUPPORTED_LATCH_PROTOCOL_VERSION = 1;
-    REQUIRED_LATCH_CAPABILITIES = ["create"];
-    LATCH_STANDALONE_INSTALL_COMMAND = "curl -fsSL https://raw.githubusercontent.com/jchaselubitz/Latch/main/scripts/install-cli.sh | bash";
-    LATCH_DISCOVERY_CACHE_FILENAME = "latch-discovery.json";
-    defaultCommandRunner = ({ executable, argv }) => {
-      try {
-        const stdout = execFileSync3(executable, argv, {
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "pipe"],
-          timeout: 5e3,
-          env: latchChildEnvironment()
-        });
-        return { status: 0, stdout: String(stdout), stderr: "" };
-      } catch (error) {
-        const err = error;
-        if (err.code === "ENOENT") {
-          return { status: null, stdout: "", stderr: "ENOENT" };
-        }
-        return {
-          status: typeof err.status === "number" ? err.status : 1,
-          stdout: err.stdout ? String(err.stdout) : "",
-          stderr: err.stderr ? String(err.stderr) : String(error)
-        };
-      }
-    };
-  }
-});
-
 // ../packages/core/dist/service/latch-send.js
 import { spawnSync as spawnSync3 } from "node:child_process";
-function trimmed6(value) {
+function trimmed7(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function probeLatchInteractionCapabilities({ executable = "latch", providerSessionId }) {
-  const sessionId = trimmed6(providerSessionId);
-  const bin = trimmed6(executable) ?? "latch";
+  const sessionId = trimmed7(providerSessionId);
+  const bin = resolveLatchBinaryPath(executable);
   if (!sessionId) {
     return {
       sendMessage: false,
@@ -17679,6 +17729,14 @@ function probeLatchInteractionCapabilities({ executable = "latch", providerSessi
       canSend: { ok: false, reason: "A Latch session id is required." }
     };
   }
+  if (!bin) {
+    return {
+      sendMessage: false,
+      sendKeys: false,
+      resolve: false,
+      canSend: { ok: false, reason: latchBinaryMissingMessage(executable) }
+    };
+  }
   const help = spawnSync3(bin, ["send", "--help"], {
     encoding: "utf8",
     shell: false,
@@ -17705,9 +17763,9 @@ ${help.stderr}`),
   };
 }
 function resolveLatchInput({ executable = "latch", providerSessionId, requestId, choice }) {
-  const sessionId = trimmed6(providerSessionId);
-  const id = trimmed6(requestId);
-  const selected = trimmed6(choice);
+  const sessionId = trimmed7(providerSessionId);
+  const id = trimmed7(requestId);
+  const selected = trimmed7(choice);
   if (!sessionId)
     throw new LatchSessionCommandError("A Latch session id is required.");
   if (!id)
@@ -17721,7 +17779,9 @@ function resolveLatchInput({ executable = "latch", providerSessionId, requestId,
   if (!capabilities.resolve || !capabilities.canSend.ok) {
     throw new LatchSessionCommandError(capabilities.canSend.reason || "This Latch session cannot resolve a pending prompt.");
   }
-  const bin = trimmed6(executable) ?? "latch";
+  const bin = resolveLatchBinaryPath(executable);
+  if (!bin)
+    throw new LatchSessionCommandError(latchBinaryMissingMessage(executable));
   const result = spawnSync3(bin, ["send", sessionId, "--resolve", `${id}=${selected}`, "--json"], {
     encoding: "utf8",
     shell: false,
@@ -17745,6 +17805,7 @@ function resolveLatchInput({ executable = "latch", providerSessionId, requestId,
 var init_latch_send = __esm({
   "../packages/core/dist/service/latch-send.js"() {
     "use strict";
+    init_latch_binary();
     init_latch_environment();
     init_latch_session();
   }
@@ -17789,7 +17850,7 @@ var init_git_run = __esm({
 });
 
 // ../packages/core/dist/service/local-target/worktree-git.js
-import { existsSync as existsSync17, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync18, realpathSync as realpathSync2 } from "node:fs";
 import path18 from "node:path";
 function resolveRealPath(targetPath) {
   try {
@@ -17825,7 +17886,7 @@ function removeGitWorktree({ primaryRepoPath, worktreePath, force }) {
   args.push(worktreePath);
   runGitResult(primaryRepoPath, args);
   runGitResult(primaryRepoPath, ["worktree", "prune"]);
-  return !existsSync17(worktreePath);
+  return !existsSync18(worktreePath);
 }
 function collectManagedWorktrees({ worktreeRoot, projects }) {
   const resolvedRoot = resolveRealPath(worktreeRoot);
@@ -17833,7 +17894,7 @@ function collectManagedWorktrees({ worktreeRoot, projects }) {
   const seen = /* @__PURE__ */ new Set();
   for (const project of projects) {
     const repoPath = project.primaryRepoPath;
-    if (!repoPath || !existsSync17(repoPath))
+    if (!repoPath || !existsSync18(repoPath))
       continue;
     const out = runGitResult(repoPath, ["worktree", "list", "--porcelain"]);
     if (!out.ok)
@@ -17911,10 +17972,10 @@ var init_worktree_git = __esm({
 });
 
 // ../packages/core/dist/service/local-target/branch-actions-git.js
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync19 } from "node:fs";
 function integrateBranch(input) {
   const { branchName, baseBranch, worktreePath, primaryRepoPath } = input;
-  if (!existsSync18(worktreePath)) {
+  if (!existsSync19(worktreePath)) {
     return {
       ok: false,
       code: "BRANCH_NO_WORKTREE",
@@ -17988,15 +18049,15 @@ function integrateBranch(input) {
 }
 function commitBranch(input) {
   const { branchName, worktreePath } = input;
-  const trimmed7 = (input.message ?? "").trim();
-  if (!trimmed7) {
+  const trimmed8 = (input.message ?? "").trim();
+  if (!trimmed8) {
     return {
       ok: false,
       code: "BRANCH_COMMIT_MESSAGE_REQUIRED",
       message: "A commit message is required."
     };
   }
-  if (!existsSync18(worktreePath)) {
+  if (!existsSync19(worktreePath)) {
     return {
       ok: false,
       code: "BRANCH_NO_WORKTREE",
@@ -18028,7 +18089,7 @@ function commitBranch(input) {
       detail: staged.stderr || staged.stdout
     };
   }
-  const commit = runGitResult(worktreePath, ["commit", "-m", trimmed7]);
+  const commit = runGitResult(worktreePath, ["commit", "-m", trimmed8]);
   if (!commit.ok) {
     return {
       ok: false,
@@ -18052,7 +18113,7 @@ function pushParent(input) {
     };
   }
   let summary = `Pushed ${baseBranch} to origin.`;
-  if (existsSync18(worktreePath) && !worktreeIsDirty(worktreePath)) {
+  if (existsSync19(worktreePath) && !worktreeIsDirty(worktreePath)) {
     if (removeGitWorktree({ primaryRepoPath, worktreePath, force: false })) {
       summary += ` Removed the merged worktree for ${branchName}.`;
     }
@@ -18061,7 +18122,7 @@ function pushParent(input) {
 }
 function publishBranch(input) {
   const { branchName, worktreePath, primaryRepoPath } = input;
-  const repo = existsSync18(worktreePath) ? worktreePath : primaryRepoPath;
+  const repo = existsSync19(worktreePath) ? worktreePath : primaryRepoPath;
   const push = runGitResult(repo, ["push", "-u", "origin", branchName]);
   if (!push.ok) {
     return {
@@ -18111,7 +18172,7 @@ var init_branch_status_git = __esm({
 });
 
 // ../packages/core/dist/service/local-target/commit-message-diff-git.js
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 function collectWorktreeChanges(worktreePath) {
   const status = runGitResult(worktreePath, ["status", "--porcelain"]);
   const diff = runGitResult(worktreePath, ["diff", "HEAD"]);
@@ -18127,7 +18188,7 @@ ${diff.stdout}`);
   return sections.join("\n\n");
 }
 function gatherCommitMessageDiff(worktreePath) {
-  if (!existsSync19(worktreePath)) {
+  if (!existsSync20(worktreePath)) {
     return {
       ok: false,
       code: "BRANCH_NO_WORKTREE",
@@ -18188,7 +18249,7 @@ var init_result = __esm({
 });
 
 // ../packages/core/dist/service/local-target/in-process-provider.js
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 var InProcessProvider;
 var init_in_process_provider = __esm({
   "../packages/core/dist/service/local-target/in-process-provider.js"() {
@@ -18221,7 +18282,7 @@ var init_in_process_provider = __esm({
        */
       async observeResource(input) {
         const observedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const state = existsSync20(input.path) ? "available" : "missing";
+        const state = existsSync21(input.path) ? "available" : "missing";
         return ok(this.target, { state, observedAt });
       }
       /**
@@ -18668,7 +18729,7 @@ var init_branch_planning = __esm({
 
 // src/branch-preparation.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { existsSync as existsSync21, mkdirSync as mkdirSync10, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync10, statSync as statSync5 } from "node:fs";
 import os4 from "node:os";
 import path21 from "node:path";
 function runGit3(cwd, args, options = {}) {
@@ -18840,7 +18901,7 @@ function ensureBranchRef(gitRoot, decision) {
 function ensureWorktree(gitRoot, decision) {
   ensureBranchRef(gitRoot, decision);
   mkdirSync10(path21.dirname(decision.worktreePath), { recursive: true });
-  if (existsSync21(decision.worktreePath)) {
+  if (existsSync22(decision.worktreePath)) {
     if (!statSync5(decision.worktreePath).isDirectory()) {
       throw new Error(`Worktree path exists and is not a directory: ${decision.worktreePath}`);
     }
@@ -19015,16 +19076,16 @@ async function resolveProjectByIdOrName({
   backend,
   projectRef
 }) {
-  const trimmed7 = projectRef.trim();
+  const trimmed8 = projectRef.trim();
   try {
-    return await backend.get(`/api/projects/${encodeURIComponent(trimmed7)}`);
+    return await backend.get(`/api/projects/${encodeURIComponent(trimmed8)}`);
   } catch (error) {
     if (!(error instanceof CliError) || !/project not found/i.test(error.message)) throw error;
   }
   const projects = await listAccessibleProjects({ backend });
-  const match = projects.find((project) => project.name === trimmed7) ?? projects.find((project) => project.slug === trimmed7);
+  const match = projects.find((project) => project.name === trimmed8) ?? projects.find((project) => project.slug === trimmed8);
   if (!match) {
-    throw new CliError({ message: `Project not found: ${trimmed7}` });
+    throw new CliError({ message: `Project not found: ${trimmed8}` });
   }
   return match;
 }
@@ -20108,7 +20169,7 @@ var init_launch = __esm({
 });
 
 // src/launch-bootstrap.ts
-import { existsSync as existsSync22, readdirSync as readdirSync4, readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync23, readdirSync as readdirSync4, readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
 import path25 from "node:path";
 function firstCapture(match) {
   if (!match) return null;
@@ -20130,7 +20191,7 @@ function recoverLaunchBootstrapFromProjectTmp({
   const trimmedMission = missionId.trim();
   if (!trimmedMission) return empty;
   const tmpDir = projectTmpDir(workingDirectory);
-  if (!existsSync22(tmpDir)) return empty;
+  if (!existsSync23(tmpDir)) return empty;
   const prefix = `launch-${safeMissionPart(trimmedMission)}-`;
   let newest = null;
   try {
@@ -20188,8 +20249,8 @@ function promptText({
   return new Promise((resolve) => {
     rl.question(`${question}${suffix}: `, (answer) => {
       rl.close();
-      const trimmed7 = answer.trim();
-      resolve(trimmed7 || defaultValue || "");
+      const trimmed8 = answer.trim();
+      resolve(trimmed8 || defaultValue || "");
     });
   });
 }
@@ -20778,7 +20839,7 @@ var init_protocol_help = __esm({
 
 // src/vcs-sessions.ts
 import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync23, mkdirSync as mkdirSync11, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync11, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "node:fs";
 import path27 from "node:path";
 function manifestPath2(workingDirectory) {
   const key = createHash8("sha256").update(path27.resolve(workingDirectory)).digest("hex");
@@ -20787,7 +20848,7 @@ function manifestPath2(workingDirectory) {
 function readEntries(workingDirectory) {
   try {
     const target = manifestPath2(workingDirectory);
-    if (!existsSync23(target)) return [];
+    if (!existsSync24(target)) return [];
     const raw = JSON.parse(readFileSync18(target, "utf8"));
     if (!Array.isArray(raw.entries)) return [];
     const now = Date.now();
@@ -20861,7 +20922,7 @@ var init_vcs_sessions = __esm({
 import { execFileSync as execFileSync7 } from "node:child_process";
 import { createHash as createHash9 } from "node:crypto";
 import {
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   mkdirSync as mkdirSync12,
   readdirSync as readdirSync5,
   readFileSync as readFileSync19,
@@ -20973,7 +21034,7 @@ function readBashSnapshot({
 }) {
   try {
     const target = bashSnapshotPath({ workingDirectory, missionId });
-    if (!existsSync24(target)) return /* @__PURE__ */ new Map();
+    if (!existsSync25(target)) return /* @__PURE__ */ new Map();
     const raw = JSON.parse(readFileSync19(target, "utf8"));
     const byPath = /* @__PURE__ */ new Map();
     if (Array.isArray(raw.files)) {
@@ -21065,7 +21126,7 @@ function resetTouchedFiles({
       touchedFilesPath({ workingDirectory, missionId }),
       bashSnapshotPath({ workingDirectory, missionId })
     ]) {
-      if (existsSync24(target)) rmSync5(target);
+      if (existsSync25(target)) rmSync5(target);
     }
   } catch {
   }
@@ -21076,14 +21137,14 @@ function resetRationaleNotes({
 }) {
   try {
     const target = rationaleNotesPath({ workingDirectory, missionId });
-    if (existsSync24(target)) rmSync5(target);
+    if (existsSync25(target)) rmSync5(target);
   } catch {
   }
 }
 function truncateNoteText(value, max = 500) {
-  const trimmed7 = (value ?? "").replace(/\s+/g, " ").trim();
-  if (!trimmed7) return null;
-  return trimmed7.length > max ? `${trimmed7.slice(0, max - 1)}...` : trimmed7;
+  const trimmed8 = (value ?? "").replace(/\s+/g, " ").trim();
+  if (!trimmed8) return null;
+  return trimmed8.length > max ? `${trimmed8.slice(0, max - 1)}...` : trimmed8;
 }
 function readRationaleNotes({
   workingDirectory,
@@ -21091,7 +21152,7 @@ function readRationaleNotes({
 }) {
   try {
     const target = rationaleNotesPath({ workingDirectory, missionId });
-    if (!existsSync24(target)) return [];
+    if (!existsSync25(target)) return [];
     const raw = JSON.parse(readFileSync19(target, "utf8"));
     if (!Array.isArray(raw.notes)) return [];
     return raw.notes.flatMap((note) => {
@@ -21179,7 +21240,7 @@ function hasTouchedFilesLog({
   workingDirectory,
   missionId
 }) {
-  return existsSync24(touchedFilesPath({ workingDirectory, missionId }));
+  return existsSync25(touchedFilesPath({ workingDirectory, missionId }));
 }
 function readTouchedLog({
   workingDirectory,
@@ -21187,7 +21248,7 @@ function readTouchedLog({
 }) {
   try {
     const target = touchedFilesPath({ workingDirectory, missionId });
-    if (!existsSync24(target)) return null;
+    if (!existsSync25(target)) return null;
     const raw = JSON.parse(readFileSync19(target, "utf8"));
     const result = /* @__PURE__ */ new Set();
     if (Array.isArray(raw.paths)) {
@@ -21241,7 +21302,7 @@ function readPeerTouchedClaims({
   );
   if (activeMissionIds.size === 0) return [];
   const directory = path28.join(resolveGlobalDataDir(), "vcs-touched");
-  if (!existsSync24(directory)) return [];
+  if (!existsSync25(directory)) return [];
   const claims = [];
   for (const name of readdirSync5(directory)) {
     if (!name.endsWith(".json") || name.endsWith(".bash-snapshot.json")) continue;
@@ -21271,7 +21332,7 @@ function readBaselineSnapshot({
 }) {
   try {
     const target = baselineFilePath({ workingDirectory, missionId });
-    if (!existsSync24(target)) return /* @__PURE__ */ new Map();
+    if (!existsSync25(target)) return /* @__PURE__ */ new Map();
     const raw = JSON.parse(readFileSync19(target, "utf8"));
     if (Array.isArray(raw.files)) {
       const byPath = /* @__PURE__ */ new Map();
@@ -21367,7 +21428,7 @@ function compileIgnorePattern(rawPattern) {
 function loadIgnoreRules(repoRoot) {
   try {
     const target = path28.join(repoRoot, OVERLORD_IGNORE_FILENAME);
-    if (!existsSync24(target)) return [];
+    if (!existsSync25(target)) return [];
     const rules = [];
     for (const rawLine of readFileSync19(target, "utf8").split("\n")) {
       const line = rawLine.replace(/\r$/, "").trim();
@@ -21501,18 +21562,18 @@ import { readFileSync as readFileSync20 } from "node:fs";
 import path29 from "node:path";
 function firstNonEmptyString(value) {
   if (typeof value !== "string") return null;
-  const trimmed7 = value.trim();
-  return trimmed7 ? trimmed7 : null;
+  const trimmed8 = value.trim();
+  return trimmed8 ? trimmed8 : null;
 }
 function collectCandidates(toolInput) {
   const counts = /* @__PURE__ */ new Map();
   const order = [];
   const bump = (raw, amount) => {
     if (typeof raw !== "string") return;
-    const trimmed7 = raw.trim();
-    if (!trimmed7) return;
-    if (!counts.has(trimmed7)) order.push(trimmed7);
-    counts.set(trimmed7, (counts.get(trimmed7) ?? 0) + amount);
+    const trimmed8 = raw.trim();
+    if (!trimmed8) return;
+    if (!counts.has(trimmed8)) order.push(trimmed8);
+    counts.set(trimmed8, (counts.get(trimmed8) ?? 0) + amount);
   };
   bump(toolInput.file_path, 1);
   bump(toolInput.filePath, 1);
@@ -21736,7 +21797,7 @@ var init_resource_observations = __esm({
 
 // src/runner-identity.ts
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync25, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync12 } from "node:fs";
 import { hostname as hostname4 } from "node:os";
 import path30 from "node:path";
 function envValue(name) {
@@ -21750,7 +21811,7 @@ function resolveRunnerInstanceId(dataDir = resolveGlobalDataDir()) {
   const pinned = envValue("OVERLORD_RUNNER_INSTANCE_ID");
   if (pinned) return pinned;
   const statePath = runnerInstanceStatePath(dataDir);
-  if (existsSync25(statePath)) {
+  if (existsSync26(statePath)) {
     try {
       const parsed = JSON.parse(readFileSync21(statePath, "utf8"));
       if (typeof parsed.runnerInstanceId === "string" && parsed.runnerInstanceId.trim()) {
@@ -21804,7 +21865,15 @@ var init_runner_identity = __esm({
 
 // src/runner-service.ts
 import { execFile } from "node:child_process";
-import { chmodSync as chmodSync5, existsSync as existsSync26, mkdirSync as mkdirSync14, readFileSync as readFileSync22, rmSync as rmSync6, writeFileSync as writeFileSync13 } from "node:fs";
+import {
+  chmodSync as chmodSync5,
+  existsSync as existsSync27,
+  mkdirSync as mkdirSync14,
+  readFileSync as readFileSync22,
+  rmSync as rmSync6,
+  statSync as statSync7,
+  writeFileSync as writeFileSync13
+} from "node:fs";
 import os5 from "node:os";
 import path31 from "node:path";
 import { promisify } from "node:util";
@@ -21812,6 +21881,38 @@ function writeServiceFile(filePath, contents) {
   writeFileSync13(filePath, contents, { mode: 384 });
   chmodSync5(filePath, 384);
 }
+function resolveRunnerEntryScript(argv = process.argv) {
+  return argv[1] ? path31.resolve(argv[1]) : null;
+}
+function readRunnerExecutableFileIdentity(filePath, stat = statSync7) {
+  try {
+    const metadata = stat(filePath);
+    return { dev: metadata.dev, ino: metadata.ino, mtimeMs: metadata.mtimeMs };
+  } catch (error) {
+    return error.code === "ENOENT" ? null : void 0;
+  }
+}
+function captureRunnerSupervisorIdentity({
+  execPath = process.execPath,
+  entryScript = resolveRunnerEntryScript(),
+  stat = statSync7
+} = {}) {
+  return {
+    program: readRunnerExecutableFileIdentity(execPath, stat),
+    entryScript: entryScript ? readRunnerExecutableFileIdentity(entryScript, stat) : void 0
+  };
+}
+function executableIdentityChanged(initial, current) {
+  if (current === null) return true;
+  if (!initial || !current) return false;
+  return initial.dev !== current.dev || initial.ino !== current.ino || initial.mtimeMs !== current.mtimeMs;
+}
+function shouldRestartRunnerSupervisor({
+  initial,
+  current
+}) {
+  return executableIdentityChanged(initial.program, current.program) || executableIdentityChanged(initial.entryScript, current.entryScript);
+}
 function emptyRunnerServiceState() {
   return {
     serviceKind: null,
@@ -21832,7 +21933,7 @@ function runnerServiceStatePath(dataDir = resolveGlobalDataDir()) {
 }
 function readRunnerServiceState(dataDir = resolveGlobalDataDir()) {
   const filePath = runnerServiceStatePath(dataDir);
-  if (!existsSync26(filePath)) return emptyRunnerServiceState();
+  if (!existsSync27(filePath)) return emptyRunnerServiceState();
   try {
     const parsed = JSON.parse(readFileSync22(filePath, "utf8"));
     return { ...emptyRunnerServiceState(), ...parsed };
@@ -21850,45 +21951,14 @@ function patchRunnerServiceState(patch, dataDir = resolveGlobalDataDir()) {
   writeRunnerServiceState(next, dataDir);
   return next;
 }
-function runnerFocusStatePath(dataDir = resolveGlobalDataDir()) {
-  return path31.join(dataDir, RUNNER_FOCUS_STATE_FILENAME);
-}
-function readDesktopFocusState(dataDir = resolveGlobalDataDir()) {
-  const filePath = runnerFocusStatePath(dataDir);
-  if (!existsSync26(filePath)) return { lastFocusedAt: null };
-  try {
-    const parsed = JSON.parse(readFileSync22(filePath, "utf8"));
-    return { lastFocusedAt: parsed.lastFocusedAt ?? null };
-  } catch {
-    return { lastFocusedAt: null };
-  }
-}
-function withinWindow(timestamp, now, windowMs) {
-  if (!timestamp) return false;
-  const ms = Date.parse(timestamp);
-  if (Number.isNaN(ms)) return false;
-  return now - ms <= windowMs;
-}
-function selectBasePollIntervalMs({
-  lastLaunchedAt,
-  lastDesktopFocusAt = null,
-  now
-}) {
-  const jobActive = withinWindow(lastLaunchedAt, now, IDLE_BACKOFF_MS);
-  const focusActive = withinWindow(lastDesktopFocusAt, now, DESKTOP_FOCUS_WINDOW_MS);
-  return jobActive || focusActive ? FAST_POLL_INTERVAL_MS : SLOW_POLL_INTERVAL_MS;
-}
 function applyPollJitter(intervalMs, random = Math.random) {
   const spread = intervalMs * 0.1;
   return Math.round(intervalMs + (random() * 2 - 1) * spread);
 }
-function nextRunnerLastError(pollError) {
-  return pollError;
-}
 function resolveOverlordAppInvocation({
   platform: platform2 = process.platform,
   homedir: homedir2 = os5.homedir(),
-  exists = existsSync26
+  exists = existsSync27
 } = {}) {
   if (platform2 !== "darwin") return null;
   const appDirs = [
@@ -21920,27 +21990,15 @@ function resolveOvldInvocation(argv = process.argv, execPath = process.execPath)
   }
   return { program: execPath, args: ["runner", "supervise"] };
 }
-function describeServicePublisher({
-  execProgram,
-  platform: platform2 = process.platform
-}) {
-  if (platform2 !== "darwin" || !execProgram) {
-    return { publisher: "unknown", needsReinstallForOverlord: false };
-  }
-  if (execProgram.includes(".app/Contents/MacOS/")) {
-    return { publisher: "overlord", needsReinstallForOverlord: false };
-  }
-  return { publisher: "node", needsReinstallForOverlord: true };
-}
 function buildRunnerServiceEnv({
   backendUrl,
   overlordHome,
   runAsElectronNode
 }) {
   const env = {
-    OVERLORD_BACKEND_URL: backendUrl,
     PATH: process.env.PATH?.trim() || "/usr/local/bin:/usr/bin:/bin"
   };
+  if (!isLoopbackBackendUrl(backendUrl)) env.OVERLORD_BACKEND_URL = backendUrl;
   const home = overlordHome?.trim() || process.env.OVLD_HOME?.trim();
   if (home) env.OVLD_HOME = path31.resolve(home);
   const token = process.env.OVERLORD_USER_TOKEN?.trim() || process.env.OVLD_USER_TOKEN?.trim();
@@ -22025,31 +22083,72 @@ async function runCommand(program, args) {
   const { stdout } = await execFileAsync(program, args);
   return { stdout: stdout.toString() };
 }
+function launchdDomainTarget(uid) {
+  return `gui/${uid}`;
+}
+function launchdServiceTarget(uid) {
+  return `${launchdDomainTarget(uid)}/${LAUNCHD_LABEL}`;
+}
+function planLaunchdUnloadCommands(opts) {
+  return [{ args: ["bootout", launchdServiceTarget(opts.uid)], tolerateFailure: true }];
+}
+function planLaunchdLoadCommands(opts) {
+  const service = launchdServiceTarget(opts.uid);
+  return [
+    { args: ["enable", service], tolerateFailure: true },
+    {
+      args: ["bootstrap", launchdDomainTarget(opts.uid), opts.plistPath],
+      tolerateFailure: true
+    },
+    { args: ["kickstart", service], tolerateFailure: false }
+  ];
+}
 function resolveServiceManager(platform2 = process.platform) {
   if (platform2 === "darwin") return new LaunchdManager();
   if (platform2 === "linux") return new SystemdUserManager();
   return null;
 }
-var execFileAsync, RUNNER_SERVICE_STATE_FILENAME, RUNNER_FOCUS_STATE_FILENAME, LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, FAST_POLL_INTERVAL_MS, SLOW_POLL_INTERVAL_MS, IDLE_BACKOFF_MS, DESKTOP_FOCUS_WINDOW_MS, LaunchdManager, SystemdUserManager;
+var execFileAsync, RUNNER_SERVICE_STATE_FILENAME, LAUNCHD_LABEL, SYSTEMD_UNIT_NAME, FALLBACK_POLL_INTERVAL_MS, LaunchdManager, SystemdUserManager;
 var init_runner_service = __esm({
   "src/runner-service.ts"() {
     "use strict";
     init_config();
     execFileAsync = promisify(execFile);
     RUNNER_SERVICE_STATE_FILENAME = "runner-service.json";
-    RUNNER_FOCUS_STATE_FILENAME = "runner-focus.json";
     LAUNCHD_LABEL = "io.overlord.runner";
     SYSTEMD_UNIT_NAME = "overlord-runner";
-    FAST_POLL_INTERVAL_MS = 3e3;
-    SLOW_POLL_INTERVAL_MS = 5e3;
-    IDLE_BACKOFF_MS = 2 * 60 * 60 * 1e3;
-    DESKTOP_FOCUS_WINDOW_MS = 30 * 60 * 1e3;
+    FALLBACK_POLL_INTERVAL_MS = 5e3;
     LaunchdManager = class {
       kind = "launchd";
       identifier = LAUNCHD_LABEL;
+      exec;
+      constructor(exec) {
+        this.exec = exec ?? ((args) => runCommand("launchctl", args));
+      }
       unitPath() {
         return path31.join(launchAgentsDir(), `${LAUNCHD_LABEL}.plist`);
       }
+      uid() {
+        return process.getuid?.() ?? "";
+      }
+      async runSteps(steps) {
+        for (const step of steps) {
+          try {
+            await this.exec(step.args);
+          } catch (error) {
+            if (!step.tolerateFailure) throw error;
+          }
+        }
+      }
+      /** True when launchd still has the label registered, whatever its run state. */
+      async isLoaded() {
+        try {
+          await this.exec(["list", LAUNCHD_LABEL]);
+          return true;
+        } catch {
+          return false;
+        }
+      }
       render(opts) {
         return renderLaunchdPlist({
           label: LAUNCHD_LABEL,
@@ -22061,41 +22160,33 @@ var init_runner_service = __esm({
       async install(opts) {
         mkdirSync14(launchAgentsDir(), { recursive: true });
         mkdirSync14(path31.join(resolveGlobalDataDir(), "logs"), { recursive: true });
+        await this.runSteps(planLaunchdUnloadCommands({ uid: this.uid() }));
         writeServiceFile(this.unitPath(), this.render(opts));
         if (opts.autoStart) await this.start();
       }
       async start() {
-        try {
-          await runCommand("launchctl", ["load", "-w", this.unitPath()]);
-        } catch {
-          await runCommand("launchctl", [
-            "kickstart",
-            "-k",
-            `gui/${process.getuid?.() ?? ""}/${LAUNCHD_LABEL}`
-          ]);
-        }
+        await this.runSteps(planLaunchdLoadCommands({ uid: this.uid(), plistPath: this.unitPath() }));
       }
       async stop() {
-        await runCommand("launchctl", ["unload", "-w", this.unitPath()]);
+        await this.runSteps(planLaunchdUnloadCommands({ uid: this.uid() }));
       }
       async restart() {
-        try {
-          await this.stop();
-        } catch {
-        }
+        await this.stop();
         await this.start();
       }
       async uninstall() {
-        try {
-          await this.stop();
-        } catch {
+        await this.runSteps(planLaunchdUnloadCommands({ uid: this.uid() }));
+        if (await this.isLoaded()) {
+          throw new Error(
+            `launchctl still reports ${LAUNCHD_LABEL} as loaded after bootout; left ${this.unitPath()} in place so the service can be repaired with \`ovld runner service restart\`.`
+          );
         }
-        if (existsSync26(this.unitPath())) rmSync6(this.unitPath());
+        if (existsSync27(this.unitPath())) rmSync6(this.unitPath());
       }
       async status() {
-        const installed = existsSync26(this.unitPath());
+        const installed = existsSync27(this.unitPath());
         try {
-          const { stdout } = await runCommand("launchctl", ["list"]);
+          const { stdout } = await this.exec(["list"]);
           const line = stdout.split("\n").find((row) => row.includes(LAUNCHD_LABEL));
           if (!line) return { installed, running: installed ? "stopped" : "unknown" };
           const pid = line.trim().split(/\s+/)[0];
@@ -22136,14 +22227,14 @@ var init_runner_service = __esm({
           await runCommand("systemctl", ["--user", "disable", this.identifier]);
         } catch {
         }
-        if (existsSync26(this.unitPath())) rmSync6(this.unitPath());
+        if (existsSync27(this.unitPath())) rmSync6(this.unitPath());
         try {
           await runCommand("systemctl", ["--user", "daemon-reload"]);
         } catch {
         }
       }
       async status() {
-        const installed = existsSync26(this.unitPath());
+        const installed = existsSync27(this.unitPath());
         try {
           const { stdout } = await runCommand("systemctl", ["--user", "is-active", this.identifier]);
           return { installed, running: stdout.trim() === "active" ? "running" : "stopped" };
@@ -22158,9 +22249,9 @@ var init_runner_service = __esm({
 // src/select-prompt.ts
 import { createInterface as createInterface4 } from "node:readline";
 function parseNumberedSelection(answer, count) {
-  const trimmed7 = answer.trim();
-  if (!/^\d+$/.test(trimmed7)) return null;
-  const value = Number.parseInt(trimmed7, 10);
+  const trimmed8 = answer.trim();
+  if (!/^\d+$/.test(trimmed8)) return null;
+  const value = Number.parseInt(trimmed8, 10);
   if (!Number.isInteger(value) || value < 1 || value > count) return null;
   return value - 1;
 }
@@ -22210,7 +22301,7 @@ var init_select_prompt = __esm({
 
 // src/session-key.ts
 import { createHash as createHash10 } from "node:crypto";
-import { existsSync as existsSync27, mkdirSync as mkdirSync15, readFileSync as readFileSync23, rmSync as rmSync7, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync15, readFileSync as readFileSync23, rmSync as rmSync7, writeFileSync as writeFileSync14 } from "node:fs";
 import path32 from "node:path";
 function sessionKeyCachePath({
   missionId,
@@ -22225,7 +22316,7 @@ function readCachedSessionKey({
 }) {
   try {
     const filePath = sessionKeyCachePath({ missionId, workingDirectory });
-    if (!existsSync27(filePath)) return void 0;
+    if (!existsSync28(filePath)) return void 0;
     const raw = JSON.parse(readFileSync23(filePath, "utf8"));
     return typeof raw.sessionKey === "string" && raw.sessionKey.trim() ? raw.sessionKey.trim() : void 0;
   } catch {
@@ -22238,13 +22329,13 @@ function writeCachedSessionKey({
   sessionKey
 }) {
   try {
-    const trimmed7 = sessionKey.trim();
-    if (!trimmed7) return;
+    const trimmed8 = sessionKey.trim();
+    if (!trimmed8) return;
     const filePath = sessionKeyCachePath({ missionId, workingDirectory });
     mkdirSync15(path32.dirname(filePath), { recursive: true });
     writeFileSync14(
       filePath,
-      JSON.stringify({ sessionKey: trimmed7, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }),
+      JSON.stringify({ sessionKey: trimmed8, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }),
       { mode: 384 }
     );
   } catch {
@@ -22256,7 +22347,7 @@ function clearCachedSessionKey({
 }) {
   try {
     const filePath = sessionKeyCachePath({ missionId, workingDirectory });
-    if (existsSync27(filePath)) rmSync7(filePath);
+    if (existsSync28(filePath)) rmSync7(filePath);
   } catch {
   }
 }
@@ -22272,9 +22363,10 @@ var commands_exports = {};
 __export(commands_exports, {
   resolveProtocolFileInputs: () => resolveProtocolFileInputs,
   runManagementCommand: () => runManagementCommand,
-  runProtocolCommand: () => runProtocolCommand
+  runProtocolCommand: () => runProtocolCommand,
+  runRunnerOnce: () => runRunnerOnce
 });
-import { existsSync as existsSync28, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "node:fs";
 import os6 from "node:os";
 import path33 from "node:path";
 function resourceAccessModeBody(value) {
@@ -22904,7 +22996,7 @@ async function runProtocolCommand({
     clearCachedSessionKey({ missionId, workingDirectory });
     removeActiveSession({ workingDirectory, missionId });
     clearActiveMissionPointer(workingDirectory);
-    const connectorInstallsEditHook = existsSync28(path33.join(os6.homedir(), ".claude")) || existsSync28(
+    const connectorInstallsEditHook = existsSync29(path33.join(os6.homedir(), ".claude")) || existsSync29(
       path33.join(
         os6.homedir(),
         ".cursor",
@@ -23435,6 +23527,165 @@ function isNoExecutionTargetRegisteredError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.includes("(no_execution_target_registered)");
 }
+async function runRunnerOnce({
+  runtime,
+  parsed,
+  json
+}) {
+  let claim;
+  try {
+    claim = await runtime.backend.post({
+      path: "/api/runner/claim",
+      body: {
+        projectId: flagValue(parsed.flags, "--project-id"),
+        ...clientDeviceIdentity(),
+        // Contract v40: the claim poll doubles as this runner instance's
+        // heartbeat, so local target liveness reflects a runner that can
+        // actually take work rather than any CLI traffic from the machine.
+        ...runnerRegistrationPayload()
+      }
+    });
+  } catch (error) {
+    if (isNoExecutionTargetRegisteredError(error)) {
+      throw new CliError({
+        message: `${error instanceof Error ? error.message : String(error)}
+The runner will not register a target for you \u2014 declare this machine first, then start it again.`
+      });
+    }
+    throw error;
+  }
+  const request = asRecord5(claim).request;
+  const longPoll = asRecord5(claim).longPoll === true;
+  if (!request) return { launched: false, longPoll };
+  const requestRecord = asRecord5(request);
+  const requestId = String(requestRecord.id);
+  const projectId = String(requestRecord.projectId ?? "");
+  const executionTargetId = typeof requestRecord.executionTargetId === "string" ? requestRecord.executionTargetId.trim() : "";
+  if (projectId && executionTargetId) {
+    try {
+      await reportRunnerResourceObservations({
+        backend: runtime.backend,
+        projectId,
+        executionTargetId
+      });
+    } catch {
+    }
+  }
+  try {
+    await runtime.backend.post({ path: `/api/runner/requests/${requestId}/launching` });
+    const mutation = parseMutationFromMetadata(requestRecord.metadata);
+    if (mutation) {
+      const mutationResult = await executeLocalTargetMutation({ mutation });
+      if (!mutationResult.ok) {
+        await runtime.backend.post({
+          path: `/api/runner/requests/${requestId}/failed`,
+          body: { error: mutationResult.message }
+        });
+        throw new CliError({ message: mutationResult.message });
+      }
+      await runtime.backend.post({
+        path: `/api/runner/requests/${requestId}/completed`,
+        body: { mutationResult }
+      });
+      if (json) printJson({ request, mutationResult });
+      else console.log(`Completed ${mutation.kind} for ${requestRecord.missionId}`);
+      return { launched: true, longPoll };
+    }
+    const requestedAgent = typeof requestRecord.requestedAgent === "string" ? requestRecord.requestedAgent.trim() : "";
+    if (!requestedAgent) {
+      throw new CliError({
+        message: `Execution request ${requestId} has no agent; the objective must specify one before it can be launched.`
+      });
+    }
+    const launchConfig = asRecord5(requestRecord.launchConfig);
+    const terminal = await resolveTerminalLaunchSettings({ runtime, flags: parsed.flags });
+    const missionId = String(requestRecord.missionId);
+    const dryRun = flagBoolean(parsed.flags, "--dry-run");
+    const prepared = await prepareMissionBranch({
+      runtime,
+      options: {
+        missionId,
+        workingDirectory: String(requestRecord.workingDirectory ?? process.cwd()),
+        objectiveId: String(requestRecord.objectiveId ?? ""),
+        workspaceAutomationEnabled: await readWorktreeBranchAutomationEnabled(runtime),
+        dryRun,
+        overrideBranch: flagValue(parsed.flags, "--branch"),
+        noWorktree: flagBoolean(parsed.flags, "--no-worktree")
+      }
+    });
+    await recordBranchPrepared({
+      runtime,
+      missionId,
+      requestId,
+      branchAutomation: prepared.branchAutomation
+    });
+    const launchSession = launchSessionSnapshotFromMetadata(asRecord5(requestRecord.metadata));
+    const result = await launchAgent({
+      runtime,
+      options: {
+        agent: requestedAgent,
+        missionId,
+        workingDirectory: prepared.workingDirectory,
+        model: typeof requestRecord.requestedModel === "string" ? requestRecord.requestedModel : void 0,
+        thinking: typeof requestRecord.requestedReasoningEffort === "string" ? requestRecord.requestedReasoningEffort : void 0,
+        flags: normalizeAgentLaunchFlags(launchConfig.flags),
+        preCommand: typeof launchConfig.preCommand === "string" ? launchConfig.preCommand : void 0,
+        preLaunchCommands: Array.isArray(requestRecord.preLaunchCommands) ? requestRecord.preLaunchCommands.filter(
+          (value) => typeof value === "string"
+        ) : void 0,
+        launchEnvVars: parseLaunchEnvVarsValue(requestRecord.launchEnvVars),
+        executionRequestId: requestId,
+        executionTargetId: executionTargetId || void 0,
+        launchSession,
+        ...terminal,
+        dryRun
+      }
+    });
+    if (result.providerFallbackWarning) {
+      console.error(`[overlord] ${result.providerFallbackWarning}`);
+    }
+    if (result.viewerOpen && result.viewerOpen.ok === false) {
+      console.error(`[overlord] ${result.viewerOpen.warning}`);
+    }
+    if (result.status && result.status !== 0) {
+      throw new CliError({ message: `Launch command exited with status ${result.status}` });
+    }
+    await runtime.backend.post({
+      path: `/api/runner/requests/${requestId}/launched`,
+      body: result.providerSession ? { providerSession: result.providerSession } : {}
+    });
+    if (result.providerSession && !dryRun) {
+      void postLatchHarnessEventsAfterLaunch({
+        backend: runtime.backend,
+        requestId,
+        providerSessionId: result.providerSession.providerSessionId,
+        executable: launchSession?.executionProvider.kind === "latch" ? launchSession.executionProvider.executable : void 0
+      });
+    }
+    if (json || dryRun) {
+      printJson({
+        request,
+        plan: result.plan,
+        status: result.status,
+        providerSession: result.providerSession ?? null,
+        viewerOpen: result.viewerOpen ?? null,
+        providerFallbackWarning: result.providerFallbackWarning ?? null
+      });
+    } else {
+      console.log(`Launched ${requestedAgent} for ${requestRecord.missionId}`);
+    }
+    return { launched: true, longPoll };
+  } catch (error) {
+    try {
+      await runtime.backend.post({
+        path: `/api/runner/requests/${requestId}/failed`,
+        body: { error: error instanceof Error ? error.message : String(error) }
+      });
+    } catch {
+    }
+    throw error;
+  }
+}
 async function runRunnerCommand({
   runtime,
   parsed,
@@ -23468,161 +23719,7 @@ async function runRunnerCommand({
       message: "Usage: ovld runner once|start|supervise|status|clear <objective_id>|clear-all|service <install|start|stop|restart|status|uninstall>"
     });
   }
-  const runOnce = async () => {
-    let claim;
-    try {
-      claim = await runtime.backend.post({
-        path: "/api/runner/claim",
-        body: {
-          projectId: flagValue(parsed.flags, "--project-id"),
-          ...clientDeviceIdentity(),
-          // Contract v40: the claim poll doubles as this runner instance's
-          // heartbeat, so local target liveness reflects a runner that can
-          // actually take work rather than any CLI traffic from the machine.
-          ...runnerRegistrationPayload()
-        }
-      });
-    } catch (error) {
-      if (isNoExecutionTargetRegisteredError(error)) {
-        throw new CliError({
-          message: `${error instanceof Error ? error.message : String(error)}
-The runner will not register a target for you \u2014 declare this machine first, then start it again.`
-        });
-      }
-      throw error;
-    }
-    const request = asRecord5(claim).request;
-    const longPoll = asRecord5(claim).longPoll === true;
-    if (!request) return { launched: false, longPoll };
-    const requestRecord = asRecord5(request);
-    const requestId = String(requestRecord.id);
-    const projectId = String(requestRecord.projectId ?? "");
-    const executionTargetId = typeof requestRecord.executionTargetId === "string" ? requestRecord.executionTargetId.trim() : "";
-    if (projectId && executionTargetId) {
-      try {
-        await reportRunnerResourceObservations({
-          backend: runtime.backend,
-          projectId,
-          executionTargetId
-        });
-      } catch {
-      }
-    }
-    try {
-      await runtime.backend.post({ path: `/api/runner/requests/${requestId}/launching` });
-      const mutation = parseMutationFromMetadata(requestRecord.metadata);
-      if (mutation) {
-        const mutationResult = await executeLocalTargetMutation({ mutation });
-        if (!mutationResult.ok) {
-          await runtime.backend.post({
-            path: `/api/runner/requests/${requestId}/failed`,
-            body: { error: mutationResult.message }
-          });
-          throw new CliError({ message: mutationResult.message });
-        }
-        await runtime.backend.post({
-          path: `/api/runner/requests/${requestId}/completed`,
-          body: { mutationResult }
-        });
-        if (json) printJson({ request, mutationResult });
-        else console.log(`Completed ${mutation.kind} for ${requestRecord.missionId}`);
-        return { launched: true, longPoll };
-      }
-      const requestedAgent = typeof requestRecord.requestedAgent === "string" ? requestRecord.requestedAgent.trim() : "";
-      if (!requestedAgent) {
-        throw new CliError({
-          message: `Execution request ${requestId} has no agent; the objective must specify one before it can be launched.`
-        });
-      }
-      const launchConfig = asRecord5(requestRecord.launchConfig);
-      const terminal = await resolveTerminalLaunchSettings({ runtime, flags: parsed.flags });
-      const missionId = String(requestRecord.missionId);
-      const dryRun = flagBoolean(parsed.flags, "--dry-run");
-      const prepared = await prepareMissionBranch({
-        runtime,
-        options: {
-          missionId,
-          workingDirectory: String(requestRecord.workingDirectory ?? process.cwd()),
-          objectiveId: String(requestRecord.objectiveId ?? ""),
-          workspaceAutomationEnabled: await readWorktreeBranchAutomationEnabled(runtime),
-          dryRun,
-          overrideBranch: flagValue(parsed.flags, "--branch"),
-          noWorktree: flagBoolean(parsed.flags, "--no-worktree")
-        }
-      });
-      await recordBranchPrepared({
-        runtime,
-        missionId,
-        requestId,
-        branchAutomation: prepared.branchAutomation
-      });
-      const launchSession = launchSessionSnapshotFromMetadata(asRecord5(requestRecord.metadata));
-      const result = await launchAgent({
-        runtime,
-        options: {
-          agent: requestedAgent,
-          missionId,
-          workingDirectory: prepared.workingDirectory,
-          model: typeof requestRecord.requestedModel === "string" ? requestRecord.requestedModel : void 0,
-          thinking: typeof requestRecord.requestedReasoningEffort === "string" ? requestRecord.requestedReasoningEffort : void 0,
-          flags: normalizeAgentLaunchFlags(launchConfig.flags),
-          preCommand: typeof launchConfig.preCommand === "string" ? launchConfig.preCommand : void 0,
-          preLaunchCommands: Array.isArray(requestRecord.preLaunchCommands) ? requestRecord.preLaunchCommands.filter(
-            (value) => typeof value === "string"
-          ) : void 0,
-          launchEnvVars: parseLaunchEnvVarsValue(requestRecord.launchEnvVars),
-          executionRequestId: requestId,
-          executionTargetId: executionTargetId || void 0,
-          launchSession,
-          ...terminal,
-          dryRun
-        }
-      });
-      if (result.providerFallbackWarning) {
-        console.error(`[overlord] ${result.providerFallbackWarning}`);
-      }
-      if (result.viewerOpen && result.viewerOpen.ok === false) {
-        console.error(`[overlord] ${result.viewerOpen.warning}`);
-      }
-      if (result.status && result.status !== 0) {
-        throw new CliError({ message: `Launch command exited with status ${result.status}` });
-      }
-      await runtime.backend.post({
-        path: `/api/runner/requests/${requestId}/launched`,
-        body: result.providerSession ? { providerSession: result.providerSession } : {}
-      });
-      if (result.providerSession && !dryRun) {
-        void postLatchHarnessEventsAfterLaunch({
-          backend: runtime.backend,
-          requestId,
-          providerSessionId: result.providerSession.providerSessionId,
-          executable: launchSession?.executionProvider.kind === "latch" ? launchSession.executionProvider.executable : void 0
-        });
-      }
-      if (json || dryRun) {
-        printJson({
-          request,
-          plan: result.plan,
-          status: result.status,
-          providerSession: result.providerSession ?? null,
-          viewerOpen: result.viewerOpen ?? null,
-          providerFallbackWarning: result.providerFallbackWarning ?? null
-        });
-      } else {
-        console.log(`Launched ${requestedAgent} for ${requestRecord.missionId}`);
-      }
-      return { launched: true, longPoll };
-    } catch (error) {
-      try {
-        await runtime.backend.post({
-          path: `/api/runner/requests/${requestId}/failed`,
-          body: { error: error instanceof Error ? error.message : String(error) }
-        });
-      } catch {
-      }
-      throw error;
-    }
-  };
+  const runOnce = () => runRunnerOnce({ runtime, parsed, json });
   if (sub === "once") {
     const result = await runOnce();
     if (!result.launched) {
@@ -23646,8 +23743,18 @@ async function runRunnerSupervisor({
   runOnce,
   json
 }) {
-  if (!json) console.log("Runner supervisor started. Adaptive polling for execution requests.");
+  if (!json) console.log("Runner supervisor started. Polling for execution requests.");
+  const initialExecutableIdentity = captureRunnerSupervisorIdentity();
   for (; ; ) {
+    if (shouldRestartRunnerSupervisor({
+      initial: initialExecutableIdentity,
+      current: captureRunnerSupervisorIdentity()
+    })) {
+      console.error(
+        "Runner supervisor executable was replaced or removed; exiting cleanly so the service manager restarts the installed build."
+      );
+      process.exit(0);
+    }
     const now = /* @__PURE__ */ new Date();
     let result = { launched: false, longPoll: false };
     let lastError = null;
@@ -23656,25 +23763,22 @@ async function runRunnerSupervisor({
     } catch (error) {
       if (isNoExecutionTargetRegisteredError(error)) throw error;
       lastError = error instanceof Error ? error.message : String(error);
+      console.error(`[overlord] Runner poll failed: ${lastError}`);
     }
     const state = readRunnerServiceState();
-    const focus = readDesktopFocusState();
-    const base = selectBasePollIntervalMs({
-      lastLaunchedAt: result.launched ? now.toISOString() : state.lastLaunchedAt,
-      lastDesktopFocusAt: focus.lastFocusedAt,
-      now: now.getTime()
-    });
     patchRunnerServiceState({
       lastHeartbeatAt: now.toISOString(),
       lastClaimedAt: result.launched ? now.toISOString() : state.lastClaimedAt,
       lastLaunchedAt: result.launched ? now.toISOString() : state.lastLaunchedAt,
-      // Reflect the latest poll's outcome so a resolved failure (e.g. an auth
-      // error from before the user logged in) clears instead of sticking.
-      lastError: nextRunnerLastError(lastError),
-      currentPollIntervalMs: base
+      // Reflect the latest poll's outcome rather than falling back to the stored
+      // value. A successful poll must clear a resolved failure (for example, an
+      // auth error from before login) instead of leaving the desktop status box
+      // stuck on "Runner error"; persistent failures recur on every poll.
+      lastError,
+      currentPollIntervalMs: FALLBACK_POLL_INTERVAL_MS
     });
     if (!result.longPoll) {
-      await new Promise((resolve) => setTimeout(resolve, applyPollJitter(base)));
+      await new Promise((resolve) => setTimeout(resolve, applyPollJitter(FALLBACK_POLL_INTERVAL_MS)));
     }
   }
 }
@@ -23692,10 +23796,8 @@ async function runRunnerServiceCommand({
   if (action === "status") {
     const runState = await manager.status();
     const state = readRunnerServiceState();
-    const { publisher, needsReinstallForOverlord } = describeServicePublisher({
-      execProgram: state.execProgram
-    });
-    const reinstallHint = runState.installed && needsReinstallForOverlord ? 'This service is registered under "Node.js Foundation" because it runs the plain node binary. Reinstall it from the Overlord desktop app (or with the desktop app present) to re-register it under "Overlord".' : null;
+    const publisher = process.platform !== "darwin" || !state.execProgram ? "unknown" : state.execProgram.includes(".app/Contents/MacOS/") ? "overlord" : "node";
+    const reinstallHint = runState.installed && publisher === "node" ? 'This service is registered under "Node.js Foundation" because it runs the plain node binary. Reinstall it from the Overlord desktop app (or with the desktop app present) to re-register it under "Overlord".' : null;
     const payload = {
       supported: true,
       kind: manager.kind,