local-operator-ui 0.23.0 → 0.23.2

package/out/main/index.js

@@ -13,6 +13,8 @@ const os = require("node:os");
 const node_util = require("node:util");
 const dotenv = require("dotenv");
 const electronLog = require("electron-log");
+const promises = require("node:fs/promises");
+const node_net = require("node:net");
 const node_http = require("node:http");
 const https = require("node:https");
 const electronUpdater = require("electron-updater");
@@ -55,6 +57,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 +158,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 +182,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 +193,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 +701,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 +712,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":
@@ -1528,83 +1550,97 @@ function pythonBytecodeCacheDir(userDataDir) {
 }
 function withPythonBytecodeCache(env, userDataDir) {
   const existing = env.PYTHONPYCACHEPREFIX?.trim();
-  if (existing && !insideAppBundle(existing)) return { ...env };
-  return { ...env, PYTHONPYCACHEPREFIX: pythonBytecodeCacheDir(userDataDir) };
-}
-const BUNDLED_PYTHON_TREE_NAMES = ["python", "python_aarch64"];
-function bundledPythonTreePaths(resourcesPath) {
-  return BUNDLED_PYTHON_TREE_NAMES.map((name) => path$1.join(resourcesPath, name));
-}
-const FIND = "/usr/bin/find";
-const CHMOD = "/bin/chmod";
-const DIRECTORY_ACE = "everyone deny add_file,add_subdirectory";
-const BYTECODE_ACE = "everyone deny write,append";
-const MAX_FIND_OUTPUT_BYTES = 16 * 1024 * 1024;
-const PARTIAL_SEAL_NAMED = 3;
-function describePythonTreeSeal(seal) {
-  if (!seal.supported) {
-    return "Bundled interpreter bytecode seal is macOS-only (there is no code seal to protect elsewhere); the bytecode cache prefix still applies";
-  }
-  const trees = seal.sealed.join(", ") || "(none present)";
-  if (seal.failures.length === 0) {
-    return `Bundled interpreter trees sealed against bytecode writes: ${trees}; ${seal.directories} directory path(s) selected and now refusing new entries, ${seal.bytecodeFiles} bytecode file(s) selected and now refusing rewrites`;
-  }
-  const named = seal.failures.slice(0, PARTIAL_SEAL_NAMED).join("; ");
-  const rest = seal.failures.length - PARTIAL_SEAL_NAMED;
-  return `Bundled interpreter bytecode seal INCOMPLETE: ${trees}; ${seal.directories} directory path(s) and ${seal.bytecodeFiles} bytecode file(s) selected, ${seal.failures.length} refused and left with the access they had - bytecode writes into the bundle are not prevented on every path. First refusals: ${named}${rest > 0 ? ` (+${rest} more)` : ""}`;
-}
-function sealPythonInterpreterTrees(trees) {
-  const result = {
-    sealed: [],
-    directories: 0,
-    bytecodeFiles: 0,
-    failures: [],
-    supported: process.platform === "darwin"
+  const prefix = existing && !insideAppBundle(existing) ? existing : pythonBytecodeCacheDir(userDataDir);
+  return {
+    ...env,
+    PYTHONPYCACHEPREFIX: prefix,
+    PYTHONDONTWRITEBYTECODE: "1"
   };
-  if (!result.supported) return result;
-  for (const tree of trees) {
-    let root;
-    try {
-      root = fs.lstatSync(tree);
-    } catch {
-      continue;
+}
+const VENV_BYTECODE_GUARD_FILE = "sitecustomize.py";
+const VENV_BYTECODE_GUARD_SENTINEL = "# Local Operator bytecode guard";
+function venvBytecodeGuardSource() {
+  return `${VENV_BYTECODE_GUARD_SENTINEL}. Do not edit; the app rewrites this file.
+#
+# Why this file exists: this virtual environment is built on the interpreter
+# inside the Local Operator application bundle (see pyvenv.cfg), so every module
+# this python imports has its source - and CPython's bytecode cache for it -
+# inside a code-sealed .app. A __pycache__/*.pyc written there changes a sealed
+# resource, and macOS then answers "the app is damaged" on the next launch and
+# Squirrel refuses the next in-place update with -67028
+# errSecCSBadBundleFormat.
+#
+# PYTHONDONTWRITEBYTECODE and PYTHONPYCACHEPREFIX reach only the processes the
+# app started or that inherited its environment. This file reaches every process
+# that uses this environment, including one started by a shell, a script or
+# launchd, because site.py imports sitecustomize from site-packages on every
+# start.
+#
+# The cost, stated rather than hidden: a process under this flag compiles its
+# imports and caches nothing, so the backend recompiles its import graph on each
+# start. That is the deliberate trade against an application bundle that macOS
+# refuses to open, and it is confined to this venv.
+import sys
+
+sys.dont_write_bytecode = True
+`;
+}
+function venvSitePackages(venvPath) {
+  const candidates = [path$1.join(venvPath, "Lib", "site-packages")];
+  try {
+    for (const entry of fs.readdirSync(path$1.join(venvPath, "lib"))) {
+      if (entry.startsWith("python")) {
+        candidates.push(path$1.join(venvPath, "lib", entry, "site-packages"));
+      }
     }
-    if (!root.isDirectory()) continue;
-    result.sealed.push(tree);
-    result.directories += applyAce(
-      tree,
-      ["-type", "d"],
-      DIRECTORY_ACE,
-      result.failures
-    );
-    result.bytecodeFiles += applyAce(
-      tree,
-      ["-type", "f", "-name", "*.pyc"],
-      BYTECODE_ACE,
-      result.failures
-    );
+  } catch {
   }
-  return result;
+  return candidates.filter((candidate) => fs.existsSync(candidate));
 }
-function applyAce(tree, selector, ace, failures) {
-  const run = node_child_process.spawnSync(
-    FIND,
-    [tree, ...selector, "-exec", CHMOD, "+a", ace, "{}", "+", "-print0"],
-    { encoding: "buffer", maxBuffer: MAX_FIND_OUTPUT_BYTES }
-  );
-  if (run.error) {
-    failures.push(`${tree}: ${String(run.error)}`);
-    return 0;
+function ensureVenvBytecodeGuard(venvPath) {
+  const dirs = venvSitePackages(venvPath);
+  if (dirs.length === 0) {
+    return {
+      path: null,
+      written: false,
+      reason: `no site-packages under ${venvPath} yet, so there is nothing to guard`
+    };
   }
-  for (const line of String(run.stderr).split("\n")) {
-    if (line.trim().length > 0) failures.push(line.trim());
+  const path2 = path$1.join(dirs[0], VENV_BYTECODE_GUARD_FILE);
+  const source = venvBytecodeGuardSource();
+  let existing = null;
+  try {
+    existing = fs.readFileSync(path2, "utf8");
+  } catch {
   }
-  if (run.status !== 0 && String(run.stderr).trim().length === 0) {
-    failures.push(`${tree}: ${FIND} exited ${run.status} with no explanation`);
+  if (existing === source) {
+    return {
+      path: path2,
+      written: false,
+      reason: `${path2} already refuses bytecode writes`
+    };
   }
-  let selected = 0;
-  for (const byte of run.stdout) if (byte === 0) selected += 1;
-  return selected;
+  if (existing !== null && !existing.startsWith(VENV_BYTECODE_GUARD_SENTINEL)) {
+    return {
+      path: path2,
+      written: false,
+      reason: `${path2} is not ours (no "${VENV_BYTECODE_GUARD_SENTINEL}" line), so it was left exactly as it is`
+    };
+  }
+  try {
+    fs.writeFileSync(path2, source);
+  } catch (error) {
+    return {
+      path: path2,
+      written: false,
+      reason: `could not write ${path2}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  return {
+    path: path2,
+    written: true,
+    reason: `${path2} now sets sys.dont_write_bytecode for every process using this venv`
+  };
 }
 var LogFileType = /* @__PURE__ */ ((LogFileType2) => {
   LogFileType2["INSTALLER"] = "backend-installer.log";
@@ -1828,6 +1864,905 @@ const backendConfig = loadConfig();
 const apiConfig = {
   baseUrl: backendConfig.VITE_LOCAL_OPERATOR_API_URL
 };
+const seedNamespace = "python-runtime-seed";
+const architectures = ["arm64", "x64"];
+const legacyResourceNames = ["python", "python_aarch64"];
+const checkoutSeedNames = { "arm64": "python_aarch64", "x64": "python" };
+const BUNDLED_PYTHON_LAYOUT = {
+  seedNamespace,
+  architectures,
+  legacyResourceNames,
+  checkoutSeedNames
+};
+const execute = node_util.promisify(node_child_process.execFile);
+const APP_BUNDLE_PATH = /\.app(?:\/|$)/i;
+const BYTECODE_EXTENSION = /\.py[co]$/;
+const OTOOL_LOAD_COMMAND = /Load command \d+/;
+const LC_LOAD_COMMAND_KIND = /cmd LC_(?:LOAD|LOAD_WEAK|REEXPORT|LAZY_LOAD|LOAD_UPWARD)_DYLIB\b/;
+const DYLIB_INSTALL_NAME = /\n\s*name (.+?) \(offset/;
+const RUNTIME_ID = /^[a-f0-9]{64}$/;
+const PYVENV_HOME$1 = /^home\s*=\s*(.+)$/m;
+const LOCK_OWNER = /^\s*\d+\s*$/;
+const LEGACY_BUNDLE_PYTHON_PATH = /\.app\/Contents\/Resources\/python(?:_aarch64)?\//;
+const PYTHON_SEED_NAMESPACE = BUNDLED_PYTHON_LAYOUT.seedNamespace;
+const FORMAT = 1;
+const READY = "environment-ready.json";
+const POINTER = "selected-environment.json";
+function inside(root, path2) {
+  const rel = path$1.relative(root, path2);
+  return rel === "" || !rel.startsWith(`..${path$1.sep}`) && rel !== ".." && !path$1.isAbsolute(rel);
+}
+function outsideApp(path2) {
+  if (!path$1.isAbsolute(path2) || APP_BUNDLE_PATH.test(path2)) {
+    throw new Error(
+      `Managed Python must live outside every application bundle: ${path2}`
+    );
+  }
+}
+function realDirectory(path2) {
+  const stat = fs.lstatSync(path2);
+  if (!stat.isDirectory() || stat.isSymbolicLink())
+    throw new Error(`Not a private directory: ${path2}`);
+}
+function isCache(path2) {
+  return path2.split("/").includes("__pycache__") || BYTECODE_EXTENSION.test(path2);
+}
+function runtimeManifest(root, arch, allowCaches = false) {
+  if (!["arm64", "x64"].includes(arch))
+    throw new Error(`Unsupported Python architecture: ${arch}`);
+  realDirectory(root);
+  const realRoot = fs.realpathSync(root);
+  const entries = [
+    { path: ".", mode: fs.lstatSync(root).mode & 511, kind: "directory" }
+  ];
+  function walk(directory) {
+    for (const name of fs.readdirSync(directory).sort()) {
+      const path2 = path$1.join(directory, name);
+      const rel = path$1.relative(root, path2).split(path$1.sep).join("/");
+      if (allowCaches && isCache(rel)) continue;
+      const stat = fs.lstatSync(path2);
+      const mode = stat.mode & 511;
+      if (stat.isSymbolicLink()) {
+        const target2 = fs.readlinkSync(path2);
+        if (path$1.isAbsolute(target2) || !inside(root, path$1.resolve(path$1.dirname(path2), target2)) || !inside(realRoot, fs.realpathSync(path2))) {
+          throw new Error(`Python seed link escapes its runtime: ${rel}`);
+        }
+        entries.push({ path: rel, mode, kind: "symlink", value: target2 });
+      } else if (stat.isDirectory()) {
+        entries.push({ path: rel, mode, kind: "directory" });
+        walk(path2);
+      } else if (stat.isFile() && (allowCaches || stat.nlink === 1)) {
+        entries.push({
+          path: rel,
+          mode,
+          kind: "file",
+          value: node_crypto.createHash("sha256").update(fs.readFileSync(path2)).digest("hex")
+        });
+      } else {
+        throw new Error(
+          `Python seed contains a hardlink or special file: ${rel}`
+        );
+      }
+    }
+  }
+  walk(root);
+  entries.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return { format: FORMAT, platform: "darwin", arch, entries };
+}
+function runtimeId(manifest) {
+  return node_crypto.createHash("sha256").update(JSON.stringify(manifest)).digest("hex");
+}
+function runtimeIdentity(root, arch) {
+  return runtimeId(runtimeManifest(root, arch, true));
+}
+function firstDifference(expected, actual) {
+  const expectedByPath = new Map(expected.entries.map((e) => [e.path, e]));
+  const actualByPath = new Map(actual.entries.map((e) => [e.path, e]));
+  for (const [path2, entry] of expectedByPath) {
+    const other = actualByPath.get(path2);
+    if (!other) return `${path2} is missing`;
+    if (other.kind !== entry.kind)
+      return `${path2} is a ${other.kind}, not a ${entry.kind}`;
+    if ((other.value ?? "") !== (entry.value ?? ""))
+      return `${path2} does not match the seed`;
+  }
+  for (const path2 of actualByPath.keys())
+    if (!expectedByPath.has(path2)) return `${path2} was added`;
+  return "the two trees differ in a way this message cannot name";
+}
+function managedPythonRoot(options) {
+  outsideApp(options.support);
+  return path$1.join(
+    options.support,
+    "managed-python",
+    options.packaged ? "packaged" : "dev"
+  );
+}
+function seedPath(options) {
+  return options.packaged ? path$1.join(options.resources, PYTHON_SEED_NAMESPACE, options.arch) : path$1.join(
+    options.resources,
+    BUNDLED_PYTHON_LAYOUT.checkoutSeedNames[options.arch]
+  );
+}
+function pythonPath(runtime) {
+  return path$1.join(runtime, "bin", "python3");
+}
+async function verifyMachO(root, manifest) {
+  let binaries = 0;
+  for (const entry of manifest.entries) {
+    if (entry.kind !== "file") continue;
+    const path2 = path$1.join(root, entry.path);
+    const fd = fs.openSync(path2, "r");
+    const magic = Buffer.alloc(4);
+    try {
+      fs.readSync(fd, magic, 0, 4, 0);
+    } finally {
+      fs.closeSync(fd);
+    }
+    if (![
+      "cffaedfe",
+      "cefaedfe",
+      "feedfacf",
+      "feedface",
+      "cafebabe",
+      "bebafeca"
+    ].includes(magic.toString("hex")))
+      continue;
+    binaries++;
+    await execute("/usr/bin/codesign", ["--verify", "--strict", path2], {
+      timeout: 3e4
+    });
+    const { stdout } = await execute("/usr/bin/otool", ["-l", path2], {
+      timeout: 3e4
+    });
+    for (const command of stdout.split(OTOOL_LOAD_COMMAND)) {
+      if (!LC_LOAD_COMMAND_KIND.test(command)) continue;
+      const dependency = DYLIB_INSTALL_NAME.exec(command)?.[1];
+      if (dependency && path$1.isAbsolute(dependency) && !dependency.startsWith("/usr/lib/") && !dependency.startsWith("/System/Library/")) {
+        throw new Error(
+          `Python runtime has an external load dependency: ${dependency}`
+        );
+      }
+    }
+  }
+  if (binaries === 0)
+    throw new Error("Python seed contains no signed Mach-O binaries");
+}
+function runtimesRoot(options) {
+  return path$1.join(managedPythonRoot(options), "runtimes");
+}
+function environmentsRoot(options) {
+  return path$1.join(managedPythonRoot(options), "environments");
+}
+function publishedRuntimeIsReusable(options, published) {
+  try {
+    return runtimeIdentity(published.runtime, options.arch) === runtimeIdentity(seedPath(options), options.arch);
+  } catch {
+    return false;
+  }
+}
+const GENERATION_NAME = /^[a-f0-9]{64}-[0-9a-f-]{8,}$/;
+function usableRuntimeGeneration(options, id2) {
+  let names;
+  try {
+    names = fs.readdirSync(runtimesRoot(options));
+  } catch {
+    return null;
+  }
+  for (const name of names.sort()) {
+    if (!name.startsWith(`${id2}-`)) continue;
+    const candidate = path$1.join(runtimesRoot(options), name);
+    try {
+      if (runtimeIdentity(candidate, options.arch) === id2) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function prepareRuntime(options) {
+  const seed = seedPath(options);
+  const manifest = runtimeManifest(seed, options.arch);
+  const id2 = runtimeIdentity(seed, options.arch);
+  const existing = usableRuntimeGeneration(options, id2);
+  if (existing) return { runtime: existing, id: id2 };
+  await verifyMachO(seed, manifest);
+  const root = runtimesRoot(options);
+  await promises.mkdir(root, { recursive: true, mode: 448 });
+  realDirectory(root);
+  if (!inside(fs.realpathSync(managedPythonRoot(options)), fs.realpathSync(root)))
+    throw new Error("Runtime directory escaped its managed root");
+  const runtime = path$1.join(root, `${id2}-${node_crypto.randomUUID()}`);
+  const staging = await promises.mkdtemp(path$1.join(root, ".preparing-"));
+  await execute("/usr/bin/ditto", ["--noacl", seed, staging], {
+    timeout: 12e4
+  });
+  fs.chmodSync(staging, fs.lstatSync(seed).mode & 511);
+  if (runtimeIdentity(staging, options.arch) !== id2)
+    throw new Error("The Python runtime copy did not match its signed seed");
+  for (const entry of manifest.entries) {
+    if (entry.kind !== "file") continue;
+    const source = fs.statSync(path$1.join(seed, entry.path));
+    const copied = fs.statSync(path$1.join(staging, entry.path));
+    if (source.dev === copied.dev && source.ino === copied.ino)
+      throw new Error(`Runtime copy shares a seed inode: ${entry.path}`);
+  }
+  await verifyMachO(staging, manifest);
+  await promises.rename(staging, runtime);
+  return { runtime, id: id2 };
+}
+function describe$1(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function selectionIsWellFormed(root, selection) {
+  return selection.format === FORMAT && RUNTIME_ID.test(selection.runtimeId) && selection.runtime === path$1.join(root, "runtimes", selection.runtimeId);
+}
+function selectionMatchesGeneration(root, selection) {
+  return selection.format === FORMAT && RUNTIME_ID.test(selection.runtimeId) && path$1.dirname(selection.runtime) === path$1.join(root, "runtimes") && GENERATION_NAME.test(path$1.basename(selection.runtime)) && selection.runtime.startsWith(
+    path$1.join(root, "runtimes", `${selection.runtimeId}-`)
+  ) && path$1.dirname(selection.venv) === path$1.join(root, "environments") && selection.venv.startsWith(
+    path$1.join(root, "environments", `${selection.runtimeId}-`)
+  );
+}
+function inspectManagedSelection(options) {
+  const root = managedPythonRoot(options);
+  const pointer = path$1.join(root, POINTER);
+  let raw;
+  try {
+    raw = fs.readFileSync(pointer, "utf8");
+  } catch {
+    return {
+      kind: "unprepared",
+      detail: `No environment is published for this instance (${pointer})`
+    };
+  }
+  let selection;
+  try {
+    selection = JSON.parse(raw);
+  } catch {
+    return {
+      kind: "unprepared",
+      detail: `The published environment pointer is not readable: ${pointer}`
+    };
+  }
+  if (!selectionIsWellFormed(root, selection) && !selectionMatchesGeneration(root, selection))
+    return {
+      kind: "unprepared",
+      detail: `The published environment pointer does not describe a managed environment: ${pointer}`
+    };
+  const missing = (detail) => ({
+    kind: "missing",
+    detail,
+    published: selection
+  });
+  for (const [what, path2] of [
+    ["Python runtime", selection.runtime],
+    ["environment", selection.venv]
+  ]) {
+    try {
+      realDirectory(path2);
+    } catch (error) {
+      return missing(
+        `The selected ${what} is not there any more (${path2}): ${describe$1(error)}`
+      );
+    }
+  }
+  try {
+    const ready = JSON.parse(
+      fs.readFileSync(path$1.join(selection.venv, READY), "utf8")
+    );
+    if (JSON.stringify(ready) !== JSON.stringify(selection))
+      return missing(
+        `The selected environment does not match the record published with it: ${selection.venv}`
+      );
+  } catch (error) {
+    return missing(
+      `The selected environment is not complete (${selection.venv}): ${describe$1(error)}`
+    );
+  }
+  if (!fs.existsSync(path$1.join(selection.venv, "bin", "local-operator")))
+    return missing(
+      `The selected environment has no backend installed: ${selection.venv}`
+    );
+  let home;
+  try {
+    home = PYVENV_HOME$1.exec(
+      fs.readFileSync(path$1.join(selection.venv, "pyvenv.cfg"), "utf8")
+    )?.[1]?.trim();
+  } catch (error) {
+    return missing(
+      `The selected environment has no readable pyvenv.cfg (${selection.venv}): ${describe$1(error)}`
+    );
+  }
+  if (home !== path$1.join(selection.runtime, "bin"))
+    return missing(
+      `The selected environment does not belong to its external Python runtime (${selection.venv} names ${home ?? "no runtime"})`
+    );
+  let identity;
+  try {
+    identity = runtimeIdentity(selection.runtime, options.arch);
+  } catch (error) {
+    return missing(
+      `The selected Python runtime could not be read (${selection.runtime}): ${describe$1(error)}`
+    );
+  }
+  if (identity !== selection.runtimeId) {
+    let reason;
+    try {
+      reason = firstDifference(
+        runtimeManifest(seedPath(options), options.arch, true),
+        runtimeManifest(selection.runtime, options.arch, true)
+      );
+    } catch {
+      reason = "the two trees could not be compared";
+    }
+    return missing(
+      `The selected Python runtime is no longer the runtime that was published (${reason}); a fresh runtime will be published beside it`
+    );
+  }
+  return { kind: "ready", selection };
+}
+function readManagedSelection(options) {
+  const state = inspectManagedSelection(options);
+  return state.kind === "ready" ? state.selection : null;
+}
+async function managedSelectionReady(options) {
+  return inspectManagedSelection(options).kind === "ready";
+}
+const PREPARATION_LOCK_MS = 12e4;
+function reapSupersededGenerations(options, keep, now = Date.now()) {
+  const removed = [];
+  for (const [root, kept] of [
+    [runtimesRoot(options), keep.runtime],
+    [environmentsRoot(options), keep.venv]
+  ]) {
+    let names;
+    try {
+      names = fs.readdirSync(root);
+    } catch {
+      continue;
+    }
+    const survivors = new Set(kept ? [kept] : []);
+    const generations = [];
+    for (const name of names) {
+      const path2 = path$1.join(root, name);
+      if (name.startsWith(".preparing-")) {
+        try {
+          if (now - fs.statSync(path2).mtimeMs < PREPARATION_LOCK_MS) continue;
+          fs.rmSync(path2, { recursive: true, force: true });
+          removed.push(path2);
+        } catch {
+        }
+        continue;
+      }
+      if (!GENERATION_NAME.test(name) || survivors.has(path2)) continue;
+      try {
+        generations.push({ path: path2, mtimeMs: fs.statSync(path2).mtimeMs });
+      } catch {
+      }
+    }
+    generations.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (generations.length > 0) survivors.add(generations[0].path);
+    for (const generation of generations.slice(1)) {
+      try {
+        fs.rmSync(generation.path, { recursive: true, force: true });
+        removed.push(generation.path);
+      } catch {
+      }
+    }
+  }
+  return removed;
+}
+let preparation = Promise.resolve();
+async function locked(root, work) {
+  const previous = preparation;
+  let release = () => {
+  };
+  preparation = new Promise((done) => {
+    release = done;
+  });
+  await previous;
+  const path2 = path$1.join(root, "preparation.lock");
+  let acquired = false;
+  try {
+    await promises.mkdir(root, { recursive: true, mode: 448 });
+    realDirectory(root);
+    outsideApp(fs.realpathSync(root));
+    const deadline2 = Date.now() + PREPARATION_LOCK_MS;
+    while (!acquired) {
+      if (fs.existsSync(path2) && (fs.lstatSync(path2).isSymbolicLink() || !LOCK_OWNER.test(fs.readFileSync(path2, "utf8"))))
+        throw new Error("Unrecognized preparation lock was preserved");
+      try {
+        await execute(
+          "/usr/bin/shlock",
+          ["-p", String(process.pid), "-f", path2],
+          { timeout: 5e3 }
+        );
+        acquired = true;
+      } catch {
+        if (Date.now() >= deadline2)
+          throw new Error(
+            "Another Local Operator instance is preparing its backend. Retry when it finishes."
+          );
+        await new Promise((done) => setTimeout(done, 250));
+      }
+    }
+    return await work();
+  } finally {
+    if (acquired && fs.readFileSync(path2, "utf8").trim() === String(process.pid))
+      fs.unlinkSync(path2);
+    release();
+  }
+}
+const IMPORT_PROBE = `import sys, sysconfig, os, json, encodings, webbrowser, _ssl, _sqlite3
+paths = [sys._base_executable, sys.base_prefix, sysconfig.get_path('stdlib'), encodings.__file__, webbrowser.__file__] + sys.path
+paths += [getattr(m, '__file__', '') for m in (_ssl, _sqlite3)]
+assert all('.app/' not in os.path.realpath(p).lower() for p in paths if p), paths
+print(json.dumps({'base_executable': sys._base_executable, 'base_prefix': sys.base_prefix, 'paths': paths}))`;
+async function smokeEnvironment(venv, env) {
+  const python = path$1.join(venv, "bin", "python");
+  await execute(python, ["-I", "-B", "-c", IMPORT_PROBE], {
+    env,
+    timeout: 3e4
+  });
+  const { stdout: version } = await execute(
+    python,
+    [
+      "-I",
+      "-B",
+      "-c",
+      "import importlib.metadata; print(importlib.metadata.version('local-operator'))"
+    ],
+    { env, timeout: 3e4 }
+  );
+  const home = await promises.mkdtemp(path$1.join(os.tmpdir(), "local-operator-backend-smoke-"));
+  const isolated = withPythonBytecodeCache(
+    {
+      PATH: "/usr/bin:/bin:/usr/sbin:/sbin",
+      HOME: home,
+      TMPDIR: home,
+      LANG: "en_US.UTF-8",
+      TERM: "xterm-256color",
+      LOCAL_OPERATOR_HOME: path$1.join(home, ".local-operator"),
+      LOCAL_OPERATOR_CONFIG_DIR: path$1.join(home, "config"),
+      XDG_CONFIG_HOME: path$1.join(home, "config"),
+      XDG_CACHE_HOME: path$1.join(home, "cache"),
+      XDG_DATA_HOME: path$1.join(home, "data")
+    },
+    home
+  );
+  const socket = node_net.createServer();
+  await new Promise((done, reject) => {
+    socket.once("error", reject);
+    socket.listen(0, "127.0.0.1", done);
+  });
+  const address = socket.address();
+  if (!address || typeof address === "string")
+    throw new Error("Could not allocate backend smoke port");
+  await new Promise((done) => socket.close(() => done()));
+  const child = node_child_process.spawn(
+    path$1.join(venv, "bin", "local-operator"),
+    ["serve", "--host", "127.0.0.1", "--port", String(address.port)],
+    { env: isolated, stdio: "ignore" }
+  );
+  let failed = null;
+  child.on("error", (error) => {
+    failed = error;
+  });
+  try {
+    const deadline2 = Date.now() + 6e4;
+    while (Date.now() < deadline2) {
+      if (failed) throw failed;
+      if (child.exitCode !== null)
+        throw new Error(`Backend smoke exited with ${child.exitCode}`);
+      try {
+        const response = await fetch(
+          `http://127.0.0.1:${address.port}/health`,
+          { signal: AbortSignal.timeout(1e3) }
+        );
+        if (response.ok) return version.trim();
+      } catch {
+      }
+      await new Promise((done) => setTimeout(done, 200));
+    }
+    throw new Error(
+      "The prepared backend did not become healthy; the previous selection was preserved"
+    );
+  } finally {
+    if (child.exitCode === null && child.pid) {
+      child.kill("SIGTERM");
+      await Promise.race([
+        new Promise((done) => child.once("exit", done)),
+        new Promise((done) => setTimeout(done, 5e3))
+      ]);
+      if (child.exitCode === null) child.kill("SIGKILL");
+    }
+  }
+}
+async function prepareManagedPython(options, install) {
+  return locked(managedPythonRoot(options), async () => {
+    const state = inspectManagedSelection(options);
+    if (state.kind === "ready") return state.selection;
+    const superseded = state.kind === "missing" ? state.detail : null;
+    const published = state.kind === "missing" ? state.published : void 0;
+    const root = managedPythonRoot(options);
+    reapSupersededGenerations(options, {
+      runtime: published && publishedRuntimeIsReusable(options, published) ? published.runtime : void 0
+    });
+    const { runtime, id: id2 } = await prepareRuntime(options);
+    await promises.mkdir(environmentsRoot(options), { recursive: true, mode: 448 });
+    realDirectory(environmentsRoot(options));
+    const venv = path$1.join(environmentsRoot(options), `${id2}-${node_crypto.randomUUID()}`);
+    if (!await install(venv, pythonPath(runtime)))
+      throw new Error(
+        "Backend preparation did not complete. Your previous environment and data were preserved."
+      );
+    const env = withPythonBytecodeCache({ ...process.env }, options.support);
+    const backendVersion = await smokeEnvironment(venv, env);
+    const selection = {
+      format: FORMAT,
+      runtimeId: id2,
+      runtime,
+      venv,
+      backendVersion
+    };
+    const bytes = `${JSON.stringify(selection)}
+`;
+    await promises.writeFile(path$1.join(venv, READY), bytes, { flag: "wx", mode: 384 });
+    const temporary = path$1.join(root, `.selection-${node_crypto.randomUUID()}.json`);
+    await promises.writeFile(temporary, bytes, { flag: "wx", mode: 384 });
+    await promises.rename(temporary, path$1.join(root, POINTER));
+    reapSupersededGenerations(options, { runtime, venv });
+    if (superseded)
+      console.warn(
+        `Replaced an unusable managed Python selection: ${superseded}`
+      );
+    return selection;
+  });
+}
+function isLegacyManagedCommand(command, support) {
+  const legacy = [
+    path$1.join(support, "local-operator-venv"),
+    path$1.join(support, "local-operator-venv-dev")
+  ];
+  const candidates = [command];
+  try {
+    candidates.push(fs.realpathSync(command));
+  } catch {
+  }
+  try {
+    candidates.push(fs.readFileSync(command, "utf8").slice(0, 4096));
+  } catch {
+  }
+  return candidates.some(
+    (candidate) => legacy.some((path2) => candidate.includes(`${path2}/`)) || LEGACY_BUNDLE_PYTHON_PATH.test(candidate)
+  );
+}
+const PACKAGED_VENV_DIR_NAME = "local-operator-venv";
+const DEV_VENV_DIR_NAME = "local-operator-venv-dev";
+const NO_SELECTION_DIR_NAME = "no-environment-selected";
+function isUnpreparedVenvPath(path2) {
+  return path2.endsWith(`${path$1.sep}${NO_SELECTION_DIR_NAME}`);
+}
+function managedSupportRoot(home) {
+  return path$1.join(home, "Library", "Application Support", "Local Operator");
+}
+function legacyVenvPaths(support) {
+  return [
+    path$1.join(support, PACKAGED_VENV_DIR_NAME),
+    path$1.join(support, DEV_VENV_DIR_NAME)
+  ];
+}
+const VENV_PATH_ENV = "LOCAL_OPERATOR_VENV_PATH";
+const PYVENV_HOME = /^\s*home\s*=\s*(.+?)\s*$/;
+const BUNDLED_INTERPRETER_HOME = /^(.*?\.app)\/Contents\/Resources\/python(?:_aarch64)?\//;
+function managedVenvPath(input) {
+  const name = input.packaged ? PACKAGED_VENV_DIR_NAME : DEV_VENV_DIR_NAME;
+  if (input.platform === "win32") {
+    return path$1.join(input.appDataPath, name);
+  }
+  if (input.platform === "darwin") {
+    const support = managedSupportRoot(input.home);
+    return readManagedSelection({
+      support,
+      resources: "",
+      packaged: input.packaged,
+      arch: process.arch
+    })?.venv ?? path$1.join(
+      support,
+      "managed-python",
+      input.packaged ? "packaged" : "dev",
+      NO_SELECTION_DIR_NAME
+    );
+  }
+  return path$1.join(input.home, ".config", "local-operator", name);
+}
+function venvInterpreter(venvPath) {
+  let config;
+  try {
+    config = fs.readFileSync(path$1.join(venvPath, "pyvenv.cfg"), "utf8");
+  } catch {
+    return { kind: "none" };
+  }
+  const home = config.split("\n").map((line) => line.match(PYVENV_HOME)).find((match) => match != null)?.[1];
+  if (!home) return { kind: "none" };
+  const resourceMarked = home.match(BUNDLED_INTERPRETER_HOME);
+  if (!resourceMarked) return { kind: "none" };
+  const bundle = resourceMarked[1];
+  return fs.existsSync(bundle) ? { kind: "bundled", bundle } : { kind: "missing", bundle };
+}
+function legacyEnvironmentReport(support) {
+  const lines = [];
+  for (const venv of legacyVenvPaths(support)) {
+    const resolution = venvInterpreter(venv);
+    if (resolution.kind === "none") continue;
+    lines.push(
+      resolution.kind === "missing" ? `The pre-split environment at ${venv} names an interpreter bundle that is not on disk (${resolution.bundle}); it is left exactly as it is.` : `The pre-split environment at ${venv} is built on the interpreter inside ${resolution.bundle}; it is left exactly as it is, and this instance does not use it.`
+    );
+  }
+  return lines;
+}
+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 +2770,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 +2796,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 +2910,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
@@ -1982,24 +2933,12 @@ class BackendServiceManager {
         error
       );
     }
-    if (process.platform === "win32") {
-      this.venvPath = path$1.join(this.appDataPath, "local-operator-venv");
-    } else if (process.platform === "darwin") {
-      this.venvPath = path$1.join(
-        electron.app.getPath("home"),
-        "Library",
-        "Application Support",
-        "Local Operator",
-        "local-operator-venv"
-      );
-    } else {
-      this.venvPath = path$1.join(
-        electron.app.getPath("home"),
-        ".config",
-        "local-operator",
-        "local-operator-venv"
-      );
-    }
+    this.venvPath = managedVenvPath({
+      platform: process.platform,
+      home: electron.app.getPath("home"),
+      appDataPath: this.appDataPath,
+      packaged: electron.app.isPackaged
+    });
     this.loadShellEnvironment();
     logger.info(
       `Backend Service Manager initialized. Disabled: ${this.isDisabled}`,
@@ -2246,8 +3185,28 @@ 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()) {
+        if (process.platform === "darwin" && isLegacyManagedCommand(
+          stdout.trim().split("\n")[0],
+          path$1.join(
+            electron.app.getPath("home"),
+            "Library",
+            "Application Support",
+            "Local Operator"
+          )
+        )) {
+          logger.info(
+            "The PATH command belongs to a legacy managed environment; preparing a separate backend instead",
+            LogFileType.BACKEND
+          );
+          return false;
+        }
         logger.info(
           `local-operator command found at: ${stdout.trim()}`,
           LogFileType.BACKEND
@@ -2374,12 +3333,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 +3365,120 @@ 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
-        );
+      this.venvPath = managedVenvPath({
+        platform: process.platform,
+        home: electron.app.getPath("home"),
+        appDataPath: this.appDataPath,
+        packaged: electron.app.isPackaged
+      });
+      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 +3486,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;
-          }
-          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;
-          }
-        });
-      });
-      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
-          );
-          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.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.`
         );
-        this.process = null;
-        this.isRunning = false;
-        if (this.exitResolve) {
-          this.exitResolve();
-          this.exitResolve = null;
+      }
+    };
+    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;
+        }
+        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);
+        });
+      });
+      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"
+          );
         }
       }
-      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 +3680,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 +3701,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,348 +3751,25 @@ 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;
-  }
-}
-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';
-const macosInstallScriptRaw = `#!/bin/bash
-# Local Operator Backend Installation Script for macOS
-# This script uses the bundled standalone Python and sets up a virtual environment for the Local Operator backend.
-
-set -e  # Exit immediately if a command exits with a non-zero status
-
-# Configuration
-APP_NAME="Local Operator"
-VENV_NAME="local-operator-venv"
-APP_DATA_DIR="$HOME/Library/Application Support/$APP_NAME"
-VENV_PATH="$APP_DATA_DIR/$VENV_NAME"
-LOG_FILE="$APP_DATA_DIR/backend-install.log"
-
-# Keep CPython's bytecode cache out of the application bundle.
-#
-# The bundled interpreter writes __pycache__/*.pyc beside the stdlib sources it
-# imports, and those sources live inside the code-signed .app - which is the
-# build's own extraResource. Every such write is a change to a sealed resource:
-# measured on an installed 0.17.3, \`codesign --verify --deep\` reported 308
-# \`file added:\` violations, all of them .pyc, and ShipIt then refuses the
-# in-place update with -67028 errSecCSBadBundleFormat. A file codesign reports
-# as *added* can be deleted and the seal comes back; a *modified* one cannot,
-# which is why nothing may ship a .pyc at all. The app sets this variable when
-# it spawns us; defaulting it here keeps a standalone run of this script in
-# agreement with the app about where bytecode goes. It is not a complete answer:
-# the app does not spawn every python that runs this interpreter, and a python
-# started by something else - a shell, a CLI script, an agent - has no prefix at
-# all (measured: a venv over this tree wrote 25 .pyc into it that way). The half
-# that covers those is the app's seal on the tree itself
-# (src/main/python-bytecode-cache.ts), which a standalone run of this script does
-# not apply. $HOME is the right place for the cache for the same reason the venv
-# lives there: it is never inside the thing that gets signed and swapped.
-: "\${PYTHONPYCACHEPREFIX:=$APP_DATA_DIR/python-bytecode-cache}"
-export PYTHONPYCACHEPREFIX
-
-# Determine CPU Architecture and Python Directory Name
-ARCH=$(uname -m)
-PYTHON_DIR_NAME="python" # Default for x86_64
-PYTHON_ARCH_NAME="x86_64" # For logging
-
-if [[ "$ARCH" == "x86_64" ]]; then
-  PYTHON_DIR_NAME="python"
-  PYTHON_ARCH_NAME="x86_64"
-elif [[ "$ARCH" == "arm64" ]] || [[ "$ARCH" == "aarch64" ]]; then # arm64 is what uname -m returns on Apple Silicon
-  PYTHON_DIR_NAME="python_aarch64"
-  PYTHON_ARCH_NAME="aarch64"
-else
-  echo "Error: Unsupported CPU architecture: $ARCH"
-  exit 1
-fi
-echo "Detected CPU architecture: $ARCH, using Python directory name: $PYTHON_DIR_NAME"
-
-# Check if PYTHON_BIN is already set by the installer
-if [[ -n "$PYTHON_BIN" ]]; then
-  echo "Using Python executable provided by installer: $PYTHON_BIN"
-else
-  # Get the path to the bundled Python based on architecture
-  # Try multiple possible locations to find Python
-  POSSIBLE_PYTHON_PATHS=(
-    # From environment variable (set by the installer)
-    "$ELECTRON_RESOURCE_PATH/$PYTHON_DIR_NAME/bin/python3"
-    # Absolute paths for packaged app
-    "/Applications/Local Operator.app/Contents/Resources/$PYTHON_DIR_NAME/bin/python3"
-    "$HOME/Applications/Local Operator.app/Contents/Resources/$PYTHON_DIR_NAME/bin/python3"
-    # Development paths
-    "$(dirname "$0")/../../../resources/$PYTHON_DIR_NAME/bin/python3"
-    "$(pwd)/resources/$PYTHON_DIR_NAME/bin/python3"
-    # System Python as last resort (less ideal as it might not be the version we tested with)
-    "/usr/bin/python3"
-  )
-
-  # Find the first Python that exists
-  PYTHON_BIN=""
-  echo "Searching for Python in the following locations for $PYTHON_ARCH_NAME architecture (using directory $PYTHON_DIR_NAME):"
-  for path in "\${POSSIBLE_PYTHON_PATHS[@]}"; do
-    echo "  - Checking $path"
-    if [[ -f "$path" && -x "$path" ]]; then
-      PYTHON_BIN="$path"
-      echo "Found Python at $path"
-      break
-    else
-      echo "    Not found or not executable."
-    fi
-  done
-
-  # If we couldn't find Python, try to use the system Python
-  if [[ -z "$PYTHON_BIN" ]]; then
-    echo "Bundled Python for $PYTHON_ARCH_NAME not found in directory $PYTHON_DIR_NAME. Attempting to use system Python..."
-    if command -v python3 &>/dev/null; then
-      PYTHON_BIN=$(command -v python3)
-      echo "Warning: Using system Python at $PYTHON_BIN. This may lead to unexpected behavior."
-    else
-      echo "Error: Could not find a suitable Python executable. Tried the following paths for $PYTHON_ARCH_NAME (expected in $PYTHON_DIR_NAME):"
-      for path in "\${POSSIBLE_PYTHON_PATHS[@]}"; do
-        echo "  - $path (failed)"
-      done
-      exit 1
-    fi
-  fi
-fi
-
-# Create app data directory if it doesn't exist
-mkdir -p "$APP_DATA_DIR"
-
-# Start logging - capture everything and ensure it's visible to parent process
-exec > >(tee -a "$LOG_FILE") 2> >(tee -a "$LOG_FILE" >&2)
-echo "=============================================="
-echo "$(date): Starting Local Operator backend installation..."
-echo "=============================================="
-echo "Python bin path: $PYTHON_BIN"
-echo "Virtual environment path: $VENV_PATH"
-echo "App data directory: $APP_DATA_DIR"
-echo "Log file: $LOG_FILE"
-echo "=============================================="
-
-# --- FFmpeg Installation ---
-BIN_DIR="$APP_DATA_DIR/bin"
-FFMPEG_BIN="$BIN_DIR/ffmpeg"
-
-echo "Ensuring bin directory exists: $BIN_DIR"
-mkdir -p "$BIN_DIR"
-
-# Check if FFmpeg is already installed and executable
-if [ -f "$FFMPEG_BIN" ] && [ -x "$FFMPEG_BIN" ]; then
-    echo "FFmpeg already installed at $FFMPEG_BIN. Skipping download."
-else
-    echo "FFmpeg not found or not executable. Attempting to download and install FFmpeg..."
-
-    FFMPEG_DOWNLOAD_URL=""
-
-    if [[ "$ARCH" == "x86_64" ]]; then
-        FFMPEG_DOWNLOAD_URL="https://github.com/eugeneware/ffmpeg-static/releases/download/b6.0/ffmpeg-mac-x64"
-    elif [[ "$ARCH" == "arm64" ]] || [[ "$ARCH" == "aarch64" ]]; then
-        FFMPEG_DOWNLOAD_URL="https://github.com/eugeneware/ffmpeg-static/releases/download/b6.0/ffmpeg-mac-arm64"
-    else
-        echo "Error: Unsupported CPU architecture for FFmpeg download: $ARCH"
-        exit 1
-    fi
-
-    echo "Downloading FFmpeg from: $FFMPEG_DOWNLOAD_URL"
-    if curl -L "$FFMPEG_DOWNLOAD_URL" -o "$FFMPEG_BIN"; then
-        echo "FFmpeg downloaded successfully to $FFMPEG_BIN"
-        chmod +x "$FFMPEG_BIN"
-        echo "Set executable permissions for $FFMPEG_BIN"
-    else
-        echo "Error: Failed to download FFmpeg from $FFMPEG_DOWNLOAD_URL"
-        exit 1
-    fi
-
-    # Verify FFmpeg is executable after download
-    if [ ! -f "$FFMPEG_BIN" ] || [ ! -x "$FFMPEG_BIN" ]; then
-        echo "Error: FFmpeg binary not found or not executable after download."
-        exit 1
-    fi
-fi
-
-echo "FFmpeg installation complete. FFmpeg binary is at: $FFMPEG_BIN"
-# --- End FFmpeg Installation ---
-
-# Verify bundled Python exists
-if [ ! -f "$PYTHON_BIN" ]; then
-  echo "Error: Bundled Python not found at $PYTHON_BIN"
-  echo "Please ensure standalone Python is properly installed in the application resources."
-  exit 1
-fi
-
-# Make sure Python binary is executable
-chmod +x "$PYTHON_BIN"
-echo "Using bundled Python: $PYTHON_BIN"
-"$PYTHON_BIN" --version
-
-# Check if Python has venv module available
-echo "Checking for venv module availability..."
-"$PYTHON_BIN" -m venv --help > /dev/null 2>&1 || {
-  echo "ERROR: Python venv module not available in the Python installation"
-  echo "Python details:"
-  "$PYTHON_BIN" --version
-  "$PYTHON_BIN" -c "import sys; print('Prefix:', sys.prefix); print('Exec Prefix:', sys.exec_prefix)"
-  "$PYTHON_BIN" -c "import sys; print('Modules path:'); print('\\n'.join(sys.path))"
-  exit 1
-}
-echo "venv module is available"
-
-# Create virtual environment if it doesn't exist
-if [ ! -d "$VENV_PATH" ]; then
-  echo "Creating virtual environment at $VENV_PATH..."
-  # Remove any potentially corrupted virtual environment
-  if [ -e "$VENV_PATH" ]; then
-    echo "Removing existing but potentially corrupted venv directory..."
-    rm -rf "$VENV_PATH"
-  fi
-  
-  # Make sure parent directory exists and is writable
-  mkdir -p "$(dirname "$VENV_PATH")"
-  
-  # Create the virtual environment with verbosity
-  "$PYTHON_BIN" -m venv "$VENV_PATH" || {
-    echo "ERROR: Failed to create virtual environment. Exit code: $?"
-    echo "Virtual environment path: $VENV_PATH"
-    echo "Python binary used: $PYTHON_BIN"
-    ls -la "$(dirname "$VENV_PATH")"
-    echo "Python executable permissions:"
-    ls -la "$PYTHON_BIN"
-    exit 1
+    })().finally(() => {
+      this.restartPromise = null;
+    });
+    return this.restartPromise;
   }
