impel-cli 0.20.24 → 0.20.26

package/RELEASE_NOTES.md

@@ -1,5 +1,24 @@
 # Release notes
 
+## 0.20.26 — Native task-board navigation
+
+- Embeds Tasks in each managed desktop app's content view instead of a
+  separate always-on-top window, so selecting another sidebar destination
+  reliably dismisses the tenant board and completes the vendor navigation.
+- Removes the redundant desktop frame around the MCP App so the task-board
+  toolbar and workspace occupy the complete host content surface.
+- Rebuilds existing managed bundles onto the corrected embedded-view contract.
+
+## 0.20.25 — Embedded tenant task boards
+
+- Adds a persistent Tasks destination to the exact managed Claude and
+  ChatGPT/Codex desktop wrappers and keeps the native sidebar visible while the
+  tenant board is open.
+- Loads the existing Impel MCP App through a sandboxed desktop host while all
+  credentials and task RPC stay in the Electron main process.
+- Rebuilds existing managed bundles onto the reviewed preload contract and
+  hides auxiliary task windows when the tenant app loses focus.
+
 ## 0.20.24 — Keep Codex adapters silent until terminal
 
 - Explicitly forbids every collaboration tool inside active and recovery Codex

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impel-cli",
-  "version": "0.20.24",
+  "version": "0.20.26",
   "description": "Prepare isolated Claude and Codex workspaces for every accessible Impel tenant",
   "type": "module",
   "bin": {

package/src/apps.js

@@ -24,6 +24,12 @@ import { ADHOC_IDENTITY, codesignIdentityArgs, desiredSigningMode, resolveSignin
 import { applyImpelClaudeSandbox } from "./claudeSandbox.js";
 import { brandedEnvironmentName, RUNTIME_BRAND } from "./runtimeBrand.js";
 import { IMPEL_CODEX_PARENT_DELEGATION_INSTRUCTIONS } from "./commands/launch.js";
+import {
+  desktopTasksAssetPaths,
+  desktopTasksHostHtml,
+  desktopTasksMainPreload,
+  desktopTasksViewPreload,
+} from "./desktopTasks.js";
 
 export const CLAUDE_CONFIG_ID = "1ced0000-0000-4000-8000-000000000001";
 const CHATGPT_CONFIG_START = `# >>> ${RUNTIME_BRAND.cli.command} app managed gateway >>>`;
@@ -284,7 +290,9 @@ export function managedAppIdentity(target, tenantId = null, tenantName = null) {
 // namespaces for fixed native-agent bindings.
 // 31: enable the reviewed MCP Apps renderer in pinned Codex Desktop profiles
 // and install Claude task, notification, and permission lifecycle hooks.
-export const CURRENT_CONFIG_VERSION = 31;
+// 32: install a persistent tenant-bound Tasks navigation surface in the
+// managed Claude and ChatGPT/Codex desktop wrappers.
+export const CURRENT_CONFIG_VERSION = 32;
 
 // Identifies the bundle-BUILDING logic — the asar patches, plist rewrites,
 // helper rebranding, and signing. A vendored bundle is rebuilt only when this
@@ -293,7 +301,7 @@ export const CURRENT_CONFIG_VERSION = 31;
 // — which is what made every `impel update` re-trigger macOS permission
 // prompts. Bump this ONLY when a code change alters the bytes of a built
 // bundle; leave it alone for changes that don't touch bundle contents.
-export const BUNDLE_BUILD_FINGERPRINT = "bundle-2026-08-01.1";
+export const BUNDLE_BUILD_FINGERPRINT = "bundle-2026-08-08.2";
 
 /** Parse the tenant's install manifest, or null when absent/corrupt. */
 export function readTenantManifest(homeDir = os.homedir(), tenantId = null) {
@@ -364,6 +372,7 @@ export function bundleIsCurrent(status, {
       compatibility.patches?.followupBoundAgentEnable === 1
       && compatibility.patches?.followupBoundAgentFilter === 1
       && compatibility.patches?.followupBoundAgentChip === 1
+      && compatibility.patches?.desktopTasksPreload === 1
       && claudePatchSetMatchesCompatibility(compatibility)
       && managedClaudeRendererMatchesCompatibility(status, compatibility)
     ))
@@ -376,6 +385,7 @@ export function bundleIsCurrent(status, {
       && compatibility.patches?.threadResumeProviderOverride === 1
       && compatibility.patches?.structuredProviderFallbackDisabled === 2
       && compatibility.patches?.tenantDisplayNamePreload === 2
+      && compatibility.patches?.desktopTasksPreload === 1
     )),
   );
 }
@@ -414,6 +424,7 @@ const CLAUDE_COMPATIBILITY_PATCH_KEYS = Object.freeze([
   "followupBoundAgentEnable",
   "followupBoundAgentFilter",
   "followupBoundAgentChip",
+  "desktopTasksPreload",
 ]);
 const CLAUDE_COMPATIBILITY_RENDERER_GROUPS = Object.freeze(["agentMentions"]);
 
@@ -589,6 +600,14 @@ export function appPaths(homeDir = os.homedir(), tenantId = null, {
   };
 }
 
+function writeDesktopTasksProfileAssets(root) {
+  const assets = desktopTasksAssetPaths(root);
+  writeAtomic(assets.mainPreload, desktopTasksMainPreload(), 0o600);
+  writeAtomic(assets.viewPreload, desktopTasksViewPreload(), 0o600);
+  writeAtomic(assets.hostHtml, desktopTasksHostHtml(), 0o600);
+  return assets;
+}
+
 function readClaudeSafeStorageMetadata(paths) {
   const metadataPath = path.join(paths.claude.root, CLAUDE_SAFE_STORAGE_METADATA);
   try {
@@ -794,6 +813,7 @@ export function installManagedAppFiles({
 
   const installed = [];
   for (const target of targets) {
+    writeDesktopTasksProfileAssets(paths[target].root);
     // Non-bundle targets are the background-refresh / fast-open path: configs,
     // token helper, catalog, and manifest only. Bundle swaps require the app
     // to be closed (see quitBlockingApps), so those paths never attempt one.
@@ -810,12 +830,14 @@ export function installManagedAppFiles({
         resolvedVendorPaths.chatgpt,
         config.gatewayUrl,
         homeDir,
+        config.tenantId,
       );
       else writeVendoredClaudeBundle(
         paths,
         resolvedVendorPaths.claude,
         config.gatewayUrl,
         claudeSafeStorageName,
+        config.tenantId,
       );
       if (config.tenantId) {
         // A successful tenant-specific rebuild supersedes the old global
@@ -1700,13 +1722,13 @@ exec "$NODE" "$CLI" token${tenantArgs}
   writeAtomic(target, script, 0o700);
 }
 
-function writeVendoredClaudeBundle(paths, vendorPath, gatewayUrl, safeStorageName) {
+function writeVendoredClaudeBundle(paths, vendorPath, gatewayUrl, safeStorageName, tenantId) {
   return withBundleMutationLock(paths.claude.launcher, () => (
-    writeVendoredClaudeBundleLocked(paths, vendorPath, gatewayUrl, safeStorageName)
+    writeVendoredClaudeBundleLocked(paths, vendorPath, gatewayUrl, safeStorageName, tenantId)
   ));
 }
 
-function writeVendoredClaudeBundleLocked(paths, vendorPath, gatewayUrl, safeStorageName) {
+function writeVendoredClaudeBundleLocked(paths, vendorPath, gatewayUrl, safeStorageName, tenantId) {
   if (!vendorPath) throw new Error("Claude vendor app is unavailable");
   if (!isVendableVendorApp("claude", vendorPath)) {
     const bundleId = readBundleIdentifier(vendorPath);
@@ -1747,6 +1769,7 @@ function writeVendoredClaudeBundleLocked(paths, vendorPath, gatewayUrl, safeStor
       planUsageRequestPatchCount = patchClaudePlanUsageRequest(asarPath);
     }
     const safeStorageNamePatchCount = patchClaudeSafeStorageName(asarPath);
+    const desktopTasksPreloadPatchCount = patchDesktopTasksPreload(asarPath, "claude");
     const newAsarHash = asarHeaderHash(asarPath);
 
     updateBundleIdentity(plistPath, {
@@ -1765,6 +1788,13 @@ function writeVendoredClaudeBundleLocked(paths, vendorPath, gatewayUrl, safeStor
     setPlistEnvironmentString(plistPath, "CLAUDE_USER_DATA_DIR", paths.claude.userData);
     setPlistEnvironmentString(plistPath, "CLAUDE_CONFIG_DIR", paths.claude.userData);
     setPlistEnvironmentString(plistPath, "IMPEL_CN", safeStorageName);
+    const desktopTasks = desktopTasksAssetPaths(paths.claude.root);
+    setPlistEnvironmentString(plistPath, "IMPEL_DESKTOP_TASKS_NODE", process.execPath);
+    setPlistEnvironmentString(plistPath, "IMPEL_DESKTOP_TASKS_CLI", IMPEL_CLI_ENTRYPOINT);
+    setPlistEnvironmentString(plistPath, "IMPEL_DESKTOP_TASKS_TENANT", tenantId || "");
+    setPlistEnvironmentString(plistPath, "IMPEL_DESKTOP_TASKS_HOST_HTML", desktopTasks.hostHtml);
+    setPlistEnvironmentString(plistPath, "IMPEL_DESKTOP_TASKS_VIEW_PRELOAD", desktopTasks.viewPreload);
+    setPlistEnvironmentString(plistPath, "IMPEL_DT", desktopTasks.mainPreload);
     rebrandElectronHelpers(staging, {
       fromName: "Claude",
       toName: paths.claude.displayName,
@@ -1795,6 +1825,7 @@ function writeVendoredClaudeBundleLocked(paths, vendorPath, gatewayUrl, safeStor
         followupBoundAgentEnable: agentMentionPatches.enable,
         followupBoundAgentFilter: agentMentionPatches.filter,
         followupBoundAgentChip: agentMentionPatches.chip,
+        desktopTasksPreload: desktopTasksPreloadPatchCount,
       },
       rendererAssets: {
         agentMentions: agentMentionPatches.assets,
@@ -1818,13 +1849,13 @@ function claudeUsageCompatibilityEnabled(gatewayUrl) {
   }
 }
 
-function writeVendoredChatGPTBundle(paths, vendorPath, gatewayUrl, homeDir) {
+function writeVendoredChatGPTBundle(paths, vendorPath, gatewayUrl, homeDir, tenantId) {
   return withBundleMutationLock(paths.chatgpt.launcher, () => (
-    writeVendoredChatGPTBundleLocked(paths, vendorPath, gatewayUrl, homeDir)
+    writeVendoredChatGPTBundleLocked(paths, vendorPath, gatewayUrl, homeDir, tenantId)
   ));
 }
 
-function writeVendoredChatGPTBundleLocked(paths, vendorPath, gatewayUrl, homeDir) {
+function writeVendoredChatGPTBundleLocked(paths, vendorPath, gatewayUrl, homeDir, tenantId) {
   if (!vendorPath) throw new Error("ChatGPT/Codex vendor app is unavailable");
   const definition = APP_DEFINITIONS.chatgpt;
   const executableName = definition.executableNames.find((name) => (
@@ -1861,6 +1892,7 @@ function writeVendoredChatGPTBundleLocked(paths, vendorPath, gatewayUrl, homeDir
     const fastModePatchCount = patchFastModeAuthGate(runtimeAsarPath);
     const threadProviderPatches = patchChatGPTThreadRouting(runtimeAsarPath);
     const structuredFallbackPatchCount = patchChatGPTStructuredProviderFallback(runtimeAsarPath);
+    const desktopTasksPreloadPatchCount = patchDesktopTasksPreload(runtimeAsarPath, "chatgpt");
     const asarHash = asarHeaderHash(runtimeAsarPath);
     const vendorExecutable = path.join(vendorBundle, "Contents", "MacOS", executableName);
     const signingIdentity = resolveVendoredAppSigningIdentity(vendorExecutable);
@@ -1877,7 +1909,7 @@ function writeVendoredChatGPTBundleLocked(paths, vendorPath, gatewayUrl, homeDir
     // the script stays in MacOS as the executable (pre-Tahoe layout).
     writeAtomic(
       path.join(launchHost ? path.join(staging, "Contents", "Resources") : macos, "launch"),
-      vendoredChatGPTLauncher(paths, vendorBundleName, executableName, gatewayUrl),
+      vendoredChatGPTLauncher(paths, vendorBundleName, executableName, gatewayUrl, tenantId),
       0o755,
     );
     if (launchHost) {
@@ -1911,6 +1943,7 @@ function writeVendoredChatGPTBundleLocked(paths, vendorPath, gatewayUrl, homeDir
         structuredProviderFallbackDisabled: structuredFallbackPatchCount,
         desktopAPIForGatewayAuth: 0,
         tenantDisplayNamePreload: 2,
+        desktopTasksPreload: desktopTasksPreloadPatchCount,
       },
       vendorSignaturesPreserved: true,
       resourceRoot: CHATGPT_RESOURCE_ROOT,
@@ -2131,6 +2164,24 @@ function patchFastModeAuthGate(asarPath) {
   return applyFixedWidthAsarPatches(asarPath, archive, patches, "ChatGPT/Codex Fast-mode eligibility contract");
 }
 
+function patchDesktopTasksPreload(asarPath, target) {
+  const footer = target === "claude"
+    ? "//# sourceMappingURL=index.pre.js.map\n"
+    : "//# sourceMappingURL=early-bootstrap.js.map";
+  const loader = "require(process.env.IMPEL_DT)";
+  const trailingNewline = footer.endsWith("\n") ? "\n" : "";
+  if (loader.length >= footer.length - trailingNewline.length) {
+    throw new Error("desktop Tasks preload no longer fits the vendor ASAR contract");
+  }
+  const replacement = `${loader.padEnd(footer.length - trailingNewline.length, " ")}${trailingNewline}`;
+  return patchFixedWidthAsarString(
+    asarPath,
+    footer,
+    replacement,
+    `${target === "claude" ? "Claude" : "ChatGPT/Codex"} desktop Tasks preload`,
+  );
+}
+
 /**
  * Force every desktop app-server thread request onto the tenant's configured
  * Impel provider. The pinned renderer passes null for internal metadata turns,
@@ -2497,8 +2548,9 @@ function vendoredChatGPTWrapperPlist(vendorPath, asarHash, identity, executableN
 `;
 }
 
-function vendoredChatGPTLauncher(paths, vendorBundleName, executableName, gatewayUrl) {
+function vendoredChatGPTLauncher(paths, vendorBundleName, executableName, gatewayUrl, tenantId) {
   const codexAccountBaseUrl = `${gatewayUrl}/chatgpt_passthrough/backend-api`;
+  const desktopTasks = desktopTasksAssetPaths(paths.chatgpt.root);
   return `#!/bin/sh
 set -eu
 umask 077
@@ -2531,6 +2583,12 @@ BROWSER_DATA=${shellQuote(paths.chatgpt.browserData)}
 mkdir -p "$BROWSER_DATA"
 export IMPEL_APP_DISPLAY_NAME=${shellQuote(paths.chatgpt.displayName)}
 export IMPEL_APP_BUNDLE_ID=${shellQuote(paths.chatgpt.bundleIdentifier)}
+export IMPEL_DESKTOP_TASKS_NODE=${shellQuote(process.execPath)}
+export IMPEL_DESKTOP_TASKS_CLI=${shellQuote(IMPEL_CLI_ENTRYPOINT)}
+export IMPEL_DESKTOP_TASKS_TENANT=${shellQuote(tenantId || "")}
+export IMPEL_DESKTOP_TASKS_HOST_HTML=${shellQuote(desktopTasks.hostHtml)}
+export IMPEL_DESKTOP_TASKS_VIEW_PRELOAD=${shellQuote(desktopTasks.viewPreload)}
+export IMPEL_DT=${shellQuote(desktopTasks.mainPreload)}
 PRELOAD="$HERE/../Resources/impel-chatgpt-preload.cjs"
 export NODE_OPTIONS="--require=\\\"$PRELOAD\\\""
 # Electron resolves resources from the Impel wrapper when the nested app is
@@ -2671,6 +2729,7 @@ if (process.type === "browser" && displayName && bundleIdentifier) {
     return loaded;
   };
 }
+
 `;
 }
 

package/src/desktopTasks.js

@@ -0,0 +1,1019 @@
+import path from "node:path";
+
+export const DESKTOP_TASKS_RESOURCE_URI = "ui://impel/tasks/v1/index.html";
+
+export function desktopTasksAssetPaths(root) {
+  const directory = path.join(root, "desktop-tasks");
+  return {
+    directory,
+    mainPreload: path.join(directory, "main-preload.cjs"),
+    viewPreload: path.join(directory, "view-preload.cjs"),
+    hostHtml: path.join(directory, "host.html"),
+  };
+}
+
+const NAVIGATION_SOURCE = String.raw`(() => {
+  const NAV_ID = "impel-desktop-tasks-nav";
+  const NAV_SLOT_ID = "impel-desktop-tasks-nav-slot";
+  const ACTIVE_CLASS = "impel-desktop-tasks-active";
+  const TASKS_ICON = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="3" y="3" width="18" height="18" rx="2"></rect><path d="M9 3v18"></path><path d="M15 3v18"></path></svg>';
+  if (window.__impelDesktopTasksCleanup) window.__impelDesktopTasksCleanup();
+
+  let nav = null;
+  let slot = null;
+  let active = false;
+  let lastAnchor = null;
+
+  const label = (element) => [
+    element.getAttribute("aria-label"),
+    element.getAttribute("title"),
+    element.textContent,
+  ].filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+
+  const visible = (element) => {
+    const rect = element.getBoundingClientRect();
+    const style = getComputedStyle(element);
+    return rect.width > 0 && rect.height > 0 && rect.right > 0 && rect.bottom > 0
+      && rect.left < innerWidth && rect.top < innerHeight
+      && style.display !== "none" && style.visibility !== "hidden";
+  };
+
+  const roots = () => {
+    const found = [document];
+    for (let index = 0; index < found.length; index += 1) {
+      for (const element of found[index].querySelectorAll("*")) {
+        if (element.shadowRoot && !found.includes(element.shadowRoot)) found.push(element.shadowRoot);
+      }
+    }
+    return found;
+  };
+
+  const queryAll = (selector) => roots().flatMap((root) => [...root.querySelectorAll(selector)]);
+  const queryFirst = (selector) => queryAll(selector)[0] || null;
+
+  const controls = () => queryAll("button, a, [role=\"button\"], [role=\"link\"], [tabindex]")
+    .filter((element) => !element.closest("#" + NAV_ID + ", #" + NAV_SLOT_ID));
+
+  const findControl = (pattern) => {
+    const matches = controls().filter((element) => pattern.test(label(element)));
+    return matches.find(visible) || matches[0] || null;
+  };
+
+  const findSidebar = () => {
+    const explicit = queryFirst("aside.app-shell-left-panel, aside, [data-app-shell-left-panel], nav[aria-label]");
+    if (explicit && visible(explicit)) return explicit;
+    return null;
+  };
+
+  const findMain = () => {
+    const candidates = [
+      queryFirst("main[data-app-shell-main-surface]"),
+      queryFirst("main.main-surface"),
+      queryFirst("main"),
+      queryFirst("[role=\"main\"]"),
+    ].filter(Boolean);
+    return candidates.find(visible) || candidates[0] || null;
+  };
+
+  const mainBounds = () => {
+    const main = findMain();
+    let rect = main?.getBoundingClientRect();
+    const sidebar = findSidebar();
+    const side = sidebar?.getBoundingClientRect();
+    const anchor = lastAnchor?.getBoundingClientRect();
+    const inferred = anchor
+      && anchor.left < 48
+      && anchor.right >= 180
+      && anchor.right < innerWidth * 0.55
+      ? anchor.right + 8
+      : 0;
+    const sidebarRight = side && side.left <= 8 && side.width < innerWidth * 0.55
+      ? side.right
+      : inferred;
+    if (!rect || rect.width < 240 || rect.height < 240) {
+      rect = { left: sidebarRight, top: 0, width: innerWidth - sidebarRight, height: innerHeight };
+    } else if (sidebarRight > rect.left + 8 && rect.width > innerWidth * 0.7) {
+      rect = {
+        left: sidebarRight,
+        top: rect.top,
+        width: innerWidth - sidebarRight,
+        height: rect.height,
+      };
+    }
+    return {
+      x: Math.max(0, Math.round(rect.left)),
+      y: Math.max(0, Math.round(rect.top)),
+      width: Math.max(320, Math.round(rect.width)),
+      height: Math.max(320, Math.round(rect.height)),
+    };
+  };
+
+  const signal = (action) => {
+    const bounds = mainBounds();
+    const query = new URLSearchParams({
+      x: String(bounds.x),
+      y: String(bounds.y),
+      width: String(bounds.width),
+      height: String(bounds.height),
+    });
+    location.href = "impel-tasks://" + action + "?" + query.toString();
+  };
+
+  const select = (selected) => {
+    active = selected;
+    if (!nav) return;
+    nav.dataset.selected = String(selected);
+    nav.setAttribute("aria-current", selected ? "page" : "false");
+    nav.classList.toggle("bg-token-list-hover-background", selected);
+    nav.classList.toggle(ACTIVE_CLASS, selected);
+  };
+  window.__impelDesktopTasksSetActive = select;
+
+  const replaceText = (element) => {
+    const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
+    let changed = false;
+    while (walker.nextNode()) {
+      const text = walker.currentNode.nodeValue || "";
+      if (!/(?:new\s+(?:chat|thread)|pull requests?|scheduled|plugins?|skills?|cowork|code)\b/i.test(text)) continue;
+      walker.currentNode.nodeValue = text.replace(
+        /(?:new\s+(?:chat|thread)|pull requests?|scheduled|plugins?|skills?|cowork|code)\b/i,
+        "Tasks",
+      );
+      changed = true;
+    }
+    return changed;
+  };
+
+  const stripVendorActions = (element) => {
+    for (const candidate of [element, ...element.querySelectorAll("*")]) {
+      for (const attribute of [...candidate.attributes]) {
+        if (attribute.name.startsWith("data-app-action-") || attribute.name === "data-testid") {
+          candidate.removeAttribute(attribute.name);
+        }
+      }
+    }
+    element.removeAttribute("href");
+    element.removeAttribute("target");
+    element.querySelectorAll("[id]").forEach((candidate) => candidate.removeAttribute("id"));
+    element.querySelectorAll("kbd, [data-slot=\"shortcut\"]").forEach((candidate) => candidate.remove());
+  };
+
+  const makeNav = (template) => {
+    const button = template ? template.cloneNode(true) : document.createElement("button");
+    stripVendorActions(button);
+    button.id = NAV_ID;
+    button.type = "button";
+    button.setAttribute("aria-label", "Tasks");
+    button.setAttribute("title", "Tasks");
+    button.classList.add("impel-desktop-tasks-nav");
+    if (!replaceText(button)) button.textContent = "Tasks";
+    const icon = button.querySelector("svg");
+    if (icon) {
+      icon.setAttribute("viewBox", "0 0 24 24");
+      icon.setAttribute("fill", "none");
+      icon.setAttribute("stroke", "currentColor");
+      icon.setAttribute("stroke-width", "2");
+      icon.setAttribute("stroke-linecap", "round");
+      icon.setAttribute("stroke-linejoin", "round");
+      icon.innerHTML = '<rect x="3" y="3" width="18" height="18" rx="2"></rect><path d="M9 3v18"></path><path d="M15 3v18"></path>';
+    }
+    else button.insertAdjacentHTML("afterbegin", TASKS_ICON);
+    button.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      select(true);
+      signal("show");
+    });
+    button.addEventListener("keydown", (event) => {
+      if (event.key !== "Enter" && event.key !== " ") return;
+      event.preventDefault();
+      select(true);
+      signal("show");
+    });
+    return button;
+  };
+
+  const placement = (control) => {
+    if (!control) return null;
+    let child = control;
+    let parent = control.parentElement;
+    while (parent && parent !== document.body) {
+      const style = getComputedStyle(parent);
+      if (style.display === "flex" && style.flexDirection === "column") {
+        return { stack: parent, child };
+      }
+      child = parent;
+      parent = parent.parentElement;
+    }
+    return null;
+  };
+
+  const ensureNav = () => {
+    const anchor = findControl(/^pull requests?\b/i)
+      || findControl(/^(?:start\s+)?new\s+(?:chat|thread)\b/i)
+      || findControl(/^scheduled\b/i)
+      || findControl(/^plugins?\b/i)
+      || findControl(/^cowork\b/i)
+      || findControl(/^code\b/i);
+    lastAnchor = anchor;
+    if (!nav?.isConnected) nav = makeNav(anchor);
+    const target = placement(anchor);
+    if (target) {
+      if (!slot?.isConnected || (slot !== nav && !slot.contains(nav))) {
+        slot = target.child === anchor ? nav : target.child.cloneNode(false);
+        if (slot !== nav) {
+          slot.id = NAV_SLOT_ID;
+          slot.removeAttribute("aria-label");
+          slot.removeAttribute("title");
+          slot.append(nav);
+        }
+      }
+      if (slot.parentElement !== target.stack || slot.nextElementSibling !== target.child) {
+        target.stack.insertBefore(slot, target.child);
+      }
+    } else if (anchor?.parentElement) {
+      anchor.insertAdjacentElement("afterend", nav);
+      slot = nav;
+    } else if (!nav.isConnected) {
+      slot = null;
+    }
+    select(active);
+  };
+
+  const style = document.createElement("style");
+  style.id = "impel-desktop-tasks-nav-style";
+  style.textContent = [
+    "#" + NAV_ID + " svg { width: 16px; height: 16px; flex: 0 0 auto; }",
+    "#" + NAV_ID + "." + ACTIVE_CLASS + " { background: color-mix(in srgb, CanvasText 10%, transparent); }",
+    "#" + NAV_ID + ":focus-visible { outline: 2px solid #7c8cff; outline-offset: 2px; }",
+  ].join("\n");
+  document.head.append(style);
+
+  const onClick = (event) => {
+    if (!active || event.target instanceof Element && event.target.closest("#" + NAV_ID)) return;
+    const sidebar = findSidebar();
+    if (!sidebar || !(event.target instanceof Node) || !sidebar.contains(event.target)) return;
+    select(false);
+    setTimeout(() => signal("hide"), 0);
+  };
+  const onResize = () => {
+    if (active) signal("layout");
+  };
+  window.addEventListener("click", onClick, true);
+  window.addEventListener("resize", onResize);
+
+  const observer = new MutationObserver((records) => {
+    const external = records.some((record) => {
+      const target = record.target instanceof Element ? record.target : record.target?.parentElement;
+      return target && !target.closest("#" + NAV_ID + ", #" + NAV_SLOT_ID);
+    });
+    if (external) ensureNav();
+  });
+  observer.observe(document.body, { childList: true, subtree: true });
+  ensureNav();
+
+  const navRect = nav?.getBoundingClientRect();
+  const result = {
+    connected: Boolean(nav?.isConnected),
+    visible: Boolean(nav && visible(nav)),
+    text: nav?.textContent?.replace(/\s+/g, " ").trim() || null,
+    anchor: lastAnchor ? label(lastAnchor) : null,
+    bounds: navRect ? {
+      x: Math.round(navRect.x),
+      y: Math.round(navRect.y),
+      width: Math.round(navRect.width),
+      height: Math.round(navRect.height),
+    } : null,
+  };
+
+  window.__impelDesktopTasksCleanup = () => {
+    observer.disconnect();
+    window.removeEventListener("click", onClick, true);
+    window.removeEventListener("resize", onResize);
+    nav?.remove();
+    if (slot && slot !== nav) slot.remove();
+    style.remove();
+    delete window.__impelDesktopTasksSetActive;
+  };
+  return result;
+})();`;
+
+const NATIVE_NAVIGATION_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'">
+    <style>
+      :root { color-scheme: light dark; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+      * { box-sizing: border-box; }
+      html, body { width: 100%; height: 100%; margin: 0; overflow: hidden; background: transparent; }
+      button {
+        width: 100%; height: 100%; display: flex; align-items: center; gap: 9px;
+        border: 0; border-radius: 8px; padding: 0 12px;
+        background: color-mix(in srgb, Canvas 92%, CanvasText 8%); color: CanvasText;
+        font: 13px/1 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        text-align: left; cursor: pointer;
+      }
+      button:hover, button[data-active="true"] { background: color-mix(in srgb, CanvasText 13%, Canvas); }
+      button:focus-visible { outline: 2px solid #7c8cff; outline-offset: -2px; }
+      svg { width: 16px; height: 16px; flex: 0 0 auto; }
+    </style>
+  </head>
+  <body>
+    <button id="tasks" type="button" aria-label="Tasks">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="3" y="3" width="18" height="18" rx="2"></rect><path d="M9 3v18"></path><path d="M15 3v18"></path></svg>
+      <span>Tasks</span>
+    </button>
+    <script>
+      const button = document.getElementById("tasks");
+      button.addEventListener("pointerdown", (event) => {
+        if (event.button !== 0) return;
+        event.preventDefault();
+        button.dataset.active = "true";
+        window.impelDesktopTasks.show();
+      });
+      window.__impelDesktopTasksSetActive = (active) => { button.dataset.active = String(Boolean(active)); };
+    </script>
+  </body>
+</html>`;
+
+export function desktopTasksMainPreload() {
+  return `"use strict";
+
+if (
+  process.type === "browser"
+  && process.env.IMPEL_DESKTOP_TASKS_NODE
+  && process.env.IMPEL_DESKTOP_TASKS_CLI
+  && process.env.IMPEL_DESKTOP_TASKS_TENANT
+  && process.env.IMPEL_DESKTOP_TASKS_HOST_HTML
+  && process.env.IMPEL_DESKTOP_TASKS_VIEW_PRELOAD
+  && !globalThis.__impelDesktopTasksMainInstalled
+) {
+  globalThis.__impelDesktopTasksMainInstalled = true;
+  const fs = require("node:fs");
+  const path = require("node:path");
+  const readline = require("node:readline");
+  const { spawn } = require("node:child_process");
+  const { pathToFileURL } = require("node:url");
+  const navSource = ${JSON.stringify(NAVIGATION_SOURCE)};
+  const nativeNavUrl = "data:text/html;charset=utf-8," + encodeURIComponent(${JSON.stringify(NATIVE_NAVIGATION_HTML)});
+  const nodePath = process.env.IMPEL_DESKTOP_TASKS_NODE;
+  const cliPath = process.env.IMPEL_DESKTOP_TASKS_CLI;
+  const tenantId = process.env.IMPEL_DESKTOP_TASKS_TENANT;
+  const hostHtml = process.env.IMPEL_DESKTOP_TASKS_HOST_HTML;
+  const viewPreload = process.env.IMPEL_DESKTOP_TASKS_VIEW_PRELOAD;
+  const resourceUri = ${JSON.stringify(DESKTOP_TASKS_RESOURCE_URI)};
+  const rpcChannel = "impel-desktop-tasks:rpc";
+  const openLinkChannel = "impel-desktop-tasks:open-link";
+  const closeChannel = "impel-desktop-tasks:close";
+  const nativeShowChannel = "impel-desktop-tasks:native-show";
+  const runtimeStatusPath = path.join(path.dirname(hostHtml), "runtime-status.json");
+  const record = (stage, error = null) => {
+    try {
+      const detail = error instanceof Error ? error.message : error == null ? null : String(error);
+      fs.writeFileSync(runtimeStatusPath, JSON.stringify({
+        schemaVersion: 1,
+        stage,
+        detail,
+        processType: process.type || null,
+        electronVersion: process.versions.electron || null,
+        pid: process.pid,
+        updatedAt: new Date().toISOString(),
+      }, null, 2) + "\\n", { mode: 0o600 });
+    } catch {}
+  };
+
+  class TasksMcpClient {
+    constructor() {
+      this.child = null;
+      this.starting = null;
+      this.pending = new Map();
+      this.sequence = 0;
+    }
+
+    failPending(message) {
+      for (const entry of this.pending.values()) entry.reject(new Error(message));
+      this.pending.clear();
+    }
+
+    send(method, params) {
+      if (!this.child?.stdin?.writable) return Promise.reject(new Error("Tasks bridge is unavailable."));
+      const id = ++this.sequence;
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          this.pending.delete(id);
+          try {
+            this.child?.stdin?.write(JSON.stringify({
+              jsonrpc: "2.0",
+              method: "notifications/cancelled",
+              params: { requestId: id, reason: "desktop Tasks request timed out" },
+            }) + "\\n");
+          } catch {}
+          reject(new Error("Tasks request timed out."));
+        }, 75000);
+        this.pending.set(id, {
+          resolve: (value) => { clearTimeout(timer); resolve(value); },
+          reject: (error) => { clearTimeout(timer); reject(error); },
+        });
+        this.child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\\n");
+      });
+    }
+
+    async ensureStarted() {
+      if (this.child?.stdin?.writable) return;
+      if (this.starting) return this.starting;
+      this.starting = (async () => {
+        if (!nodePath || !cliPath || !tenantId) throw new Error("Tasks bridge configuration is incomplete.");
+        const child = spawn(nodePath, [cliPath, "mcp", "--target", "tasks", "--tenant", tenantId], {
+          stdio: ["pipe", "pipe", "pipe"],
+          env: { ...process.env, IMPEL_MANAGED_MCP: "1" },
+        });
+        this.child = child;
+        child.stderr.resume();
+        const lines = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+        lines.on("line", (line) => {
+          let message;
+          try { message = JSON.parse(line); } catch { return; }
+          const entry = this.pending.get(message.id);
+          if (!entry) return;
+          this.pending.delete(message.id);
+          if (message.error) entry.reject(new Error(message.error.message || "Tasks request failed."));
+          else entry.resolve(message.result);
+        });
+        const closed = () => {
+          if (this.child === child) this.child = null;
+          this.failPending("Tasks bridge exited.");
+        };
+        child.once("error", closed);
+        child.once("exit", closed);
+        try {
+          await this.send("initialize", {
+            protocolVersion: "2025-06-18",
+            capabilities: {},
+            clientInfo: { name: "impel-desktop-tasks", version: "1.0.0" },
+          });
+          child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\\n");
+        } catch (error) {
+          if (this.child === child) this.child = null;
+          try { child.kill(); } catch {}
+          throw error;
+        }
+      })().finally(() => { this.starting = null; });
+      return this.starting;
+    }
+
+    async request(method, params) {
+      await this.ensureStarted();
+      return this.send(method, params);
+    }
+
+    close() {
+      const child = this.child;
+      this.child = null;
+      this.failPending("Tasks bridge closed.");
+      try { child?.kill(); } catch {}
+    }
+  }
+
+  const install = (electron) => {
+    const {
+      app,
+      BrowserWindow,
+      WebContentsView,
+      ipcMain,
+      shell,
+      webContents: electronWebContents,
+    } = electron;
+    if (!app || !BrowserWindow || !WebContentsView || !ipcMain || !electronWebContents) {
+      record("unsupported-electron-surface");
+      return;
+    }
+    const client = new TasksMcpClient();
+    const windows = new Map();
+    const allowedViewContents = new Set();
+    const internalViewContents = new Set();
+    const nativeNavOwners = new Map();
+    const hostUrl = pathToFileURL(hostHtml).href;
+    let hasAnyDomNavigation = false;
+    let creatingInternalWindow = false;
+    const createInternalWindow = (options) => {
+      creatingInternalWindow = true;
+      try {
+        return new BrowserWindow(options);
+      } finally {
+        creatingInternalWindow = false;
+      }
+    };
+
+    const parseBounds = (url, window) => {
+      const parsed = new URL(url);
+      const content = window.getContentBounds();
+      const number = (name, fallback) => {
+        const value = Number.parseInt(parsed.searchParams.get(name) || "", 10);
+        return Number.isFinite(value) ? value : fallback;
+      };
+      const x = Math.max(0, Math.min(content.width - 240, number("x", 0)));
+      const y = Math.max(0, Math.min(content.height - 240, number("y", 0)));
+      return {
+        x,
+        y,
+        width: Math.max(240, Math.min(content.width - x, number("width", content.width - x))),
+        height: Math.max(240, Math.min(content.height - y, number("height", content.height - y))),
+      };
+    };
+
+    const stateFor = (window) => {
+      let state = windows.get(window.id);
+      if (!state) {
+        state = {
+          view: null,
+          bounds: null,
+          visible: false,
+          nativeNav: null,
+          hasDomNavigation: false,
+        };
+        windows.set(window.id, state);
+      }
+      return state;
+    };
+
+    const createView = (window) => {
+      const state = stateFor(window);
+      if (state.view && !state.view.webContents.isDestroyed()) return state;
+      const view = new WebContentsView({
+        webPreferences: {
+          preload: viewPreload,
+          contextIsolation: true,
+          nodeIntegration: false,
+          sandbox: true,
+          spellcheck: false,
+        },
+      });
+      window.contentView.addChildView(view);
+      view.setVisible(false);
+      view.setBackgroundColor("#181818");
+      allowedViewContents.add(view.webContents);
+      internalViewContents.add(view.webContents);
+      view.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
+      view.webContents.on("will-navigate", (event, url) => {
+        if (url !== hostUrl) event.preventDefault();
+      });
+      view.webContents.on("destroyed", () => {
+        allowedViewContents.delete(view.webContents);
+        internalViewContents.delete(view.webContents);
+        try { window.contentView.removeChildView(view); } catch {}
+        if (state.view === view) state.view = null;
+      });
+      view.webContents.loadURL(hostUrl).catch((error) => record("view-load-failed", error));
+      state.view = view;
+      return state;
+    };
+
+    const show = (window, bounds) => {
+      const state = createView(window);
+      state.bounds = bounds;
+      state.visible = true;
+      state.view.setBounds(bounds);
+      state.view.setVisible(true);
+      state.view.webContents.focus();
+      const boardStatus = () => ({
+        parentBounds: window.getBounds(),
+        parentContentBounds: window.getContentBounds(),
+        boardBounds: state.view.getBounds(),
+        boardVisible: state.visible,
+        boardFocused: state.view.webContents.isFocused(),
+      });
+      record("board-shown", JSON.stringify(boardStatus()));
+      setTimeout(() => {
+        if (state.view && !state.view.webContents.isDestroyed()) record("board-visible-check", JSON.stringify(boardStatus()));
+      }, 2000);
+    };
+    const hide = (window) => {
+      const state = windows.get(window.id);
+      if (!state) return;
+      state.visible = false;
+      state.view?.setVisible(false);
+      window.webContents.focus();
+    };
+
+    const layoutBoard = (window) => {
+      const state = windows.get(window.id);
+      if (!state?.visible || !state.view || !state.bounds || state.view.webContents.isDestroyed()) return;
+      state.view.setBounds(state.bounds);
+    };
+
+    const nativeBoardBounds = (window) => {
+      const content = window.getContentBounds();
+      const x = Math.min(296, Math.max(0, content.width - 240));
+      return { x, y: 0, width: Math.max(240, content.width - x), height: Math.max(240, content.height) };
+    };
+
+    const layoutNativeNav = (window) => {
+      const state = windows.get(window.id);
+      if (!state?.nativeNav || state.nativeNav.isDestroyed()) return;
+      const content = window.getContentBounds();
+      state.nativeNav.setBounds({
+        x: content.x + 12,
+        y: content.y + Math.max(48, content.height - 92),
+        width: Math.min(120, Math.max(80, content.width - 24)),
+        height: 38,
+      });
+    };
+
+    const ensureNativeNav = (window) => {
+      if (!window || window.isDestroyed()) return;
+      const state = stateFor(window);
+      if (state.nativeNav && !state.nativeNav.isDestroyed()) return;
+      const navView = createInternalWindow({
+        parent: window,
+        frame: false,
+        transparent: false,
+        show: false,
+        resizable: false,
+        movable: false,
+        minimizable: false,
+        maximizable: false,
+        fullscreenable: false,
+        skipTaskbar: true,
+        hasShadow: false,
+        acceptFirstMouse: true,
+        backgroundColor: "#292929",
+        webPreferences: {
+          preload: viewPreload,
+          contextIsolation: true,
+          nodeIntegration: false,
+          sandbox: true,
+          spellcheck: false,
+        },
+      });
+      navView.setAlwaysOnTop(true, "floating");
+      state.nativeNav = navView;
+      internalViewContents.add(navView.webContents);
+      nativeNavOwners.set(navView.webContents, window);
+      navView.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
+      navView.webContents.on("will-navigate", (event, url) => {
+        if (url !== nativeNavUrl) event.preventDefault();
+      });
+      navView.webContents.on("destroyed", () => {
+        internalViewContents.delete(navView.webContents);
+        nativeNavOwners.delete(navView.webContents);
+      });
+      navView.webContents.on("did-finish-load", () => {
+        navView.webContents.executeJavaScript(
+          "typeof window.impelDesktopTasks?.show === 'function'",
+          true,
+        ).then((ready) => record(ready ? "native-navigation-ready" : "native-navigation-bridge-missing"))
+          .catch((error) => record("native-navigation-check-failed", error));
+      });
+      navView.webContents.loadURL(nativeNavUrl).catch((error) => record("native-navigation-load-failed", error));
+      layoutNativeNav(window);
+      navView.showInactive();
+      navView.moveTop();
+      record("native-navigation-installed");
+    };
+
+    const removeNativeNav = (window) => {
+      const state = windows.get(window.id);
+      if (!state?.nativeNav) return;
+      const navView = state.nativeNav;
+      state.nativeNav = null;
+      internalViewContents.delete(navView.webContents);
+      nativeNavOwners.delete(navView.webContents);
+      try {
+        navView.destroy();
+      } catch {}
+    };
+
+    const ownerWindow = (contents) => {
+      const direct = BrowserWindow.fromWebContents(contents);
+      if (direct && !direct.isDestroyed()) return direct;
+      const owner = contents.getOwnerBrowserWindow?.();
+      if (owner && !owner.isDestroyed()) return owner;
+      const focused = BrowserWindow.getFocusedWindow();
+      if (focused && !focused.isDestroyed()) return focused;
+      return BrowserWindow.getAllWindows().find((window) => !window.isDestroyed() && window.isVisible())
+        || BrowserWindow.getAllWindows().find((window) => !window.isDestroyed())
+        || null;
+    };
+
+    const attachContents = (contents) => {
+      if (
+        !contents
+        || contents.isDestroyed()
+        || contents.__impelDesktopTasksAttached
+        || internalViewContents.has(contents)
+      ) return;
+      contents.__impelDesktopTasksAttached = true;
+      const surface = () => ({
+        id: contents.id,
+        type: contents.getType?.() || null,
+        url: contents.getURL?.() || null,
+      });
+      const inject = (attempt = 0) => {
+        if (internalViewContents.has(contents) || contents.getURL?.() === hostUrl) return;
+        const frames = contents.mainFrame?.framesInSubtree || [];
+        Promise.all(frames.map(async (frame) => ({
+          frameUrl: frame.url,
+          result: await frame.executeJavaScript(navSource, true),
+        })))
+          .then((results) => {
+            record("navigation-injected", JSON.stringify({ ...surface(), frames: results }));
+            const window = ownerWindow(contents);
+            if (!window) return;
+            const state = stateFor(window);
+            if (results.some(({ result }) => result?.anchor)) {
+              hasAnyDomNavigation = true;
+              state.hasDomNavigation = true;
+              for (const owner of BrowserWindow.getAllWindows()) removeNativeNav(owner);
+            } else if (attempt < 3) setTimeout(() => inject(attempt + 1), 1000);
+            else if (!state.hasDomNavigation && !hasAnyDomNavigation) ensureNativeNav(window);
+          })
+          .catch((error) => record(
+            "navigation-injection-failed",
+            JSON.stringify(surface()) + ": " + String(error),
+          ));
+      };
+      contents.on("did-finish-load", () => inject());
+      contents.on("did-frame-finish-load", () => inject());
+      if (!contents.isLoadingMainFrame()) setTimeout(() => inject(), 0);
+      const handleNavigation = (event, url) => {
+        if (!String(url).startsWith("impel-tasks://")) return;
+        event.preventDefault();
+        const window = ownerWindow(contents);
+        if (!window) return;
+        let action;
+        try { action = new URL(url).hostname; } catch { return; }
+        if (action === "hide") hide(window);
+        else if (action === "show") show(window, parseBounds(url, window));
+        else if (action === "layout") {
+          const state = windows.get(window.id);
+          if (state?.visible) show(window, parseBounds(url, window));
+        }
+      };
+      contents.on("will-navigate", handleNavigation);
+      contents.on("will-frame-navigate", handleNavigation);
+    };
+
+    const attachWindow = (window) => {
+      if (
+        !window
+        || window.isDestroyed()
+        || creatingInternalWindow
+        || window.getParentWindow?.()
+        || window.__impelDesktopTasksWindowAttached
+      ) return;
+      window.__impelDesktopTasksWindowAttached = true;
+      attachContents(window.webContents);
+      window.on("resize", () => {
+        layoutNativeNav(window);
+        layoutBoard(window);
+      });
+      window.on("move", () => layoutBoard(window));
+      window.on("focus", () => {
+        const state = windows.get(window.id);
+        if (state?.nativeNav && !state.nativeNav.isDestroyed()) {
+          state.nativeNav.showInactive();
+          state.nativeNav.moveTop();
+        }
+        if (state?.visible && state.view && !state.view.webContents.isDestroyed()) state.view.setVisible(true);
+      });
+      window.on("blur", () => setTimeout(() => {
+        const state = windows.get(window.id);
+        const focused = BrowserWindow.getFocusedWindow();
+        if (focused === state?.nativeNav) return;
+        state?.nativeNav?.hide();
+        state?.view?.setVisible(false);
+      }, 1000));
+      window.on("minimize", () => {
+        const state = windows.get(window.id);
+        state?.nativeNav?.hide();
+        state?.view?.setVisible(false);
+      });
+      window.on("restore", () => {
+        const state = windows.get(window.id);
+        state?.nativeNav?.showInactive();
+        if (state?.visible) state.view?.setVisible(true);
+      });
+      window.on("closed", () => {
+        const state = windows.get(window.id);
+        if (state) {
+          if (state.view) {
+            allowedViewContents.delete(state.view.webContents);
+            internalViewContents.delete(state.view.webContents);
+          }
+          if (state.nativeNav) internalViewContents.delete(state.nativeNav.webContents);
+          if (state.nativeNav) nativeNavOwners.delete(state.nativeNav.webContents);
+          try {
+            if (state.view) {
+              window.contentView.removeChildView(state.view);
+              state.view.webContents.close();
+            }
+            if (state.nativeNav) {
+              state.nativeNav.destroy();
+            }
+          } catch {}
+          windows.delete(window.id);
+        }
+      });
+    };
+
+    ipcMain.handle(rpcChannel, async (event, request) => {
+      if (!allowedViewContents.has(event.sender)) throw new Error("Untrusted Tasks view.");
+      if (request?.method === "resources/read" && request?.params?.uri === resourceUri) {
+        return client.request("resources/read", { uri: resourceUri });
+      }
+      if (request?.method === "tools/call") {
+        const name = request?.params?.name;
+        const allowed = new Set(["show_tasks", "list_tasks", "get_task", "list_members", "create_task", "update_task"]);
+        if (!allowed.has(name)) throw new Error("Unsupported Tasks tool.");
+        const args = request?.params?.arguments;
+        if (args != null && (typeof args !== "object" || Array.isArray(args))) {
+          throw new Error("Invalid Tasks tool arguments.");
+        }
+        return client.request("tools/call", { name, arguments: args || {} });
+      }
+      throw new Error("Unsupported Tasks request.");
+    });
+    ipcMain.handle(openLinkChannel, async (event, rawUrl) => {
+      if (!allowedViewContents.has(event.sender)) throw new Error("Untrusted Tasks view.");
+      const url = new URL(String(rawUrl));
+      if (url.protocol !== "https:" || url.username || url.password) throw new Error("Invalid Tasks link.");
+      await shell.openExternal(url.href);
+      return {};
+    });
+    ipcMain.on(closeChannel, (event) => {
+      if (!allowedViewContents.has(event.sender)) return;
+      for (const window of BrowserWindow.getAllWindows()) {
+        if (windows.get(window.id)?.view?.webContents === event.sender) {
+          hide(window);
+          const nativeNav = windows.get(window.id)?.nativeNav;
+          nativeNav?.webContents.executeJavaScript(
+            "window.__impelDesktopTasksSetActive?.(false);",
+            true,
+          ).catch(() => {});
+          for (const contents of electronWebContents.getAllWebContents()) {
+            if (internalViewContents.has(contents) || contents.isDestroyed()) continue;
+            for (const frame of contents.mainFrame?.framesInSubtree || []) {
+              frame.executeJavaScript(
+                "window.__impelDesktopTasksSetActive?.(false);",
+                true,
+              ).catch(() => {});
+            }
+          }
+          break;
+        }
+      }
+    });
+    ipcMain.on(nativeShowChannel, (event) => {
+      const window = nativeNavOwners.get(event.sender);
+      if (!window || window.isDestroyed()) return;
+      record("native-navigation-selected");
+      show(window, nativeBoardBounds(window));
+    });
+
+    const hideAuxiliaryOutsideApp = () => {
+      const focused = BrowserWindow.getFocusedWindow();
+      if (focused && (windows.has(focused.id) || internalViewContents.has(focused.webContents))) return;
+      for (const state of windows.values()) {
+        state.nativeNav?.hide();
+        state.view?.setVisible(false);
+      }
+    };
+
+    app.on("browser-window-created", (_event, window) => attachWindow(window));
+    app.on("browser-window-blur", () => setTimeout(hideAuxiliaryOutsideApp, 150));
+    app.on("hide", hideAuxiliaryOutsideApp);
+    app.on("web-contents-created", (_event, contents) => setTimeout(() => attachContents(contents), 0));
+    app.on("before-quit", () => client.close());
+    for (const window of BrowserWindow.getAllWindows()) attachWindow(window);
+    for (const contents of electronWebContents.getAllWebContents()) attachContents(contents);
+    record("main-installed");
+  };
+
+  record("preload-loaded");
+  try {
+    install(require("electron"));
+  } catch (error) {
+    record("main-install-failed", error);
+  }
+}
+`;
+}
+
+export function desktopTasksViewPreload() {
+  return `"use strict";
+
+const { contextBridge, ipcRenderer } = require("electron");
+contextBridge.exposeInMainWorld("impelDesktopTasks", Object.freeze({
+  rpc: (request) => ipcRenderer.invoke("impel-desktop-tasks:rpc", request),
+  openLink: (url) => ipcRenderer.invoke("impel-desktop-tasks:open-link", url),
+  close: () => ipcRenderer.send("impel-desktop-tasks:close"),
+  show: () => ipcRenderer.send("impel-desktop-tasks:native-show"),
+}));
+`;
+}
+
+export function desktopTasksHostHtml() {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; frame-src 'self' data:; img-src data:;">
+    <title>Impel Tasks</title>
+    <style>
+      :root { color-scheme: light dark; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+      * { box-sizing: border-box; }
+      html, body { width: 100%; height: 100%; margin: 0; overflow: hidden; background: Canvas; color: CanvasText; }
+      body { display: grid; grid-template-rows: minmax(0, 1fr); }
+      iframe { width: 100%; height: 100%; border: 0; background: Canvas; }
+      #status { display: grid; place-items: center; padding: 24px; color: color-mix(in srgb, CanvasText 65%, transparent); text-align: center; }
+      #status[hidden] { display: none; }
+    </style>
+  </head>
+  <body>
+    <div id="status" role="status">Loading Impel Tasks…</div>
+    <iframe id="widget" title="Impel Tasks" sandbox="allow-scripts allow-forms" hidden></iframe>
+    <script>
+      (() => {
+        const bridge = window.impelDesktopTasks;
+        const frame = document.getElementById("widget");
+        const status = document.getElementById("status");
+        let initialResult = null;
+        let initialized = false;
+        const send = (message) => frame.contentWindow?.postMessage(message, "*");
+        const reply = (id, result, error) => send(error
+          ? { jsonrpc: "2.0", id, error: { code: -32000, message: error } }
+          : { jsonrpc: "2.0", id, result });
+
+        window.addEventListener("message", async (event) => {
+          if (event.source !== frame.contentWindow) return;
+          const message = event.data;
+          if (!message || message.jsonrpc !== "2.0") return;
+          if (message.method === "ui/initialize") {
+            reply(message.id, {
+              protocolVersion: "2026-01-26",
+              hostInfo: { name: "Impel Desktop Tasks", version: "1.0.0" },
+              hostCapabilities: { openLinks: {}, serverTools: {} },
+              hostContext: {
+                theme: matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light",
+                platform: "desktop",
+                displayMode: "fullscreen",
+                availableDisplayModes: ["fullscreen"],
+              },
+            });
+            return;
+          }
+          if (message.method === "ui/notifications/initialized") {
+            if (!initialized && initialResult) {
+              initialized = true;
+              send({ jsonrpc: "2.0", method: "ui/notifications/tool-result", params: initialResult });
+            }
+            return;
+          }
+          if (message.method === "tools/call") {
+            try {
+              const result = await bridge.rpc({ method: "tools/call", params: message.params || {} });
+              reply(message.id, result);
+            } catch (error) {
+              reply(message.id, null, error instanceof Error ? error.message : "Tasks request failed.");
+            }
+            return;
+          }
+          if (message.method === "ui/open-link") {
+            try {
+              await bridge.openLink(message.params?.url);
+              reply(message.id, {});
+            } catch (error) {
+              reply(message.id, null, error instanceof Error ? error.message : "Tasks link failed.");
+            }
+            return;
+          }
+          if (message.method === "ui/request-display-mode") {
+            reply(message.id, { mode: "fullscreen" });
+          }
+        });
+
+        window.addEventListener("keydown", (event) => {
+          if (event.key === "Escape") bridge.close();
+        });
+        Promise.all([
+          bridge.rpc({ method: "resources/read", params: { uri: ${JSON.stringify(DESKTOP_TASKS_RESOURCE_URI)} } }),
+          bridge.rpc({ method: "tools/call", params: { name: "show_tasks", arguments: { scope: "visible", limit: 50 } } }),
+        ]).then(([resource, result]) => {
+          const html = resource?.contents?.find((entry) => entry?.uri === ${JSON.stringify(DESKTOP_TASKS_RESOURCE_URI)})?.text;
+          if (typeof html !== "string" || !html.includes("<html")) throw new Error("Tasks widget resource is unavailable.");
+          initialResult = result;
+          status.hidden = true;
+          frame.hidden = false;
+          frame.srcdoc = html;
+        }).catch((error) => {
+          status.textContent = error instanceof Error ? error.message : "Impel Tasks could not be loaded.";
+        });
+      })();
+    </script>
+  </body>
+</html>
+`;
+}