local-operator-ui 0.25.3 → 0.25.5

package/out/main/index.js

@@ -13438,21 +13438,377 @@ function registerDesktopIPC(window, expectedUrl, request, streams, media, notifi
     });
   }
 }
-function presentWindow(window, show) {
+const WINDOW_MODES = ["normal", "headless", "inactive"];
+const WINDOW_MODE_ENV = "LOCAL_OPERATOR_UI_WINDOW_MODE";
+const WINDOW_SIZE_ENV = "LOCAL_OPERATOR_UI_WINDOW_SIZE";
+const WINDOW_MODE_FLAG = "--window-mode";
+const WINDOW_SIZE_FLAG = "--window-size";
+const AGENT_LAUNCH_FLAGS = [
+  "--user-data-dir",
+  "--remote-debugging-port"
+];
+const LAUNCHER_KEEP_ALIVE_ENV = "LOCAL_OPERATOR_UI_HEADLESS_KEEP_ALIVE";
+const LAUNCHER_POLL_INTERVAL_MS = 2e3;
+const LAUNCHER_EXIT_DEADLINE_MS = 1e4;
+const WINDOW_MIN_WIDTH = 800;
+const WINDOW_MIN_HEIGHT = 600;
+const WINDOW_MAX_EDGE = 16384;
+const DEFAULT_WINDOW_WIDTH = 1380;
+const DEFAULT_WINDOW_HEIGHT = 900;
+const WINDOW_BEHAVIOUR = {
+  normal: {
+    show: "focus",
+    focusable: true,
+    backgroundThrottling: true,
+    hideDock: false
+  },
+  inactive: {
+    show: "inactive",
+    focusable: true,
+    backgroundThrottling: false,
+    // Visible on purpose, so it keeps its tile: a run somebody wants to
+    // watch has to be findable in the Dock.
+    hideDock: false
+  },
+  headless: {
+    show: "never",
+    focusable: false,
+    backgroundThrottling: false,
+    hideDock: true
+  }
+};
+function readFlag(argv, name) {
+  let found = false;
+  let valueless = false;
+  let value;
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === name) {
+      const next = argv[index + 1];
+      found = true;
+      if (next === void 0 || next.startsWith("--")) {
+        valueless = true;
+        continue;
+      }
+      value = next;
+      continue;
+    }
+    if (argument.startsWith(`${name}=`)) {
+      found = true;
+      value = argument.slice(name.length + 1);
+    }
+  }
+  return { found, value, valueless };
+}
+function parseWindowMode(value) {
+  if (value === void 0) return null;
+  const normalized = value.trim().toLowerCase();
+  return WINDOW_MODES.includes(normalized) ? normalized : null;
+}
+const WINDOW_SIZE_PATTERN = /^(\d+)\s*[x×]\s*(\d+)$/i;
+function parseWindowSize(value) {
+  if (value === void 0) return null;
+  const match = value.trim().match(WINDOW_SIZE_PATTERN);
+  if (!match) return null;
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (width <= 0 || height <= 0) return null;
+  return { width, height };
+}
+function resolveWindowLaunchPlan(input = {}) {
+  const env = input.env ?? {};
+  const argv = input.argv ?? [];
+  const problems = [];
+  const modeFlag = readFlag(argv, WINDOW_MODE_FLAG);
+  const modeValue = modeFlag.found ? modeFlag.value : env[WINDOW_MODE_ENV];
+  const modeRaw = typeof modeValue === "string" && modeValue.trim() === "" ? void 0 : modeValue;
+  const parsedMode = parseWindowMode(modeRaw);
+  const unnamed = !modeFlag.found && modeRaw === void 0;
+  const agentFlag = unnamed ? AGENT_LAUNCH_FLAGS.find((flag) => readFlag(argv, flag).found) : void 0;
+  const platform = input.platform ?? process.platform;
+  const driven = unnamed && agentFlag === void 0 && input.packaged === false && platform !== "win32" && input.stdinIsTTY !== true && input.stdoutIsTTY !== true;
+  const assumed = agentFlag ? `${agentFlag} marks an agent-driven launch, and no window mode was named` : driven ? "the launch is not a packaged app and has no terminal on either stream, so it is a driven run rather than the operator using the app" : null;
+  if (modeFlag.found && modeFlag.value === void 0) {
+    problems.push(
+      `${WINDOW_MODE_FLAG} needs a value: ${WINDOW_MODES.join("|")}`
+    );
+  } else if (modeFlag.valueless) {
+    problems.push(
+      `${WINDOW_MODE_FLAG} was given with no value; keeping "${modeRaw}"`
+    );
+  } else if (modeValue !== void 0 && modeRaw === void 0) {
+    problems.push(
+      `${modeFlag.found ? WINDOW_MODE_FLAG : WINDOW_MODE_ENV} names no mode (empty value)${assumed ? "" : "; using normal"}`
+    );
+  } else if (parsedMode === null && modeRaw !== void 0) {
+    problems.push(
+      `${modeFlag.found ? WINDOW_MODE_FLAG : WINDOW_MODE_ENV}="${modeRaw}" is not one of ${WINDOW_MODES.join("|")}; using normal`
+    );
+  }
+  const mode = parsedMode ?? (assumed ? "headless" : "normal");
+  const sizeFlag = readFlag(argv, WINDOW_SIZE_FLAG);
+  const sizeRaw = sizeFlag.found ? sizeFlag.value : env[WINDOW_SIZE_ENV];
+  const parsedSize = parseWindowSize(sizeRaw);
+  if (sizeFlag.found && sizeFlag.value === void 0) {
+    problems.push(`${WINDOW_SIZE_FLAG} needs a value: <width>x<height>`);
+  } else if (sizeFlag.valueless) {
+    problems.push(
+      `${WINDOW_SIZE_FLAG} was given with no value; keeping "${String(sizeRaw)}"`
+    );
+  } else if (parsedSize === null && sizeRaw !== void 0) {
+    problems.push(
+      `${sizeFlag.found ? WINDOW_SIZE_FLAG : WINDOW_SIZE_ENV}="${sizeRaw}" is not <width>x<height>; using ${DEFAULT_WINDOW_WIDTH}x${DEFAULT_WINDOW_HEIGHT}`
+    );
+  }
+  const requested = parsedSize ?? {
+    width: DEFAULT_WINDOW_WIDTH,
+    height: DEFAULT_WINDOW_HEIGHT
+  };
+  const width = Math.min(
+    Math.max(requested.width, WINDOW_MIN_WIDTH),
+    WINDOW_MAX_EDGE
+  );
+  const height = Math.min(
+    Math.max(requested.height, WINDOW_MIN_HEIGHT),
+    WINDOW_MAX_EDGE
+  );
+  if (width !== requested.width || height !== requested.height) {
+    problems.push(
+      `window size ${requested.width}x${requested.height} clamped to ${width}x${height} (floor ${WINDOW_MIN_WIDTH}x${WINDOW_MIN_HEIGHT}, ceiling ${WINDOW_MAX_EDGE})`
+    );
+  }
+  return {
+    mode,
+    assumed,
+    ...WINDOW_BEHAVIOUR[mode],
+    width,
+    height,
+    problems
+  };
+}
+const WINDOW_INTENT_KEY = "localOperatorWindowMode";
+function windowIntentPayload(mode, requester = {}) {
+  return {
+    [WINDOW_INTENT_KEY]: {
+      mode,
+      ...requester.pid === void 0 ? {} : { pid: requester.pid },
+      ...requester.cwd === void 0 ? {} : { cwd: requester.cwd }
+    }
+  };
+}
+const MAX_DECLARED_CWD = 200;
+function breaksALine(character) {
+  const point = character.codePointAt(0) ?? 0;
+  return point <= 31 || point === 127 || point >= 128 && point <= 159 || point === 8232 || point === 8233;
+}
+function declaredField(value) {
+  if (typeof value !== "string" || value === "") return void 0;
+  const flat = [...value].map((character) => breaksALine(character) ? " " : character).join("").trim();
+  if (flat === "") return void 0;
+  return flat.length > MAX_DECLARED_CWD ? `${flat.slice(0, MAX_DECLARED_CWD)}...` : flat;
+}
+function readWindowIntent(additionalData) {
+  if (typeof additionalData !== "object" || additionalData === null)
+    return null;
+  const value = additionalData[WINDOW_INTENT_KEY];
+  if (typeof value === "string") {
+    const mode2 = parseWindowMode(value);
+    return mode2 === null ? null : { mode: mode2 };
+  }
+  if (typeof value !== "object" || value === null) return null;
+  const fields = value;
+  const mode = typeof fields.mode === "string" ? parseWindowMode(fields.mode) : null;
+  if (mode === null) return null;
+  return {
+    mode,
+    /*
+     * A pid is a safe integer or it is not a pid. The DECLARED fields are made
+     * safe for a line-oriented log (review round 2, NIT-2): the payload is
+     * whatever the losing process chose to say about itself, and a `cwd` with a
+     * newline in it — legal on POSIX — would forge a second `[window-raise]` line.
+     * Nothing is ever DECIDED from either field, which is why the validation is
+     * about the log rather than about trust.
+     */
+    ...typeof fields.pid === "number" && Number.isSafeInteger(fields.pid) ? { pid: fields.pid } : {},
+    ...declaredField(fields.cwd) === void 0 ? {} : { cwd: declaredField(fields.cwd) }
+  };
+}
+function resolveSecondLaunchShow(input) {
+  const carried = readWindowIntent(input.additionalData);
+  if (carried !== null) return WINDOW_BEHAVIOUR[carried.mode].show;
+  return resolveWindowLaunchPlan({ argv: input.argv ?? [] }).show;
+}
+const KEEP_ALIVE_VALUES = ["1", "true", "yes", "on"];
+function resolveLauncherWatchPlan(input) {
+  const env = input.env ?? {};
+  const keepAlive = (env[LAUNCHER_KEEP_ALIVE_ENV] ?? "").trim().toLowerCase();
+  if (KEEP_ALIVE_VALUES.includes(keepAlive)) {
+    return {
+      watch: false,
+      launcherPid: null,
+      reason: `${LAUNCHER_KEEP_ALIVE_ENV}=${keepAlive} was set, so this run outlives its launcher`
+    };
+  }
+  if (input.mode !== "headless") {
+    return {
+      watch: false,
+      launcherPid: null,
+      reason: `window mode ${input.mode} is not launcher-bound: a person can close it`
+    };
+  }
+  if (!Number.isInteger(input.launcherPid) || input.launcherPid <= 1) {
+    return {
+      watch: false,
+      launcherPid: null,
+      reason: "headless run already detached (no launcher to outlive)"
+    };
+  }
+  return {
+    watch: true,
+    launcherPid: input.launcherPid,
+    reason: `headless run launched by pid ${input.launcherPid}; it quits when that process goes`
+  };
+}
+function describeWindowLaunch(plan, platform = process.platform) {
+  const behaviour = plan.show === "never" ? "window created and never shown" : plan.show === "inactive" ? "window shown without activating the app" : "window shown and focused";
+  const assumption = plan.assumed ? ` (mode assumed: ${plan.assumed})` : "";
+  const extras = [
+    plan.hideDock && platform === "darwin" ? "no Dock tile" : null
+  ].filter((part) => part !== null);
+  const suffix = extras.length === 0 ? "" : `, ${extras.join(", ")}`;
+  return `window mode ${plan.mode}: ${plan.width}x${plan.height}, ${behaviour}, page throttling ${plan.backgroundThrottling ? "on" : "off"}${suffix}${assumption}`;
+}
+const MODE_OF_SHOW = {
+  focus: "normal",
+  inactive: "inactive",
+  never: "headless"
+};
+function requesterFields(context) {
+  const who = context.requester;
+  return [
+    who?.pid === void 0 ? null : `pid=${who.pid}`,
+    who?.cwd === void 0 ? null : `cwd=${who.cwd}`
+  ].filter((field) => field !== null);
+}
+function raiseLine(context, requested, applied) {
+  return [
+    `trigger=${context.trigger}`,
+    `mode=${MODE_OF_SHOW[requested]}`,
+    `requested=${requested}`,
+    ...requesterFields(context),
+    `applied=${applied.join("+")}`
+  ].join(" ");
+}
+function presentWindow(window, show, context) {
   if (show === "never") return;
-  if (window.isMinimized()) window.restore();
-  if (show === "inactive") window.showInactive();
-  else window.show();
+  const applied = [];
+  if (window.isMinimized()) {
+    window.restore();
+    applied.push("restore");
+  }
+  if (show === "inactive") {
+    window.showInactive();
+    applied.push("showInactive");
+  } else {
+    window.show();
+    applied.push("show");
+  }
+  context.report?.(raiseLine(context, show, applied));
+}
+function canCreateWindowFor(show) {
+  return show !== "never";
+}
+const OPERATOR_SHOW = "focus";
+function reportParked(session, context) {
+  reportParkState([session], "parked", context);
+}
+function reportParkState(sessions, applied, context) {
+  context.report?.(
+    [
+      `trigger=${context.trigger}`,
+      `mode=${MODE_OF_SHOW.never}`,
+      "requested=never",
+      `parked=${sessions.join(",")}`,
+      ...requesterFields(context),
+      `applied=${applied}`
+    ].join(" ")
+  );
+}
+function reportParkedDelivered(session, context) {
+  reportParkState([session], "delivered", context);
+}
+function reportParkedLeftWaiting(sessions, context) {
+  reportParkState(sessions, "left+waiting", context);
+}
+function reportParkedEvicted(session, context) {
+  reportParkState([session], "evicted", context);
 }