-  echo "Successfully created virtual environment"
-fi
-
-# Verify the virtual environment structure
-echo "Verifying virtual environment structure..."
-if [ ! -f "$VENV_PATH/bin/python" ] || [ ! -f "$VENV_PATH/bin/pip" ]; then
-  echo "ERROR: Virtual environment is missing critical components"
-  echo "Contents of virtual environment directory:"
-  ls -la "$VENV_PATH"
-  if [ -d "$VENV_PATH/bin" ]; then
-    echo "Contents of bin directory:"
-    ls -la "$VENV_PATH/bin"
-  fi
-  exit 1
-fi
-echo "Virtual environment structure verified"
-
-# Activate virtual environment and install local-operator
-echo "Installing local-operator in virtual environment..."
-source "$VENV_PATH/bin/activate"
-
-echo "Upgrading pip..."
-python -m pip install --upgrade pip || {
-  echo "ERROR: Failed to upgrade pip. Exit code: $?"
-  echo "pip version before failing:"
-  pip --version
-  exit 1
-}
-echo "pip upgrade successful:"
-pip --version
-
-# Check network connectivity to PyPI
-echo "Checking network connectivity to PyPI..."
-curl -s https://pypi.org/pypi/local-operator/json -o /dev/null || {
-  echo "WARNING: Could not reach PyPI. Network connectivity issues might prevent installation."
-  echo "Attempting to ping common domains to diagnose network issues:"
-  ping -c 1 google.com || echo "Cannot ping google.com"
-  ping -c 1 pypi.org || echo "Cannot ping pypi.org"
 }
