overlord-cli 0.2608141252.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, {
@@ -21804,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";
@@ -21812,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,
@@ -21850,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(),
@@ -21920,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();
@@ -22025,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,
@@ -22061,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];
@@ -22272,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";
@@ -23435,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,
@@ -23468,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) {
@@ -23646,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;
@@ -23656,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)));
     }
   }
 }
@@ -23692,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,