-function raiseWindow(window, show) {
+function reportParksAtQuit(sessions, report) {
+  report(
+    [
+      "trigger=app-quit",
+      `mode=${MODE_OF_SHOW.never}`,
+      "requested=never",
+      `parked=${sessions.join(",")}`,
+      "applied=dropped+quit"
+    ].join(" ")
+  );
+}
+function raiseWindow(window, show, context) {
   if (show === "never") return;
-  if (window.isMinimized()) window.restore();
+  const applied = [];
   if (show === "inactive") {
+    if (window.isMinimized()) {
+      context.report?.(raiseLine(context, show, ["skipped", "minimised"]));
+      return;
+    }
     window.showInactive();
+    applied.push("showInactive");
+  } else {
+    if (window.isMinimized()) {
+      window.restore();
+      applied.push("restore");
+    }
+    window.show();
+    window.focus();
+    applied.push("show", "focus");
+  }
+  context.report?.(raiseLine(context, show, applied));
+}
+function readSecondLaunchRequest(input) {
+  const commandLine = input.commandLine ?? [];
+  const intent = readWindowIntent(input.additionalData);
+  const requester = {};
+  if (intent?.pid !== void 0) requester.pid = intent.pid;
+  const cwd = intent?.cwd ?? input.workingDirectory;
+  if (cwd !== void 0 && cwd !== "") requester.cwd = cwd;
+  return {
+    session: readOpenSessionArgv(commandLine),
+    show: resolveSecondLaunchShow({
+      argv: commandLine,
+      additionalData: input.additionalData
+    }),
+    requester: Object.keys(requester).length === 0 ? null : requester
+  };
+}
+function applySecondLaunch(request, target2) {
+  if (request.session !== null) {
+    if (target2.openConversation) {
+      target2.openConversation(request.session, request);
+    } else {
+      target2.queue(request.session, request);
+    }
+    return;
+  }
+  if (!target2.window) {
+    if (canCreateWindowFor(request.show)) target2.openWindow?.(request);
     return;
   }
-  window.show();
-  window.focus();
+  raiseWindow(target2.window, request.show, {
+    trigger: "second-instance",
+    requester: request.requester ?? void 0,
+    report: target2.report
+  });
 }
 const NOTIFY_TTL_MS = 10 * 60 * 1e3;
 const MAX_DEDUPE_KEYS = 2048;
@@ -13486,11 +13842,12 @@ const SILENT_HOST = {
 };
 const RENDERER_REPORT_TTL_MS = 45e3;
 class DesktopNotifier {
-  constructor(window, request, windowRaise = "focus", host = SILENT_HOST) {
+  constructor(window, request, windowRaise = "focus", host = SILENT_HOST, raiseReport) {
     this.window = window;
     this.request = request;
     this.windowRaise = windowRaise;
     this.host = host;
+    this.raiseReport = raiseReport;
   }
   delivered = /* @__PURE__ */ new Map();
   /** Last known frontend epoch per session, to key dedupe on owner epoch. */
@@ -14101,7 +14458,10 @@ class DesktopNotifier {
         return;
       }
       target2.webContents.send("desktop-open-conversation", { sessionId: sessionId2 });
-      raiseWindow(target2, this.windowRaise);
+      raiseWindow(target2, this.windowRaise, {
+        trigger: "banner-click",
+        report: this.raiseReport
+      });
     });
     notification.show();
   }
