local-operator-ui 0.23.0 → 0.23.1

package/out/main/index.js

@@ -55,6 +55,11 @@ const profileName = zod.z.string().min(1).max(128).refine(
   )
 );
 const target = zod.z.object({ kind: zod.z.enum(["agent", "team"]), name: profileName }).strict();
+const modelSelection = zod.z.object({
+  provider: zod.z.string().min(1).max(128),
+  model_id: zod.z.string().min(1).max(512),
+  reasoning_effort: zod.z.string().min(1).max(64).nullable()
+}).strict();
 const profileFields = zod.z.object({
   kind: zod.z.enum(["role", "specialist"]).optional(),
   description: zod.z.string().max(8e3).optional(),
@@ -151,7 +156,14 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
     op: zod.z.literal("sessions.create"),
     requestId,
     cwd: zod.z.string().min(1).max(4096),
-    target: target.optional()
+    target: target.optional(),
+    /*
+     * OMITTED when the user never picked anything, so the body is the one
+     * this op sent before the draft's chips could open: making them
+     * actionable is strictly additive, and a `null` here would be a
+     * different request for every caller that never asked.
+     */
+    model: modelSelection.optional()
   }).strict(),
   /*
    * What a NEW conversation's readings would be, without creating anything.
@@ -168,7 +180,9 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
    * disagree with the session the first send creates.
    *
    * Body and response mirror `sessions.create` deliberately: same `cwd`, same
-   * optional `target`, same 422 for an unresolvable profile. The response is a
+   * optional `target`, same `model` and same 422 for an unresolvable profile —
+   * the pane is asking the question it will ask for real on the first send, so
+   * the two bodies are derived from one selection. The response is a
    * `CanonicalFrontendSync` — the wire shape `sessions.watch` streams — whose
    * `snapshot.session_id` is EMPTY, because there is no session. The renderer
    * passes it to the strip and never into the canonical sessions store.
@@ -177,7 +191,11 @@ const desktopRequestSchema = zod.z.discriminatedUnion("op", [
     op: zod.z.literal("sessions.preview"),
     requestId,
     cwd: zod.z.string().min(1).max(4096),
-    target: target.optional()
+    target: target.optional(),
+    /* Present only when the pane's chips were used: the preview then answers
+       the reading the CHOSEN model gives, which is the ladder and window the
+       first turn will actually get. */
+    model: modelSelection.optional()
   }).strict(),
   zod.z.object({ op: zod.z.literal("sessions.get"), sessionId }).strict(),
   zod.z.object({
@@ -681,7 +699,8 @@ function desktopEndpoint(request) {
         body: {
           request_id: request.requestId,
           cwd: request.cwd,
-          ...request.target ? { target: request.target } : {}
+          ...request.target ? { target: request.target } : {},
+          ...request.model ? { model: request.model } : {}
         }
       };
     case "sessions.preview":
@@ -691,7 +710,8 @@ function desktopEndpoint(request) {
         body: {
           request_id: request.requestId,
           cwd: request.cwd,
-          ...request.target ? { target: request.target } : {}
+          ...request.target ? { target: request.target } : {},
+          ...request.model ? { model: request.model } : {}
         }
       };
     case "sessions.get":
@@ -1828,6 +1848,268 @@ const backendConfig = loadConfig();
 const apiConfig = {
   baseUrl: backendConfig.VITE_LOCAL_OPERATOR_API_URL
 };
+const SHEBANG = /^#!([^\r\n]+)\r?\n/;
+const PYTHON_NAME = /[/\\]python(?:\d+(?:\.\d+)*)?$/;
+const SERVE_ENTRYPOINT = "from local_operator.cli import main; main()";
+const PROBE_SCRIPT = "import json, sys; from local_operator.cli import main; print(json.dumps([sys.executable, getattr(sys, '_base_executable', None) or sys.executable, callable(main), [p for p in sys.path if p and p.startswith(sys.prefix)]]))";
+const DEFAULT_BUDGET = {
+  totalMs: 45e3,
+  attemptMs: 3e4,
+  graceMs: 2e3,
+  slackMs: 2e3
+};
+const DISCOVERY_TIMEOUT_MS = 5e3;
+const INTERPRETER_RESOLUTION_WORST_MS = DEFAULT_BUDGET.totalMs + 2 * (DISCOVERY_TIMEOUT_MS + DEFAULT_BUDGET.graceMs + DEFAULT_BUDGET.slackMs);
+class ProbeTimeout extends Error {
+  constructor(interpreter, timeoutMs) {
+    super(
+      `${interpreter} did not answer an identity probe within ${timeoutMs} ms`
+    );
+    this.name = "ProbeTimeout";
+  }
+}
+const describe = (error) => error instanceof Error ? error.message : String(error);
+function runBounded(command, args, env, bounds) {
+  return new Promise((resolve, reject) => {
+    const child = node_child_process.spawn(command, args, {
+      env,
+      // Piped, so the answer is read rather than inherited by the app.
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    let settled = false;
+    let timedOut = false;
+    const timers = [];
+    const settle2 = (finish) => {
+      if (settled) return;
+      settled = true;
+      for (const timer of timers) clearTimeout(timer);
+      timers.length = 0;
+      finish();
+    };
+    timers.push(
+      setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+        timers.push(setTimeout(() => child.kill("SIGKILL"), bounds.graceMs));
+        timers.push(
+          setTimeout(
+            () => settle2(() => reject(new ProbeTimeout(command, bounds.timeoutMs))),
+            bounds.graceMs + bounds.slackMs
+          )
+        );
+      }, bounds.timeoutMs)
+    );
+    child.on("error", (error) => settle2(() => reject(error)));
+    child.on(
+      "close",
+      (code, signal) => settle2(() => {
+        if (timedOut) {
+          reject(new ProbeTimeout(command, bounds.timeoutMs));
+          return;
+        }
+        if (code === 0) {
+          resolve(stdout);
+          return;
+        }
+        const detail = errorTail(stderr);
+        reject(
+          new Error(
+            `exited with code ${code ?? "null"}${signal ? ` (${signal})` : ""}${detail ? `: ${detail}` : ""}`
+          )
+        );
+      })
+    );
+  });
+}
+const errorTail = (text, lines = 3) => {
+  const kept = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (kept.length === 0) return "";
+  const tail = kept.slice(-lines).join(" | ");
+  return kept.length > lines ? `… ${tail}` : tail;
+};
+function parseIdentity(stdout, interpreter) {
+  const parsed = JSON.parse(stdout.trim());
+  const [executable, baseExecutable, callable, prefixPaths] = parsed;
+  if (typeof executable !== "string" || typeof callable !== "boolean")
+    throw new Error(`${interpreter} reported no usable identity`);
+  return {
+    executable,
+    baseExecutable: baseExecutable || executable,
+    callable,
+    prefixPaths: Array.isArray(prefixPaths) ? prefixPaths : []
+  };
+}
+async function probeOnce(interpreter, env, timeoutMs, bounds) {
+  return parseIdentity(
+    await runBounded(interpreter, ["-c", PROBE_SCRIPT], env, {
+      ...bounds,
+      timeoutMs
+    }),
+    interpreter
+  );
+}
+async function probeWithin(interpreter, env, deadline2, bounds) {
+  let lastTimeout = null;
+  for (let attempt = 1; ; attempt++) {
+    const remaining = deadline2 - Date.now() - bounds.graceMs - bounds.slackMs;
+    if (remaining <= 0) {
+      if (lastTimeout) throw lastTimeout;
+      throw new Error(
+        `the ${bounds.totalMs} ms interpreter-probe budget ran out before ${interpreter} answered`
+      );
+    }
+    try {
+      return await probeOnce(
+        interpreter,
+        env,
+        Math.min(bounds.attemptMs, remaining),
+        bounds
+      );
+    } catch (error) {
+      if (error instanceof ProbeTimeout) {
+        lastTimeout = error;
+        if (attempt < PROBE_ATTEMPTS && Date.now() < deadline2) continue;
+      }
+      throw error;
+    }
+  }
+}
+const PROBE_ATTEMPTS = 2;
+async function planFor(identity, interpreter, port, env, platform, deadline2, bounds) {
+  if (!identity.callable || !path$1.isAbsolute(identity.executable))
+    throw new Error(
+      `the CLI entrypoint does not import in ${identity.executable || interpreter}`
+    );
+  const args = ["-c", SERVE_ENTRYPOINT, "serve", "--port", String(port)];
+  if (platform !== "win32")
+    return {
+      command: "bash",
+      args: ["-c", 'exec "$@"', "owned-serve", identity.executable, ...args],
+      env
+    };
+  if (identity.executable.toLowerCase() === identity.baseExecutable.toLowerCase())
+    return { command: identity.executable, args, env };
+  if (!path$1.isAbsolute(identity.baseExecutable))
+    throw new Error(
+      `it is a venv redirector whose base interpreter is not an absolute path (${identity.baseExecutable || "nothing"})`
+    );
+  const baseEnv = {
+    ...env,
+    // Windows' own separator, deliberately independent of the host evaluating
+    // the plan: the plan describes the Windows launch, not the machine that
+    // built it, and the test host is not Windows.
+    PYTHONPATH: [...identity.prefixPaths, env.PYTHONPATH].filter(Boolean).join(";")
+  };
+  const base = await probeWithin(
+    identity.baseExecutable,
+    baseEnv,
+    deadline2,
+    bounds
+  );
+  if (!base.callable || base.executable.toLowerCase() !== identity.baseExecutable.toLowerCase())
+    throw new Error(
+      `its base interpreter ${identity.baseExecutable} is not the serving process (${base.callable ? `it reported itself as ${base.executable || "nothing"}` : "it cannot import local_operator.cli even with the venv's own import paths"})`
+    );
+  return { command: identity.baseExecutable, args, env: baseEnv };
+}
+async function ownedServeLaunch(interpreters, port, env, platform = process.platform, budget = {}, fallbackClaims) {
+  const bounds = {
+    ...DEFAULT_BUDGET,
+    ...budget
+  };
+  const deadline2 = Date.now() + bounds.totalMs;
+  const rejected = [];
+  const attempt = async (claims) => {
+    for (const interpreter of [...new Set(claims)]) {
+      if (!path$1.isAbsolute(interpreter)) {
+        rejected.push(`${interpreter || "(empty)"}: not an absolute path`);
+        continue;
+      }
+      try {
+        const identity = await probeWithin(interpreter, env, deadline2, bounds);
+        return await planFor(
+          identity,
+          interpreter,
+          port,
+          env,
+          platform,
+          deadline2,
+          bounds
+        );
+      } catch (error) {
+        rejected.push(`${interpreter}: ${describe(error)}`);
+      }
+    }
+    return null;
+  };
+  if (interpreters.length === 0 && !fallbackClaims)
+    throw new Error(
+      "No backend interpreter was resolved. Install the Local Operator backend (`uv tool install local-operator`) or pair an external backend."
+    );
+  const planned = await attempt(interpreters) ?? (fallbackClaims ? await attempt(await fallbackClaims()) : null);
+  if (planned) return planned;
+  throw new Error(
+    `No backend interpreter could be proven. Tried ${rejected.length}: ${rejected.join("; ")}. Install the backend with a supported installer (\`uv tool install local-operator\`) or pair an external backend.`
+  );
+}
+async function firstLine(command, args, env) {
+  try {
+    const stdout = await runBounded(command, args, env, {
+      ...DEFAULT_BUDGET,
+      timeoutMs: DISCOVERY_TIMEOUT_MS
+    });
+    const line = stdout.trim().split(/\r?\n/)[0]?.trim();
+    return line ? line : null;
+  } catch {
+    return null;
+  }
+}
+async function windowsInterpreterCandidates(consolePath, env) {
+  const directory = path$1.dirname(consolePath);
+  const tool = path$1.basename(consolePath).replace(/\.(exe|cmd|bat)$/i, "");
+  const candidates = [path$1.join(directory, "python.exe")];
+  const uvTools = env.UV_TOOL_DIR ?? (env.APPDATA ? path$1.join(env.APPDATA, "uv", "tools") : null);
+  if (uvTools) candidates.push(path$1.join(uvTools, tool, "Scripts", "python.exe"));
+  const pipxHome = env.PIPX_HOME ?? (env.LOCALAPPDATA ? path$1.join(env.LOCALAPPDATA, "pipx") : null) ?? (env.USERPROFILE ? path$1.join(env.USERPROFILE, "pipx") : null);
+  if (pipxHome)
+    candidates.push(path$1.join(pipxHome, "venvs", tool, "Scripts", "python.exe"));
+  return [...new Set(candidates)].filter(
+    (candidate) => path$1.isAbsolute(candidate) && fs.existsSync(candidate)
+  );
+}
+async function windowsPathInterpreterCandidates(env) {
+  const found = [];
+  const onPath = await firstLine("where", ["python.exe"], env);
+  if (onPath) found.push(onPath);
+  const viaLauncher = await firstLine(
+    "py",
+    ["-3", "-c", "import sys; print(sys.executable)"],
+    env
+  );
+  if (viaLauncher) found.push(viaLauncher);
+  return [...new Set(found)].filter(
+    (candidate) => path$1.isAbsolute(candidate) && fs.existsSync(candidate)
+  );
+}
+function consoleInterpreter(consolePath) {
+  const script = fs.readFileSync(consolePath, "utf8");
+  const shebang = SHEBANG.exec(script)?.[1];
+  if (!shebang || !path$1.isAbsolute(shebang) || !PYTHON_NAME.test(shebang) || !script.includes("from local_operator.cli import main")) {
+    throw new Error(
+      "Cannot safely own this backend launcher; use a directly paired external backend"
+    );
+  }
+  return shebang;
+}
 var LocalOperatorStartupMode = /* @__PURE__ */ ((LocalOperatorStartupMode2) => {
   LocalOperatorStartupMode2["EXISTING_SERVER"] = "EXISTING_SERVER";
   LocalOperatorStartupMode2["GLOBAL_INSTALL"] = "GLOBAL_INSTALL";
@@ -1835,8 +2117,21 @@ var LocalOperatorStartupMode = /* @__PURE__ */ ((LocalOperatorStartupMode2) => {
   LocalOperatorStartupMode2["NOT_STARTED"] = "NOT_STARTED";
   return LocalOperatorStartupMode2;
 })(LocalOperatorStartupMode || {});
+const CONSOLE_DISCOVERY_TIMEOUT_MS = 5e3;
+const CONSOLE_RESOLUTION_WORST_MS = 2 * CONSOLE_DISCOVERY_TIMEOUT_MS;
+const SHUTDOWN_TIMEOUT_DEFAULTS = {
+  restart: 1e4,
+  // 10 seconds for restart operations
+  normal: 5e3,
+  // 5 seconds for normal shutdowns
+  force: 3e3
+  // 3 seconds before force killing after SIGKILL
+};
+const OWNED_STOP_WORST_MS = SHUTDOWN_TIMEOUT_DEFAULTS.normal + SHUTDOWN_TIMEOUT_DEFAULTS.force;
+const READINESS_POLL_INTERVAL_MS = 1e3;
 const execPromise = node_util.promisify(node_child_process.exec);
 const ENV_VAR_REGEX = /^([^=]+)=(.*)$/;
+const LINE_BREAK = /\r?\n/;
 class BackendServiceManager {
   process = null;
   isRunning = false;
@@ -1848,8 +2143,18 @@ class BackendServiceManager {
   appDataPath = electron.app.getPath("userData");
   venvPath;
   healthCheckInterval = null;
-  exitPromise = null;
-  exitResolve = null;
+  /** The only process this manager may terminate. Null means it owns nothing,
+   * which is a reason to report "nothing to stop" - never to go looking. */
+  ownedServe = null;
+  /** In-flight start, so a stop can await the resolver/readiness work that has
+   * not yet produced a child. Without it, cleanup can return before a spawn
+   * that was already committed, and the caller installs over a live serve. */
+  startPromise = null;
+  restartPromise = null;
+  /** Bumped by every stop. A start that began under an older epoch cannot
+   * report success or adopt its child: the cancellation happened after it
+   * checked, and this is what it re-checks across each await. */
+  startEpoch = 0;
   shellEnv = {};
   // External/dev backends may be explicitly paired through main's environment.
   // Managed starts always rotate this; it is never exposed by preload or logs.
@@ -1952,14 +2257,7 @@ class BackendServiceManager {
   // Flag to track when the app is being closed
   isAutoUpdating = false;
   // Flag to track when an autoupdate is in progress
-  shutdownTimeoutMs = {
-    restart: 1e4,
-    // 10 seconds for restart operations
-    normal: 5e3,
-    // 5 seconds for normal shutdowns
-    force: 3e3
-    // 3 seconds before force killing after SIGKILL
-  };
+  shutdownTimeoutMs = { ...SHUTDOWN_TIMEOUT_DEFAULTS };
   // Configurable timeouts for different shutdown scenarios
   /**
    * Constructor
@@ -2246,7 +2544,12 @@ class BackendServiceManager {
         `Checking if local-operator command exists: ${command}`,
         LogFileType.BACKEND
       );
-      const { stdout } = await execPromise(command);
+      const { stdout } = await execPromise(command, {
+        // Bounded: a quit that arrives mid-start waits on this same path, and an
+        // unbounded child here is a wait with nothing underneath it.
+        timeout: CONSOLE_DISCOVERY_TIMEOUT_MS,
+        windowsHide: true
+      });
       if (stdout.trim()) {
         logger.info(
           `local-operator command found at: ${stdout.trim()}`,
@@ -2374,12 +2677,30 @@ class BackendServiceManager {
     }
     return false;
   }
+  /** Keep PATH discovery authoritative; `ownedServeLaunch` proves the identity
+   * of what it found rather than trusting the name it was resolved under. */
+  async resolveGlobalConsole(env) {
+    const { stdout } = await execPromise(
+      process.platform === "win32" ? "where local-operator" : "which local-operator",
+      { env, timeout: CONSOLE_DISCOVERY_TIMEOUT_MS }
+    );
+    return stdout.trim().split(LINE_BREAK)[0];
+  }
   /**
    * Start the backend service
    * @returns Promise resolving to true if the backend was started successfully, false otherwise
    */
-  async start() {
-    this.isAppClosing = false;
+  start() {
+    if (this.isAppClosing) return Promise.resolve(false);
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = this.startOwned(this.startEpoch).finally(() => {
+      this.startPromise = null;
+    });
+    return this.startPromise;
+  }
+  async startOwned(epoch) {
+    if (this.ownedServe?.stop) return false;
+    if (this.ownedServe) return this.isRunning;
     if (this.isDisabled) {
       logger.info(
         "Backend Service Manager is disabled. Skipping backend start.",
@@ -2388,155 +2709,114 @@ class BackendServiceManager {
       this.notifyBackendReady();
       return true;
     }
-    if (await this.checkExistingBackend()) {
+    const existing = await this.checkExistingBackend();
+    if (epoch !== this.startEpoch || this.isAppClosing) return false;
+    if (existing) {
       this.isRunning = true;
       this.startupMode = "EXISTING_SERVER";
       this.startHealthCheck();
       return true;
     }
     this.desktopToken = node_crypto.randomBytes(32).toString("hex");
+    let captured = null;
     try {
-      if (await this.checkLocalOperatorExists()) {
-        logger.info(
-          "Using globally installed local-operator command",
-          LogFileType.BACKEND
-        );
+      const globalInstall = await this.checkLocalOperatorExists();
+      const env = this.backendSpawnEnv();
+      let interpreters;
+      if (globalInstall) {
         this.startupMode = "GLOBAL_INSTALL";
-        const cmd = process.platform === "win32" ? "cmd.exe" : "bash";
-        const args = process.platform === "win32" ? ["/c", `local-operator serve --port ${this.port}`] : ["-c", `local-operator serve --port ${this.port}`];
-        logger.info(
-          `Starting backend service with global command: ${cmd} ${args.join(" ")}`,
-          LogFileType.BACKEND
-        );
-        this.process = node_child_process.spawn(cmd, args, {
-          detached: false,
-          // Ensure process is not detached from parent
-          stdio: "pipe",
-          env: this.backendSpawnEnv(),
-          // On Windows, we need to create a new process group to ensure proper termination
-          ...process.platform === "win32" ? { windowsHide: true } : {}
-        });
+        const executable = await this.resolveGlobalConsole(env);
+        interpreters = process.platform === "win32" ? await windowsInterpreterCandidates(executable, env) : [consoleInterpreter(executable)];
       } else {
-        logger.info(
-          "Global local-operator not found, using virtual environment",
-          LogFileType.BACKEND
-        );
         this.startupMode = "APP_BUNDLED_VENV";
-        let cmd;
-        let args;
-        if (process.platform === "win32") {
-          const localOperatorExe = path$1.join(
-            this.venvPath,
-            "Scripts",
-            "local-operator.exe"
-          );
-          if (fs.existsSync(localOperatorExe)) {
-            cmd = localOperatorExe;
-            args = ["serve", "--port", this.port.toString()];
-          } else {
-            const pythonExe = path$1.join(this.venvPath, "Scripts", "python.exe");
-            if (fs.existsSync(pythonExe)) {
-              cmd = pythonExe;
-              args = [
-                "-m",
-                "local_operator",
-                "serve",
-                "--port",
-                this.port.toString()
-              ];
-            } else {
-              const activateScript = path$1.join(
-                this.venvPath,
-                "Scripts",
-                "Activate.ps1"
-              );
-              cmd = "powershell.exe";
-              args = [
-                "-ExecutionPolicy",
-                "Bypass",
-                "-Command",
-                `"& '${activateScript}'; local-operator serve --port ${this.port}"`
-              ];
-            }
-          }
-        } else {
-          const activateScript = path$1.join(this.venvPath, "bin", "activate");
-          cmd = "bash";
-          args = [
-            "-c",
-            `. "${activateScript}" && local-operator serve --port ${this.port}`
-          ];
-        }
-        logger.info(
-          `Starting backend service with venv: ${cmd} ${args.join(" ")}`,
-          LogFileType.BACKEND
+        const bin = path$1.join(
+          this.venvPath,
+          process.platform === "win32" ? "Scripts" : "bin"
         );
-        this.process = node_child_process.spawn(cmd, args, {
-          detached: false,
-          // Ensure process is not detached from parent
-          stdio: "pipe",
-          env: this.backendSpawnEnv(),
-          // On Windows, we need to create a new process group to ensure proper termination
-          ...process.platform === "win32" ? { windowsHide: true } : {}
-        });
-      }
-      if (this.process.stdout) {
-        this.process.stdout.on("data", (data) => {
+        interpreters = [
+          path$1.join(bin, process.platform === "win32" ? "python.exe" : "python")
+        ];
+        env.VIRTUAL_ENV = this.venvPath;
+        env.PATH = `${bin}${process.platform === "win32" ? ";" : ":"}${env.PATH ?? ""}`;
+        env.PYTHONHOME = void 0;
+      }
+      const launch = await ownedServeLaunch(
+        interpreters,
+        this.port,
+        env,
+        process.platform,
+        {},
+        // The PATH-side claims spawn discovery children, so they are offered
+        // only after the claims above have all failed (round 3, F14).
+        process.platform === "win32" ? () => windowsPathInterpreterCandidates(env) : void 0
+      );
+      if (epoch !== this.startEpoch || this.isAppClosing) return false;
+      const child = node_child_process.spawn(launch.command, launch.args, {
+        detached: false,
+        stdio: "pipe",
+        // The plan owns the environment it proved: a Windows venv's base
+        // interpreter needs the venv's import paths, added there and not here.
+        env: launch.env,
+        windowsHide: true
+      });
+      const generation = this.captureServe(child);
+      captured = generation;
+      if (child.stdout) {
+        child.stdout.on("data", (data) => {
           logger.info(`Backend stdout: ${data}`, LogFileType.BACKEND);
         });
       }
-      if (this.process.stderr) {
-        this.process.stderr.on("data", (data) => {
+      if (child.stderr) {
+        child.stderr.on("data", (data) => {
           logger.error(`Backend stderr: ${data}`, LogFileType.BACKEND);
         });
       }
-      this.process.on("exit", (code) => {
-        logger.info(
-          `Backend process exited with code ${code}`,
-          LogFileType.BACKEND
-        );
-        this.isRunning = false;
-        this.process = null;
-        if (this.exitResolve) {
-          this.exitResolve();
-          this.exitResolve = null;
-        }
-        const isExpectedWindowsExit = process.platform === "win32" && (this.isAppClosing || this.isAutoUpdating) && code === 1;
-        if (code !== 0 && code !== null && !isExpectedWindowsExit) {
-          electron.dialog.showErrorBox(
-            "Backend Error",
-            `The Local Operator backend service exited unexpectedly with code ${code}. Please restart the application.`
-          );
-        }
-      });
       let attempts = 0;
       const maxAttempts = 30;
       while (attempts < maxAttempts) {
-        if (await this.checkHealth()) {
+        const healthy = await this.checkHealth();
+        if (epoch !== this.startEpoch || generation.exited || generation.stop)
+          break;
+        if (healthy) {
           this.isRunning = true;
           this.startHealthCheck();
           this.notifyBackendReady();
           return true;
         }
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        await new Promise(
+          (resolve) => setTimeout(resolve, READINESS_POLL_INTERVAL_MS)
+        );
         attempts++;
       }
+      await this.stopGeneration(generation, false);
+      if (epoch !== this.startEpoch) return false;
       logger.error(
         "Failed to start backend service after multiple attempts",
         LogFileType.BACKEND
       );
-      electron.dialog.showErrorBox(
+      this.reportStartFailure(
         "Backend Error",
         "Failed to start the Local Operator backend service. Please check the logs for more information."
       );
       return false;
     } catch (error) {
+      if (captured) {
+        try {
+          await this.stopGeneration(captured, false);
+        } catch (cleanupError) {
+          logger.error(
+            "Owned backend cleanup after a failed start did not confirm exit",
+            LogFileType.BACKEND,
+            cleanupError
+          );
+        }
+      }
       logger.error(
         "Error starting backend service:",
         LogFileType.BACKEND,
         error
       );
-      electron.dialog.showErrorBox(
+      this.reportStartFailure(
         "Backend Error",
         `Error starting the Local Operator backend service: ${error}`
       );
@@ -2544,232 +2824,156 @@ class BackendServiceManager {
     }
   }
   /**
-   * Stop the backend service
-   * @param isRestart - Whether this stop is part of a restart operation
-   * @returns Promise resolving when the backend has been stopped
+   * Stop only the captured serve generation, including failed startups. A port
+   * or process name is not ownership. Unconfirmed exit blocks replacement.
    */
   async stop(isRestart = false) {
-    if (!isRestart) {
-      this.isAppClosing = true;
-    }
+    this.startEpoch++;
+    if (!isRestart) this.isAppClosing = true;
     this.disposeStreamRelay();
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval);
-      this.healthCheckInterval = null;
-    }
-    if (this.isDisabled || this.isExternalBackend) {
-      logger.info(
-        "Skipping backend stop (disabled or external backend)",
-        LogFileType.BACKEND
-      );
-      return;
-    }
-    if (this.process && this.isRunning) {
-      logger.info(
-        `Stopping backend service... (isRestart: ${isRestart})`,
-        LogFileType.BACKEND
-      );
-      this.exitPromise = new Promise((resolve) => {
-        this.exitResolve = resolve;
-        if (!this.process) {
-          if (this.exitResolve) {
-            this.exitResolve();
-            this.exitResolve = null;
-          }
+    this.stopHealthCheck();
+    const generation = this.ownedServe;
+    if (generation) await this.stopGeneration(generation, isRestart);
+    await this.startPromise;
+  }
+  captureServe(child) {
+    let resolveExit = () => {
+    };
+    const generation = {
+      child,
+      exited: false,
+      exit: new Promise((resolve) => {
+        resolveExit = resolve;
+      }),
+      resolveExit: () => resolveExit(),
+      stop: null,
+      timers: /* @__PURE__ */ new Set()
+    };
+    this.ownedServe = generation;
+    this.process = child;
+    const exited = (code) => {
+      if (generation.exited) return;
+      generation.exited = true;
+      for (const timer of generation.timers) clearTimeout(timer);
+      generation.timers.clear();
+      generation.resolveExit();
+      if (this.ownedServe !== generation) return;
+      this.ownedServe = null;
+      this.process = null;
+      this.isRunning = false;
+      if (code != null && code !== 0 && !generation.stop && !this.isAppClosing && !this.isAutoUpdating) {
+        electron.dialog.showErrorBox(
+          "Backend Error",
+          `The Local Operator backend service exited unexpectedly with code ${code}. Please restart the application.`
+        );
+      }
+    };
+    child.once("exit", exited);
+    child.on("error", (error) => {
+      logger.error("Owned backend process error", LogFileType.BACKEND, error);
+      if (child.pid === void 0) exited();
+    });
+    return generation;
+  }
+  /** Signals may only be sent while the handle itself still reports a live
+   * process. Node keeps `kill()` callable on a reaped child, and on a PID the
+   * OS has since recycled that call reaches whatever now holds the number. */
+  canSignal(generation) {
+    return !generation.exited && generation.child.exitCode === null && generation.child.signalCode === null;
+  }
+  /**
+   * The one termination sequence: SIGTERM, wait out the grace, SIGKILL, wait
+   * again, and throw if the process never reported exit.
+   *
+   * Failing rather than returning is the point. Callers use a resolved stop as
+   * permission to replace the backend - install over it, spawn a successor - so
+   * "we signalled it and moved on" would authorise exactly the double-serve
+   * this class exists to prevent. An unconfirmed exit keeps ownership, and the
+   * caller reports failure instead of proceeding.
+   */
+  stopGeneration(generation, isRestart) {
+    if (generation.stop) return generation.stop;
+    generation.stop = (async () => {
+      const waitForExit = (ms) => new Promise((resolve) => {
+        if (generation.exited) {
+          resolve(true);
           return;
         }
-        this.process.once("exit", () => {
-          logger.info("Backend process exited", LogFileType.BACKEND);
-          this.process = null;
-          this.isRunning = false;
-          if (this.exitResolve) {
-            this.exitResolve();
-            this.exitResolve = null;
-          }
+        const timer = setTimeout(() => {
+          generation.timers.delete(timer);
+          resolve(false);
+        }, ms);
+        generation.timers.add(timer);
+        void generation.exit.then(() => {
+          clearTimeout(timer);
+          generation.timers.delete(timer);
+          resolve(true);
         });
       });
-      try {
-        const pid = this.process.pid;
-        if (process.platform === "win32") {
-          if (pid) {
-            logger.info(
-              `Terminating Windows process with PID ${pid}`,
-              LogFileType.BACKEND
-            );
-            node_child_process.spawn("taskkill", ["/pid", pid.toString(), "/t"]);
-          }
-        } else {
-          logger.info(
-            "Sending SIGTERM to backend process",
-            LogFileType.BACKEND
-          );
-          this.process.kill("SIGTERM");
-        }
-        let forceKillTimeoutId = null;
-        const timeoutPromise = new Promise((resolve) => {
-          const timeoutMs = isRestart ? this.shutdownTimeoutMs.restart : this.shutdownTimeoutMs.normal;
-          logger.info(
-            `Setting shutdown timeout to ${timeoutMs}ms for ${isRestart ? "restart" : "normal"} operation`,
-            LogFileType.BACKEND
+      if (this.canSignal(generation)) generation.child.kill("SIGTERM");
+      const grace = isRestart ? this.shutdownTimeoutMs.restart : this.shutdownTimeoutMs.normal;
+      if (!await waitForExit(grace)) {
+        if (this.canSignal(generation)) generation.child.kill("SIGKILL");
+        if (!await waitForExit(this.shutdownTimeoutMs.force)) {
+          throw new Error(
+            "Owned backend exit is unconfirmed; refusing replacement"
           );
-          forceKillTimeoutId = setTimeout(() => {
-            if (this.process) {
-              logger.info(
-                `Backend process did not exit within ${timeoutMs}ms, force killing`,
-                LogFileType.BACKEND
-              );
-              try {
-                if (process.platform === "win32" && this.process.pid) {
-                  node_child_process.spawn("taskkill", [
-                    "/pid",
-                    this.process.pid.toString(),
-                    "/f",
-                    "/t"
-                  ]);
-                  try {
-                    execPromise(
-                      'taskkill /f /im python.exe /fi "WINDOWTITLE eq *local-operator*" /t'
-                    ).catch((error) => {
-                      logger.warn(
-                        "Error terminating python processes:",
-                        LogFileType.BACKEND,
-                        error
-                      );
-                    });
-                    execPromise("taskkill /f /im local-operator.exe /t").catch(
-                      (error) => {
-                        logger.warn(
-                          "Error terminating local-operator processes:",
-                          LogFileType.BACKEND,
-                          error
-                        );
-                      }
-                    );
-                  } catch (taskkillError) {
-                    logger.warn(
-                      "Error executing taskkill command:",
-                      LogFileType.BACKEND,
-                      taskkillError
-                    );
-                  }
-                } else if (this.process) {
-                  this.process.kill("SIGKILL");
-                  if (!isRestart) {
-                    try {
-                      execPromise('pkill -f "local-operator serve"').catch(
-                        (error) => {
-                          logger.warn(
-                            "Error killing processes by pattern:",
-                            LogFileType.BACKEND,
-                            error
-                          );
-                        }
-                      );
-                    } catch (pkillError) {
-                      logger.warn(
-                        "Error executing pkill command:",
-                        LogFileType.BACKEND,
-                        pkillError
-                      );
-                    }
-                  }
-                  setTimeout(() => {
-                    if (this.process) {
-                      logger.warn(
-                        `Process still exists after SIGKILL, attempting more aggressive termination after ${this.shutdownTimeoutMs.force}ms`,
-                        LogFileType.BACKEND
-                      );
-                      try {
-                        if (!isRestart) {
-                          execPromise(
-                            'pkill -9 -f "local-operator serve"'
-                          ).catch(() => {
-                          });
-                        }
-                        this.process = null;
-                        this.isRunning = false;
-                        if (this.exitResolve) {
-                          this.exitResolve();
-                          this.exitResolve = null;
-                        }
-                      } catch (finalError) {
-                        logger.error(
-                          "Error during final force kill attempt:",
-                          LogFileType.BACKEND,
-                          finalError
-                        );
-                      }
-                    }
-                  }, this.shutdownTimeoutMs.force);
-                }
-              } catch (error) {
-                logger.error(
-                  "Error force killing process:",
-                  LogFileType.BACKEND,
-                  error
-                );
-              }
-              this.process = null;
-              this.isRunning = false;
-              if (this.exitResolve) {
-                this.exitResolve();
-                this.exitResolve = null;
-              }
-            }
-            resolve();
-          }, timeoutMs);
-        });
-        await Promise.race([this.exitPromise, timeoutPromise]);
-        if (forceKillTimeoutId) {
-          clearTimeout(forceKillTimeoutId);
-          forceKillTimeoutId = null;
-        }
-        if (!isRestart) {
-          logger.info(
-            "Performing additional cleanup for final shutdown",
-            LogFileType.BACKEND
-          );
-          try {
-            if (process.platform === "win32") {
-              await execPromise(
-                'taskkill /f /im python.exe /fi "WINDOWTITLE eq *local-operator*" /t'
-              ).catch(() => {
-              });
-              await execPromise("taskkill /f /im local-operator.exe /t").catch(
-                () => {
-                }
-              );
-            } else {
-              await execPromise('pkill -f "local-operator serve"').catch(() => {
-              });
-              await new Promise((resolve) => setTimeout(resolve, 1e3));
-              await execPromise('pkill -9 -f "local-operator serve"').catch(
-                () => {
-                }
-              );
-            }
-          } catch (cleanupError) {
-            logger.warn(
-              "Error during additional cleanup (this may be normal if processes were already terminated):",
-              LogFileType.BACKEND,
-              cleanupError
-            );
-          }
-        }
-      } catch (error) {
-        logger.error(
-          "Error stopping backend process:",
-          LogFileType.BACKEND,
-          error
-        );
-        this.process = null;
-        this.isRunning = false;
-        if (this.exitResolve) {
-          this.exitResolve();
-          this.exitResolve = null;
         }
       }
-      logger.info("Backend service stopped", LogFileType.BACKEND);
+      if (!isRestart && !this.ownedServe)
+        this.startupMode = "NOT_STARTED";
+      logger.info("Owned backend generation stopped", LogFileType.BACKEND);
+    })();
+    return generation.stop;
+  }
+  stopHealthCheck() {
+    if (this.healthCheckInterval) clearInterval(this.healthCheckInterval);
+    this.healthCheckInterval = null;
+  }
+  /** Whether a quit may proceed. `will-quit` cannot await a listener, so it
+   * prevents the first quit, runs cleanup, and asks this on the retry. */
+  /** Whether a shutdown is in flight.
+   *
+   * `stop(false)` is terminal and is what the quit path calls, so this is the
+   * state a caller checks before raising blocking UI it would never be able to
+   * dismiss - `index.ts`'s start-failure paths are the callers. */
+  isShuttingDown() {
+    return this.isAppClosing;
+  }
+  /**
+   * Report a start failure to the user - unless the app is on its way out.
+   *
+   * `showErrorBox` is a native modal: it parks the main thread until somebody
+   * dismisses it, and Electron cannot run the quit it was asked for past a
+   * parked thread. On the quit path that is not a message, it is a deadlock -
+   * the quit has already prevented itself, the owned cleanup it waits on can
+   * never finish, and the quit's own failsafe cannot even fire, because that is
+   * a timer on the thread the dialog holds (review round 4, Q-20: a SIGTERM
+   * during the first start left the app alive 50 s later with the failsafe line
+   * never logged). A shutdown in flight logs the failure instead, where the
+   * post-mortem finds it without the process still being up.
+   */
+  reportStartFailure(title, message) {
+    if (this.isAppClosing) {
+      logger.error(
+        `${title} (not shown; the app is shutting down): ${message}`,
+        LogFileType.BACKEND
+      );
+      return;
+    }
+    electron.dialog.showErrorBox(title, message);
+  }
+  isOwnedCleanupComplete() {
+    return this.isAppClosing && !this.ownedServe && !this.startPromise;
+  }
+  /** Synchronous exit cannot await cleanup. Canonical runtimes deliberately
+   * outlive their HTTP server, so neither PID rediscovery nor descent is safe. */
+  emergencyStopOwned() {
+    this.startEpoch++;
+    this.isAppClosing = true;
+    const generation = this.ownedServe;
+    if (generation && !generation.exited && generation.child.exitCode === null && generation.child.signalCode === null) {
+      generation.child.kill("SIGKILL");
     }
   }
   /**
@@ -2814,7 +3018,10 @@ class BackendServiceManager {
    * assertable without waiting out a 30s interval.
    */
   async checkUnhealthyBackend() {
+    const epoch = this.startEpoch;
     const isHealthy = await this.checkHealth();
+    if (epoch !== this.startEpoch || this.isAppClosing || this.isAutoUpdating || this.isDisabled)
+      return;
     if (isHealthy) return;
     logger.info("Backend health check failed", LogFileType.BACKEND);
     if (this.isExternalBackend) {
@@ -2832,8 +3039,7 @@ class BackendServiceManager {
       await this.start();
       return;
     }
-    await this.stop(true);
-    await this.start();
+    await this.restart();
   }
   /**
    * Get the port number used by the backend service
@@ -2883,52 +3089,21 @@ class BackendServiceManager {
    * timeouts from the stop operation don't affect the newly started process
    * @returns Promise resolving to true if the restart was successful, false otherwise
    */
-  async restart() {
-    logger.info("Restarting backend service...", LogFileType.BACKEND);
-    this.isAppClosing = false;
-    await this.stop(true);
-    await new Promise((resolve) => setTimeout(resolve, 2e3));
-    if (this.process) {
-      logger.warn(
-        "Process still exists after stop, attempting to force terminate",
-        LogFileType.BACKEND
-      );
+  restart() {
+    if (this.restartPromise) return this.restartPromise;
+    this.restartPromise = (async () => {
       try {
-        if (process.platform === "win32" && this.process.pid) {
-          await node_util.promisify(node_child_process.exec)(`taskkill /pid ${this.process.pid} /f /t`);
-        } else if (this.process) {
-          this.process.kill("SIGKILL");
-        }
-        await new Promise((resolve) => {
-          if (!this.process) {
-            resolve(null);
-            return;
-          }
-          this.process.once("exit", () => {
-            resolve(null);
-          });
-          setTimeout(resolve, 1e3);
-        });
-        this.process = null;
-        this.isRunning = false;
+        await this.stop(true);
+        if (this.isAppClosing) return false;
+        return await this.start();
       } catch (error) {
-        logger.error(
-          "Error force killing process during restart:",
-          LogFileType.BACKEND,
-          error
-        );
+        logger.error("Backend restart refused", LogFileType.BACKEND, error);
+        return false;
       }
-    }
-    const success = await this.start();
-    if (success) {
-      logger.info(
-        "Backend service restarted successfully",
-        LogFileType.BACKEND
-      );
-    } else {
-      logger.error("Failed to restart backend service", LogFileType.BACKEND);
-    }
-    return success;
+    })().finally(() => {
+      this.restartPromise = null;
+    });
+    return this.restartPromise;
   }
 }
 const linuxInstallScriptRaw = '#!/bin/bash\n# Local Operator Backend Installation Script for Linux\n# This script sets up a virtual environment for the Local Operator backend\n# without requiring sudo or admin privileges.\n\n# Exit on error, undefined variables, and failed pipe commands\nset -e  # Exit immediately if a command exits with a non-zero status\nset -u  # Error on unset variables\nset -o pipefail  # Fail if any command in a pipe fails\n\n# Configuration\n# Variables APP_NAME and MIN_PYTHON_VERSION removed as they were unused\nVENV_NAME="local-operator-venv"\nAPP_DATA_DIR="${HOME}/.config/local-operator"\nVENV_PATH="${APP_DATA_DIR}/${VENV_NAME}"\nLOG_FILE="${APP_DATA_DIR}/backend-install.log"\nTIMESTAMP=$(date +"%Y-%m-%d_%H-%M-%S")\n\n# Keep CPython\'s bytecode cache out of the application directory.\n#\n# Same reason as the macOS script: an interpreter writing __pycache__/*.pyc\n# beside its own stdlib sources writes into the installed tree. Linux does not\n# code-seal the app the way macOS does, so this is uniformity and hygiene here\n# rather than the load-bearing fix it is on macOS - but it is also the value a\n# standalone run of this script has to agree with, because the app and the\n# script must not disagree about where bytecode goes.\n: "${PYTHONPYCACHEPREFIX:=${APP_DATA_DIR}/python-bytecode-cache}"\nexport PYTHONPYCACHEPREFIX\n\n# Create app data directory if it doesn\'t exist\nif ! mkdir -p "${APP_DATA_DIR}"; then\n  echo "ERROR: Unable to create app data directory at ${APP_DATA_DIR}"\n  echo "Please check permissions and try again."\n  exit 1\nfi\n\n# Handle cleanup on script exit\ncleanup() {\n  # Remove any temporary files created during execution\n  if [ -f "${APP_DATA_DIR}/get-pip.py" ]; then\n    rm -f "${APP_DATA_DIR}/get-pip.py"\n  fi\n  if [ -n "${FFMPEG_TEMP_ARCHIVE:-}" ] && [ -f "${FFMPEG_TEMP_ARCHIVE}" ]; then\n    log "Removing temporary FFmpeg archive: ${FFMPEG_TEMP_ARCHIVE}"\n    rm -f "${FFMPEG_TEMP_ARCHIVE}"\n  fi\n  echo "$(date): Cleanup completed."\n}\n\n# Set trap only for manual interruption (SIGINT, SIGTERM), not normal exits\ntrap cleanup SIGINT SIGTERM\n\n\n# Start logging\nexec > >(tee -a "${LOG_FILE}") 2>&1\necho "[${TIMESTAMP}]: Starting Local Operator backend installation..."\necho "[${TIMESTAMP}]: System information: $(uname -a)"\n\n# Function to log messages with timestamp (defined later, but used by FFmpeg section)\n_log_internal() {\n  local internal_timestamp\n  internal_timestamp=$(date +"%Y-%m-%d %H:%M:%S")\n  echo "[${internal_timestamp}] $1"\n}\n\n# --- FFmpeg Installation ---\nBIN_DIR="${APP_DATA_DIR}/bin"\nFFMPEG_BIN="${BIN_DIR}/ffmpeg" # Path to ffmpeg binary\n\n_log_internal "Ensuring bin directory exists: ${BIN_DIR}"\nif ! mkdir -p "${BIN_DIR}"; then\n    _log_internal "ERROR: Unable to create bin directory at ${BIN_DIR}"\n    exit 1\nfi\n\n# Check if FFmpeg is already installed and executable\nif [ -f "${FFMPEG_BIN}" ] && [ -x "${FFMPEG_BIN}" ]; then\n    _log_internal "FFmpeg already installed at ${FFMPEG_BIN}. Skipping download."\nelse\n    _log_internal "FFmpeg not found or not executable. Attempting to download and install FFmpeg..."\n\n    FFMPEG_DOWNLOAD_URL=""\n\n    LINUX_ARCH=$(uname -m)\n    if [[ "${LINUX_ARCH}" == "x86_64" ]]; then\n        FFMPEG_DOWNLOAD_URL="https://github.com/eugeneware/ffmpeg-static/releases/download/b6.0/ffmpeg-linux-x64"\n    elif [[ "${LINUX_ARCH}" == "aarch64" ]] || [[ "${LINUX_ARCH}" == "arm64" ]]; then\n        FFMPEG_DOWNLOAD_URL="https://github.com/eugeneware/ffmpeg-static/releases/download/b6.0/ffmpeg-linux-arm64"\n    else\n        _log_internal "Error: Unsupported CPU architecture for FFmpeg download: ${LINUX_ARCH}"\n        exit 1\n    fi\n\n    _log_internal "Downloading FFmpeg from: ${FFMPEG_DOWNLOAD_URL}"\n    if command -v curl >/dev/null 2>&1; then\n        if ! curl -L "${FFMPEG_DOWNLOAD_URL}" -o "${FFMPEG_BIN}"; then\n            _log_internal "Error: Failed to download FFmpeg using curl from ${FFMPEG_DOWNLOAD_URL}"\n            exit 1\n        fi\n    elif command -v wget >/dev/null 2>&1; then\n        if ! wget -O "${FFMPEG_BIN}" "${FFMPEG_DOWNLOAD_URL}"; then\n            _log_internal "Error: Failed to download FFmpeg using wget from ${FFMPEG_DOWNLOAD_URL}"\n            exit 1\n        fi\n    else\n        _log_internal "Error: Neither curl nor wget found. Cannot download FFmpeg."\n        exit 1\n    fi\n    _log_internal "FFmpeg binary downloaded successfully to ${FFMPEG_BIN}"\n\n    chmod +x "${FFMPEG_BIN}"\n    _log_internal "Set executable permissions for ${FFMPEG_BIN}"\n\n    # Verify FFmpeg is executable after download\n    if [ ! -f "${FFMPEG_BIN}" ] || [ ! -x "${FFMPEG_BIN}" ]; then\n        _log_internal "Error: FFmpeg binary not found or not executable after download."\n        exit 1\n    fi\nfi\n\n_log_internal "FFmpeg installation complete. FFmpeg binary is at: ${FFMPEG_BIN}"\n\n# Function to check if a command exists\ncommand_exists() {\n  command -v "$1" >/dev/null 2>&1\n}\n\n# Function to log messages with timestamp\nlog() {\n  local timestamp\n  timestamp=$(date +"%Y-%m-%d %H:%M:%S")\n  echo "[${timestamp}] $1"\n}\n\n# Function to display error messages and exit\nerror_exit() {\n  log "ERROR: $1" >&2\n  exit "${2:-1}"\n}\n\n# Function to check if Python binary is valid for current architecture\nis_valid_python_binary() {\n  local python_path="$1"\n  \n  # First check if file exists and is executable\n  if [ ! -f "${python_path}" ] || [ ! -x "${python_path}" ]; then\n    return 1\n  fi\n  \n  # Try to run a simple Python command to verify it works on current architecture\n  "${python_path}" -c "print(\'Testing Python executable\')" >/dev/null 2>&1\n  return $?\n}\n\n# Check for network connectivity to key servers\ncheck_connectivity() {\n  log "Checking network connectivity..."\n  local servers=("pypi.org" "bootstrap.pypa.io")\n  local has_connectivity=false\n  \n  for server in "${servers[@]}"; do\n    if command_exists curl; then\n      if curl --connect-timeout 5 -s "https://${server}" -o /dev/null; then\n        has_connectivity=true\n        break\n      fi\n    elif command_exists wget; then\n      if wget --timeout=5 -q --spider "https://${server}"; then\n        has_connectivity=true\n        break\n      fi\n    fi\n  done\n  \n  if [ "$has_connectivity" = false ]; then\n    log "WARNING: Network connectivity issues detected. This may affect installation."\n  else\n    log "Network connectivity confirmed."\n  fi\n}\n\n# Call connectivity check\ncheck_connectivity\n\n# Check if PYTHON_BIN is already set by the installer\nif [ -n "${PYTHON_BIN:-}" ]; then\n  log "Using Python executable provided by installer: ${PYTHON_BIN}"\n  # Verify the provided Python binary works on this architecture\n  if ! is_valid_python_binary "${PYTHON_BIN}"; then\n    log "Warning: The provided Python binary is not compatible with this system architecture."\n    log "Will attempt to find a system Python installation instead."\n    PYTHON_BIN=""\n  fi\nfi\n\n# If PYTHON_BIN is empty or invalid, try to find a suitable Python installation\nif [ -z "${PYTHON_BIN:-}" ] || ! is_valid_python_binary "${PYTHON_BIN:-}"; then\n  # Try to find a suitable Python installation\n  log "Looking for a suitable Python installation..."\n  \n  # Try multiple possible locations to find Python\n  POSSIBLE_PYTHON_PATHS=(\n    # System paths first (more likely to be compatible with current architecture)\n    "/usr/local/bin/python3.12"\n    "/usr/bin/python3.12"\n    "/usr/local/bin/python3"\n    "/usr/bin/python3"\n    # From environment variable (set by the installer)\n    "${ELECTRON_RESOURCE_PATH:-}/python/bin/python3"\n    # Development paths\n    "$(dirname "$0")/../../../resources/python/bin/python3"\n    "$(pwd)/resources/python/bin/python3"\n  )\n\n  # Find the first Python that exists and is version 3.12+ and works on this architecture\n  PYTHON_BIN=""\n  for path in "${POSSIBLE_PYTHON_PATHS[@]}"; do\n    # Skip empty paths that might come from unset environment variables\n    if [ -z "${path}" ]; then\n      continue\n    fi\n    \n    if is_valid_python_binary "${path}"; then\n      # Check Python version\n      if PY_VERSION=$("${path}" -c "import sys; print(f\'{sys.version_info.major}.{sys.version_info.minor}\')" 2>/dev/null); then\n        MAJOR=$(echo "${PY_VERSION}" | cut -d. -f1)\n        MINOR=$(echo "${PY_VERSION}" | cut -d. -f2)\n        if [ "${MAJOR}" -eq 3 ] && [ "${MINOR}" -ge 12 ]; then\n          PYTHON_BIN="${path}"\n          log "Found suitable Python ${PY_VERSION} at ${path}"\n          break\n        else\n          log "Python at ${path} is version ${PY_VERSION}, which is below the required 3.12+"\n        fi\n      fi\n    else\n      if [ -f "${path}" ]; then\n        log "Python at ${path} exists but is not compatible with this system architecture"\n      fi\n    fi\n  done\n\n  # If we couldn\'t find a suitable Python, exit with error\n  if [ -z "${PYTHON_BIN:-}" ]; then\n    error_exit "No suitable Python installation found (version 3.12 or higher required).\\nPlease install Python 3.12 or higher before running this script.\\nYou can install Python from https://www.python.org/downloads/"\n  fi\nfi\n\necho "Using Python: $PYTHON_BIN"\n"$PYTHON_BIN" --version || {\n  echo "Error: Failed to run Python. Please ensure it is executable and accessible."\n  echo "System architecture: $(uname -m)"\n  echo "Python binary architecture: $(file "$PYTHON_BIN" 2>/dev/null || echo \'Unable to determine\')"\n  exit 1\n}\n\n# Detect the Linux distribution to provide specific instructions\nif command_exists lsb_release; then\n  DISTRO=$(lsb_release -is)\n  DISTRO_VERSION=$(lsb_release -rs)\n  echo "Detected Linux distribution: $DISTRO $DISTRO_VERSION"\nelif [ -f /etc/os-release ]; then\n  DISTRO=$(grep -oP \'(?<=^ID=).+\' /etc/os-release | tr -d \'"\')\n  DISTRO_VERSION=$(grep -oP \'(?<=^VERSION_ID=).+\' /etc/os-release | tr -d \'"\')\n  echo "Detected Linux distribution: $DISTRO $DISTRO_VERSION"\nelse\n  DISTRO="unknown"\n  echo "Unable to detect Linux distribution"\nfi\n\n# Check if Python has venv module and ensurepip available\nlog "Checking for venv module and ensurepip availability..."\nVENV_AVAILABLE=0\nENSUREPIP_AVAILABLE=0\n\n"${PYTHON_BIN}" -c "import venv" > /dev/null 2>&1 || VENV_AVAILABLE=1\n"${PYTHON_BIN}" -c "import ensurepip" > /dev/null 2>&1 || ENSUREPIP_AVAILABLE=1\n\n# If venv is still not available, try to use virtualenv as a fallback\nif [ $VENV_AVAILABLE -ne 0 ]; then\n  echo "venv module is not available. Checking for virtualenv as an alternative..."\n  \n  # Check if virtualenv is already installed\n  if "$PYTHON_BIN" -c "import virtualenv" > /dev/null 2>&1; then\n    echo "virtualenv is available, will use it instead of venv"\n  else\n    echo "ERROR: Neither venv nor virtualenv is available."\n    echo "Python 3.12 and venv should be installed as package dependencies."\n    echo "Please ensure Python 3.12 and venv are properly installed on your system."\n    exit 1\n  fi\nfi\n\n# Create virtual environment if it doesn\'t exist\nif [ ! -d "$VENV_PATH" ]; then\n  echo "Creating virtual environment at $VENV_PATH..."\n  # Remove any potentially corrupted virtual environment\n  if [ -e "$VENV_PATH" ]; then\n    echo "Removing existing but potentially corrupted venv directory..."\n    rm -rf "$VENV_PATH"\n  fi\n  \n  # Make sure parent directory exists and is writable\n  mkdir -p "$(dirname "$VENV_PATH")"\n  \n  # Try different methods to create a virtual environment\n  VENV_CREATE_STATUS=1\n  \n  # First try with venv if available\n  if [ $VENV_AVAILABLE -eq 0 ] && [ $ENSUREPIP_AVAILABLE -eq 0 ]; then\n    echo "Creating virtual environment using venv module..."\n    "$PYTHON_BIN" -m venv "$VENV_PATH"\n    VENV_CREATE_STATUS=$?\n  fi\n  \n  # If venv failed, try virtualenv\n  if [ $VENV_CREATE_STATUS -ne 0 ]; then\n    echo "venv creation failed with status $VENV_CREATE_STATUS. Falling back to virtualenv..."\n    if command_exists virtualenv; then\n      virtualenv -p "$PYTHON_BIN" "$VENV_PATH"\n      VENV_CREATE_STATUS=$?\n    elif "$PYTHON_BIN" -m pip list | grep -q virtualenv; then\n      "$PYTHON_BIN" -m virtualenv -p "$PYTHON_BIN" "$VENV_PATH"\n      VENV_CREATE_STATUS=$?\n    else\n      echo "ERROR: Both venv and virtualenv are unavailable or failed."\n      echo "Python 3.12 and venv should be installed as package dependencies."\n      echo "Please ensure Python 3.12 and venv are properly installed on your system."\n      echo "You can install Python 3.12 from https://www.python.org/downloads/"\n      exit 1\n    fi\n  fi\n  \n  # Check if virtual environment creation was successful\n  if [ $VENV_CREATE_STATUS -ne 0 ]; then\n    log "ERROR: Failed to create virtual environment. Exit code: $VENV_CREATE_STATUS"\n    log "Virtual environment path: $VENV_PATH"\n    log "Python binary used: $PYTHON_BIN"\n    ls -la "$(dirname "$VENV_PATH")" || true\n    log "Python executable permissions:"\n    ls -la "$PYTHON_BIN" || true\n    \n    # Check for common issues\n    log "Checking for common virtual environment creation issues..."\n    \n    # Check disk space\n    df -h "$(dirname "$VENV_PATH")" || true\n    \n    # Check if directory is writable\n    if [ ! -w "$(dirname "$VENV_PATH")" ]; then\n      log "ERROR: Directory $(dirname "$VENV_PATH") is not writable"\n    fi\n    \n    # Try to create a minimal virtual environment manually as a last resort\n    log "Attempting to create a minimal virtual environment manually..."\n    mkdir -p "$VENV_PATH/bin" || error_exit "Could not create directory $VENV_PATH/bin"\n    echo "#!/bin/bash" > "$VENV_PATH/bin/activate"\n    echo "export VIRTUAL_ENV=\\"$VENV_PATH\\"" >> "$VENV_PATH/bin/activate"\n    echo "export PATH=\\"$VENV_PATH/bin:\\$PATH\\"" >> "$VENV_PATH/bin/activate"\n    echo "unset PYTHONHOME" >> "$VENV_PATH/bin/activate"\n    chmod +x "$VENV_PATH/bin/activate" || error_exit "Could not set execute permissions on activate script"\n    \n    # Create symlinks to the system Python\n    ln -sf "$PYTHON_BIN" "$VENV_PATH/bin/python" || log "WARNING: Failed to create symlink for python"\n    ln -sf "$PYTHON_BIN" "$VENV_PATH/bin/python3" || log "WARNING: Failed to create symlink for python3"\n    \n    # Try to bootstrap pip\n    log "Bootstrapping pip in the minimal virtual environment..."\n    if command_exists curl; then\n      curl -s https://bootstrap.pypa.io/get-pip.py -o "$APP_DATA_DIR/get-pip.py" || log "WARNING: Failed to download get-pip.py"\n    elif command_exists wget; then\n      wget -q -O "$APP_DATA_DIR/get-pip.py" https://bootstrap.pypa.io/get-pip.py || log "WARNING: Failed to download get-pip.py"\n    else\n      log "ERROR: Neither curl nor wget available to download get-pip.py"\n      error_exit "Installation cannot continue without being able to download pip"\n    fi\n    \n    # shellcheck disable=SC1090\n    source "$VENV_PATH/bin/activate" && python "$APP_DATA_DIR/get-pip.py" --no-warn-script-location\n    \n    if [ ! -f "$VENV_PATH/bin/pip" ]; then\n      error_exit "Failed to create even a minimal virtual environment."\n    else\n      log "Created a minimal virtual environment as a fallback."\n    fi\n  else\n    log "Successfully created virtual environment"\n  fi\nfi\n\n# Verify the virtual environment structure\necho "Verifying virtual environment structure..."\nif [ ! -f "$VENV_PATH/bin/python" ]; then\n  echo "Python executable missing in virtual environment, creating symlink..."\n  ln -sf "$PYTHON_BIN" "$VENV_PATH/bin/python"\nfi\n\nif [ ! -f "$VENV_PATH/bin/pip" ]; then\n  echo "pip missing in virtual environment, attempting to bootstrap it..."\n  curl -s https://bootstrap.pypa.io/get-pip.py -o "$APP_DATA_DIR/get-pip.py"\n  "$VENV_PATH/bin/python" "$APP_DATA_DIR/get-pip.py" --no-warn-script-location\n  \n  if [ ! -f "$VENV_PATH/bin/pip" ]; then\n    echo "ERROR: Failed to bootstrap pip in the virtual environment"\n    exit 1\n  fi\nfi\n\necho "Virtual environment structure verified"\n\n# Activate virtual environment and install local-operator\necho "Installing local-operator in virtual environment..."\nsource "$VENV_PATH/bin/activate"\n\necho "Upgrading pip..."\npython -m pip install --upgrade pip || {\n  echo "WARNING: Failed to upgrade pip. Will try to continue with existing pip version."\n  pip --version\n}\n\n# Check network connectivity to PyPI\necho "Checking network connectivity to PyPI..."\nif command_exists curl; then\n  curl -s https://pypi.org/pypi/local-operator/json -o /dev/null || {\n    echo "WARNING: Could not reach PyPI. Network connectivity issues might prevent installation."\n  }\nelif command_exists wget; then\n  wget -q --spider https://pypi.org/pypi/local-operator/json || {\n    echo "WARNING: Could not reach PyPI. Network connectivity issues might prevent installation."\n  }\nfi\n\necho "Installing local-operator package..."\npython -m pip install --verbose local-operator || {\n  echo "ERROR: Failed to install local-operator package. Exit code: $?"\n  echo "Python version:"\n  python --version\n  echo "pip version:"\n  pip --version\n  echo "Available pip packages:"\n  pip list\n  exit 1\n}\necho "local-operator installation successful"\n\n# Verify installation\nif [ -f "$VENV_PATH/bin/local-operator" ]; then\n  log "Local Operator backend installed successfully!"\n  \n  # Show more information about the installed binary\n  ls -la "$VENV_PATH/bin/local-operator" || true\n  file "$VENV_PATH/bin/local-operator" 2>/dev/null || log "Note: \'file\' command not available"\n  \n  # Try to run the version command with full error output\n  log "Testing local-operator binary..."\n  "$VENV_PATH/bin/local-operator" --version || {\n    log "ERROR: local-operator binary exists but failed to execute. Exit code: $?"\n    log "Binary details:"\n    file "$VENV_PATH/bin/local-operator" 2>/dev/null || log "Note: \'file\' command not available"\n    log "Binary permissions:"\n    ls -la "$VENV_PATH/bin/local-operator" || true\n    log ""\n    log "This could be due to missing dependencies or architecture incompatibility."\n    log "Try running the binary manually to see specific errors."\n    \n    # Don\'t exit here - just warn the user\n    log "WARNING: Installation completed but binary verification failed."\n  }\n  \n  # Create a summary of the installation\n  SUMMARY_FILE="${APP_DATA_DIR}/installation-summary-${TIMESTAMP}.txt"\n  {\n    echo "=== Local Operator Backend Installation Summary ==="\n    echo "Timestamp: $(date)"\n    echo "Python Version: $("${PYTHON_BIN}" --version 2>&1)"\n    echo "Virtual Environment: ${VENV_PATH}"\n    echo "Binary Location: ${VENV_PATH}/bin/local-operator"\n    echo "To activate the virtual environment, run: source ${VENV_PATH}/bin/activate"\n    echo "To test the installation, run: ${VENV_PATH}/bin/local-operator --version"\n    echo "Log file: ${LOG_FILE}"\n    echo "=================================================="\n  } > "${SUMMARY_FILE}"\n  \n  log "Installation summary saved to: ${SUMMARY_FILE}"\nelse\n  log "Error: Failed to install Local Operator backend. Binary not found."\n  log "Contents of bin directory:"\n  ls -la "$VENV_PATH/bin/" || true\n  log "Check the log file for details: ${LOG_FILE}"\n  error_exit "Installation failed. Binary not installed properly."\nfi\n\nlog "Installation completed successfully at $(date)"\n\n# Clean up temporary files now that installation is complete\ncleanup\n\n# Print final instructions\nlog ""\nlog "=== INSTALLATION COMPLETE ==="\nlog "You can now use the Local Operator backend by running: ${VENV_PATH}/bin/local-operator"\nlog "Installation directory: ${VENV_PATH}"\nlog "Log file: ${LOG_FILE}"\nlog "================================"\n';
@@ -9379,8 +9554,8 @@ function readInstallIdentity(shimPath) {
   }
   let shebang = null;
   try {
-    const firstLine = fs.readFileSync(shimPath, "utf8").split("\n", 1)[0] ?? "";
-    shebang = firstLine.startsWith("#!") ? firstLine : null;
+    const firstLine2 = fs.readFileSync(shimPath, "utf8").split("\n", 1)[0] ?? "";
+    shebang = firstLine2.startsWith("#!") ? firstLine2 : null;
   } catch {
     shebang = null;
   }
@@ -10491,86 +10666,6 @@ ${heal.removed.join("\n")}`,
     electron.ipcMain.removeHandler("quit-for-update-install");
     this.mainWindow = null;
   }
-  /**
-   * Register the backend service for proper shutdown when app quits
-   * This ensures that restarted backend services are properly shut down
-   */
-  registerBackendShutdown() {
-    if (!this.backendService || this.backendService.isUsingExternalBackend()) {
-      return;
-    }
-    const shutdownHandler = async () => {
-      logger.info(
-        "Shutting down backend service before app quit...",
-        LogFileType.UPDATE_SERVICE
-      );
-      try {
-        await this.backendService?.stop(false);
-        logger.info(
-          "Backend service successfully shut down before app quit",
-          LogFileType.UPDATE_SERVICE
-        );
-      } catch (error) {
-        logger.error(
-          "Error shutting down backend service before app quit:",
-          LogFileType.UPDATE_SERVICE,
-          error
-        );
-        try {
-          logger.info(
-            "Attempting forced shutdown of backend service...",
-            LogFileType.UPDATE_SERVICE
-          );
-          await this.forceTerminateBackendProcess();
-          logger.info(
-            "Forced shutdown of backend service completed",
-            LogFileType.UPDATE_SERVICE
-          );
-        } catch (forceError) {
-          logger.error(
-            "Error during forced shutdown of backend service:",
-            LogFileType.UPDATE_SERVICE,
-            forceError
-          );
-        }
-      }
-    };
-    electron.app.removeAllListeners("before-quit");
-    electron.app.once("before-quit", shutdownHandler);
-    electron.app.once("will-quit", shutdownHandler);
-    logger.info(
-      "Registered backend service for proper shutdown on app quit",
-      LogFileType.UPDATE_SERVICE
-    );
-  }
-  /**
-   * Force terminate the backend process using platform-specific commands
-   * This is a last resort method when normal termination fails
-   */
-  async forceTerminateBackendProcess() {
-    if (!this.backendService) {
-      return;
-    }
-    const execAsync = node_util.promisify(node_child_process.exec);
-    try {
-      if (process.platform === "win32") {
-        await execAsync('taskkill /f /im "local-operator serve" /t');
-        await execAsync(
-          `wmic process where "commandline like '%local-operator serve%'" call terminate`
-        );
-      } else {
-        await execAsync('pkill -f "local-operator serve"');
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-        await execAsync('pkill -9 -f "local-operator serve"');
-      }
-    } catch (error) {
-      logger.warn(
-        "Error during force termination (this may be normal if process was already terminated):",
-        LogFileType.UPDATE_SERVICE,
-        error
-      );
-    }
-  }
   /**
    * Set up event handlers for the autoUpdater
    */
@@ -10818,6 +10913,15 @@ ${heal.removed.join("\n")}`,
       let block = null;
       try {
         block = await this.runInstallPreflight(this.lastUpdateInfo);
+        if (!block) await this.backendService?.stop(false);
+      } catch (error) {
+        this.updateStage = "idle";
+        logger.error(
+          "Update handoff refused: owned backend cleanup failed",
+          LogFileType.UPDATE_SERVICE,
+          error
+        );
+        return false;
       } finally {
         this.installPreflightInFlight = false;
       }
@@ -11649,16 +11753,6 @@ ${pipRun.stderr.trim()}`,
         "Restarting backend service after update...",
         LogFileType.UPDATE_SERVICE
       );
-      await new Promise((resolve) => setTimeout(resolve, 2e3));
-      const isHealthy = await this.checkBackendHealth();
-      if (isHealthy) {
-        logger.warn(
-          "Backend service is still running after stop command, attempting force termination",
-          LogFileType.UPDATE_SERVICE
-        );
-        await this.forceTerminateBackendProcess();
-        await new Promise((resolve) => setTimeout(resolve, 2e3));
-      }
       const restartSuccess = await this.backendService.restart();
       if (restartSuccess) {
         logger.info(
@@ -11692,7 +11786,6 @@ ${pipRun.stderr.trim()}`,
             return false;
           }
         }
-        this.registerBackendShutdown();
       } else {
         logger.error(
           "Failed to restart backend service after update",
@@ -12280,6 +12373,16 @@ function createWindow() {
 }
 const backendService = new BackendServiceManager();
 const backendInstaller = new BackendInstaller();
+const reportBackendFailure = (message, fileType) => {
+  if (backendService.isShuttingDown()) {
+    logger.error(
+      `Backend Error (not shown; the app is shutting down): ${message}`,
+      fileType
+    );
+    return;
+  }
+  electron.dialog.showErrorBox("Backend Error", message);
+};
 const windowLaunch = resolveWindowLaunchPlan({
   env: process.env,
   argv: process.argv
@@ -12644,9 +12747,9 @@ electron.app.whenReady().then(async () => {
             "Failed to start backend after installation, quitting app",
             LogFileType.INSTALLER
           );
-          electron.dialog.showErrorBox(
-            "Backend Error",
-            "Failed to start the Local Operator backend service after installation. Please restart the application."
+          reportBackendFailure(
+            "Failed to start the Local Operator backend service after installation. Please restart the application.",
+            LogFileType.INSTALLER
           );
           electron.app.quit();
           return;
@@ -12658,9 +12761,9 @@ electron.app.whenReady().then(async () => {
             "Failed to start backend with existing installation, quitting app",
             LogFileType.BACKEND
           );
-          electron.dialog.showErrorBox(
-            "Backend Error",
-            "Failed to start the Local Operator backend service. Please restart the application."
+          reportBackendFailure(
+            "Failed to start the Local Operator backend service. Please restart the application.",
+            LogFileType.BACKEND
           );
           electron.app.quit();
           return;
@@ -12784,161 +12887,34 @@ electron.app.on("window-all-closed", () => {
   );
   electron.app.quit();
 });
-electron.app.on("will-quit", async (event) => {
-  const isBackendManagerDisabled = process.env.VITE_DISABLE_BACKEND_MANAGER === "true";
-  if (!isBackendManagerDisabled && !backendService.isUsingExternalBackend()) {
-    event.preventDefault();
-    try {
-      logger.info(
-        "App is quitting, stopping the Local Operator backend service...",
-        LogFileType.BACKEND
-      );
-      await backendService.stop(false);
-      logger.info(
-        "Local Operator backend service successfully stopped",
-        LogFileType.BACKEND
-      );
-      logger.info(
-        "Performing additional cleanup to ensure complete termination",
-        LogFileType.BACKEND
-      );
-      if (process.platform === "win32") {
-        try {
-          require("node:child_process").execSync(
-            'taskkill /f /im python.exe /fi "WINDOWTITLE eq *local-operator*" /t',
-            { stdio: "ignore" }
-          );
-          require("node:child_process").execSync(
-            "taskkill /f /im local-operator.exe /t",
-            { stdio: "ignore" }
-          );
-        } catch (err) {
-          logger.error(
-            "Error during Windows process cleanup (may be normal):",
-            LogFileType.BACKEND,
-            err
-          );
-        }
-      } else {
-        try {
-          require("node:child_process").execSync(
-            'pkill -f "local-operator serve"',
-            { stdio: "ignore" }
-          );
-          await new Promise((resolve) => setTimeout(resolve, 1e3));
-          require("node:child_process").execSync(
-            'pkill -9 -f "local-operator serve"',
-            { stdio: "ignore" }
-          );
-        } catch (err) {
-          logger.error(
-            "Error during Unix process cleanup (may be normal):",
-            LogFileType.BACKEND,
-            err
-          );
-        }
-      }
-      let allProcessesTerminated = true;
-      try {
-        if (process.platform === "win32") {
-          const { stdout: pythonOutput } = require("node:child_process").execSync(
-            `tasklist /fi "imagename eq python.exe" /fo csv`,
-            { encoding: "utf8" }
-          );
-          const hasPythonProcesses = pythonOutput?.trim().includes("python.exe");
-          const { stdout: localOperatorOutput } = require("node:child_process").execSync(
-            `tasklist /fi "imagename eq local-operator.exe" /fo csv`,
-            { encoding: "utf8" }
-          );
-          const hasLocalOperatorProcesses = localOperatorOutput?.trim().includes("local-operator.exe");
-          allProcessesTerminated = !hasPythonProcesses && !hasLocalOperatorProcesses;
-        } else {
-          const { stdout } = require("node:child_process").execSync(
-            `pgrep -f "local-operator serve" || echo ""`,
-            { encoding: "utf8" }
-          );
-          allProcessesTerminated = !stdout?.trim();
-        }
-      } catch (err) {
-        logger.error(
-          "Error checking for remaining processes:",
-          LogFileType.BACKEND,
-          err
-        );
-        allProcessesTerminated = true;
-      }
-      if (!allProcessesTerminated) {
-        logger.error(
-          "Some backend processes may still be running, attempting final cleanup",
-          LogFileType.BACKEND
-        );
-        try {
-          if (process.platform === "win32") {
-            require("node:child_process").execSync(
-              "taskkill /f /im python.exe /t",
-              { stdio: "ignore" }
-            );
-          } else {
-            require("node:child_process").execSync("pkill -9 -f python", {
-              stdio: "ignore"
-            });
-          }
-        } catch (finalErr) {
-          logger.error(
-            "Error during final cleanup (may be normal):",
-            LogFileType.BACKEND,
-            finalErr
-          );
-        }
-      }
-    } catch (error) {
-      logger.error(
-        "Error stopping the Local Operator backend service:",
-        LogFileType.BACKEND,
-        error
-      );
-      logger.info(
-        "Trying alternative termination approach",
-        LogFileType.BACKEND
-      );
-      if (process.platform === "win32") {
-        try {
-          require("node:child_process").execSync(
-            'taskkill /f /im python.exe /fi "WINDOWTITLE eq *local-operator*" /t',
-            { stdio: "ignore" }
-          );
-          require("node:child_process").execSync(
-            "taskkill /f /im local-operator.exe /t",
-            { stdio: "ignore" }
-          );
-        } catch (_err) {
-        }
-      } else {
-        try {
-          require("node:child_process").execSync(
-            'pkill -f "local-operator serve"',
-            { stdio: "ignore" }
-          );
-          require("node:child_process").execSync(
-            'sleep 1 && pkill -9 -f "local-operator serve"',
-            { stdio: "ignore" }
-          );
-        } catch (_err) {
-        }
-      }
-    } finally {
-      logger.info("Exiting application...", LogFileType.BACKEND);
-      setTimeout(() => {
-        logger.info("Forcing app exit", LogFileType.BACKEND);
-        electron.app.exit(0);
-      }, 2e3);
-    }
-  } else if (!isBackendManagerDisabled && backendService.isUsingExternalBackend()) {
-    logger.info(
-      "Using external backend, skipping termination on app quit",
+const QUIT_FAILSAFE_MARGIN_MS = 5e3;
+const QUIT_CLEANUP_FAILSAFE_MS = CONSOLE_RESOLUTION_WORST_MS + INTERPRETER_RESOLUTION_WORST_MS + OWNED_STOP_WORST_MS + READINESS_POLL_INTERVAL_MS + QUIT_FAILSAFE_MARGIN_MS;
+let backendQuitPending = false;
+electron.app.on("will-quit", (event) => {
+  if (backendService.isOwnedCleanupComplete()) return;
+  event.preventDefault();
+  if (backendQuitPending) return;
+  backendQuitPending = true;
+  const failsafe = setTimeout(() => {
+    logger.error(
+      `Owned backend cleanup did not finish within ${QUIT_CLEANUP_FAILSAFE_MS} ms; exiting with failure`,
       LogFileType.BACKEND
     );
-  }
+    electron.app.exit(1);
+  }, QUIT_CLEANUP_FAILSAFE_MS);
+  failsafe.unref();
+  void backendService.stop(false).then(() => {
+    clearTimeout(failsafe);
+    electron.app.quit();
+  }).catch((error) => {
+    clearTimeout(failsafe);
+    logger.error(
+      "Owned backend cleanup failed; exiting with failure",
+      LogFileType.BACKEND,
+      error
+    );
+    electron.app.exit(1);
+  });
 });
 electron.app.on("before-quit", () => {
   logger.info("App is about to quit", LogFileType.BACKEND);
@@ -12947,114 +12923,24 @@ electron.app.on("before-quit", () => {
   void stopBrowserHost();
 });
 process.on("exit", () => {
-  logger.info(
-    "Process exit event detected, ensuring the Local Operator backend service is terminated",
-    LogFileType.BACKEND
-  );
   try {
-    if (!process.env.VITE_DISABLE_BACKEND_MANAGER && !backendService.isUsingExternalBackend()) {
-      logger.info(
-        "Forcing termination of the Local Operator backend service",
-        LogFileType.BACKEND
-      );
-      logger.info(
-        "Performing final cleanup of any remaining backend processes",
-        LogFileType.BACKEND
-      );
-      if (process.platform === "win32") {
-        try {
-          require("node:child_process").spawnSync("cmd.exe", [
-            "/c",
-            'taskkill /f /im python.exe /fi "WINDOWTITLE eq *local-operator*" /t'
-          ]);
-          require("node:child_process").spawnSync("cmd.exe", [
-            "/c",
-            "taskkill /f /im local-operator.exe /t"
-          ]);
-        } catch (_err) {
-        }
-      } else {
-        try {
-          require("node:child_process").spawnSync("bash", [
-            "-c",
-            `ps aux | grep "local-operator serve" | grep -v grep | awk '{print $2}' | xargs -r kill -15`
-          ]);
-          require("node:child_process").spawnSync("bash", [
-            "-c",
-            `sleep 1 && ps aux | grep "local-operator serve" | grep -v grep | awk '{print $2}' | xargs -r kill -9`
-          ]);
-        } catch (_err) {
-        }
-      }
-    } else if (!process.env.VITE_DISABLE_BACKEND_MANAGER && backendService.isUsingExternalBackend()) {
-      logger.info(
-        "Using external backend, skipping force termination",
-        LogFileType.BACKEND
-      );
-    }
+    backendService.emergencyStopOwned();
   } catch (error) {
-    logger.error("Error in exit handler", LogFileType.BACKEND, error);
+    logger.error(
+      "Owned backend emergency cleanup failed",
+      LogFileType.BACKEND,
+      error
+    );
   }
   posthogClient.shutdown();
 });
 process.on("uncaughtException", (error) => {
   logger.error("Uncaught exception", LogFileType.BACKEND, error);
-  if (backendService && !process.env.VITE_DISABLE_BACKEND_MANAGER && !backendService.isUsingExternalBackend()) {
-    logger.info(
-      "Attempting to stop our backend service due to uncaught exception",
-      LogFileType.BACKEND
-    );
-    backendService.stop().catch((stopError) => {
-      logger.error(
-        "Error stopping the Local Operator backend service:",
-        LogFileType.BACKEND,
-        stopError
-      );
-      logger.info(
-        "Trying alternative termination approach",
-        LogFileType.BACKEND
-      );
-      if (process.platform === "win32") {
-        try {
-          require("node:child_process").spawnSync("cmd.exe", [
-            "/c",
-            'taskkill /f /im python.exe /fi "WINDOWTITLE eq *local-operator*" /t'
-          ]);
-          require("node:child_process").spawnSync("cmd.exe", [
-            "/c",
-            "taskkill /f /im local-operator.exe /t"
-          ]);
-        } catch (_err) {
-        }
-      } else {
-        try {
-          require("node:child_process").spawnSync("bash", [
-            "-c",
-            `ps aux | grep "local-operator serve" | grep -v grep | awk '{print $2}' | xargs -r kill -15`
-          ]);
-          require("node:child_process").spawnSync("bash", [
-            "-c",
-            `sleep 1 && ps aux | grep "local-operator serve" | grep -v grep | awk '{print $2}' | xargs -r kill -9`
-          ]);
-        } catch (_err) {
-        }
-      }
-    }).finally(() => {
-      setTimeout(() => {
-        logger.info(
-          "Forcing app exit after uncaught exception",
-          LogFileType.BACKEND
-        );
-        process.exit(1);
-      }, 1e3);
-    });
-  } else if (backendService && !process.env.VITE_DISABLE_BACKEND_MANAGER && backendService.isUsingExternalBackend()) {
-    logger.info(
-      "Using external backend, skipping termination on uncaught exception",
-      LogFileType.BACKEND
+  void backendService.stop(false).catch((stopError) => {
+    logger.error(
+      "Owned backend cleanup failed",
+      LogFileType.BACKEND,
+      stopError
     );
-    process.exit(1);
-  } else {
-    process.exit(1);
-  }
+  }).finally(() => process.exit(1));
 });