overlord-cli 0.2608141841.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}
 `;
@@ -5566,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") {
@@ -16335,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))
@@ -16501,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))
@@ -16643,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")
@@ -16657,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: {
@@ -16684,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;
@@ -16692,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 {
@@ -16706,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";
@@ -16751,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;
@@ -16765,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({
@@ -16783,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":
@@ -16801,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,
@@ -16826,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);
@@ -16838,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()
@@ -16847,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({
@@ -16874,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
   };
 }
@@ -16900,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();
@@ -16914,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;
@@ -16935,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;
@@ -16970,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 };
@@ -16995,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"],
@@ -17067,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([
@@ -17096,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) {
@@ -17112,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();
@@ -17187,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] : [];
@@ -17256,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);
@@ -17288,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,
@@ -17323,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,
@@ -17347,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
@@ -17369,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.`);
@@ -17392,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,
@@ -17414,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,
@@ -17690,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,
@@ -17716,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)
@@ -17732,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,
@@ -17756,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();
   }
@@ -17800,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 {
@@ -17836,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);
@@ -17844,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)
@@ -17922,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",
@@ -17999,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",
@@ -18039,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,
@@ -18063,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}.`;
     }
@@ -18072,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 {
@@ -18122,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"]);
@@ -18138,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",
@@ -18199,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"() {
@@ -18232,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 });
       }
       /**
@@ -18679,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 = {}) {
@@ -18851,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}`);
     }
@@ -19026,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;
 }
@@ -20119,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;
@@ -20141,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 {
@@ -20199,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 || "");
     });
   });
 }
@@ -20789,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");
@@ -20798,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();
@@ -20872,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,
@@ -20984,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)) {
@@ -21076,7 +21126,7 @@ function resetTouchedFiles({
       touchedFilesPath({ workingDirectory, missionId }),
       bashSnapshotPath({ workingDirectory, missionId })
     ]) {
-      if (existsSync24(target)) rmSync5(target);
+      if (existsSync25(target)) rmSync5(target);
     }
   } catch {
   }
@@ -21087,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,
@@ -21102,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) => {
@@ -21190,7 +21240,7 @@ function hasTouchedFilesLog({
   workingDirectory,
   missionId
 }) {
-  return existsSync24(touchedFilesPath({ workingDirectory, missionId }));
+  return existsSync25(touchedFilesPath({ workingDirectory, missionId }));
 }
 function readTouchedLog({
   workingDirectory,
@@ -21198,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)) {
@@ -21252,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;
@@ -21282,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();
@@ -21378,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();
@@ -21512,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);
@@ -21747,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) {
@@ -21761,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()) {
@@ -21817,7 +21867,7 @@ var init_runner_identity = __esm({
 import { execFile } from "node:child_process";
 import {
   chmodSync as chmodSync5,
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   mkdirSync as mkdirSync14,
   readFileSync as readFileSync22,
   rmSync as rmSync6,
@@ -21883,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 };
@@ -21908,7 +21958,7 @@ function applyPollJitter(intervalMs, random = Math.random) {
 function resolveOverlordAppInvocation({
   platform: platform2 = process.platform,
   homedir: homedir2 = os5.homedir(),
-  exists = existsSync26
+  exists = existsSync27
 } = {}) {
   if (platform2 !== "darwin") return null;
   const appDirs = [
@@ -22131,10 +22181,10 @@ var init_runner_service = __esm({
             `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 this.exec(["list"]);
           const line = stdout.split("\n").find((row) => row.includes(LAUNCHD_LABEL));
@@ -22177,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" };
@@ -22199,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;
 }
@@ -22251,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,
@@ -22266,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 {
@@ -22279,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 {
@@ -22297,7 +22347,7 @@ function clearCachedSessionKey({
 }) {
   try {
     const filePath = sessionKeyCachePath({ missionId, workingDirectory });
-    if (existsSync27(filePath)) rmSync7(filePath);
+    if (existsSync28(filePath)) rmSync7(filePath);
   } catch {
   }
 }
@@ -22316,7 +22366,7 @@ __export(commands_exports, {
   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) {
@@ -22946,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",