-
-echo "Installing local-operator package..."
-python -m pip install --upgrade --verbose local-operator || {
-  echo "ERROR: Failed to install local-operator package. Exit code: $?"
-  echo "Python version:"
-  python --version
-  echo "pip version:"
-  pip --version
-  echo "Available pip packages:"
-  pip list
-  echo "Pip config:"
-  pip config list
-  echo "Network diagnosis:"
-  curl -I https://pypi.org || echo "Cannot reach PyPI server"
-  exit 1
-}
-echo "local-operator installation successful"
-
-# Verify installation
-if [ -f "$VENV_PATH/bin/local-operator" ]; then
-  echo "Local Operator backend installed successfully!"
-  
-  # Show more information about the installed binary
-  ls -la "$VENV_PATH/bin/local-operator"
-  file "$VENV_PATH/bin/local-operator"
-  
-  # Try to run the version command with full error output
-  echo "Testing local-operator binary..."
-  "$VENV_PATH/bin/local-operator" --version || {
-    echo "ERROR: local-operator binary exists but failed to execute. Exit code: $?"
-    echo "Binary details:"
-    file "$VENV_PATH/bin/local-operator"
-    echo "Binary permissions:"
-    ls -la "$VENV_PATH/bin/local-operator"
-    echo "Dependencies:"
-    if command -v otool >/dev/null; then
-      otool -L "$VENV_PATH/bin/local-operator" || echo "Could not get dependencies with otool"
-    fi
-    exit 1
-  }
-else
-  echo "Error: Failed to install Local Operator backend. Binary not found."
-  echo "Contents of bin directory:"
-  ls -la "$VENV_PATH/bin/"
-  exit 1
-fi
-
-echo "$(date): Installation completed successfully."
-`;
+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# Which environment this installs into - the app\'s decision, handed in. See the\n# macOS script for why the script must not re-derive it (a packaged and an\n# unpackaged instance use different environments, and only the app knows which\n# it is); `LOCAL_OPERATOR_VENV_PATH` is set from `managedVenvPath`.\n: "${LOCAL_OPERATOR_VENV_PATH:=$VENV_PATH}"\nVENV_PATH="$LOCAL_OPERATOR_VENV_PATH"\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# The refusal half of the pair, set rather than merged with whatever the caller\n# had: CPython reads the flag before its first import, so nothing this script\n# runs - `-m venv`, pip, the venv they create - can write a `__pycache__` at\n# all. Kept in step with the app\'s `withPythonBytecodeCache`, which sets both\n# variables on every python it spawns.\nexport PYTHONDONTWRITEBYTECODE=1\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';
+const macosInstallScriptRaw = '#!/bin/bash\n# Local Operator Backend Installation Script for macOS\n# This script uses the bundled standalone Python and sets up a virtual environment for the Local Operator backend.\n\nset -e  # Exit immediately if a command exits with a non-zero status\n\n# Configuration\nAPP_NAME="Local Operator"\nVENV_NAME="local-operator-venv"\nAPP_DATA_DIR="${LOCAL_OPERATOR_SUPPORT_PATH:-$HOME/Library/Application Support/$APP_NAME}"\nVENV_PATH="$APP_DATA_DIR/$VENV_NAME"\nLOG_FILE="$APP_DATA_DIR/backend-install.log"\n\n# Which environment this installs into. The path is the app\'s decision, not this\n# script\'s: a packaged install and an unpackaged one must not share an\n# environment (the venv is built on whatever interpreter the instance resolves,\n# and the installed bundle\'s stdlib lives inside the code-sealed .app), and only\n# the app knows which one it is. The app passes its answer in\n# (`LOCAL_OPERATOR_VENV_PATH`, set from `managedVenvPath` in\n# src/main/backend/venv-paths.ts).\n#\n# macOS REFUSES a standalone run rather than falling back, and the asymmetry with\n# the Linux and Windows scripts is deliberate. Their default is the packaged name,\n# which is harmless there; here it is the exact environment this split exists to\n# stop a second instance from writing into - the measured failure is a dev-venv\n# interpreter whose stdlib is `/Applications/Local Operator.app/Contents/\n# Resources/python_aarch64`, so a silent default would rebuild that venv and\n# `pip install` into it, which is what R1 of the review caught. A caller that\n# cannot name the environment is a caller that should not be installing into one.\n: "${LOCAL_OPERATOR_VENV_PATH:?Pass the resolved managed environment path (see venv-paths.ts); this script will not guess which instance it belongs to}"\nVENV_PATH="$LOCAL_OPERATOR_VENV_PATH"\n\n# Keep CPython\'s bytecode cache out of the application bundle.\n#\n# The bundled interpreter writes __pycache__/*.pyc beside the stdlib sources it\n# imports, and those sources live inside the code-signed .app - which is the\n# build\'s own extraResource. Every such write is a change to a sealed resource:\n# measured on an installed 0.17.3, `codesign --verify --deep` reported 308\n# `file added:` violations, all of them .pyc, and ShipIt then refuses the\n# in-place update with -67028 errSecCSBadBundleFormat. A file codesign reports\n# as *added* can be deleted and the seal comes back; a *modified* one cannot,\n# which is why nothing may ship a .pyc at all. The app sets this variable when\n# it spawns us; defaulting it here keeps a standalone run of this script in\n# agreement with the app about where bytecode goes. It is not a complete answer:\n# the app does not spawn every python that runs this interpreter, and a python\n# started by something else - a shell, a CLI script, an agent - has no prefix at\n# all (measured: a venv over this tree wrote 25 .pyc into it that way). The half\n# that covers those is the app\'s seal on the tree itself\n# (src/main/python-bytecode-cache.ts), which a standalone run of this script does\n# not apply. $HOME is the right place for the cache for the same reason the venv\n# lives there: it is never inside the thing that gets signed and swapped.\n: "${PYTHONPYCACHEPREFIX:=$APP_DATA_DIR/python-bytecode-cache}"\nexport PYTHONPYCACHEPREFIX\n\n# And the refusal half of the same pair, so a standalone run of this script\n# cannot write bytecode into the bundle even where the redirect above does not\n# apply - a relative or unwritable prefix, or a child that drops the variable.\n# CPython reads the flag before its first import, so this script\'s own\n# `python -m venv`, its pip runs and the venv they create all compile without\n# writing a `__pycache__` anywhere. Measured on CPython: `0` and the empty\n# string are the two falsy spellings, so the value is set rather than merged\n# with whatever the caller had.\nexport PYTHONDONTWRITEBYTECODE=1\n\n# The architecture block that used to live here computed and logged the name of\n# a directory for an in-bundle search this script no longer performs: every run\n# announced which architecture-named directory it was about to use, and then\n# installed from `PYTHON_BIN` anyway - the line stated the opposite of how the\n# script finds Python, and the names it computed were used nowhere else (review\n# N1). Which interpreter to build the environment with is the caller\'s decision,\n# checked immediately below.\n\n# The app prepares a complete external runtime before invoking this script.\n# Searching /Applications here would reintroduce legacy-bundle execution during\n# migration. Standalone callers must make the same explicit path decision.\n: "${PYTHON_BIN:?Pass an external prepared Python executable}"\ncase "$PYTHON_BIN" in\n  *.app/*) echo "Refusing to execute Python inside an application bundle" >&2; exit 1 ;;\nesac\n\n# Create app data directory if it doesn\'t exist\nmkdir -p "$APP_DATA_DIR"\n\n# Start logging - capture everything and ensure it\'s visible to parent process\nexec > >(tee -a "$LOG_FILE") 2> >(tee -a "$LOG_FILE" >&2)\necho "=============================================="\necho "$(date): Starting Local Operator backend installation..."\necho "=============================================="\necho "Python bin path: $PYTHON_BIN"\necho "Virtual environment path: $VENV_PATH"\necho "App data directory: $APP_DATA_DIR"\necho "Log file: $LOG_FILE"\necho "=============================================="\n\n# --- FFmpeg Installation ---\nBIN_DIR="$APP_DATA_DIR/bin"\nFFMPEG_BIN="$BIN_DIR/ffmpeg"\n\necho "Ensuring bin directory exists: $BIN_DIR"\nmkdir -p "$BIN_DIR"\n\n# Check if FFmpeg is already installed and executable\nif [ -f "$FFMPEG_BIN" ] && [ -x "$FFMPEG_BIN" ]; then\n    echo "FFmpeg already installed at $FFMPEG_BIN. Skipping download."\nelse\n    echo "FFmpeg not found or not executable. Attempting to download and install FFmpeg..."\n\n    # The architecture, read here because this URL is the one place left that needs\n    # it: the environment is built on `PYTHON_BIN`, handed in above, so nothing\n    # else in this script derives anything from `uname -m`. The block that used to\n    # compute it at the top of the file was removed with the in-bundle interpreter\n    # search it existed for (review N1) - and that removal took this variable with\n    # it while this block still read it, so `$ARCH` was empty for every caller,\n    # including the app, and any install on a machine without a cached ffmpeg\n    # exited 1 here, before the venv was ever created. Measured: `bash\n    # src/main/backend/scripts/macos-install-script.sh` with `PYTHON_BIN` set stops\n    # on "Unsupported CPU architecture for FFmpeg download:".\n    ARCH=$(uname -m)\n\n    FFMPEG_DOWNLOAD_URL=""\n\n    if [[ "$ARCH" == "x86_64" ]]; then\n        FFMPEG_DOWNLOAD_URL="https://github.com/eugeneware/ffmpeg-static/releases/download/b6.0/ffmpeg-mac-x64"\n    elif [[ "$ARCH" == "arm64" ]] || [[ "$ARCH" == "aarch64" ]]; then\n        FFMPEG_DOWNLOAD_URL="https://github.com/eugeneware/ffmpeg-static/releases/download/b6.0/ffmpeg-mac-arm64"\n    else\n        echo "Error: Unsupported CPU architecture for FFmpeg download: $ARCH"\n        exit 1\n    fi\n\n    echo "Downloading FFmpeg from: $FFMPEG_DOWNLOAD_URL"\n    if curl -L "$FFMPEG_DOWNLOAD_URL" -o "$FFMPEG_BIN"; then\n        echo "FFmpeg downloaded successfully to $FFMPEG_BIN"\n        chmod +x "$FFMPEG_BIN"\n        echo "Set executable permissions for $FFMPEG_BIN"\n    else\n        echo "Error: Failed to download FFmpeg from $FFMPEG_DOWNLOAD_URL"\n        exit 1\n    fi\n\n    # Verify FFmpeg is executable after download\n    if [ ! -f "$FFMPEG_BIN" ] || [ ! -x "$FFMPEG_BIN" ]; then\n        echo "Error: FFmpeg binary not found or not executable after download."\n        exit 1\n    fi\nfi\n\necho "FFmpeg installation complete. FFmpeg binary is at: $FFMPEG_BIN"\n# --- End FFmpeg Installation ---\n\n# Verify bundled Python exists\nif [ ! -f "$PYTHON_BIN" ]; then\n  echo "Error: Bundled Python not found at $PYTHON_BIN"\n  echo "Please ensure standalone Python is properly installed in the application resources."\n  exit 1\nfi\n\n# Make sure Python binary is executable\necho "Using bundled Python: $PYTHON_BIN"\n"$PYTHON_BIN" --version\n\n# Check if Python has venv module available\necho "Checking for venv module availability..."\n"$PYTHON_BIN" -m venv --help > /dev/null 2>&1 || {\n  echo "ERROR: Python venv module not available in the Python installation"\n  echo "Python details:"\n  "$PYTHON_BIN" --version\n  "$PYTHON_BIN" -c "import sys; print(\'Prefix:\', sys.prefix); print(\'Exec Prefix:\', sys.exec_prefix)"\n  "$PYTHON_BIN" -c "import sys; print(\'Modules path:\'); print(\'\\n\'.join(sys.path))"\n  exit 1\n}\necho "venv module is available"\n\n# Create virtual environment if it doesn\'t exist\nif [ ! -d "$VENV_PATH" ]; then\n  echo "Creating virtual environment at $VENV_PATH..."\n  # Never repair a path we did not create. Preparation allocates a fresh final\n  # pathname; a collision is evidence to preserve, not a reason to delete it.\n  if [ -e "$VENV_PATH" ] || [ -L "$VENV_PATH" ]; then\n    echo "Refusing to replace an existing environment path: $VENV_PATH" >&2\n    exit 1\n  fi\n  \n  # Make sure parent directory exists and is writable\n  mkdir -p "$(dirname "$VENV_PATH")"\n  \n  # Create the virtual environment with verbosity\n  "$PYTHON_BIN" -m venv "$VENV_PATH" || {\n    echo "ERROR: Failed to create virtual environment. Exit code: $?"\n    echo "Virtual environment path: $VENV_PATH"\n    echo "Python binary used: $PYTHON_BIN"\n    ls -la "$(dirname "$VENV_PATH")"\n    echo "Python executable permissions:"\n    ls -la "$PYTHON_BIN"\n    exit 1\n  }\n  echo "Successfully created virtual environment"\nfi\n\n# Verify the virtual environment structure\necho "Verifying virtual environment structure..."\nif [ ! -f "$VENV_PATH/bin/python" ] || [ ! -f "$VENV_PATH/bin/pip" ]; then\n  echo "ERROR: Virtual environment is missing critical components"\n  echo "Contents of virtual environment directory:"\n  ls -la "$VENV_PATH"\n  if [ -d "$VENV_PATH/bin" ]; then\n    echo "Contents of bin directory:"\n    ls -la "$VENV_PATH/bin"\n  fi\n  exit 1\nfi\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 "ERROR: Failed to upgrade pip. Exit code: $?"\n  echo "pip version before failing:"\n  pip --version\n  exit 1\n}\necho "pip upgrade successful:"\npip --version\n\n# Check network connectivity to PyPI\necho "Checking network connectivity to PyPI..."\ncurl -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  echo "Attempting to ping common domains to diagnose network issues:"\n  ping -c 1 google.com || echo "Cannot ping google.com"\n  ping -c 1 pypi.org || echo "Cannot ping pypi.org"\n}\n\necho "Installing local-operator package..."\npython -m pip install --upgrade --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  echo "Pip config:"\n  pip config list\n  echo "Network diagnosis:"\n  curl -I https://pypi.org || echo "Cannot reach PyPI server"\n  exit 1\n}\necho "local-operator installation successful"\n\n# Verify installation\nif [ -f "$VENV_PATH/bin/local-operator" ]; then\n  echo "Local Operator backend installed successfully!"\n  \n  # Show more information about the installed binary\n  ls -la "$VENV_PATH/bin/local-operator"\n  file "$VENV_PATH/bin/local-operator"\n  \n  # Try to run the version command with full error output\n  echo "Testing local-operator binary..."\n  "$VENV_PATH/bin/local-operator" --version || {\n    echo "ERROR: local-operator binary exists but failed to execute. Exit code: $?"\n    echo "Binary details:"\n    file "$VENV_PATH/bin/local-operator"\n    echo "Binary permissions:"\n    ls -la "$VENV_PATH/bin/local-operator"\n    echo "Dependencies:"\n    if command -v otool >/dev/null; then\n      otool -L "$VENV_PATH/bin/local-operator" || echo "Could not get dependencies with otool"\n    fi\n    exit 1\n  }\nelse\n  echo "Error: Failed to install Local Operator backend. Binary not found."\n  echo "Contents of bin directory:"\n  ls -la "$VENV_PATH/bin/"\n  exit 1\nfi\n\necho "$(date): Installation completed successfully."\n';
 const windowsInstallScriptRaw = `# Local Operator Backend Installation Script for Windows
 # This script installs pyenv-win, Python 3.12, and sets up a virtual environment for the Local Operator backend.
 
@@ -3237,6 +3782,17 @@ $VenvPath = "$AppDataDir\\\\$VenvName"
 $LogFile = "$AppDataDir\\\\backend-install-shell.log"
 $PyenvDir = "$env:USERPROFILE\\\\.pyenv"
 
+# Which environment this installs into - the app's decision, handed in rather
+# than re-derived. A packaged install and an unpackaged one must not share an
+# environment (the venv is built on whatever interpreter the instance resolves),
+# and only the app knows which it is: LOCAL_OPERATOR_VENV_PATH carries
+# managedVenvPath's answer (src/main/backend/venv-paths.ts). The default above is
+# what a standalone run uses - the packaged name, because that is what every
+# install on a disk today has.
+if ($env:LOCAL_OPERATOR_VENV_PATH) {
+    $VenvPath = $env:LOCAL_OPERATOR_VENV_PATH
+}
+
 # Keep CPython's bytecode cache out of the application directory.
 #
 # Same rule as the macOS script, and stated here for the same reason: an
@@ -3250,6 +3806,11 @@ if (-not $env:PYTHONPYCACHEPREFIX) {
     $env:PYTHONPYCACHEPREFIX = "$AppDataDir\\\\python-bytecode-cache"
 }
 
+# The refusal half of the same pair, kept in step with the app's
+# \`withPythonBytecodeCache\`: CPython reads the flag before its first import, so
+# nothing this script runs can write a __pycache__ at all.
+$env:PYTHONDONTWRITEBYTECODE = "1"
+
 # Create app data directory if it doesn't exist
 if (-not (Test-Path $AppDataDir)) {
     New-Item -ItemType Directory -Path $AppDataDir -Force | Out-Null
@@ -3542,45 +4103,60 @@ try {
 const macosInstallScript = macosInstallScriptRaw;
 const linuxInstallScript = linuxInstallScriptRaw;
 const windowsInstallScript = windowsInstallScriptRaw;
+const SETUP_FAILURE_CAUSES = [
+  [
+    /ENOSPC|No space left|not enough (?:free )?space/i,
+    "This Mac ran out of disk space while setting up the backend. Free some space and retry."
+  ],
+  [
+    /Another Local Operator instance is preparing/i,
+    "Another copy of Local Operator is setting up its backend right now. Retry in a moment."
+  ],
+  [
+    /*
+     * The smoke arm only. `did not complete` used to be in here, and it is the
+     * phrase `prepareManagedPython` throws when the install callback returns
+     * false - a pip or network failure, where nothing was installed at all - so
+     * the user read "The backend was installed but did not start correctly" about
+     * an install that never happened (review round 2, N6). It now falls through
+     * to the generic cause, which is true of it, and the app's own sentence still
+     * follows under `The app recorded:`.
+     */
+    /did not become healthy|Backend smoke|exited with/i,
+    "The backend was installed but did not start correctly."
+  ],
+  [
+    /ENOENT|no such file or directory|could not find|did not match its signed seed/i,
+    "A file the setup needed was missing, which usually means the download or the copy did not finish."
+  ]
+];
+function backendSetupFailureDetail(error, support) {
+  const raw = error instanceof Error ? error.message : String(error);
+  const cause = SETUP_FAILURE_CAUSES.find(([pattern]) => pattern.test(raw))?.[1] ?? "The backend could not be set up on this Mac.";
+  return [
+    `What happened: ${cause}`,
+    `The app recorded: ${raw}`,
+    `Where its environment lives: ${support}/managed-python`
+  ].join("\n\n");
+}
 class BackendInstaller {
   appDataPath = electron.app.getPath("userData");
   venvPath;
   resourcesPath;
   pythonPath = null;
+  preparationWindow = null;
   /**
    * Constructor
    */
   constructor() {
-    if (process.platform === "win32") {
-      this.venvPath = path$1.join(this.appDataPath, "local-operator-venv");
-    } else if (process.platform === "darwin") {
-      this.venvPath = path$1.join(
-        electron.app.getPath("home"),
-        "Library",
-        "Application Support",
-        "Local Operator",
-        "local-operator-venv"
-      );
-    } else {
-      this.venvPath = path$1.join(
-        electron.app.getPath("home"),
-        ".config",
-        "local-operator",
-        "local-operator-venv"
-      );
-    }
-    this.resourcesPath = process.env.NODE_ENV === "development" ? path$1.join(process.cwd(), "resources") : path$1.join(process.resourcesPath);
-    if (electron.app.isPackaged) {
-      const seal = sealPythonInterpreterTrees(
-        bundledPythonTreePaths(process.resourcesPath)
-      );
-      const message = describePythonTreeSeal(seal);
-      if (seal.supported && seal.failures.length > 0) {
-        logger.warn(message, LogFileType.INSTALLER);
-      } else {
-        logger.info(message, LogFileType.INSTALLER);
-      }
-    }
+    this.venvPath = managedVenvPath({
+      platform: process.platform,
+      home: electron.app.getPath("home"),
+      appDataPath: this.appDataPath,
+      packaged: electron.app.isPackaged
+    });
+    this.resourcesPath = !electron.app.isPackaged ? path$1.join(process.cwd(), "resources") : path$1.join(process.resourcesPath);
+    if (process.platform !== "darwin") this.guardVenvBytecode();
     this.pythonPath = this.findPython();
     logger.info(
       `Backend Installer initialized. Virtual environment path: ${this.venvPath}`,
@@ -3597,6 +4173,7 @@ class BackendInstaller {
    * @returns Path to Python executable or null if not found
    */
   findPython() {
+    if (process.platform === "darwin") return null;
     const possibilities = [];
     if (process.arch === "arm64") {
       possibilities.push(
@@ -3639,12 +4216,31 @@ class BackendInstaller {
     );
     return null;
   }
+  /**
+   * Make the app-managed venv refuse bytecode writes for every process that
+   * uses it, whoever started it.
+   *
+   * Logged rather than silent in both directions: a guard that was already
+   * there, one this call wrote, and one that could not be written (no venv yet,
+   * or a `sitecustomize.py` the operator owns) are three different states of the
+   * same guarantee, and the field diagnosis starts from which one this machine
+   * is in. `ensureVenvBytecodeGuard` never replaces a file it did not write.
+   */
+  guardVenvBytecode() {
+    const guard = ensureVenvBytecodeGuard(this.venvPath);
+    logger.info(
+      `Bytecode guard in the app-managed venv: ${guard.reason}`,
+      LogFileType.INSTALLER
+    );
+  }
   /**
    * Check if backend is installed
    * @returns Promise resolving to true if the backend is installed, false otherwise
    */
   async isInstalled() {
     try {
+      if (process.platform === "darwin")
+        return await managedSelectionReady(this.managedOptions());
       if (!fs.existsSync(this.venvPath)) {
         logger.info(
           `Virtual environment not found at ${this.venvPath}`,
@@ -3691,30 +4287,90 @@ class BackendInstaller {
    * Install backend
    * @returns Promise resolving to true if the backend was installed successfully, false otherwise
    */
+  managedOptions() {
+    return {
+      support: path$1.join(
+        electron.app.getPath("home"),
+        "Library",
+        "Application Support",
+        "Local Operator"
+      ),
+      resources: this.resourcesPath,
+      packaged: electron.app.isPackaged,
+      arch: process.arch
+    };
+  }
   async install() {
-    try {
-      const { response } = await electron.dialog.showMessageBox({
-        type: "info",
-        title: "First-Time Setup Required",
-        message: "Local Operator needs to set up some components to work properly. This one-time process will take just a few moments.",
-        buttons: ["Set Up Now", "Cancel"],
-        defaultId: 0,
-        cancelId: 1
-      });
-      if (response === 1) {
-        logger.info(
-          "User cancelled backend installation",
-          LogFileType.INSTALLER
+    if (process.platform !== "darwin") return this.installEnvironment();
+    for (; ; ) {
+      try {
+        const state = inspectManagedSelection(this.managedOptions());
+        if (state.kind === "missing")
+          logger.warn(
+            `Published backend environment is not usable and will be rebuilt: ${state.detail}`,
+            LogFileType.INSTALLER
+          );
+        await prepareManagedPython(
+          this.managedOptions(),
+          async (venv, python) => {
+            this.venvPath = venv;
+            this.pythonPath = python;
+            return this.installEnvironment();
+          }
         );
-        setTimeout(() => {
-          electron.app.exit(0);
-        }, 500);
-        return false;
+        return true;
+      } catch (error) {
+        logger.error(
+          "Backend preparation failed",
+          LogFileType.INSTALLER,
+          error
+        );
+        const { response } = await electron.dialog.showMessageBox({
+          type: "error",
+          title: "Backend setup could not finish",
+          message: "Your existing environment and data were preserved. Retry setup to start this version of Local Operator.",
+          detail: backendSetupFailureDetail(
+            error,
+            this.managedOptions().support
+          ),
+          buttons: ["Retry setup", "Quit"],
+          defaultId: 0,
+          cancelId: 1
+        });
+        if (response !== 0) return false;
+      } finally {
+        if (this.preparationWindow && !this.preparationWindow.isDestroyed())
+          this.preparationWindow.close();
+        this.preparationWindow = null;
+      }
+    }
+  }
+  async installEnvironment() {
+    try {
+      if (process.platform !== "darwin") {
+        const { response } = await electron.dialog.showMessageBox({
+          type: "info",
+          title: "First-Time Setup Required",
+          message: "Local Operator needs to set up some components to work properly. This one-time process will take just a few moments.",
+          buttons: ["Set Up Now", "Cancel"],
+          defaultId: 0,
+          cancelId: 1
+        });
+        if (response === 1) {
+          logger.info(
+            "User cancelled backend installation",
+            LogFileType.INSTALLER
+          );
+          setTimeout(() => {
+            electron.app.exit(0);
+          }, 500);
+          return false;
+        }
       }
       let scriptPath;
       let cmd;
       let args;
-      const tempDir = os.tmpdir();
+      const tempDir = fs.mkdtempSync(path$1.join(os.tmpdir(), "local-operator-install-"));
       if (process.platform === "win32") {
         scriptPath = path$1.join(tempDir, "install-backend-windows.ps1");
         fs.writeFileSync(scriptPath, windowsInstallScript);
@@ -3759,6 +4415,8 @@ class BackendInstaller {
           sandbox: false
         }
       });
+      if (process.platform === "darwin")
+        this.preparationWindow = progressWindow;
       if (utils.is.dev && process.env.ELECTRON_RENDERER_URL) {
         progressWindow.loadURL(
           `${process.env.ELECTRON_RENDERER_URL}/installer`
@@ -3833,6 +4491,13 @@ class BackendInstaller {
         try {
           const env = withPythonBytecodeCache({ ...process.env }, this.appDataPath);
           env.ELECTRON_RESOURCE_PATH = this.resourcesPath;
+          env[VENV_PATH_ENV] = this.venvPath;
+          env.HOME = electron.app.getPath("home");
+          env.LOCAL_OPERATOR_SUPPORT_PATH = process.platform === "darwin" ? this.managedOptions().support : this.appDataPath;
+          logger.info(
+            `Setting ${VENV_PATH_ENV} to ${this.venvPath}`,
+            LogFileType.INSTALLER
+          );
           logger.info(
             `Setting ELECTRON_RESOURCE_PATH to ${this.resourcesPath}`,
             LogFileType.INSTALLER
@@ -3912,7 +4577,7 @@ class BackendInstaller {
       });
       ipcMain.removeListener("cancel-installation", cancelHandler);
       electron.app.removeListener("before-quit", appQuitHandler);
-      if (!progressWindow.isDestroyed()) {
+      if (process.platform !== "darwin" && !progressWindow.isDestroyed()) {
         progressWindow.close();
       }
       if (installationCancelled) {
@@ -3928,6 +4593,7 @@ class BackendInstaller {
           "Backend installation completed successfully",
           LogFileType.INSTALLER
         );
+        this.guardVenvBytecode();
         const localOperatorPath = process.platform === "win32" ? path$1.join(this.venvPath, "Scripts", "local-operator.exe") : path$1.join(this.venvPath, "bin", "local-operator");
         if (!fs.existsSync(localOperatorPath)) {
           logger.error(
@@ -3942,23 +4608,25 @@ class BackendInstaller {
           "Installation verified successfully",
           LogFileType.INSTALLER
         );
-        const { response: successResponse } = await electron.dialog.showMessageBox({
-          type: "info",
-          title: "Setup Complete",
-          message: "Local Operator is ready to use. Everything has been set up successfully.",
-          buttons: ["Let's Go!", "Cancel"],
-          defaultId: 0,
-          cancelId: 1
-        });
-        if (successResponse === 1) {
-          logger.info(
-            "User ended session after successful installation",
-            LogFileType.INSTALLER
-          );
-          setTimeout(() => {
-            electron.app.exit(0);
-          }, 500);
-          return false;
+        if (process.platform !== "darwin") {
+          const { response: successResponse } = await electron.dialog.showMessageBox({
+            type: "info",
+            title: "Setup Complete",
+            message: "Local Operator is ready to use. Everything has been set up successfully.",
+            buttons: ["Let's Go!", "Cancel"],
+            defaultId: 0,
+            cancelId: 1
+          });
+          if (successResponse === 1) {
+            logger.info(
+              "User ended session after successful installation",
+              LogFileType.INSTALLER
+            );
+            setTimeout(() => {
+              electron.app.exit(0);
+            }, 500);
+            return false;
+          }
         }
         await new Promise((resolve) => setTimeout(resolve, 500));
         if (process.platform === "win32") {
@@ -8378,15 +9046,20 @@ ${probe.stderr}`.trim();
     detail: marker ? `${marker}: ${output || "no output"}` : `codesign --verify exited ${probe.exitCode}: ${output || "no output"}`
   };
 }
