codex-plus-patcher 0.7.1 → 0.8.0

package/src/core/plugin-audit.js

@@ -40,6 +40,7 @@ function parseArgs(argv) {
     includeNativeOpenProbes: false,
     noProgress: false,
     quiet: false,
+    devInstanceId: "audit",
   };
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
@@ -53,6 +54,7 @@ function parseArgs(argv) {
     else if (arg === "--source-home") args.sourceHome = path.resolve(expandPath(next()));
     else if (arg === "--dev-home") args.devHome = path.resolve(expandPath(next()));
     else if (arg === "--electron-user-data") args.electronUserDataPath = path.resolve(expandPath(next()));
+    else if (arg === "--dev-instance-id") args.devInstanceId = next();
     else if (arg === "--remote-debugging-port" || arg === "--port") args.remoteDebuggingPort = Number(next());
     else if (arg === "--no-apply") args.apply = false;
     else if (arg === "--no-launch") args.launch = false;
@@ -168,6 +170,152 @@ async function findRendererTargetOnPort(port) {
   }
 }
 
+async function waitForMermaidViewerTarget(port, beforeIds = new Set(), timeoutMs = 10000) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError = null;
+  while (Date.now() < deadline) {
+    try {
+      const targets = await getJson(`http://127.0.0.1:${port}/json/list`);
+      const target = targets.find((entry) =>
+        !beforeIds.has(entry.id) &&
+        entry.url?.startsWith("file://") &&
+        entry.url.includes("codex-plus-mermaid-"));
+      if (target) return target;
+    } catch (error) {
+      lastError = error;
+    }
+    await delay(250);
+  }
+  throw new Error(`Timed out waiting for Mermaid viewer target on port ${port}${lastError ? `: ${lastError.message}` : ""}`);
+}
+
+async function verifyMermaidViewerRender(appCdp, port, { Session = CdpSession, timeoutMs = 15000 } = {}) {
+  const beforeTargets = await getJson(`http://127.0.0.1:${port}/json/list`).catch(() => []);
+  const beforeIds = new Set(beforeTargets.map((target) => target.id));
+  await appCdp.evaluate(`(() => {
+    const host = document.createElement("div");
+    host.setAttribute("data-markdown-copy", "code-block");
+    const pre = document.createElement("pre");
+    pre.className = "sr-only";
+    pre.textContent = "graph TD;A-->B";
+    const diagram = document.createElement("div");
+    diagram.setAttribute("data-codex-plus-mermaid-diagram", "");
+    host.append(pre, diagram);
+    document.body.appendChild(host);
+    window.CodexPlus.plugins.get("mermaidFullscreen").exports.openViewer(diagram);
+    setTimeout(() => host.remove(), 1000);
+    return true;
+  })()`);
+  const viewerTarget = await waitForMermaidViewerTarget(port, beforeIds, timeoutMs);
+  const viewer = new Session(viewerTarget.webSocketDebuggerUrl);
+  try {
+    await viewer.connect();
+    await viewer.send("Runtime.enable");
+    const deadline = Date.now() + timeoutMs;
+    let status = null;
+    while (Date.now() < deadline) {
+      status = await viewer.evaluate(`(() => {
+        const svg = document.querySelector("#stage svg");
+        const status = document.getElementById("render-status")?.textContent || "";
+        return {
+          hasSvg: Boolean(svg && svg.outerHTML.length > 1000),
+          status,
+          statusHidden: document.getElementById("render-status")?.hidden ?? null,
+          svgLength: svg?.outerHTML?.length || 0,
+          bodyText: document.body?.innerText?.slice(0, 500) || "",
+        };
+      })()`);
+      if (status.hasSvg && !/Mermaid render failed:/i.test(status.status)) {
+        return {
+          ok: true,
+          url: viewerTarget.url,
+          status: status.status,
+          svgLength: status.svgLength,
+        };
+      }
+      if (/Mermaid render failed:/i.test(status.status) || /Mermaid render failed:/i.test(status.bodyText)) break;
+      await delay(250);
+    }
+    return {
+      ok: false,
+      url: viewerTarget.url,
+      message: status?.status || "Mermaid viewer did not render an SVG",
+      status,
+    };
+  } finally {
+    try {
+      await viewer.send("Page.close");
+    } catch {
+      // The viewer may already be closed.
+    }
+    await viewer.close();
+  }
+}
+
+async function verifyProjectSelectorShortcutKey(cdp, { wait = delay, timeoutMs = 5000 } = {}) {
+  const setup = await cdp.evaluate(`new Promise((resolve) => {
+    document.dispatchEvent(new KeyboardEvent("keydown", { bubbles: true, cancelable: true, key: "Escape" }));
+    const newChatButton = Array.from(document.querySelectorAll("button")).find((button) => {
+      const rect = button.getBoundingClientRect();
+      return rect.width > 0 && rect.height > 0 && (button.innerText || "").includes("New chat");
+    });
+    newChatButton?.click?.();
+    let attempts = 0;
+    const check = () => {
+      const triggerCount = document.querySelectorAll("[data-codex-plus-project-selector-trigger]").length;
+      if (triggerCount > 0 || attempts >= 30) {
+        resolve({ triggerCount, clickedNewChat: Boolean(newChatButton) });
+        return;
+      }
+      attempts += 1;
+      setTimeout(check, 100);
+    };
+    check();
+  })`);
+  if (!setup?.triggerCount) {
+    return { ok: false, ...setup, message: "Project selector shortcut trigger marker is missing from the main composer" };
+  }
+
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "keyDown",
+    key: ".",
+    code: "Period",
+    windowsVirtualKeyCode: 190,
+    nativeVirtualKeyCode: 47,
+    modifiers: 4,
+  });
+  await cdp.send("Input.dispatchKeyEvent", {
+    type: "keyUp",
+    key: ".",
+    code: "Period",
+    windowsVirtualKeyCode: 190,
+    nativeVirtualKeyCode: 47,
+    modifiers: 4,
+  });
+
+  const deadline = Date.now() + timeoutMs;
+  let status = null;
+  while (Date.now() < deadline) {
+    status = await cdp.evaluate(`(() => {
+      const searchInput = document.querySelector("input[placeholder='Search projects']");
+      const menuCount = document.querySelectorAll("[data-radix-menu-content], [data-radix-popper-content-wrapper], [role='menu']").length;
+      return {
+        triggerCount: document.querySelectorAll("[data-codex-plus-project-selector-trigger]").length,
+        menuCount,
+        opened: Boolean(searchInput || menuCount > 0),
+        activePlaceholder: document.activeElement?.getAttribute?.("placeholder") ?? "",
+      };
+    })()`);
+    if (status.opened) {
+      await cdp.send("Input.dispatchKeyEvent", { type: "keyDown", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27, nativeVirtualKeyCode: 53 });
+      await cdp.send("Input.dispatchKeyEvent", { type: "keyUp", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27, nativeVirtualKeyCode: 53 });
+      return { ok: true, ...setup, ...status };
+    }
+    await wait(100);
+  }
+  return { ok: false, ...setup, ...status, message: `Cmd+. did not open the project selector: ${JSON.stringify(status)}` };
+}
+
 function listRunningAuditApps({
   targetApp = DEFAULT_TARGET,
   electronUserDataPath = DEFAULT_ELECTRON_USER_DATA,
@@ -361,16 +509,21 @@ async function waitForAppShellMounted(cdp, timeoutMs = 90000) {
       const root = document.getElementById("root");
       const bodyText = document.body?.innerText?.trim() ?? "";
       const interactiveCount = document.querySelectorAll("button,a,nav,[role=navigation]").length;
+      const hasErrorBoundary = /^Oops, an error has occurred\\b/.test(bodyText);
       return {
         readyState: document.readyState,
         hasRoot: Boolean(root),
         hasStartupLoader: Boolean(document.querySelector("#root .startup-loader")),
+        hasErrorBoundary,
         bodyTextLength: bodyText.length,
         elementCount: document.querySelectorAll("*").length,
         interactiveCount,
         sampleText: bodyText.slice(0, 120),
       };
     })()`);
+    if (lastStatus.hasErrorBoundary) {
+      throw new Error(`Codex app shell rendered error boundary: ${JSON.stringify(lastStatus)}`);
+    }
     if (
       lastStatus.readyState === "complete" &&
       lastStatus.hasRoot &&
@@ -407,10 +560,12 @@ function formatAuditJson(result) {
 }
 
 function formatAuditResult(result, { quiet = false } = {}) {
+  const expectedWarnings = result.expectedWarnings || [];
   if (quiet) {
-    return result.ok
-      ? "All plugin probes passed.\n"
-      : `Plugin audit failed: ${result.failures.length} failures\n`;
+    if (!result.ok) return `Plugin audit failed: ${result.failures.length} failures\n`;
+    return expectedWarnings.length > 0
+      ? "All plugin probes passed with expected warnings.\n"
+      : "All plugin probes passed.\n";
   }
 
   if (!result.ok) {
@@ -440,6 +595,13 @@ function formatAuditResult(result, { quiet = false } = {}) {
       }
       lines.push("");
     }
+    if (expectedWarnings.length > 0) {
+      lines.push("Expected warnings:");
+      for (const warning of expectedWarnings) {
+        lines.push(`  ${warning.plugin || "audit"} ${warning.code || "warning"}: ${warning.message || "expected warning"}`);
+      }
+      lines.push("");
+    }
     lines.push("Re-run with --json for full probe details.");
     return `${lines.join("\n").replace(/\n{3,}/g, "\n\n")}\n`;
   }
@@ -466,11 +628,18 @@ function formatAuditResult(result, { quiet = false } = {}) {
     `Runtime ready: ${runtime.registered ?? result.registeredPlugins?.length ?? 0} registered, ${runtime.started ?? result.startedPlugins?.length ?? 0} started`,
     `App shell: ${appShell.hasStartupLoader === false ? "mounted" : "unknown"}`,
     `Probed ${probeCount} plugins`,
+    `Warnings: ${expectedWarnings.length} expected`,
     `Native open probes: ${result.nativeOpenProbes?.included ? "included" : "skipped"}`,
     `Cleanup: ${cleanupText}`,
     "",
     "All plugin probes passed.",
   );
+  if (expectedWarnings.length > 0) {
+    lines.push("", "Expected warnings:");
+    for (const warning of expectedWarnings) {
+      lines.push(`${warning.plugin || "audit"} ${warning.code || "warning"}: ${warning.message || "expected warning"}`);
+    }
+  }
   return `${lines.join("\n")}\n`;
 }
 
@@ -661,12 +830,16 @@ function pluginAuditExpression({ includeNativeOpenProbes = false } = {}) {
     ];
     const pluginResults = {};
     const failures = [];
+    const expectedWarnings = [];
     const add = (id, ok, details = {}) => {
       pluginResults[id] = { ok, ...details };
       if (!ok) failures.push({ plugin: id, message: details.message || "probe failed", details });
     };
     const fail = (id, error, details = {}) => add(id, false, { message: error?.message || String(error), ...details });
     const pass = (id, details = {}) => add(id, true, details);
+    const warn = (id, code, message, details = {}) => {
+      expectedWarnings.push({ plugin: id, code, message, details });
+    };
     const pluginIds = () => {
       if (typeof window.CodexPlus?.plugins?.list !== "function") {
         throw new Error("CodexPlus.plugins.list is not available");
@@ -721,6 +894,120 @@ function pluginAuditExpression({ includeNativeOpenProbes = false } = {}) {
         evidence,
       };
     };
+    const waitForProjectThreadRows = async (timeoutMs = 45000) => {
+      const startedAt = Date.now();
+      while (Date.now() - startedAt < timeoutMs) {
+        const rows = document.querySelectorAll("[data-app-action-sidebar-project-list-id] [data-app-action-sidebar-thread-row]");
+        if (rows.length > 0) return rows.length;
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+      return 0;
+    };
+    const isTransparentColor = (value) => value === "rgba(0, 0, 0, 0)" || value === "transparent";
+    const waitForMountedProjectComposer = async (expectedAccent, timeoutMs = 20000) => {
+      const startedAt = Date.now();
+      while (Date.now() - startedAt < timeoutMs) {
+        const editor = document.querySelector("[data-codex-composer]");
+        const surface = editor?.closest("[data-codex-plus-user-entry]") || editor?.closest(".composer-surface-chrome");
+        if (surface) {
+          const computed = getComputedStyle(surface);
+          const surfaceAccent = computed.getPropertyValue("--codex-plus-project-accent").trim();
+          if (
+            surface.hasAttribute("data-codex-plus-user-entry") &&
+            surface.hasAttribute("data-codex-plus-project-color") &&
+            surfaceAccent === expectedAccent &&
+            computed.boxShadow !== "none"
+          ) {
+            return {
+              marked: true,
+              projectMarked: true,
+              accent: surfaceAccent,
+              boxShadow: computed.boxShadow,
+            };
+          }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+      }
+      const editor = document.querySelector("[data-codex-composer]");
+      const surface = editor?.closest("[data-codex-plus-user-entry]") || editor?.closest(".composer-surface-chrome");
+      const computed = surface ? getComputedStyle(surface) : null;
+      return {
+        marked: surface?.hasAttribute("data-codex-plus-user-entry") || false,
+        projectMarked: surface?.hasAttribute("data-codex-plus-project-color") || false,
+        accent: computed?.getPropertyValue("--codex-plus-project-accent").trim() || "",
+        boxShadow: computed?.boxShadow || "",
+      };
+    };
+    const composerPermissionPickerStatus = () => {
+      const editor = document.querySelector("[data-codex-composer]");
+      const labels = ["Full access", "Ask for approval", "Approve for me", "Custom"];
+      const normalize = (value) => String(value || "").replace(/\s+/g, " ").trim();
+      const rgb = (value) => {
+        const match = String(value || "").match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+        return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+      };
+      const luminance = (color) => {
+        if (!color) return null;
+        const channel = (value) => {
+          const normalized = value / 255;
+          return normalized <= 0.03928 ? normalized / 12.92 : Math.pow((normalized + 0.055) / 1.055, 2.4);
+        };
+        return 0.2126 * channel(color[0]) + 0.7152 * channel(color[1]) + 0.0722 * channel(color[2]);
+      };
+      const contrast = (foreground, background) => {
+        const fg = luminance(rgb(foreground));
+        const bg = luminance(rgb(background));
+        if (fg == null || bg == null) return null;
+        const lighter = Math.max(fg, bg);
+        const darker = Math.min(fg, bg);
+        return (lighter + 0.05) / (darker + 0.05);
+      };
+      const isTransparent = (value) => {
+        const text = String(value || "").trim();
+        return text === "transparent" || text === "rgba(0, 0, 0, 0)" || /rgba\([^)]*,\s*0\)$/.test(text);
+      };
+      const trigger = Array.from(document.querySelectorAll("button")).find((button) => {
+        const text = normalize(button.textContent);
+        return labels.some((label) => text === label || text.startsWith(`${label} `));
+      });
+      const triggerStyle = trigger ? getComputedStyle(trigger) : null;
+      const surface = editor?.closest("[data-codex-plus-user-entry]");
+      const surfaceStyle = surface ? getComputedStyle(surface) : null;
+      let labelStyle = null;
+      if (trigger) {
+        const walker = document.createTreeWalker(trigger, NodeFilter.SHOW_TEXT);
+        while (walker.nextNode()) {
+          const node = walker.currentNode;
+          if (normalize(node.nodeValue) !== "") {
+            labelStyle = getComputedStyle(node.parentElement);
+            break;
+          }
+        }
+      }
+      const triggerColor = triggerStyle?.color || null;
+      const labelColor = labelStyle?.color || triggerColor;
+      const labelTextFillColor = labelStyle?.webkitTextFillColor || triggerStyle?.webkitTextFillColor || null;
+      const effectiveLabelColor = labelTextFillColor && !isTransparent(labelTextFillColor) ? labelTextFillColor : labelColor;
+      const surfaceBackground = surfaceStyle?.backgroundColor || null;
+      return {
+        editorMounted: Boolean(editor),
+        editorEditable: editor?.getAttribute("contenteditable") === "true",
+        editorText: normalize(editor?.textContent),
+        triggerMounted: Boolean(trigger),
+        triggerText: normalize(trigger?.textContent),
+        triggerDisabled: Boolean(trigger?.disabled),
+        triggerAriaDisabled: trigger?.getAttribute("aria-disabled") || null,
+        triggerState: trigger?.getAttribute("data-state") || null,
+        triggerOpacity: triggerStyle?.opacity || null,
+        triggerColor,
+        labelColor,
+        labelTextFillColor,
+        surfaceBackground,
+        triggerContrast: contrast(effectiveLabelColor, surfaceBackground),
+        labelTextFillTransparent: isTransparent(labelTextFillColor),
+        triggerClassName: String(trigger?.className || ""),
+      };
+    };
     const jsx = (type, props, key) => ({ type, props: props || {}, key });
     const jsxs = jsx;
     const reviewDeps = {
@@ -835,14 +1122,63 @@ function pluginAuditExpression({ includeNativeOpenProbes = false } = {}) {
         props?.style?.["--codex-plus-project-accent"] === accent);
       const liveRows = Array.from(document.querySelectorAll("[data-codex-plus-project-color]"));
       const liveAccents = liveRows.map((row) => getComputedStyle(row).getPropertyValue("--codex-plus-project-accent").trim()).filter(Boolean);
+      const projectThreadRowCount = await waitForProjectThreadRows();
+      let selectedProjectAccent = "";
+      let mountedComposer = null;
+      const unstyledProjectThreadLists = Array.from(document.querySelectorAll("[data-app-action-sidebar-project-list-id]"))
+        .map((list) => {
+          const projectId = list.getAttribute("data-app-action-sidebar-project-list-id") || "";
+          const projectRow = document.querySelector(`[data-app-action-sidebar-project-row][data-app-action-sidebar-project-id="${CSS.escape(projectId)}"]`);
+          const threadRows = Array.from(list.querySelectorAll("[data-app-action-sidebar-thread-row]"));
+          if (!projectRow || threadRows.length === 0) return null;
+          const projectAccent = getComputedStyle(projectRow).getPropertyValue("--codex-plus-project-accent").trim();
+          const listComputed = getComputedStyle(list);
+          const listAccent = listComputed.getPropertyValue("--codex-plus-project-accent").trim();
+          const listBackground = listComputed.backgroundColor;
+          if (!selectedProjectAccent) {
+            selectedProjectAccent = projectAccent;
+            threadRows[0].click();
+          }
+          const unstyledRows = threadRows.filter((row) => {
+            const computed = getComputedStyle(row);
+            const rowAccent = computed.getPropertyValue("--codex-plus-project-accent").trim();
+            return rowAccent !== projectAccent || isTransparentColor(computed.backgroundColor);
+          });
+          return list.hasAttribute("data-codex-plus-project-sidebar-color") &&
+            listAccent === projectAccent &&
+            !isTransparentColor(listBackground) &&
+            unstyledRows.length === 0
+            ? null
+            : {
+                projectId,
+                projectLabel: projectRow.getAttribute("data-app-action-sidebar-project-label") || projectRow.innerText.trim(),
+                projectAccent,
+                listAccent,
+                listBackground,
+                threadRows: threadRows.length,
+                unstyledRows: unstyledRows.length,
+                listMarked: list.hasAttribute("data-codex-plus-project-sidebar-color"),
+              };
+        })
+        .filter(Boolean);
+      if (selectedProjectAccent) mountedComposer = await waitForMountedProjectComposer(selectedProjectAccent);
       if (!accent) throw new Error("Project accent was not computed");
       if (!matchingProps) throw new Error("Project, thread, bubble, and composer props do not share an accent");
+      if (projectThreadRowCount === 0) throw new Error("No visible project child thread rows appeared; project sidebar styling was not proven");
+      if (unstyledProjectThreadLists.length > 0) {
+        throw new Error(`Project sidebar child rows or list containers are not styled like their project rows: ${JSON.stringify(unstyledProjectThreadLists.slice(0, 4))}`);
+      }
+      if (!mountedComposer?.marked || !mountedComposer?.projectMarked || mountedComposer?.accent !== selectedProjectAccent) {
+        throw new Error(`Mounted composer does not carry the selected project accent: ${JSON.stringify(mountedComposer)}`);
+      }
       pass("projectColors", {
         ...details,
         accent,
         matchingProps,
         liveRows: liveRows.length,
         liveAccents: Array.from(new Set(liveAccents)).slice(0, 8),
+        styledProjectThreadLists: projectThreadRowCount,
+        mountedComposer,
       });
     } catch (error) {
       fail("projectColors", error);
@@ -860,6 +1196,33 @@ function pluginAuditExpression({ includeNativeOpenProbes = false } = {}) {
       fail("projectPathHeader", error);
     }
 
+    try {
+      const status = composerPermissionPickerStatus();
+      if (status.editorMounted && status.editorEditable && status.triggerMounted) {
+        const lowOpacity = Number(status.triggerOpacity) < 0.5;
+        const lowContrast = status.triggerContrast != null && status.triggerContrast < 4.5;
+        if (lowOpacity || lowContrast || status.labelTextFillTransparent) {
+          throw new Error(`Composer permissions picker text is unreadable: ${JSON.stringify(status)}`);
+        }
+        const ariaDisabled = status.triggerAriaDisabled === "true";
+        const visuallyDisabled = /\bopacity-40\b/.test(status.triggerClassName);
+        if (status.triggerDisabled || ariaDisabled || visuallyDisabled) {
+          warn(
+            "audit",
+            "composer-permission-picker-disabled",
+            "Composer permissions picker is disabled while the composer is editable",
+            status,
+          );
+        }
+      }
+      if (!status.editorMounted || !status.triggerMounted) {
+        throw new Error(`Composer permissions picker was not found: ${JSON.stringify(status)}`);
+      }
+      pass("audit", { composerPermissionPicker: status });
+    } catch (error) {
+      fail("audit", error);
+    }
+
     try {
       const details = checkCommon("sidebarNameBlur");
       const metadata = window.CodexPlus.ui.commands.commandMetadata().some((command) => command.id === "codexPlusToggleSidebarNameBlur");
@@ -938,7 +1301,34 @@ function pluginAuditExpression({ includeNativeOpenProbes = false } = {}) {
       if (ranked[0] !== "hassio-dev") throw new Error(`Fuzzy ranking returned ${ranked.join(", ")}`);
       if (highlightCount === 0) throw new Error("Fuzzy match highlight did not render");
       if (selected[0] !== "hassio-dev" || events.length !== 2) throw new Error("Enter-to-first-result adapter did not select first ranked result");
-      pass("projectSelectorShortcut", { ...details, ranked, highlightCount, selected });
+      document.dispatchEvent(new KeyboardEvent("keydown", { bubbles: true, cancelable: true, key: "Escape" }));
+      const newChatButton = Array.from(document.querySelectorAll("button")).find((button) => {
+        const rect = button.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0 && (button.innerText || "").includes("New chat");
+      });
+      newChatButton?.click?.();
+      let triggerCount = 0;
+      for (let attempt = 0; attempt < 20; attempt += 1) {
+        triggerCount = document.querySelectorAll("[data-codex-plus-project-selector-trigger]").length;
+        if (triggerCount > 0) break;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      if (triggerCount === 0) throw new Error("Project selector shortcut trigger marker is missing from the main composer");
+      const syntheticShortcut = await new Promise((resolve) => {
+        const event = new KeyboardEvent("keydown", { bubbles: true, cancelable: true, key: ".", metaKey: true });
+        document.dispatchEvent(event);
+        setTimeout(() => {
+          const searchInput = document.querySelector("input[placeholder='Search projects']");
+          const menu = document.querySelector("[data-radix-menu-content], [data-radix-popper-content-wrapper], [role='menu']");
+          resolve({
+            defaultPrevented: event.defaultPrevented,
+            opened: Boolean(searchInput || menu),
+            activePlaceholder: document.activeElement?.getAttribute?.("placeholder") ?? "",
+          });
+        }, 400);
+      });
+      document.dispatchEvent(new KeyboardEvent("keydown", { bubbles: true, cancelable: true, key: "Escape" }));
+      pass("projectSelectorShortcut", { ...details, ranked, highlightCount, selected, triggerCount, syntheticShortcut });
     } catch (error) {
       fail("projectSelectorShortcut", error);
     }
@@ -991,6 +1381,7 @@ function pluginAuditExpression({ includeNativeOpenProbes = false } = {}) {
       ok: failures.length === 0,
       failures,
       pluginResults,
+      expectedWarnings,
       registeredPlugins: typeof window.CodexPlus?.plugins?.list === "function" ? pluginIds() : null,
       startedPlugins: started(),
     };
@@ -1009,6 +1400,8 @@ async function runAudit(args, {
   const Session = operations.CdpSession || CdpSession;
   const waitRuntime = operations.waitForLiveRuntime || waitForLiveRuntime;
   const waitAppShell = operations.waitForAppShellMounted || waitForAppShellMounted;
+  const verifyMermaidViewer = operations.verifyMermaidViewerRender || verifyMermaidViewerRender;
+  const verifyProjectSelectorShortcut = operations.verifyProjectSelectorShortcutKey || verifyProjectSelectorShortcutKey;
   const cleanupApp = operations.cleanupLaunchedAuditApp || cleanupLaunchedAuditApp;
   const checkStability = operations.checkKeepOpenAppStability || checkKeepOpenAppStability;
   const preflightAudit = operations.auditPreflight || auditPreflight;
@@ -1041,15 +1434,17 @@ async function runAudit(args, {
         }),
       );
     }
-    syncResult = await withAuditProgress(
-      progress,
-      "Syncing dev home",
-      "Synced dev home",
-      () => syncHome({
-        sourceHome: args.sourceHome,
-        devHome: args.devHome,
-      }),
-    );
+    if (args.apply || args.launch) {
+      syncResult = await withAuditProgress(
+        progress,
+        "Syncing dev home",
+        "Synced dev home",
+        () => syncHome({
+          sourceHome: args.sourceHome,
+          devHome: args.devHome,
+        }),
+      );
+    }
     if (preflight.launch) {
       launchResult = await withAuditProgress(
         progress,
@@ -1060,6 +1455,7 @@ async function runAudit(args, {
           devHome: args.devHome,
           electronUserDataPath: args.electronUserDataPath,
           remoteDebuggingPort: port,
+          devInstanceId: args.devInstanceId,
         }),
       );
     }
@@ -1090,9 +1486,53 @@ async function runAudit(args, {
       "Probed plugins",
       () => cdp.evaluate(pluginAuditExpression({ includeNativeOpenProbes: args.includeNativeOpenProbes })),
     );
+    if (live.pluginResults?.projectSelectorShortcut?.ok) {
+      const shortcut = await withAuditProgress(
+        progress,
+        "Verifying project selector shortcut",
+        "Project selector shortcut opened",
+        () => verifyProjectSelectorShortcut(cdp),
+      );
+      live.pluginResults.projectSelectorShortcut.shortcut = shortcut;
+      if (!shortcut.ok) {
+        live.ok = false;
+        live.pluginResults.projectSelectorShortcut.ok = false;
+        live.failures.push({
+          plugin: "projectSelectorShortcut",
+          message: shortcut.message || "Cmd+. did not open the project selector",
+        });
+      }
+    }
+    const shouldProbeMermaidViewer = live.pluginResults?.mermaidFullscreen?.ok;
+    const mermaidViewerRender = shouldProbeMermaidViewer
+      ? await withAuditProgress(
+        progress,
+        "Verifying Mermaid viewer render",
+        "Mermaid viewer rendered",
+        () => verifyMermaidViewer(cdp, port, { Session }),
+      )
+      : null;
+    if (mermaidViewerRender != null) {
+      live.pluginResults.mermaidFullscreen.viewerRenderProbe = mermaidViewerRender;
+      if (!mermaidViewerRender.ok) {
+        live.ok = false;
+        live.pluginResults.mermaidFullscreen.ok = false;
+        live.failures.push({
+          plugin: "mermaidFullscreen",
+          message: `Mermaid viewer render failed: ${mermaidViewerRender.message || "no SVG rendered"}`,
+        });
+      }
+    }
+    appShellStatus = await withAuditProgress(
+      progress,
+      "Verifying Codex app shell after probes",
+      "App shell still healthy",
+      () => waitAppShell(cdp),
+    );
     result = {
       ok: live.ok,
       failures: live.failures,
+      expectedWarnings: live.expectedWarnings || [],
       pluginResults: live.pluginResults,
       target: {
         app: path.resolve(args.target),
@@ -1115,6 +1555,8 @@ async function runAudit(args, {
         command: launchResult.command,
         args: launchResult.args,
         pid: launchResult.pid,
+        devBundle: launchResult.devBundle,
+        instanceIdentity: launchResult.instanceIdentity,
       },
       registeredPlugins: live.registeredPlugins,
       startedPlugins: live.startedPlugins,
@@ -1124,6 +1566,7 @@ async function runAudit(args, {
       nativeOpenProbes: {
         included: Boolean(args.includeNativeOpenProbes),
       },
+      mermaidViewerRender,
       preflight,
     };
     return result;
@@ -1135,6 +1578,7 @@ async function runAudit(args, {
         message: error.message,
         details: error.details,
       }],
+      expectedWarnings: [],
       pluginResults: {},
       target: {
         app: path.resolve(args.target),
@@ -1157,6 +1601,8 @@ async function runAudit(args, {
         command: launchResult.command,
         args: launchResult.args,
         pid: launchResult.pid,
+        devBundle: launchResult.devBundle,
+        instanceIdentity: launchResult.instanceIdentity,
       },
       registeredPlugins: null,
       startedPlugins: null,
@@ -1263,5 +1709,7 @@ module.exports = {
   shouldShowAuditProgress,
   waitForAppShellMounted,
   waitForLiveRuntime,
+  verifyMermaidViewerRender,
+  verifyProjectSelectorShortcutKey,
   waitForRendererTarget,
 };