overlord-cli 0.2608132027.0 → 0.2608141841.0

package/dist/index.js

@@ -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, {
@@ -16556,12 +16567,88 @@ var init_latch_environment = __esm({
   }
 });
 
-// ../packages/core/dist/service/latch-launch.js
+// ../packages/core/dist/service/terminal-profile-types.js
+function parseViewerOpenAs(value) {
+  return typeof value === "string" && value.trim().toLowerCase() === "tab" ? "tab" : DEFAULT_VIEWER_OPEN_AS;
+}
 function trimmed(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
+function viewerKindForLauncher(launcher) {
+  const value = trimmed(launcher);
+  if (!value)
+    return "inline";
+  const lowered = value.toLowerCase();
+  if (lowered === "iterm2" || lowered === "iterm")
+    return "iterm";
+  if (lowered === "terminal")
+    return "terminal";
+  return "custom";
+}
+function normalizeExecutionProvider(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const cast = value;
+  const kind = trimmed(cast.kind)?.toLowerCase() === "latch" ? "latch" : "direct";
+  return {
+    kind,
+    executable: trimmed(cast.executable) ?? DEFAULT_LATCH_EXECUTABLE
+  };
+}
+function launchSessionSnapshotFromMetadata(metadata) {
+  const raw = metadata?.[LAUNCH_SESSION_METADATA_KEY];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return null;
+  const cast = raw;
+  if (cast.version !== TERMINAL_PROFILE_VERSION)
+    return null;
+  const viewer = cast.viewer && typeof cast.viewer === "object" && !Array.isArray(cast.viewer) ? cast.viewer : null;
+  const launcher = trimmed(viewer?.launcher);
+  const source = (value) => trimmed(value) === "target" ? "target" : "user_default";
+  return {
+    version: TERMINAL_PROFILE_VERSION,
+    executionProvider: normalizeExecutionProvider(cast.executionProvider) ?? {
+      ...DEFAULT_EXECUTION_PROVIDER
+    },
+    viewer: {
+      kind: trimmed(viewer?.kind) ? trimmed(viewer?.kind) : viewerKindForLauncher(launcher),
+      launcher,
+      openOnLaunch: viewer?.openOnLaunch !== false,
+      // A snapshot frozen before `openAs` existed carries none; `window` is what
+      // those runs actually did, so the absent case must not become `tab`.
+      openAs: parseViewerOpenAs(viewer?.openAs)
+    },
+    executionProviderSource: source(cast.executionProviderSource),
+    viewerOpenSource: source(cast.viewerOpenSource),
+    resolvedAt: trimmed(cast.resolvedAt) ?? ""
+  };
+}
+var DEFAULT_VIEWER_OPEN_AS, TERMINAL_PROFILE_VERSION, DEFAULT_LATCH_EXECUTABLE, DEFAULT_EXECUTION_PROVIDER, DEFAULT_OPEN_VIEWER_ON_LAUNCH, DEFAULT_LAUNCH_SESSION_DEFAULTS, LAUNCH_SESSION_METADATA_KEY;
+var init_terminal_profile_types2 = __esm({
+  "../packages/core/dist/service/terminal-profile-types.js"() {
+    "use strict";
+    DEFAULT_VIEWER_OPEN_AS = "window";
+    TERMINAL_PROFILE_VERSION = 1;
+    DEFAULT_LATCH_EXECUTABLE = "latch";
+    DEFAULT_EXECUTION_PROVIDER = {
+      kind: "direct",
+      executable: DEFAULT_LATCH_EXECUTABLE
+    };
+    DEFAULT_OPEN_VIEWER_ON_LAUNCH = true;
+    DEFAULT_LAUNCH_SESSION_DEFAULTS = {
+      executionProvider: { ...DEFAULT_EXECUTION_PROVIDER },
+      openViewerOnLaunch: DEFAULT_OPEN_VIEWER_ON_LAUNCH
+    };
+    LAUNCH_SESSION_METADATA_KEY = "launchSession";
+  }
+});
+
+// ../packages/core/dist/service/latch-launch.js
+function trimmed2(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 = trimmed(shell) ?? "/bin/bash";
+  const shellPath = trimmed2(shell) ?? "/bin/bash";
   const cleanedEnv = {};
   for (const [key, value] of Object.entries(env)) {
     if (key.trim() && typeof value === "string")
@@ -16570,15 +16657,15 @@ function buildLatchCreateManifest({ commandString, shell = process.env.SHELL?.tr
   const display = {
     source: {
       kind: "overlord",
-      ...trimmed(externalRunId) ? { external_run_id: trimmed(externalRunId) } : {}
+      ...trimmed2(externalRunId) ? { external_run_id: trimmed2(externalRunId) } : {}
     }
   };
-  if (trimmed(title))
-    display.title = trimmed(title);
-  if (trimmed(name))
-    display.name = trimmed(name);
-  if (trimmed(commandLabel))
-    display.command_label = trimmed(commandLabel);
+  if (trimmed2(title))
+    display.title = trimmed2(title);
+  if (trimmed2(name))
+    display.name = trimmed2(name);
+  if (trimmed2(commandLabel))
+    display.command_label = trimmed2(commandLabel);
   return {
     format_version: LATCH_MANIFEST_FORMAT_VERSION,
     launch: {
@@ -16597,7 +16684,7 @@ function buildLatchCreateManifest({ commandString, shell = process.env.SHELL?.tr
 function parseLatchCreateReport(raw) {
   try {
     const parsed = JSON.parse(raw);
-    const id = trimmed(parsed.session?.id);
+    const id = trimmed2(parsed.session?.id);
     if (!id)
       return null;
     const protocolVersion = typeof parsed.protocolVersion === "number" && Number.isFinite(parsed.protocolVersion) ? parsed.protocolVersion : LATCH_MANIFEST_FORMAT_VERSION;
@@ -16605,9 +16692,9 @@ function parseLatchCreateReport(raw) {
       protocolVersion,
       session: {
         id,
-        name: trimmed(parsed.session?.name) ?? id,
-        state: trimmed(parsed.session?.state) ?? "running",
-        createdAt: trimmed(parsed.session?.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString()
+        name: trimmed2(parsed.session?.name) ?? id,
+        state: trimmed2(parsed.session?.state) ?? "running",
+        createdAt: trimmed2(parsed.session?.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString()
       }
     };
   } catch {
@@ -16619,28 +16706,28 @@ function toExecutionProviderSession({ createReport, executionTargetId, createdAt
     provider: "latch",
     providerSessionId: createReport.session.id,
     sessionName: createReport.session.name,
-    executionTargetId: trimmed(executionTargetId),
+    executionTargetId: trimmed2(executionTargetId),
     agentSessionId: null,
     createdAt: createdAt ?? createReport.session.createdAt,
     lastObservedState: createReport.session.state
   };
 }
 function existingLatchProviderSession({ latchSessionId, executionTargetId, createdAt = (/* @__PURE__ */ new Date()).toISOString() }) {
-  const providerSessionId = trimmed(latchSessionId);
+  const providerSessionId = trimmed2(latchSessionId);
   if (!providerSessionId)
     return null;
   return {
     provider: "latch",
     providerSessionId,
     sessionName: null,
-    executionTargetId: trimmed(executionTargetId),
+    executionTargetId: trimmed2(executionTargetId),
     agentSessionId: null,
     createdAt,
     lastObservedState: "running"
   };
 }
 function latchViewerFlagForKind(kind) {
-  switch (trimmed(kind)?.toLowerCase()) {
+  switch (trimmed2(kind)?.toLowerCase()) {
     case "iterm":
     case "iterm2":
       return "iterm";
@@ -16648,28 +16735,59 @@ function latchViewerFlagForKind(kind) {
       return null;
   }
 }
+function compareLatchProductVersions(a, b) {
+  const parts = (value) => value.trim().split(".").map((segment) => {
+    const parsed = Number.parseInt(segment, 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+  });
+  const left = parts(a);
+  const right = parts(b);
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const diff = (left[index] ?? 0) - (right[index] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function latchSupportsOpenAs(productVersion) {
+  const version = trimmed2(productVersion);
+  if (!version)
+    return false;
+  return compareLatchProductVersions(version, LATCH_OPEN_AS_MIN_PRODUCT_VERSION) >= 0;
+}
+function buildLatchOpenArgs({ providerSessionId, viewer, openAs, productVersion }) {
+  const args = ["open", providerSessionId, "--with", viewer];
+  if (openAs && latchSupportsOpenAs(productVersion)) {
+    args.push("--as", parseViewerOpenAs(openAs));
+  }
+  args.push("--json");
+  return args;
+}
 function latchAttachCommand({ executable = "latch", providerSessionId }) {
-  return `${trimmed(executable) ?? "latch"} attach ${providerSessionId}`;
+  return `${trimmed2(executable) ?? "latch"} attach ${providerSessionId}`;
 }
 function shouldUseLatchProvider({ providerKind, latchSelectable }) {
-  return trimmed(providerKind)?.toLowerCase() === "latch" && latchSelectable === true;
+  return trimmed2(providerKind)?.toLowerCase() === "latch" && latchSelectable === true;
 }
-var LATCH_MANIFEST_FORMAT_VERSION, DEFAULT_LATCH_TERMINAL_SIZE;
+var LATCH_MANIFEST_FORMAT_VERSION, DEFAULT_LATCH_TERMINAL_SIZE, LATCH_OPEN_AS_MIN_PRODUCT_VERSION;
 var init_latch_launch = __esm({
   "../packages/core/dist/service/latch-launch.js"() {
     "use strict";
+    init_terminal_profile_types2();
     LATCH_MANIFEST_FORMAT_VERSION = 1;
     DEFAULT_LATCH_TERMINAL_SIZE = { cols: 120, rows: 36 };
+    LATCH_OPEN_AS_MIN_PRODUCT_VERSION = "0.2608140931.0";
   }
 });
 
 // ../packages/core/dist/service/latch-session.js
 import { spawnSync as spawnSync2 } from "node:child_process";
-function trimmed2(value) {
+function trimmed3(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function parseState(value) {
-  switch (trimmed2(value)) {
+  switch (trimmed3(value)) {
     case "running":
       return "running";
     case "exited":
@@ -16708,11 +16826,11 @@ function runLatchJson({ executable, args }) {
   }
 }
 function inspectLatchSession({ executable = "latch", providerSessionId }) {
-  const sessionId = trimmed2(providerSessionId);
+  const sessionId = trimmed3(providerSessionId);
   if (!sessionId)
     throw new LatchSessionCommandError("A Latch session id is required.");
   const report = runLatchJson({
-    executable: trimmed2(executable) ?? "latch",
+    executable: trimmed3(executable) ?? "latch",
     args: ["inspect", sessionId, "--json"]
   });
   const state = parseState(report.state);
@@ -16720,47 +16838,61 @@ 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: trimmed2(report.id) ?? sessionId,
-    name: trimmed2(report.name) ?? sessionId,
+    providerSessionId: trimmed3(report.id) ?? sessionId,
+    name: trimmed3(report.name) ?? sessionId,
     state,
     exitCode: typeof exit?.code === "number" && Number.isFinite(exit.code) ? exit.code : null,
     inspectedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function openLatchSession({ executable = "latch", providerSessionId, viewerKind }) {
-  const sessionId = trimmed2(providerSessionId);
+function readLatchProductVersion(executable) {
+  try {
+    return trimmed3(runLatchJson({ executable, args: ["capabilities", "--json"] }).productVersion);
+  } catch {
+    return null;
+  }
+}
+function openLatchSession({ executable = "latch", providerSessionId, viewerKind, openAs }) {
+  const sessionId = trimmed3(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 report = runLatchJson({
-    executable: trimmed2(executable) ?? "latch",
-    args: ["open", sessionId, "--with", viewer, "--json"]
+    executable: exe,
+    args: buildLatchOpenArgs({
+      providerSessionId: sessionId,
+      viewer,
+      openAs,
+      productVersion: openAs ? readLatchProductVersion(exe) : null
+    })
   });
   if (report.opened !== true) {
     throw new LatchSessionCommandError(`Latch did not open the ${viewer} viewer.`);
   }
   return {
-    providerSessionId: trimmed2(report.id) ?? sessionId,
-    viewer: trimmed2(report.viewer) ?? viewer,
-    opened: true
+    providerSessionId: trimmed3(report.id) ?? sessionId,
+    viewer: trimmed3(report.viewer) ?? viewer,
+    opened: true,
+    behavior: trimmed3(report.behavior) ? parseViewerOpenAs(report.behavior) : null
   };
 }
 function stopLatchSession({ executable = "latch", providerSessionId }) {
-  const sessionId = trimmed2(providerSessionId);
+  const sessionId = trimmed3(providerSessionId);
   if (!sessionId)
     throw new LatchSessionCommandError("A Latch session id is required.");
   const report = runLatchJson({
-    executable: trimmed2(executable) ?? "latch",
+    executable: trimmed3(executable) ?? "latch",
     args: ["stop", sessionId, "--json"]
   });
   const state = parseState(report.state);
   if (!state)
     throw new LatchSessionCommandError("Latch returned an unsupported session state.");
   return {
-    providerSessionId: trimmed2(report.id) ?? sessionId,
+    providerSessionId: trimmed3(report.id) ?? sessionId,
     state
   };
 }
@@ -16770,6 +16902,7 @@ var init_latch_session = __esm({
     "use strict";
     init_latch_environment();
     init_latch_launch();
+    init_terminal_profile_types2();
     LatchSessionCommandError = class extends Error {
       constructor(message) {
         super(message);
@@ -16781,17 +16914,17 @@ var init_latch_session = __esm({
 
 // ../packages/core/dist/service/latch-events.js
 import { spawn as spawn3 } from "node:child_process";
-function trimmed3(value) {
+function trimmed4(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 = trimmed3(row.type);
-  const sessionId = trimmed3(row.sessionId);
-  const at = trimmed3(row.at);
-  const harnessVersion = trimmed3(row.harnessVersion);
+  const type = trimmed4(row.type);
+  const sessionId = trimmed4(row.sessionId);
+  const at = trimmed4(row.at);
+  const harnessVersion = trimmed4(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;
@@ -16802,26 +16935,26 @@ function parseHarnessEvent(value) {
     case "user_message":
     case "assistant_delta":
     case "assistant_message": {
-      const text = trimmed3(row.text);
+      const text = trimmed4(row.text);
       if (!text)
         return null;
       return { ...base, type, text };
     }
     case "tool_started": {
-      const tool = trimmed3(row.tool);
+      const tool = trimmed4(row.tool);
       if (!tool)
         return null;
       return { ...base, type, tool, input: row.input };
     }
     case "tool_finished": {
-      const tool = trimmed3(row.tool);
+      const tool = trimmed4(row.tool);
       if (!tool)
         return null;
       return { ...base, type, tool, output: row.output };
     }
     case "awaiting_input": {
-      const requestId = trimmed3(row.requestId);
-      const kind = trimmed3(row.kind);
+      const requestId = trimmed4(row.requestId);
+      const kind = trimmed4(row.kind);
       const prompt = typeof row.prompt === "string" ? row.prompt : null;
       if (!requestId || kind !== "permission" && kind !== "question" || prompt === null) {
         return null;
@@ -16837,7 +16970,7 @@ function parseHarnessEvent(value) {
       };
     }
     case "status": {
-      const status = trimmed3(row.status);
+      const status = trimmed4(row.status);
       if (!status)
         return null;
       return { ...base, type, status };
@@ -16862,11 +16995,11 @@ function parseHarnessEventNdjson(raw) {
   return events;
 }
 async function collectLatchEvents({ executable = "latch", providerSessionId, from = 0, idleMs = 250, timeoutMs = 8e3 }) {
-  const sessionId = trimmed3(providerSessionId);
+  const sessionId = trimmed4(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 = trimmed3(executable) ?? "latch";
+  const bin = trimmed4(executable) ?? "latch";
   return new Promise((resolve, reject) => {
     const child = spawn3(bin, ["events", sessionId, "--json", "--from", String(fromCursor)], {
       stdio: ["ignore", "pipe", "pipe"],
@@ -17281,75 +17414,6 @@ var init_git_tree = __esm({
   }
 });
 
-// ../packages/core/dist/service/terminal-profile-types.js
-function trimmed4(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function viewerKindForLauncher(launcher) {
-  const value = trimmed4(launcher);
-  if (!value)
-    return "inline";
-  const lowered = value.toLowerCase();
-  if (lowered === "iterm2" || lowered === "iterm")
-    return "iterm";
-  if (lowered === "terminal")
-    return "terminal";
-  return "custom";
-}
-function normalizeExecutionProvider(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const cast = value;
-  const kind = trimmed4(cast.kind)?.toLowerCase() === "latch" ? "latch" : "direct";
-  return {
-    kind,
-    executable: trimmed4(cast.executable) ?? DEFAULT_LATCH_EXECUTABLE
-  };
-}
-function launchSessionSnapshotFromMetadata(metadata) {
-  const raw = metadata?.[LAUNCH_SESSION_METADATA_KEY];
-  if (!raw || typeof raw !== "object" || Array.isArray(raw))
-    return null;
-  const cast = raw;
-  if (cast.version !== TERMINAL_PROFILE_VERSION)
-    return null;
-  const viewer = cast.viewer && typeof cast.viewer === "object" && !Array.isArray(cast.viewer) ? cast.viewer : null;
-  const launcher = trimmed4(viewer?.launcher);
-  const source = (value) => trimmed4(value) === "target" ? "target" : "user_default";
-  return {
-    version: TERMINAL_PROFILE_VERSION,
-    executionProvider: normalizeExecutionProvider(cast.executionProvider) ?? {
-      ...DEFAULT_EXECUTION_PROVIDER
-    },
-    viewer: {
-      kind: trimmed4(viewer?.kind) ? trimmed4(viewer?.kind) : viewerKindForLauncher(launcher),
-      launcher,
-      openOnLaunch: viewer?.openOnLaunch !== false
-    },
-    executionProviderSource: source(cast.executionProviderSource),
-    viewerOpenSource: source(cast.viewerOpenSource),
-    resolvedAt: trimmed4(cast.resolvedAt) ?? ""
-  };
-}
-var TERMINAL_PROFILE_VERSION, DEFAULT_LATCH_EXECUTABLE, DEFAULT_EXECUTION_PROVIDER, DEFAULT_OPEN_VIEWER_ON_LAUNCH, DEFAULT_LAUNCH_SESSION_DEFAULTS, LAUNCH_SESSION_METADATA_KEY;
-var init_terminal_profile_types2 = __esm({
-  "../packages/core/dist/service/terminal-profile-types.js"() {
-    "use strict";
-    TERMINAL_PROFILE_VERSION = 1;
-    DEFAULT_LATCH_EXECUTABLE = "latch";
-    DEFAULT_EXECUTION_PROVIDER = {
-      kind: "direct",
-      executable: DEFAULT_LATCH_EXECUTABLE
-    };
-    DEFAULT_OPEN_VIEWER_ON_LAUNCH = true;
-    DEFAULT_LAUNCH_SESSION_DEFAULTS = {
-      executionProvider: { ...DEFAULT_EXECUTION_PROVIDER },
-      openViewerOnLaunch: DEFAULT_OPEN_VIEWER_ON_LAUNCH
-    };
-    LAUNCH_SESSION_METADATA_KEY = "launchSession";
-  }
-});
-
 // ../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";
@@ -19186,7 +19250,9 @@ function createLatchSession({
 function openLatchViewer({
   executable = DEFAULT_LATCH_EXECUTABLE,
   providerSessionId,
-  viewerKind
+  viewerKind,
+  openAs,
+  productVersion
 }) {
   const viewer = latchViewerFlagForKind(viewerKind);
   const attachCommand = latchAttachCommand({ executable, providerSessionId });
@@ -19197,9 +19263,10 @@ function openLatchViewer({
       attachCommand
     };
   }
+  const sendsOpenAs = Boolean(openAs) && latchSupportsOpenAs(productVersion);
   const result = spawnLatchJson({
     executable,
-    args: ["open", providerSessionId, "--with", viewer, "--json"]
+    args: buildLatchOpenArgs({ providerSessionId, viewer, openAs, productVersion })
   });
   if (result.status !== 0) {
     const detail = (result.stderr || result.stdout || `exit ${result.status ?? "null"}`).trim();
@@ -19209,7 +19276,7 @@ function openLatchViewer({
       attachCommand
     };
   }
-  return { ok: true, viewer };
+  return { ok: true, viewer, openAs: sendsOpenAs ? parseViewerOpenAs(openAs) : null };
 }
 var init_latch_launch2 = __esm({
   "src/latch-launch.ts"() {
@@ -19917,6 +19984,7 @@ async function launchAgent({
   let providerFallbackWarning = null;
   let useLatch = false;
   let resolvedLatchExecutable = executable;
+  let latchProductVersion = null;
   const existingProviderSession = providerKind === "latch" ? existingLatchProviderSession({
     latchSessionId: process.env.LATCH_SESSION_ID,
     executionTargetId: options.executionTargetId
@@ -19960,6 +20028,7 @@ async function launchAgent({
       });
       if (useLatch && discovery.state === "found") {
         resolvedLatchExecutable = discovery.resolvedPath;
+        latchProductVersion = discovery.productVersion;
       }
       if (!useLatch) {
         providerFallbackWarning = discovery.state === "not_installed" ? `Latch is not installed on this execution target (${discovery.installCommand}); falling back to direct launch.` : discovery.state === "incompatible" ? `Latch is incompatible (${discovery.missingCapability}: ${discovery.detail}); falling back to direct launch.` : "Latch is unavailable; falling back to direct launch.";
@@ -19984,7 +20053,9 @@ async function launchAgent({
       viewerOpen = openLatchViewer({
         executable: resolvedLatchExecutable,
         providerSessionId: created.providerSession.providerSessionId,
-        viewerKind: snapshot?.viewer.kind ?? "iterm"
+        viewerKind: snapshot?.viewer.kind ?? "iterm",
+        openAs: snapshot?.viewer.openAs ?? null,
+        productVersion: latchProductVersion
       });
     }
     return {
@@ -21744,7 +21815,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 existsSync26,
+  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";
@@ -21752,6 +21831,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,
@@ -21790,41 +21901,10 @@ 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(),
@@ -21860,27 +21940,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();
@@ -21965,31 +22033,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,
@@ -22001,41 +22110,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());
       }
       async status() {
         const installed = existsSync26(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];
@@ -22212,7 +22313,8 @@ 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 os6 from "node:os";
@@ -23375,6 +23477,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,
@@ -23408,161 +23669,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) {
@@ -23586,8 +23693,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;
@@ -23596,25 +23713,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)));
     }
   }
 }
@@ -23632,10 +23746,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,