-function installedBundleSealBlock(appBundlePath, detail, version) {
+function installedBundleSealBlock(appBundlePath, detail, version, context = "update") {
+  const message = context === "startup" ? "This copy of Local Operator did not pass its integrity check, so it can't repair itself." : version ? `This install of Local Operator can't be updated in place, so the update to version ${version} was stopped before the app quit.` : "This install of Local Operator can't be updated in place, so the update was stopped before the app quit.";
   return {
     code: "installed-bundle-not-sealed",
-    message: version ? `This install of Local Operator can't be updated in place, so the update to version ${version} was stopped before the app quit.` : "This install of Local Operator can't be updated in place, so the update was stopped before the app quit.",
+    message,
     remedy: {
       text: "Quit Local Operator, then download a fresh copy and replace the app in Applications.",
       url: DOWNLOAD_PAGE_URL
     },
-    detail: `${appBundlePath}: ${detail}`
+    detail: `${appBundlePath}: ${detail}`,
+    ...context === "startup" ? {
+      heading: "This copy of Local Operator needs replacing",
+      dismissLabel: "Not now"
+    } : {}
   };
 }
 const VIOLATION_LINE = /^file (added|modified|missing):\s*(.+)$/;
@@ -8418,7 +9091,12 @@ function canonicalPath(path2) {
     }
   }
 }