@@ -17144,176 +17504,6 @@ class ViewerRecordPublisher {
     }
   }
 }
-const WINDOW_MODES = ["normal", "headless", "inactive"];
-const WINDOW_MODE_ENV = "LOCAL_OPERATOR_UI_WINDOW_MODE";
-const WINDOW_SIZE_ENV = "LOCAL_OPERATOR_UI_WINDOW_SIZE";
-const WINDOW_MODE_FLAG = "--window-mode";
-const WINDOW_SIZE_FLAG = "--window-size";
-const AGENT_LAUNCH_FLAGS = [
-  "--user-data-dir",
-  "--remote-debugging-port"
-];
-const LAUNCHER_KEEP_ALIVE_ENV = "LOCAL_OPERATOR_UI_HEADLESS_KEEP_ALIVE";
-const LAUNCHER_POLL_INTERVAL_MS = 2e3;
-const LAUNCHER_EXIT_DEADLINE_MS = 1e4;
-const WINDOW_MIN_WIDTH = 800;
-const WINDOW_MIN_HEIGHT = 600;
-const WINDOW_MAX_EDGE = 16384;
-const DEFAULT_WINDOW_WIDTH = 1380;
-const DEFAULT_WINDOW_HEIGHT = 900;
-const WINDOW_BEHAVIOUR = {
-  normal: {
-    show: "focus",
-    focusable: true,
-    backgroundThrottling: true,
-    hideDock: false
-  },
-  inactive: {
-    show: "inactive",
-    focusable: true,
-    backgroundThrottling: false,
-    // Visible on purpose, so it keeps its tile: a run somebody wants to
-    // watch has to be findable in the Dock.
-    hideDock: false
-  },
-  headless: {
-    show: "never",
-    focusable: false,
-    backgroundThrottling: false,
-    hideDock: true
-  }
-};
-function readFlag(argv, name) {
-  for (let index = 0; index < argv.length; index += 1) {
-    const argument = argv[index];
-    if (argument === name) {
-      const next = argv[index + 1];
-      return { found: true, value: next?.startsWith("--") ? void 0 : next };
-    }
-    if (argument.startsWith(`${name}=`)) {
-      return { found: true, value: argument.slice(name.length + 1) };
-    }
-  }
-  return { found: false, value: void 0 };
-}
-function parseWindowMode(value) {
-  if (value === void 0) return null;
-  const normalized = value.trim().toLowerCase();
-  return WINDOW_MODES.includes(normalized) ? normalized : null;
-}
-const WINDOW_SIZE_PATTERN = /^(\d+)\s*[x×]\s*(\d+)$/i;
-function parseWindowSize(value) {
-  if (value === void 0) return null;
-  const match = value.trim().match(WINDOW_SIZE_PATTERN);
-  if (!match) return null;
-  const width = Number(match[1]);
-  const height = Number(match[2]);
-  if (width <= 0 || height <= 0) return null;
-  return { width, height };
-}
-function resolveWindowLaunchPlan(input = {}) {
-  const env = input.env ?? {};
-  const argv = input.argv ?? [];
-  const problems = [];
-  const modeFlag = readFlag(argv, WINDOW_MODE_FLAG);
-  const modeValue = modeFlag.found ? modeFlag.value : env[WINDOW_MODE_ENV];
-  const modeRaw = typeof modeValue === "string" && modeValue.trim() === "" ? void 0 : modeValue;
-  const parsedMode = parseWindowMode(modeRaw);
-  const unnamed = !modeFlag.found && modeRaw === void 0;
-  const agentFlag = unnamed ? AGENT_LAUNCH_FLAGS.find((flag) => readFlag(argv, flag).found) : void 0;
-  const platform = input.platform ?? process.platform;
-  const driven = unnamed && agentFlag === void 0 && input.packaged === false && platform !== "win32" && input.stdinIsTTY !== true && input.stdoutIsTTY !== true;
-  const assumed = agentFlag ? `${agentFlag} marks an agent-driven launch, and no window mode was named` : driven ? "the launch is not a packaged app and has no terminal on either stream, so it is a driven run rather than the operator using the app" : null;
-  if (modeFlag.found && modeFlag.value === void 0) {
-    problems.push(
-      `${WINDOW_MODE_FLAG} needs a value: ${WINDOW_MODES.join("|")}`
-    );
-  } else if (modeValue !== void 0 && modeRaw === void 0) {
-    problems.push(
-      `${modeFlag.found ? WINDOW_MODE_FLAG : WINDOW_MODE_ENV} names no mode (empty value)${assumed ? "" : "; using normal"}`
-    );
-  } else if (parsedMode === null && modeRaw !== void 0) {
-    problems.push(
-      `${modeFlag.found ? WINDOW_MODE_FLAG : WINDOW_MODE_ENV}="${modeRaw}" is not one of ${WINDOW_MODES.join("|")}; using normal`
-    );
-  }
-  const mode = parsedMode ?? (assumed ? "headless" : "normal");
-  const sizeFlag = readFlag(argv, WINDOW_SIZE_FLAG);
-  const sizeRaw = sizeFlag.found ? sizeFlag.value : env[WINDOW_SIZE_ENV];
-  const parsedSize = parseWindowSize(sizeRaw);
-  if (sizeFlag.found && sizeFlag.value === void 0) {
-    problems.push(`${WINDOW_SIZE_FLAG} needs a value: <width>x<height>`);
-  } else if (parsedSize === null && sizeRaw !== void 0) {
-    problems.push(
-      `${sizeFlag.found ? WINDOW_SIZE_FLAG : WINDOW_SIZE_ENV}="${sizeRaw}" is not <width>x<height>; using ${DEFAULT_WINDOW_WIDTH}x${DEFAULT_WINDOW_HEIGHT}`
-    );
-  }
-  const requested = parsedSize ?? {
-    width: DEFAULT_WINDOW_WIDTH,
-    height: DEFAULT_WINDOW_HEIGHT
-  };
-  const width = Math.min(
-    Math.max(requested.width, WINDOW_MIN_WIDTH),
-    WINDOW_MAX_EDGE
-  );
-  const height = Math.min(
-    Math.max(requested.height, WINDOW_MIN_HEIGHT),
-    WINDOW_MAX_EDGE
-  );
-  if (width !== requested.width || height !== requested.height) {
-    problems.push(
-      `window size ${requested.width}x${requested.height} clamped to ${width}x${height} (floor ${WINDOW_MIN_WIDTH}x${WINDOW_MIN_HEIGHT}, ceiling ${WINDOW_MAX_EDGE})`
-    );
-  }
-  return {
-    mode,
-    assumed,
-    ...WINDOW_BEHAVIOUR[mode],
-    width,
-    height,
-    problems
-  };
-}
-const KEEP_ALIVE_VALUES = ["1", "true", "yes", "on"];
-function resolveLauncherWatchPlan(input) {
-  const env = input.env ?? {};
-  const keepAlive = (env[LAUNCHER_KEEP_ALIVE_ENV] ?? "").trim().toLowerCase();
-  if (KEEP_ALIVE_VALUES.includes(keepAlive)) {
-    return {
-      watch: false,
-      launcherPid: null,
-      reason: `${LAUNCHER_KEEP_ALIVE_ENV}=${keepAlive} was set, so this run outlives its launcher`
-    };
-  }
-  if (input.mode !== "headless") {
-    return {
-      watch: false,
-      launcherPid: null,
-      reason: `window mode ${input.mode} is not launcher-bound: a person can close it`
-    };
-  }
-  if (!Number.isInteger(input.launcherPid) || input.launcherPid <= 1) {
-    return {
-      watch: false,
-      launcherPid: null,
-      reason: "headless run already detached (no launcher to outlive)"
-    };
-  }
-  return {
-    watch: true,
-    launcherPid: input.launcherPid,
-    reason: `headless run launched by pid ${input.launcherPid}; it quits when that process goes`
-  };
-}
-function describeWindowLaunch(plan, platform = process.platform) {
-  const behaviour = plan.show === "never" ? "window created and never shown" : plan.show === "inactive" ? "window shown without activating the app" : "window shown and focused";
-  const assumption = plan.assumed ? ` (mode assumed: ${plan.assumed})` : "";
-  const extras = [
-    plan.hideDock && platform === "darwin" ? "no Dock tile" : null
-  ].filter((part) => part !== null);
-  const suffix = extras.length === 0 ? "" : `, ${extras.join(", ")}`;
-  return `window mode ${plan.mode}: ${plan.width}x${plan.height}, ${behaviour}, page throttling ${plan.backgroundThrottling ? "on" : "off"}${suffix}${assumption}`;
-}
 const BASE64_FILE_EXTENSIONS = ["csv", "tsv", "xls", "xlsx", "ods"];
 const resolveUserPath = (filePath, cwd) => {
   if (filePath === "~") return electron.app.getPath("home");
@@ -17349,9 +17539,6 @@ for (const problem of windowLaunch.problems) {
   logger.warn(`[window-mode] ${problem}`, LogFileType.BACKEND);
   console.log(`[window-mode] ${problem}`);
 }
-if (windowLaunch.mode !== "normal") {
-  console.log(`[window-mode] ${describeWindowLaunch(windowLaunch)}`);
-}
 let headlessExitDeadline = null;
 function armHeadlessExitDeadline(why) {
   if (headlessExitDeadline) return;
@@ -17531,7 +17718,11 @@ function createApplicationMenu() {
   const menu = electron.Menu.buildFromTemplate(template);
   electron.Menu.setApplicationMenu(menu);
 }
-function createWindow(initialSession = null, openCatalogue = false) {
+const ownLaunchRequest = () => ({
+  show: windowLaunch.show,
+  trigger: "initial-present"
+});
+function createWindow(initialSession = null, openCatalogue = false, request = ownLaunchRequest()) {
   const mainWindow2 = new electron.BrowserWindow({
     width: windowLaunch.width,
     height: windowLaunch.height,
@@ -17606,15 +17797,23 @@ function createWindow(initialSession = null, openCatalogue = false) {
       ...rendererArgumentFlags(initialSession, openCatalogue)
     }
   });
-  if (initialSession) holdPresentUntilConversation(mainWindow2, initialSession);
+  if (initialSession)
+    holdPresentUntilConversation(mainWindow2, initialSession, request);
   mainWindow2.webContents.on("console-message", (_event, level, message) => {
     if (level < 2) return;
     const write = level >= 3 ? logger.error : logger.warn;
     write.call(logger, `[renderer] ${message}`, LogFileType.BACKEND);
   });
+  let presentHandled = false;
   mainWindow2.on("ready-to-show", () => {
+    if (presentHandled) return;
+    presentHandled = true;
     if (!heldForConversation.has(mainWindow2.id)) {
-      presentWindow(mainWindow2, windowLaunch.show);
+      presentWindow(mainWindow2, request.show, {
+        trigger: request.trigger,
+        requester: request.requester,
+        report: reportRaise
+      });
     }
     if (windowLaunch.mode === "normal") return;
     setTimeout(() => {
@@ -17706,6 +17905,20 @@ const reportBackendFailure = (message, fileType) => {
   }
   electron.dialog.showErrorBox("Backend Error", message);
 };
+const reportRaise = (line) => {
+  logger.info(`[window-raise] ${line}`, LogFileType.BACKEND);
+};
+function describeForwardedLaunch(profile, session) {
+  const named = session === null ? null : `the conversation it named (${session})`;
+  const handed = named === null ? "it named no conversation" : `${named} rides with it`;
+  const effect = windowLaunch.show === "never" ? named === null ? `${handed}, so nothing is waiting to be opened, and it will not raise a window in the meantime` : `${handed}: the app will open it once a window is open, and it will not raise a window in the meantime (up to ${PARKED_LAUNCH_LIMIT} conversations wait; an older one is dropped and logged)` : windowLaunch.show === "inactive" ? `${handed}; the app may order its window forward without activating it` : `${handed}; the app will raise its window`;
+  return `[second-instance] this launch did not start a window of its own: the app already open is the instance answering (profile: ${profile}), and this launch's window mode (${windowLaunch.mode}) was handed to it — ${effect}. Quit that app to start a fresh instance. Exiting.`;
+}
+const secondInstanceRequest = (request) => ({
+  show: request.show,
+  trigger: "second-instance",
+  requester: request.requester ?? void 0
+});
 const devDriverArming = resolveDevDriverArming({
   env: launchEnv,
   windowMode: windowLaunch.mode
@@ -17732,19 +17945,67 @@ function rendererArgumentFlags(initialSession, openCatalogue) {
   ];
   return flags.length > 0 ? { additionalArguments: flags } : {};
 }
-let queuedSession = null;
+const parkedLaunches = [];
+const PARKED_LAUNCH_LIMIT = 16;
+function parkLaunch(session, request) {
+  parkedLaunches.push({ session, request });
+  reportParked(session, {
+    trigger: request.trigger,
+    requester: request.requester,
+    report: reportRaise
+  });
+  if (parkedLaunches.length <= PARKED_LAUNCH_LIMIT) return;
+  const evicted = parkedLaunches.shift();
+  if (evicted) {
+    reportParkedEvicted(evicted.session, {
+      trigger: evicted.request.trigger,
+      requester: evicted.request.requester,
+      report: reportRaise
+    });
+  }
+}
+function claimParkedFor(window, deliver, painted) {
+  const claimed = parkedLaunches.slice(0, parkedLaunches.length);
+  if (claimed.length === 0) return 0;
+  window.webContents.once("did-finish-load", () => {
+    for (const queued of claimed) {
+      const at = parkedLaunches.indexOf(queued);
+      if (at === -1) continue;
+      parkedLaunches.splice(at, 1);
+      reportParkedDelivered(queued.session, {
+        trigger: queued.request.trigger,
+        requester: queued.request.requester,
+        report: reportRaise
+      });
+      if (queued === painted) continue;
+      deliver(queued.session, queued.request);
+    }
+  });
+  window.once("closed", () => {
+    for (const queued of claimed) {
+      if (!parkedLaunches.includes(queued)) continue;
+      reportParkedLeftWaiting([queued.session], {
+        trigger: queued.request.trigger,
+        requester: queued.request.requester,
+        report: reportRaise
+      });
+    }
+  });
+  return claimed.length;
+}
 let viewerRecord = null;
 let viewerEndpoint = null;
 let openConversationInWindow = null;
+let openOwnWindow = null;
 let attachBrowserHostToWindow = null;
 const CONVERSATION_PAINT_FALLBACK_MS = 3e3;
 const heldForConversation = /* @__PURE__ */ new Map();
-function holdPresentUntilConversation(window, session) {
+function holdPresentUntilConversation(window, session, request) {
   const timer = setTimeout(() => {
     releaseHeldWindow(window.id);
   }, CONVERSATION_PAINT_FALLBACK_MS);
   timer.unref?.();
-  heldForConversation.set(window.id, { session, timer });
+  heldForConversation.set(window.id, { session, timer, request });
 }
 function releaseHeldWindow(windowId) {
   const held = heldForConversation.get(windowId);
@@ -17752,7 +18013,13 @@ function releaseHeldWindow(windowId) {
   clearTimeout(held.timer);
   heldForConversation.delete(windowId);
   const window = electron.BrowserWindow.fromId(windowId);
-  if (window && !window.isDestroyed()) presentWindow(window, windowLaunch.show);
+  if (window && !window.isDestroyed()) {
+    presentWindow(window, held.request.show, {
+      trigger: held.request.trigger,
+      requester: held.request.requester,
+      report: reportRaise
+    });
+  }
   return true;
 }
 function releaseHeldWindowFor(session) {
@@ -17780,22 +18047,67 @@ const actualSizeFromEvent = () => {
     mainWindow.webContents.setZoomFactor(1);
   }
 };
-const gotTheLock = electron.app.requestSingleInstanceLock();
+const gotTheLock = electron.app.requestSingleInstanceLock(
+  windowIntentPayload(windowLaunch.mode, {
+    // What the winner's log line names when it acts on this request (UX U2).
+    // Declared by this process about itself, so it is diagnostic only: nothing
+    // here is ever decided from it.
+    pid: process.pid,
+    cwd: process.cwd()
+  })
+);
 if (!gotTheLock) {
   logger.warn("Another instance is already running. Quitting this instance.");
+  console.log(
+    describeForwardedLaunch(
+      electron.app.getPath("userData"),
+      readSecondLaunchRequest({ commandLine: process.argv }).session
+    )
+  );
   electron.app.quit();
 } else {
-  electron.app.on("second-instance", (_event, commandLine) => {
-    const requested = readOpenSessionArgv(commandLine);
-    if (requested) {
-      if (openConversationInWindow) openConversationInWindow(requested);
-      else queuedSession = requested;
-      return;
-    }
-    if (mainWindow) {
-      raiseWindow(mainWindow, windowLaunch.show);
+  if (windowLaunch.mode !== "normal") {
+    console.log(`[window-mode] ${describeWindowLaunch(windowLaunch)}`);
+  }
+  electron.app.on(
+    "second-instance",
+    (_event, commandLine, workingDirectory, additionalData) => {
+      applySecondLaunch(
+        readSecondLaunchRequest({
+          commandLine,
+          additionalData,
+          workingDirectory
+        }),
+        {
+          window: mainWindow,
+          openConversation: openConversationInWindow ? (session, request) => openConversationInWindow?.(
+            session,
+            secondInstanceRequest(request)
+          ) : null,
+          /*
+           * No window, and nothing to deliver to it: a request that may come forward
+           * opens the app's own window, exactly as the app's own launch does. It used
+           * to do nothing at all (`if (!target.window) return`), so the operator
+           * launching the app again while it ran saw nothing appear — and a
+           * conversation parked by a `headless` request was never opened by the
+           * launch that should have opened it. The window this creates consumes
+           * whatever is parked as its initial session.
+           */
+          openWindow: openOwnWindow ? (request) => openOwnWindow?.(secondInstanceRequest(request)) : null,
+          // Parked, not dropped: a second instance can arrive while the first is
+          // still starting, and a discarded id is a click that silently did
+          // nothing — the defect this path exists to remove. The request is parked
+          // WITH it, so the flush cannot re-derive it from argv that is gone, and
+          // the queue holds EVERY parked request rather than the last one
+          // (review round 2, MAJOR-1).
+          queue: (session, request) => {
+            parkLaunch(session, secondInstanceRequest(request));
+          },
+          report: reportRaise
+        }
+      );
     }
-  });
+  );
 }
 electron.app.whenReady().then(async () => {
   utils.electronApp.setAppUserModelId("com.local-operator");
@@ -17857,7 +18169,14 @@ electron.app.whenReady().then(async () => {
       },
       // A banner click with no window recreates one and navigates it. The
       // queue lives in `openSessionInWindow` because window creation does.
-      reopen: (sessionId2) => openSessionInWindow(sessionId2),
+      // A banner click's recreate path: the window it makes is presented as far
+      // as THIS process's launch plan allows, because the click came from inside
+      // this process. The trigger names the click rather than the delivery, so
+      // the log tells the three conversation-carrying requests apart.
+      reopen: (sessionId2) => openSessionInWindow(sessionId2, {
+        show: windowLaunch.show,
+        trigger: "banner-click"
+      }),
       /*
        * The renderer's report that this conversation is on screen. Two
        * consumers, and neither is delivery:
@@ -17872,7 +18191,10 @@ electron.app.whenReady().then(async () => {
         viewerRecord?.noteSession(sessionId2);
         releaseHeldWindowFor(sessionId2);
       }
-    }
+    },
+    // A clicked banner comes forward through this same raise policy, and its
+    // line is what tells that trigger apart from the other four.
+    reportRaise
   );
   backendService.onBackendReady(() => {
     void desktopNotifier.refreshNotificationContract();
@@ -17914,13 +18236,19 @@ electron.app.whenReady().then(async () => {
   const endpoint2 = new ViewerEndpoint(
     {
       resumeSession: async (sessionId2) => {
-        openSessionInWindow(sessionId2);
+        openSessionInWindow(sessionId2, {
+          show: windowLaunch.show,
+          trigger: "viewer-resume"
+        });
         return `showing ${sessionId2}`;
       },
       focusWindow: async () => {
         const window = mainWindow;
         if (window && !window.isDestroyed()) {
-          raiseWindow(window, windowLaunch.show);
+          raiseWindow(window, windowLaunch.show, {
+            trigger: "viewer-focus",
+            report: reportRaise
+          });
           return "raised the window";
         }
         setupMainWindowWithUpdateService();
@@ -18307,9 +18635,19 @@ electron.app.whenReady().then(async () => {
   }
   createApplicationMenu();
   let updateService = null;
-  function setupMainWindowWithUpdateService(initialSession = null, openCatalogue = false) {
-    mainWindow = createWindow(initialSession, openCatalogue);
+  function setupMainWindowWithUpdateService(initialSession = null, openCatalogue = false, request = ownLaunchRequest()) {
+    const parked = initialSession === null && !openCatalogue ? parkedLaunches[0] : void 0;
+    mainWindow = createWindow(
+      parked?.session ?? initialSession,
+      openCatalogue,
+      request
+    );
     const windowId = mainWindow.webContents.id;
+    claimParkedFor(
+      mainWindow,
+      (session, request2) => openSessionInWindow(session, request2),
+      parked
+    );
     if (mainWindow) {
       mainWindow.webContents.on("before-input-event", (event, input) => {
         const isCmdOrCtrl = input.control || input.meta;
@@ -18399,28 +18737,35 @@ electron.app.whenReady().then(async () => {
       );
     }
   }
-  function openSessionInWindow(sessionId2) {
+  function openSessionInWindow(sessionId2, request) {
     const window = mainWindow;
     if (window && !window.isDestroyed()) {
       window.webContents.send("desktop-open-conversation", { sessionId: sessionId2 });
-      raiseWindow(window, windowLaunch.show);
+      raiseWindow(window, request.show, {
+        trigger: request.trigger,
+        requester: request.requester,
+        report: reportRaise
+      });
       return;
     }
-    setupMainWindowWithUpdateService(sessionId2, sessionId2 === null);
+    if (!canCreateWindowFor(request.show)) {
+      if (sessionId2 !== null) parkLaunch(sessionId2, request);
+      return;
+    }
+    setupMainWindowWithUpdateService(sessionId2, sessionId2 === null, request);
   }
   openConversationInWindow = openSessionInWindow;
+  openOwnWindow = (request) => setupMainWindowWithUpdateService(null, false, request);
   attachBrowserHostToWindow = (window) => {
     void startBrowserHostForWindow(window);
   };
   setupMainWindowWithUpdateService(launchSession, launchCatalogue);
-  if (queuedSession) {
-    const queued = queuedSession;
-    queuedSession = null;
-    openSessionInWindow(queued);
-  }
   electron.app.on("activate", () => {
     if (electron.BrowserWindow.getAllWindows().length === 0) {
-      setupMainWindowWithUpdateService();
+      setupMainWindowWithUpdateService(null, false, {
+        show: OPERATOR_SHOW,
+        trigger: "initial-present"
+      });
     }
   });
 }).catch((error) => {
@@ -18501,6 +18846,12 @@ const holdQuitForSessionCookieSnapshot = createSessionCookieQuitHold({
 electron.app.on("before-quit", async (event) => {
   if (await holdQuitForSessionCookieSnapshot(event)) return;
   logger.info("App is about to quit", LogFileType.BACKEND);
+  if (parkedLaunches.length > 0) {
+    reportParksAtQuit(
+      parkedLaunches.map((parked) => parked.session),
+      reportRaise
+    );
+  }
   if (windowLaunch.mode === "headless") {
     launcherWatch?.stop();
     armHeadlessExitDeadline("the app is quitting");