-const BUNDLED_PYTHON_DIRS = ["python", "python_aarch64"];
+const BUNDLED_PYTHON_DIRS = [
+  ...BUNDLED_PYTHON_LAYOUT.legacyResourceNames,
+  ...BUNDLED_PYTHON_LAYOUT.architectures.map(
+    (arch) => `${BUNDLED_PYTHON_LAYOUT.seedNamespace}/${arch}`
+  )
+];
 function isPythonBytecodePath(bundlePath, candidate) {
   const bundle = canonicalPath(bundlePath);
   const path2 = canonicalPath(candidate);
@@ -9379,8 +10057,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;
   }
@@ -9465,7 +10143,7 @@ function resolveGlobalInstallPlan(input) {
     sourceBuild: false
   };
 }
-function buildPipUpgradeCommand(pythonPath) {
+function buildPipUpgradeCommand(pythonPath2) {
   const args = [
     "-m",
     "pip",
@@ -9476,9 +10154,9 @@ function buildPipUpgradeCommand(pythonPath) {
     "local-operator"
   ];
   return {
-    command: pythonPath,
+    command: pythonPath2,
     args,
-    display: `"${pythonPath}" ${args.join(" ")}`
+    display: `"${pythonPath2}" ${args.join(" ")}`
   };
 }
 const PIP_SHOW_VERSION_REGEX = /^Version:\s*(.+)$/m;
@@ -9503,6 +10181,7 @@ const BUNDLE_ID_REGEX = /^[\w.-]+$/;
 const INSTALL_IN_FLIGHT_RECHECK_MS = 1e4;
 const LAUNCHCTL_NOT_LOADED_REGEX = /could not find|no such process/i;
 const SEAL_PROBE_TIMEOUT_MS = 45e3;
+const STARTUP_SEAL_PROBE_DELAY_MS = 15e3;
 function versionSuffix(version) {
   return version ? ` to version ${version}` : "";
 }
@@ -9585,6 +10264,19 @@ class UpdateService {
   /** A failed install detected from the marker on this start, if any. */
   pendingInstallFailure = null;
   installFailureDelivered = false;
+  /**
+   * A refusal this process found at start-up, if any.
+   *
+   * Kept apart from `pendingInstallFailure` because they are different facts with
+   * different remedies - that one is an install that did not finish, this one is a
+   * bundle that can no longer be replaced in place - and both can be true of the
+   * same start. Delivered through the same scheduler shape for the same reason:
+   * the window is loading when this is produced (the service is constructed as
+   * the window is created), and a bare `webContents.send` with no subscriber
+   * still reports success.
+   */
+  pendingInstallBlock = null;
+  installBlockDelivered = false;
   /**
    * An install this process found still running, if any.
    *
@@ -9651,6 +10343,15 @@ class UpdateService {
     electronUpdater.autoUpdater.autoInstallOnAppQuit = false;
     this.setupUpdateEvents();
     this.recoverPendingInstall();
+    const sealProbe = setTimeout(() => {
+      void this.repairReachableBundleSeals().catch((error) => {
+        logger.warn(
+          `Start-up seal check could not run: ${error instanceof Error ? error.message : String(error)}`,
+          LogFileType.UPDATE_SERVICE
+        );
+      });
+    }, STARTUP_SEAL_PROBE_DELAY_MS);
+    sealProbe.unref();
     this.startPeriodicUpdateChecks();
   }
   /**
@@ -9718,13 +10419,32 @@ class UpdateService {
       `Update refused (${block.code}): ${block.detail}`,
       LogFileType.UPDATE_SERVICE
     );
-    this.sendToRenderer("update-install-blocked", {
+    this.sendToRenderer(
+      "update-install-blocked",
+      this.installBlockPayload(block, version ?? null)
+    );
+  }
+  /**
+   * The refusal payload the renderer's panel reads.
+   *
+   * One builder, so a refusal found at start-up and one found by the pre-flight
+   * cannot arrive in two shapes: the renderer keys the heading off `code` and the
+   * remedy off `remedy`, and a field missing in one path is a panel that renders
+   * nothing where the user was told what to do.
+   */
+  installBlockPayload(block, version) {
+    return {
       code: block.code,
-      version: version ?? null,
+      version,
       message: block.message,
       remedy: block.remedy,
-      detail: block.detail
-    });
+      detail: block.detail,
+      // Both optional, and both must travel: the payload is built field by
+      // field, so a copy the main process owns and this builder forgets is a
+      // panel that renders the default heading (design D2, D3).
+      heading: block.heading ?? null,
+      dismissLabel: block.dismissLabel ?? null
+    };
   }
   /**
    * Read the marker a previous run may have left, and act on it.
@@ -9744,6 +10464,14 @@ class UpdateService {
    * alone entirely, and the re-check below reports what really happens to it.
    */
   recoverPendingInstall() {
+    if (!electron.app.isPackaged) {
+      const marker2 = readPendingInstallMarker(this.markerDir());
+      logger.info(
+        marker2 ? `Unpackaged instance: leaving the packaged app's pending install marker for version ${marker2.targetVersion} alone, with its install job and staging tree; this process cannot act on an install of a bundle it is not.` : "Unpackaged instance: no packaged install state to leave alone.",
+        LogFileType.UPDATE_SERVICE
+      );
+      return;
+    }
     const marker = readPendingInstallMarker(this.markerDir());
     const outcome = evaluatePendingInstall({
       marker,
@@ -9956,6 +10684,43 @@ class UpdateService {
       LogFileType.UPDATE_SERVICE
     );
   }
+  /**
+   * Deliver a refusal found at start-up once the renderer can hear it.
+   *
+   * Same shape as the failure's delivery, for the same measured reason: the
+   * refusal is produced while the window is loading (the service is constructed
+   * as the window is created), the panel subscribes from a React effect that can
+   * run after `did-finish-load`, and `sendToRenderer` answers true for a push
+   * that no subscriber saw. Unlike the failure it clears nothing on the way out -
+   * this refusal is not tied to any on-disk state, and the pre-flight's own
+   * direct push (`sendInstallBlock`) stays the path used when the window is
+   * already up.
+   */
+  scheduleInstallBlockDelivery(block) {
+    this.pendingInstallBlock = block;
+    if (this.installBlockDelivered) return;
+    const deliver = () => this.deliverPendingInstallBlock();
+    const webContents = this.mainWindow?.webContents;
+    if (webContents && !webContents.isDestroyed()) {
+      webContents.once("did-finish-load", deliver);
+    }
+    setTimeout(deliver, 5e3);
+  }
+  deliverPendingInstallBlock() {
+    const block = this.pendingInstallBlock;
+    if (!block || this.installBlockDelivered) return;
+    if (!this.sendToRenderer(
+      "update-install-blocked",
+      this.installBlockPayload(block, null)
+    )) {
+      return;
+    }
+    this.installBlockDelivered = true;
+    logger.info(
+      "Reported a start-up refusal to the renderer",
+      LogFileType.UPDATE_SERVICE
+    );
+  }
   /**
    * A substituted answer to "is this app's install job loaded", or null.
    *
@@ -10200,17 +10965,68 @@ class UpdateService {
    * backend. Those writes are `file added:` violations and deleting exactly
    * those files restores the seal (measured; see `healPythonBytecode`), where a
    * bundle broken any other way still gets the reinstall refusal below.
+   *
+   * The probe, the retry and the heal are `readBundleSeal` and `repairBundleSeal`
+   * below, shared with the start-up repair pass: this method is the update-time
+   * policy on top of them (an unanswerable probe proceeds, an unhealable bundle
+   * refuses the install), and it must not grow a second copy of either.
    */
   async probeInstalledBundleSeal(version) {
+    const bundlePath = this.runningBundlePath();
+    if (!bundlePath) return null;
+    const { seal, heal, block } = await this.repairBundleSeal(
+      bundlePath,
+      version
+    );
+    if (seal.kind === "unavailable") {
+      logger.warn(
+        `Seal check could not run twice, continuing with the install: ${seal.detail}`,
+        LogFileType.UPDATE_SERVICE
+      );
+      return null;
+    }
+    if (seal.kind === "sealed") {
+      logger.info(
+        heal ? `Installed bundle sealed again after removing ${heal.removed.length} added bytecode file(s); continuing with the install.` : `Installed bundle passed its seal check: ${bundlePath}`,
+        LogFileType.UPDATE_SERVICE
+      );
+    }
+    return block;
+  }
+  /**
+   * The `.app` this process runs from, or null when it is not a bundle layout.
+   *
+   * Shared by the pre-flight and the start-up repair pass so both ask about the
+   * same bundle, and so the "unpacked or dev run" answer is stated once: not a
+   * bundle we recognise means nothing to verify, and refusing every install
+   * because the path did not parse would be worse than the risk it guards
+   * against.
+   */
+  runningBundlePath() {
     if (process.platform !== "darwin" || !electron.app.isPackaged) return null;
     const bundlePath = appBundleFromExecutable(process.execPath);
     if (!bundlePath) {
       logger.warn(
-        `Could not derive an app bundle from ${process.execPath}; skipping the seal pre-flight.`,
+        `Could not derive an app bundle from ${process.execPath}; skipping the seal checks.`,
         LogFileType.UPDATE_SERVICE
       );
       return null;
     }
+    return bundlePath;
+  }
+  /**
+   * One `codesign --verify` of `bundlePath`, retried once when it could not run.
+   *
+   * The retry lives here rather than at either caller because "did not complete"
+   * is a fact about the probe, not about the install being offered: measured on
+   * macOS 26.5, a 1 GiB bundle answers in 6.1 s warm, and a timeout or a probe
+   * that died silently used to arrive as exit code 1 - which the pre-flight read
+   * as "codesign rejected this bundle" and turned into a permanent reinstall
+   * message (review R5). `probe` is returned beside the verdict because the
+   * heal reads the violations out of the raw stdout, and a second probe for them
+   * would be a second answer about one bundle.
+   */
+  async readBundleSeal(bundlePath) {
     const probeBundle = () => runCommand(
       "/usr/bin/codesign",
       ["--verify", "--deep", "--verbose=2", bundlePath],
@@ -10226,20 +11042,29 @@ class UpdateService {
       probe = await probeBundle();
       seal = evaluateBundleSeal(probe);
     }
-    if (seal.kind === "unavailable") {
-      logger.warn(
-        `Seal check could not run twice, continuing with the install: ${seal.detail}`,
-        LogFileType.UPDATE_SERVICE
-      );
-      return null;
-    }
-    if (seal.kind === "sealed") {
-      logger.info(
-        `Installed bundle passed its seal check: ${bundlePath}`,
-        LogFileType.UPDATE_SERVICE
-      );
-      return null;
-    }
+    return { seal, probe };
+  }
+  /**
+   * Probe the bundle, heal the one break we cause, and probe again.
+   *
+   * The whole mechanism, run identically by the update pre-flight and by the
+   * start-up pass: a sealed bundle is returned untouched, an unsealed one is
+   * healed only when the plan says the break is ours (`planPythonBytecodeHeal`),
+   * and the verdict that follows the heal is a fresh probe rather than an
+   * assumption about what a deletion did. `block` is the refusal to show when the
+   * bundle cannot be put back together, and it carries the version the caller was
+   * asked about (null at start-up, where no update is being offered yet).
+   *
+   * Why start-up also runs this: the break is introduced by the app running, not
+   * by the update, so by the time an install is attempted the bundle may already
+   * have been refused by macOS at launch - measured on 2026-09-14, a bundle
+   * signed at 09:31:53 with one added
+   * `lib/python3.12/__pycache__/webbrowser.cpython-312.pyc` at 10:11:29, and no
+   * packaged instance ever came back to report it.
+   */
+  async repairBundleSeal(bundlePath, version, context = "update") {
+    const { seal, probe } = await this.readBundleSeal(bundlePath);
+    if (seal.kind !== "unsealed") return { seal, heal: null, block: null };
     logger.error(
       `Installed bundle failed its seal check: ${seal.detail}`,
       LogFileType.UPDATE_SERVICE
@@ -10251,28 +11076,117 @@ class UpdateService {
         `Installed bundle is not healable in place: ${heal.reason}`,
         LogFileType.UPDATE_SERVICE
       );
-      return installedBundleSealBlock(bundlePath, seal.detail, version);
+      return {
+        seal,
+        heal,
+        block: installedBundleSealBlock(
+          bundlePath,
+          seal.detail,
+          version,
+          context
+        )
+      };
     }
     logger.info(
       `Removed ${heal.removed.length} bytecode file(s) our own interpreter had written into the sealed bundle: ${heal.reason}. Paths:
 ${heal.removed.join("\n")}`,
       LogFileType.UPDATE_SERVICE
     );
-    const healed = evaluateBundleSeal(await probeBundle());
+    const { probe: healedProbe } = await this.readBundleSeal(bundlePath);
+    const healed = evaluateBundleSeal(healedProbe);
     if (healed.kind === "sealed") {
-      logger.info(
-        `Installed bundle sealed again after removing ${heal.removed.length} added bytecode file(s); continuing with the install.`,
-        LogFileType.UPDATE_SERVICE
-      );
-      return null;
+      return { seal: healed, heal, block: null };
     }
     logger.error(
       `Installed bundle still fails its seal check after healing: ${healed.detail}`,
       LogFileType.UPDATE_SERVICE
     );
-    return installedBundleSealBlock(bundlePath, healed.detail, version);
+    return {
+      seal: healed,
+      heal,
+      block: installedBundleSealBlock(
+        bundlePath,
+        healed.detail,
+        version,
+        context
+      )
+    };
+  }
+  /** Inspect only the app this process runs from. An unpackaged instance must
+   * never traverse, heal, seal or otherwise mutate another installed bundle. */
+  async repairReachableBundleSeals() {
+    this.reportLegacyVenvInterpreters();
+    const running = this.runningBundlePath();
+    if (running) await this.repairRunningBundleSeal(running);
+  }
+  /**
+   * Say what the pre-split environments resolve to, and change nothing.
+   *
+   * An install from before this change has a venv whose `pyvenv.cfg` `home` is
+   * inside an `.app`, and one whose bundle is already gone is a state this
+   * machine has actually been in. Both are reported because they explain the log
+   * a support conversation reads - "this venv belongs to a bundle that is not
+   * here any more" and "this venv is still built on the installed app's
+   * interpreter" are different facts, and silence makes them look like the same
+   * healthy one. Neither is repaired: those environments are left byte-identical,
+   * deliberately, so a rollback to an older build still finds what it built.
+   *
+   * Darwin only, and by construction rather than by choice: what is reported is a
+   * venv built on the interpreter inside a code-sealed `.app`, and no other
+   * platform has one (`BUNDLED_INTERPRETER_HOME` requires the `.app` component).
+   *
+   * It reads `legacyVenvPaths`, NOT `managedVenvPath`. That was the bug: on darwin
+   * `managedVenvPath` answers with the post-split selection venv - whose
+   * `pyvenv.cfg` names the external runtime by construction - or with the
+   * `no-environment-selected` sentinel, so both iterations took the `continue` and
+   * nothing was ever logged for the state this exists to describe (review R7).
+   */
+  reportLegacyVenvInterpreters() {
+    if (process.platform !== "darwin") return;
+    for (const line of legacyEnvironmentReport(
+      managedSupportRoot(electron.app.getPath("home"))
+    ))
+      logger.info(line, LogFileType.UPDATE_SERVICE);
+  }
+  /**
+   * Repair this bundle's seal at start-up, and say so either way.
+   *
+   * What this catches: a bundle that already carries bytecode its own interpreter
+   * wrote after it was signed. macOS refuses such a bundle at launch
+   * ("damaged and can't be opened") and ShipIt refuses the next in-place update
+   * with -67028, so a break found here is repaired before either can happen, and
+   * one that cannot be repaired is reported with the same refusal/remedy panel
+   * the pre-flight uses - the user has to replace the app by hand, and finding
+   * that out at the next update is worse than being told now.
+   *
+   * Nothing is reported when the bundle is sealed, which is every ordinary
+   * start: the log line is the evidence that the pass ran at all.
+   */
+  async repairRunningBundleSeal(bundlePath) {
+    const { seal, heal, block } = await this.repairBundleSeal(
+      bundlePath,
+      null,
+      "startup"
+    );
+    if (seal.kind === "sealed") {
+      logger.info(
+        heal ? `Start-up seal repair: removed ${heal.removed.length} added bytecode file(s) from ${bundlePath}, and the bundle verifies again.` : `Start-up seal check: ${bundlePath} is a sealed code object.`,
+        LogFileType.UPDATE_SERVICE
+      );
+      return;
+    }
+    if (seal.kind === "unavailable") {
+      logger.warn(
+        `Start-up seal check could not run: ${seal.detail}`,
+        LogFileType.UPDATE_SERVICE
+      );
+      return;
+    }
+    if (block) this.scheduleInstallBlockDelivery(block);
   }
-  /** File names the updater's metadata knows this update by. */
+  /**
+   * File names the updater's metadata knows this update by.
+   */
   stagedArtifactCandidates(info) {
     const names = /* @__PURE__ */ new Set();
     if (info?.path) names.add(path$1.basename(info.path));
@@ -10491,86 +11405,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
    */
@@ -10809,6 +11643,13 @@ ${heal.removed.join("\n")}`,
         );
         return false;
       }
+      if (!electron.app.isPackaged) {
+        logger.info(
+          "Refusing to start an update install: this instance is unpackaged, so it is not the bundle an install replaces.",
+          LogFileType.UPDATE_SERVICE
+        );
+        return false;
+      }
       logger.info(
         "Preparing to quit and install the update...",
         LogFileType.UPDATE_SERVICE
@@ -10818,6 +11659,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;
       }
@@ -11440,9 +12290,9 @@ ${heal.removed.join("\n")}`,
    * @returns Promise resolving to true if update was successful, false otherwise
    */
   /** The version the bundled environment has installed, via `pip show`. */
-  async readBundledBackendVersion(pythonPath) {
+  async readBundledBackendVersion(pythonPath2) {
     const probe = await runCommand(
-      pythonPath,
+      pythonPath2,
       ["-m", "pip", "show", "local-operator"],
       { timeoutMs: 12e4, env: this.pythonSpawnEnv() }
     );
@@ -11582,16 +12432,19 @@ ${heal.removed.join("\n")}`,
           LogFileType.UPDATE_SERVICE
         );
       }
-      let pythonPath = "";
+      let pythonPath2 = "";
       const venvPath = this.backendService?.getVenvPath();
       if (venvPath && electron.app.isPackaged) {
         const venvBinDir = process.platform === "win32" ? "Scripts" : "bin";
         const pythonName = process.platform === "win32" ? "python.exe" : "python3";
-        pythonPath = path$1.join(venvPath, venvBinDir, pythonName);
+        pythonPath2 = path$1.join(venvPath, venvBinDir, pythonName);
       }
-      if (!pythonPath || !fs.existsSync(pythonPath)) {
+      if (!pythonPath2 || !fs.existsSync(pythonPath2)) {
         logger.error(
-          `Cannot update the bundled backend: no Python at ${pythonPath || "an unknown path"}`,
+          // `managedVenvPath` answers with a sentinel when no environment has
+          // been published, and "no Python at …/no-environment-selected" sent a
+          // reader to a directory-shaped path that nothing creates (review N3).
+          isUnpreparedVenvPath(venvPath ?? "") ? "Cannot update the bundled backend: no environment has been selected for this instance yet" : `Cannot update the bundled backend: no Python at ${pythonPath2 || "an unknown path"}`,
           LogFileType.UPDATE_SERVICE
         );
         await this.restartBackendAfterFailedUpgrade();
@@ -11601,8 +12454,8 @@ ${heal.removed.join("\n")}`,
         );
         return false;
       }
-      const pip = buildPipUpgradeCommand(pythonPath);
-      const versionBefore = await this.readBundledBackendVersion(pythonPath);
+      const pip = buildPipUpgradeCommand(pythonPath2);
+      const versionBefore = await this.readBundledBackendVersion(pythonPath2);
       logger.info(
         `Executing pip command: ${pip.display}`,
         LogFileType.UPDATE_SERVICE
@@ -11623,7 +12476,7 @@ ${pipRun.stderr.trim()}`,
           LogFileType.UPDATE_SERVICE
         );
       }
-      const versionAfter = await this.readBundledBackendVersion(pythonPath);
+      const versionAfter = await this.readBundledBackendVersion(pythonPath2);
       const upgradeLanded = pipRun.exitCode === 0 && didUpgradeLand({
         before: versionBefore,
         after: versionAfter,
@@ -11649,16 +12502,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 +12535,6 @@ ${pipRun.stderr.trim()}`,
             return false;
           }
         }
-        this.registerBackendShutdown();
       } else {
         logger.error(
           "Failed to restart backend service after update",
@@ -12280,6 +13122,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 +13496,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 +13510,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 +13636,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 +13672,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));
 });