@shawnowen/comet-mcp 2.4.1 → 2.4.2

package/extension/sidepanel.js

@@ -591,10 +591,6 @@ function buildWindowScopedEquanautContext({ windowId, groups = [], tabs = [] })
     "When the user switches windows, discard this window context and bind only to the new active window.",
     "Use only the tabs, tab groups, task threads, browser-session settings, and window instructions listed in this window context.",
     "Do not infer, inspect, summarize, or act on tabs or groups from any other browser window.",
-    "For focus, display, fullscreen, or lock questions, treat host-supplied Comet diagnostics as in-scope local context.",
-    "Relevant local diagnostics include CDP session status, Comet launch/profile configuration, top-display window policy, macOS Accessibility window bounds, AXFullScreen state, launch agents, and Comet-related processes.",
-    "If those diagnostics are absent, name the exact missing diagnostic surface instead of saying the issue is outside browser scope.",
-    "Never claim that local focus or display locking is unknowable when Comet-Bridge, host shell, or macOS Accessibility diagnostics can be requested by the owning agent.",
     "Keep responses synchronized with this active window's task threads.",
     "",
     `Parent window folder id: ${key || "unknown"}`,
@@ -3660,6 +3656,31 @@ function buildSidepanelGlobalContextCatalog() {
     status: agentState.status || "unknown",
     taskThreadId: taskGroup,
   }));
+  const descriptionRecords = Object.entries(state.entityDescriptions || {}).map(([id, entry]) => ({
+    id,
+    title: id,
+    entityType: entry?.entityType || id.split(":")[0],
+    entityId: entry?.entityId || id.split(":").slice(1).join(":"),
+    description: normalizeDescriptionText(typeof entry === "string" ? entry : entry?.description),
+    extensionOwned: true,
+  }));
+  const windowLabelRecords = Object.entries(state.settings?.windowLabels || {}).map(
+    ([windowId, entry]) => ({
+      id: windowId,
+      windowId,
+      title: typeof entry === "string" ? entry : entry?.label || windowId,
+      label: typeof entry === "string" ? entry : entry?.label || "",
+      source: typeof entry === "string" ? "manual" : entry?.source || "manual",
+      extensionOwned: true,
+    })
+  );
+  const lifecycleBindings = Array.from(state.bindingWindows.entries()).map(([windowId, info]) => ({
+    id: info?.binding?.bindingId || windowId,
+    windowId,
+    title: info?.binding?.codexSessionId || info?.binding?.projectThreadId || windowId,
+    status: info?.bindingStatus || "unbound",
+    extensionOwned: true,
+  }));
   return SessionLogic.buildGlobalContextCatalog({
     liveSessions: (state.groups || []).map(buildSidepanelCatalogRecordFromGroup),
     archivedSessions: state.archived || [],
@@ -3668,9 +3689,26 @@ function buildSidepanelGlobalContextCatalog() {
     gatewayTools: [
       { id: "inspect", title: "Inspect task thread", status: "available" },
       { id: "search", title: "Search task threads", status: "available" },
+      { id: "update_description", title: "Update metadata description", status: "available" },
+      { id: "bulk_update_descriptions", title: "Bulk update descriptions", status: "available" },
+      { id: "rename_window", title: "Rename window label", status: "available" },
+      { id: "rename_group", title: "Rename tab group", status: "available" },
+      { id: "rename_tab", title: "Rename archived tab row", status: "available" },
+      { id: "rename_archive", title: "Rename archived task thread", status: "available" },
+      { id: "update_task_status", title: "Update task-thread status", status: "available" },
+      { id: "save_snapshot", title: "Save group snapshot", status: "available" },
+      {
+        id: "manage_selected_item",
+        title: "Manage full-screen selected items",
+        status: "available",
+      },
       { id: "dispatch_to_fleet", title: "Dispatch to fleet", status: "gateway_required" },
       { id: "get_fleet_status", title: "Get fleet status", status: "available" },
     ],
+    selectedItems: getPrimeSelectedItemCatalog(),
+    lifecycleBindings,
+    windowLabels: windowLabelRecords,
+    descriptions: descriptionRecords,
     slashCommands: getEquanautSlashCommands(),
     plugins: getEquanautPlugins(),
   });
@@ -3744,7 +3782,7 @@ function formatRouterCatalogForPrompt(envelope) {
     "[Equanaut Global Read-Only Catalog]",
     "Use this catalog for search and summaries across saved task threads, archived sessions, recently closed sessions, and fleet state.",
     "Do not mutate catalog records unless a router intent validates the target against active-window and profile policy.",
-    `Counts: live=${counts.live || 0}, archived=${counts.archived || 0}, recent=${counts.recent || 0}, unified=${counts.unified || 0}, fleet=${counts.fleet || 0}, gatewayTools=${counts.gatewayTools || 0}, slashCommands=${counts.slashCommands || 0}, plugins=${counts.plugins || 0}`,
+    `Counts: live=${counts.live || 0}, archived=${counts.archived || 0}, recent=${counts.recent || 0}, unified=${counts.unified || 0}, fleet=${counts.fleet || 0}, gatewayTools=${counts.gatewayTools || 0}, selectedItems=${counts.selectedItems || 0}, lifecycleBindings=${counts.lifecycleBindings || 0}, windowLabels=${counts.windowLabels || 0}, descriptions=${counts.descriptions || 0}, slashCommands=${counts.slashCommands || 0}, plugins=${counts.plugins || 0}`,
   ];
   const sections = [
     ["Live", catalog.liveSessions || []],
@@ -3752,6 +3790,11 @@ function formatRouterCatalogForPrompt(envelope) {
     ["Recently Closed", catalog.recentlyClosed || []],
     ["Unified Threads", catalog.unifiedThreads || []],
     ["Fleet", catalog.fleetMembers || []],
+    ["Gateway Tools", catalog.gatewayTools || []],
+    ["Selected Items", catalog.selectedItems || []],
+    ["Lifecycle Bindings", catalog.lifecycleBindings || []],
+    ["Window Labels", catalog.windowLabels || []],
+    ["Descriptions", catalog.descriptions || []],
     ["Slash Commands", catalog.slashCommands || []],
     ["Plugins", catalog.plugins || []],
   ];
@@ -4249,12 +4292,13 @@ function createArchiveEntryNode(entry) {
   const isExpanded = state.expandedGroups.has(archiveKey);
   const urls = entry.urls || [];
   const archiveDescription = normalizeRecordDescription(entry);
+  const status = fsWorkflowStatus(entry);
 
   const stateClasses = [
     entry.starred ? "starred" : "",
     entry.locked ? "locked" : "",
     entry.pinned ? "pinned" : "",
-    entry.status === "pending" ? "status-pending" : "",
+    status === "pending" ? "status-pending" : "",
   ]
     .filter(Boolean)
     .join(" ");
@@ -4329,7 +4373,7 @@ function createArchiveEntryNode(entry) {
     indicators.push(el("span", { className: "archive-indicator", title: "Locked" }, "🔒"));
   if (entry.pinned)
     indicators.push(el("span", { className: "archive-indicator", title: "Pinned" }, "📌"));
-  if (entry.status === "pending")
+  if (status === "pending")
     indicators.push(el("span", { className: "archive-indicator status-badge pending" }, "Pending"));
   if (archiveDescription)
     indicators.push(
@@ -5075,9 +5119,9 @@ function showArchiveContextMenu(e, entry) {
       action: () => updateStatusAction(entry.taskThreadId, "pending"),
     },
     {
-      label: "Mark as archived",
-      icon: "📦",
-      action: () => updateStatusAction(entry.taskThreadId, "archived"),
+      label: "Mark as done",
+      icon: "✅",
+      action: () => updateStatusAction(entry.taskThreadId, "done"),
     },
     {
       label: entry.pinned ? "Unpin" : "Pin to top",
@@ -5975,6 +6019,213 @@ function isFullscreenMode() {
   );
 }
 
+// Figma node 5:27 "Header Menu" mapped into the full-page extension shell.
+const FS_HOME_ROUTE = "home";
+const FS_DASHBOARD_BASE_URL = "http://localhost:3847/";
+const FS_NAVIGATION_ITEMS = Object.freeze([
+  {
+    route: "home",
+    label: "Home",
+    icon: "⌂",
+    kind: "internal",
+    description: "Return to the full-page session manager home.",
+  },
+  {
+    route: "capabilities",
+    label: "Capabilities",
+    icon: "⚙",
+    kind: "dashboard",
+    dashboardHash: "capabilities",
+    description: "Open the unified capabilities dashboard.",
+  },
+  {
+    route: "live-browser",
+    label: "Live Browser",
+    icon: "⚡",
+    kind: "dashboard",
+    dashboardHash: "live",
+    description: "Open the live browser dashboard.",
+  },
+  {
+    route: "sessions",
+    label: "Sessions",
+    icon: "📡",
+    kind: "dashboard",
+    dashboardHash: "sessions",
+    description: "Open the unified sessions dashboard.",
+  },
+  {
+    route: "dispatch",
+    label: "Dispatch",
+    icon: "↗",
+    kind: "dashboard",
+    dashboardHash: "dispatch",
+    description: "Open the dispatch view.",
+  },
+  {
+    route: "test-suite",
+    label: "Test Suite",
+    icon: "⌬",
+    kind: "dashboard",
+    dashboardHash: "tests",
+    description: "Open the test suite dashboard.",
+  },
+  {
+    route: "window-map",
+    label: "Window Map",
+    icon: "▦",
+    kind: "dashboard",
+    dashboardHash: "mapping",
+    description: "Open the managed window map.",
+  },
+  {
+    route: "task-threads",
+    label: "Task Threads",
+    icon: "▤",
+    kind: "dashboard",
+    dashboardHash: "threads",
+    description: "Open the unified taskthreads dashboard.",
+  },
+  {
+    route: "skill-reference",
+    label: "Skill Reference",
+    icon: "☰",
+    kind: "docs",
+    href: "https://github.com/EQUAStart/equa-comet-browser-control/blob/main/docs/SKILL-ULTIMATE.md",
+    description: "Open the skill reference documentation.",
+  },
+]);
+
+function fsGetNavigationItem(route) {
+  return FS_NAVIGATION_ITEMS.find((item) => item.route === route);
+}
+
+function fsReadFullscreenRoute() {
+  const params = new URLSearchParams(window.location.search);
+  const route = params.get("route") || window.location.hash.replace("#", "");
+  return fsGetNavigationItem(route) ? route : FS_HOME_ROUTE;
+}
+
+function fsBuildNavigationUrl(item) {
+  if (item.kind === "dashboard") {
+    const url = new URL(FS_DASHBOARD_BASE_URL);
+    url.searchParams.set("returnUrl", fsBuildNavigationUrl(fsGetNavigationItem(FS_HOME_ROUTE)));
+    url.hash = item.dashboardHash;
+    return url.toString();
+  }
+  if (item.kind === "docs") return item.href;
+
+  const url = new URL(window.location.href);
+  url.searchParams.set("mode", "fullscreen");
+  url.searchParams.set("route", item.route);
+  url.hash = "";
+  return url.toString();
+}
+
+function fsOpenNavigationUrl(url) {
+  if (globalThis.chrome?.tabs?.create) {
+    globalThis.chrome.tabs.create({ url });
+    return;
+  }
+  window.open(url, "_blank", "noopener");
+}
+
+function fsScrollAndFocus(element) {
+  if (!element) return;
+  element.scrollIntoView({ block: "start", behavior: "smooth" });
+  if (!element.hasAttribute("tabindex")) element.setAttribute("tabindex", "-1");
+  element.focus({ preventScroll: true });
+}
+
+function fsSetFullscreenRoute(route) {
+  const item = fsGetNavigationItem(route) || fsGetNavigationItem(FS_HOME_ROUTE);
+  if (!item || item.kind !== "internal") return;
+
+  const url = new URL(window.location.href);
+  url.searchParams.set("mode", "fullscreen");
+  url.searchParams.set("route", item.route);
+  url.hash = "";
+  window.history.replaceState({ route: item.route }, "", url);
+  fsApplyFullscreenRoute(item.route);
+}
+
+function fsApplyFullscreenRoute(route = fsReadFullscreenRoute()) {
+  const item = fsGetNavigationItem(route) || fsGetNavigationItem(FS_HOME_ROUTE);
+  if (!item || item.kind !== "internal") return;
+
+  document.body.dataset.fullscreenRoute = item.route;
+
+  if (item.route === "home") {
+    const scroll = document.getElementById("fs-main-scroll");
+    const search = document.getElementById("fs-search-input");
+    if (scroll) scroll.scrollTo({ top: 0, behavior: "smooth" });
+    if (search) search.focus({ preventScroll: true });
+    return;
+  }
+
+  if (item.route === "sessions") {
+    fsScrollAndFocus(document.getElementById("fs-groups-list"));
+    return;
+  }
+
+  if (item.route === "task-threads") {
+    fsScrollAndFocus(document.getElementById("fs-tasks-panel"));
+  }
+}
+
+function fsNavigateFromMenu(item) {
+  if (!item) return;
+  if (item.kind === "internal") {
+    fsSetFullscreenRoute(item.route);
+    return;
+  }
+  fsOpenNavigationUrl(fsBuildNavigationUrl(item));
+}
+
+function fsInitNavigationMenu() {
+  const navBtn = document.getElementById("fs-btn-navigation");
+  if (!navBtn) return;
+
+  navBtn.addEventListener("click", (event) => {
+    event.stopPropagation();
+    const activeRoute = fsReadFullscreenRoute();
+    navBtn.setAttribute("aria-expanded", "true");
+
+    showContextMenu(
+      navBtn,
+      FS_NAVIGATION_ITEMS.map((item, index) => ({
+        icon: item.icon,
+        label: item.label,
+        active: item.kind === "internal" && item.route === activeRoute,
+        action: () => {
+          navBtn.setAttribute("aria-expanded", "false");
+          fsNavigateFromMenu(item);
+        },
+        divider: false,
+      }))
+    );
+
+    requestAnimationFrame(() => {
+      const menu = document.getElementById("fs-context-menu");
+      if (!menu) return;
+      menu.setAttribute("aria-label", "Full-screen navigation");
+      menu.querySelectorAll(".fs-context-menu-item").forEach((el, index) => {
+        const item = FS_NAVIGATION_ITEMS[index];
+        if (!item) return;
+        el.dataset.route = item.route;
+        el.title = item.description || item.label;
+        if (index === 0) el.classList.add("fs-nav-home-link");
+      });
+    });
+
+    const resetExpanded = () => navBtn.setAttribute("aria-expanded", "false");
+    setTimeout(() => {
+      document.addEventListener("click", resetExpanded, { once: true });
+      document.addEventListener("keydown", resetExpanded, { once: true });
+    }, 0);
+  });
+}
+
 // ─── Reusable Components (T006-T008) ────────────────────────────────────────
 
 // T007: Toast notification
@@ -6147,7 +6398,7 @@ function fsRenderSidebar(groups) {
     totalTabs += tabCount;
     const groupId = group.taskThreadId || group.id;
     const isExpanded = fsSidebarExpanded.has(groupId);
-    const status = group.status || "archived";
+    const status = fsWorkflowStatus(group);
 
     const li = document.createElement("li");
     li.className = "fs-sidebar-item";
@@ -6333,7 +6584,7 @@ function fsSidebarContextMenu(e, groupId, group) {
   const isLocked = fsLockedGroups.has(groupId);
   const isStarred = group.starred;
   const isPinned = group.pinned;
-  const status = group.status || "archived";
+  const status = fsWorkflowStatus(group);
 
   // Create a temporary trigger at mouse position
   const trigger = document.createElement("div");
@@ -6398,12 +6649,6 @@ function fsSidebarContextMenu(e, groupId, group) {
       action: () => fsUpdateStatus(groupId, "done"),
       active: status === "done",
     },
-    {
-      icon: "\uD83D\uDCE6",
-      label: "Mark as archived",
-      action: () => fsUpdateStatus(groupId, "archived"),
-      active: status === "archived",
-    },
     { divider: true },
     { icon: "\uD83D\uDD17", label: "Copy URLs", action: () => fsShareAsUrl(group) },
     { icon: "\uD83D\uDCCB", label: "Export to text", action: () => fsExportToText(group) },
@@ -6461,8 +6706,9 @@ function fsRenderGroups(groups) {
     card.className = "fs-group-card";
     if (fsSelectedGroups.has(String(groupId))) card.classList.add("selected");
     if (fsIsGroupStale && fsIsGroupStale(group)) card.classList.add("stale");
-    if (group.status === "pending") card.classList.add("status-pending");
-    if (group.status === "done") card.classList.add("status-done");
+    const status = fsWorkflowStatus(group);
+    if (status === "pending") card.classList.add("status-pending");
+    if (status === "done") card.classList.add("status-done");
     card.id = "fs-group-" + groupId;
 
     const tabs = group.urls || group.tabs || [];
@@ -6645,6 +6891,10 @@ async function fsSaveLockedGroups() {
   await chrome.storage.local.set({ lockedGroups: [...fsLockedGroups] });
 }
 
+function fsWorkflowStatus(group) {
+  return SessionLogic.normalizeArchiveWorkflowStatus(group?.status);
+}
+
 // ─── Full-Screen Data Loading ───────────────────────────────────────────────
 
 async function fsLoadAndRender() {
@@ -6960,14 +7210,9 @@ async function fsRenderTasksPanel(groups) {
   const agents = await fsFetchAgentRegistryForPanel();
   fsTaskthreadsState.agentRegistry = agents;
 
-  const pending = fsSortGroups(
-    groups.filter((g) => g.status === "pending"),
-    fsTaskthreadsState.sortPending
-  );
-  const done = fsSortGroups(
-    groups.filter((g) => g.status === "done"),
-    fsTaskthreadsState.sortDone
-  );
+  const taskGroups = SessionLogic.fsPartitionTaskthreadGroups(groups);
+  const pending = fsSortGroups(taskGroups.pending, fsTaskthreadsState.sortPending);
+  const done = fsSortGroups(taskGroups.done, fsTaskthreadsState.sortDone);
 
   if (countEl) countEl.textContent = String(pending.length + done.length);
   if (pendingCountEl) pendingCountEl.textContent = String(pending.length);
@@ -7263,7 +7508,8 @@ function fsUpdateBulkBar() {
     );
     fsAddBulkButton("Restore", () => fsRestoreGroup(groupId));
     fsAddBulkButton("Copy URLs", () => fsShareAsUrl(group));
-    fsAddBulkButton("Mark as archived", () => fsUpdateStatus(groupId, "archived"));
+    fsAddBulkButton("Mark as pending", () => fsUpdateStatus(groupId, "pending"));
+    fsAddBulkButton("Mark as done", () => fsUpdateStatus(groupId, "done"));
     fsAddBulkButton("Move to trash", () => fsDeleteGroup(groupId), { danger: true });
   } else if (tabCount === 1 && groupCount === 0 && selectedTabs[0]) {
     const selected = selectedTabs[0];
@@ -7278,13 +7524,13 @@ function fsUpdateBulkBar() {
     if (groupCount) {
       fsAddBulkButton("Restore groups", fsBulkRestoreGroups);
       fsAddBulkButton("Copy URLs", fsBulkCopyGroups);
-      fsAddBulkButton("Mark as archived", () => fsBulkUpdateGroupStatus("archived"));
+      fsAddBulkButton("Mark as pending", () => fsBulkUpdateGroupStatus("pending"));
+      fsAddBulkButton("Mark as done", () => fsBulkUpdateGroupStatus("done"));
       fsAddBulkButton("Move groups to trash", fsBulkTrashGroups, { danger: true });
     }
     if (tabCount) {
       fsAddBulkButton("Restore tabs", fsBulkRestore);
       fsAddBulkButton("Copy URLs", fsBulkCopy);
-      fsAddBulkButton("Mark groups archived", fsBulkArchive);
       fsAddBulkButton("Move tabs to trash", fsBulkTrash, { danger: true });
     }
   }
@@ -7358,6 +7604,301 @@ function fsResolveSelectedTabs() {
   return SessionLogic.fsResolveSelectedTabs(fsSelectedTabs, fsCachedGroups);
 }
 
+function getPrimeSelectedItemCatalog() {
+  const groups = fsResolveSelectedGroups().map((group) => ({
+    id: String(group.taskThreadId || group.id),
+    entityType: "archive",
+    taskThreadId: String(group.taskThreadId || group.id),
+    title: group.sessionName || group.title || "Untitled",
+    description: normalizeRecordDescription(group),
+    status: group.status || "unknown",
+    sourceFamily: "selected",
+    extensionOwned: true,
+  }));
+  const tabs = fsResolveSelectedTabs().map((selected) => ({
+    id: `${selected.groupId}-${selected.tabIdx}`,
+    entityType: "archive-tab",
+    taskThreadId: String(selected.groupId),
+    tabIndex: selected.tabIdx,
+    title: selected.tab?.title || selected.tab?.url || "Untitled",
+    url: selected.tab?.url || "",
+    description: normalizeRecordDescription(selected.tab),
+    sourceFamily: "selected",
+    extensionOwned: true,
+  }));
+  return [...groups, ...tabs];
+}
+
+function primeCommandText(command, ...keys) {
+  for (const key of keys) {
+    if (command?.[key] !== undefined && command?.[key] !== null) {
+      return normalizeDescriptionText(command[key]);
+    }
+  }
+  return "";
+}
+
+function primeTargetTaskThreadId(target) {
+  return String(target?.taskThreadId || target?.threadId || target?.entityId || target?.id || "");
+}
+
+function primeTargetTabIndex(target) {
+  const index = Number(target?.tabIndex ?? target?.tabIdx ?? target?.index);
+  return Number.isInteger(index) && index >= 0 ? index : -1;
+}
+
+function buildPrimeValidationScope(command) {
+  if (command?.activeWindowScope) return command.activeWindowScope;
+  const windowScope = {
+    windowId: state.activeWindowId || command?.target?.windowId || "unknown",
+  };
+  return buildActiveWindowRouterScope(
+    windowScope,
+    getWindowEquanautInstructions(windowScope.windowId)
+  );
+}
+
+function validatePrimeCommand(command) {
+  const payload = {
+    ...command,
+    actorRole: command?.actorRole || "equanaut_prime",
+    activeWindowScope: buildPrimeValidationScope(command),
+  };
+  return SessionLogic.validateRouterIntent(payload);
+}
+
+async function loadPrimeArchiveGroup(taskThreadId) {
+  const groups = await sendMessage("getArchivedGroups");
+  return (groups || []).find((group) => String(group.taskThreadId || group.id) === taskThreadId);
+}
+
+async function updatePrimeArchiveTabMetadata(target, updates) {
+  const taskThreadId = primeTargetTaskThreadId(target);
+  const tabIndex = primeTargetTabIndex(target);
+  if (!taskThreadId) throw new Error("taskThreadId is required for archive tab updates");
+  if (tabIndex < 0) throw new Error("tabIndex is required for archive tab updates");
+  const group = await loadPrimeArchiveGroup(taskThreadId);
+  if (!group) throw new Error("Archive group not found: " + taskThreadId);
+  const urls = [...(group.urls || group.tabs || [])];
+  if (!urls[tabIndex]) throw new Error("Archive tab not found: " + tabIndex);
+  urls[tabIndex] = { ...urls[tabIndex], ...updates };
+  await sendMessage("updateArchiveEntry", { taskThreadId, updates: { urls } });
+  return { taskThreadId, tabIndex, updates };
+}
+
+async function executePrimeDescriptionUpdate(command) {
+  const target = command.target || {};
+  const entityType = String(target.entityType || target.type || "");
+  const description = primeCommandText(command, "description", "value", "text");
+  if (entityType === "archive-tab" || target.tabIndex !== undefined) {
+    return await updatePrimeArchiveTabMetadata(target, { description });
+  }
+  if (entityType === "archive" || target.sourceFamily === "archived") {
+    const taskThreadId = primeTargetTaskThreadId(target);
+    if (!taskThreadId) throw new Error("taskThreadId is required for archive descriptions");
+    await sendMessage("updateArchiveDescription", { taskThreadId, description });
+    return { taskThreadId, description };
+  }
+  const entityId =
+    target.entityId || target.id || target.windowId || target.groupId || target.tabId;
+  if (!entityType || entityId === undefined || entityId === null) {
+    throw new Error("entityType and entityId are required for description updates");
+  }
+  await persistEntityDescription(entityType, entityId, description);
+  return { entityType, entityId: String(entityId), description };
+}
+
+async function executePrimeRename(command) {
+  const target = command.target || {};
+  const intent = String(command.intent || "");
+  const entityType = String(target.entityType || target.type || "");
+  const title = primeCommandText(command, "newTitle", "title", "label", "name");
+  if (!title.trim()) throw new Error("New title or label is required");
+
+  if (intent === "rename_window" || entityType === "window" || entityType === "window-label") {
+    const windowId = target.windowId || target.entityId || target.id;
+    if (windowId === undefined || windowId === null) throw new Error("windowId is required");
+    await persistWindowLabel(windowId, title, "manual");
+    return { windowId: String(windowId), label: title };
+  }
+
+  if (intent === "rename_archive" || entityType === "archive") {
+    const taskThreadId = primeTargetTaskThreadId(target);
+    if (!taskThreadId) throw new Error("taskThreadId is required for archive rename");
+    await sendMessage("renameArchived", { taskThreadId, newTitle: title });
+    return { taskThreadId, title };
+  }
+
+  if (intent === "rename_tab" || entityType === "archive-tab") {
+    if (target.sourceFamily === "live" && entityType !== "archive-tab") {
+      throw new Error("Live tab titles are browser-owned; update the tab description instead");
+    }
+    return await updatePrimeArchiveTabMetadata(target, { title });
+  }
+
+  const groupId = target.groupId || target.entityId || target.id;
+  if (groupId === undefined || groupId === null) throw new Error("groupId is required");
+  if (!chrome.tabGroups?.update) throw new Error("tabGroups API unavailable");
+  await chrome.tabGroups.update(Number(groupId), { title });
+  return { groupId: String(groupId), title };
+}
+
+async function executePrimeTaskStatus(command) {
+  const target = command.target || {};
+  const taskThreadId = primeTargetTaskThreadId(target);
+  const status = primeCommandText(command, "status", "taskStatus", "value");
+  if (!taskThreadId) throw new Error("taskThreadId is required for status update");
+  if (!status) throw new Error("status is required");
+  await sendMessage("updateArchiveStatus", { taskThreadId, status });
+  return { taskThreadId, status };
+}
+
+async function executePrimeSaveSnapshot(command) {
+  const target = command.target || {};
+  const groupId = target.groupId || target.entityId || target.id;
+  if (groupId === undefined || groupId === null) throw new Error("groupId is required");
+  await saveGroupSnapshotAction(Number(groupId), target.title || command.title || "");
+  return { groupId: String(groupId), saved: true };
+}
+
+async function executePrimeSelectedItemCommand(command) {
+  const action = String(command.action || command.selectedAction || "list").toLowerCase();
+  const selected = getPrimeSelectedItemCatalog();
+  if (action === "clear_selection" || action === "clear") {
+    fsClearSelections();
+    return { selectedItems: [], cleared: true };
+  }
+  if (action === "list" || selected.length === 0) {
+    return { selectedItems: selected };
+  }
+
+  const results = [];
+  for (const item of selected) {
+    const target = { ...item, sourceFamily: "selected", extensionOwned: true };
+    if (action === "update_description" || action === "describe") {
+      results.push(
+        await executePrimeRouterIntent({
+          ...command,
+          intent: "update_description",
+          target,
+          description: command.description,
+        })
+      );
+    } else if (action === "rename") {
+      results.push(
+        await executePrimeRouterIntent({
+          ...command,
+          intent: item.entityType === "archive-tab" ? "rename_tab" : "rename_archive",
+          target,
+        })
+      );
+    } else if (action === "update_task_status" || action === "status") {
+      if (item.entityType === "archive") {
+        results.push(
+          await executePrimeRouterIntent({
+            ...command,
+            intent: "update_task_status",
+            target,
+          })
+        );
+      }
+    } else {
+      throw new Error("Unsupported selected-item action: " + action);
+    }
+  }
+  return { selectedItems: selected, results };
+}
+
+async function executePrimeRouterIntent(command = {}) {
+  if (command.intent === "bulk_update_descriptions") {
+    const targets = Array.isArray(command.targets) ? command.targets : [];
+    const results = [];
+    for (const item of targets) {
+      const target = item.target || item;
+      results.push(
+        await executePrimeRouterIntent({
+          ...command,
+          intent: "update_description",
+          target,
+          description: item.description !== undefined ? item.description : command.description,
+        })
+      );
+    }
+    return {
+      intent: "bulk_update_descriptions",
+      success: results.every((result) => result.success),
+      results,
+      audit: {
+        policyTier: "prime",
+        activeWindowId: state.activeWindowId || "unknown",
+        createdAt: new Date().toISOString(),
+      },
+    };
+  }
+
+  const validation = validatePrimeCommand(command);
+  if (!validation.allowed) {
+    return {
+      intent: command.intent || "unknown",
+      target: command.target || {},
+      success: false,
+      allowed: false,
+      denial: validation.denial,
+      audit: validation.audit,
+    };
+  }
+
+  try {
+    let result;
+    switch (command.intent) {
+      case "update_description":
+        result = await executePrimeDescriptionUpdate(command);
+        break;
+      case "rename_window":
+      case "rename_group":
+      case "rename_tab":
+      case "rename_archive":
+        result = await executePrimeRename(command);
+        break;
+      case "update_task_status":
+        result = await executePrimeTaskStatus(command);
+        break;
+      case "save_snapshot":
+        result = await executePrimeSaveSnapshot(command);
+        break;
+      case "manage_selected_item":
+        result = await executePrimeSelectedItemCommand(command);
+        break;
+      default:
+        throw new Error("Unsupported Prime command intent: " + command.intent);
+    }
+    await Promise.allSettled([
+      fetchAndRenderLiveTree(),
+      fetchAndRenderArchived(),
+      fetchAndRenderRecent(),
+    ]);
+    return {
+      intent: command.intent,
+      target: command.target || {},
+      scope: validation.scope,
+      success: true,
+      allowed: true,
+      result,
+      audit: validation.audit,
+    };
+  } catch (err) {
+    return {
+      intent: command.intent || "unknown",
+      target: command.target || {},
+      scope: validation.scope,
+      success: false,
+      allowed: true,
+      error: err?.message || String(err),
+      audit: validation.audit,
+    };
+  }
+}
+
 // T038: Bulk restore — open selected tabs in a new window
 async function fsBulkRestore() {
   const selected = fsResolveSelectedTabs();
@@ -7394,23 +7935,6 @@ async function fsBulkCopy() {
   }
 }
 
-// T038: Bulk archive — mark selected tabs' groups as archived
-async function fsBulkArchive() {
-  const selected = fsResolveSelectedTabs();
-  if (!selected.length) return;
-  const groupIds = [...new Set(selected.map((s) => s.groupId))];
-  for (const gid of groupIds) {
-    try {
-      await sendMessage("updateArchiveStatus", { taskThreadId: gid, status: "archived" });
-    } catch {
-      // continue
-    }
-  }
-  showToast(groupIds.length + " group" + (groupIds.length !== 1 ? "s" : "") + " archived");
-  fsSelectedTabs.clear();
-  await fsLoadAndRender();
-}
-
 // T038: Bulk trash — remove selected tabs from their groups
 async function fsBulkTrash() {
   const selected = fsResolveSelectedTabs();
@@ -7594,7 +8118,7 @@ function fsShowGroupContextMenu(trigger, groupId, group) {
   const isLocked = fsLockedGroups.has(groupId);
   const isStarred = group.starred;
   const isPinned = group.pinned;
-  const status = group.status || "archived";
+  const status = fsWorkflowStatus(group);
   const color = group.color || "grey";
 
   const COLORS = ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"];
@@ -7664,12 +8188,6 @@ function fsShowGroupContextMenu(trigger, groupId, group) {
       action: () => fsUpdateStatus(groupId, "done"),
       active: status === "done",
     },
-    {
-      icon: "📦",
-      label: "Mark as archived",
-      action: () => fsUpdateStatus(groupId, "archived"),
-      active: status === "archived",
-    },
     { divider: true },
     // Clipboard / sharing
     { icon: "🔗", label: "Copy URLs to clipboard", action: () => fsShareAsUrl(group) },
@@ -7863,7 +8381,7 @@ let fsHideArchived = false;
 
 // Advanced filter bar state
 const fsAdvancedFilter = {
-  status: "all", // "all" | "archived" | "pending" | "done"
+  status: "all", // "all" | "pending" | "done"
   colors: [], // [] = all, ["blue","red"] = only those
   starred: false,
   locked: false,
@@ -7886,6 +8404,11 @@ async function fsLoadFilterState() {
     if (stored.advancedFilter) {
       Object.assign(fsAdvancedFilter, stored.advancedFilter);
       if (!Array.isArray(fsAdvancedFilter.colors)) fsAdvancedFilter.colors = [];
+      if (fsAdvancedFilter.status === "archived" || fsAdvancedFilter.status === "saved") {
+        fsAdvancedFilter.status = "pending";
+      } else if (!["all", "pending", "done"].includes(fsAdvancedFilter.status)) {
+        fsAdvancedFilter.status = "all";
+      }
     }
   } catch {
     // ignore
@@ -8419,7 +8942,6 @@ function fsGetViewLabel() {
   if (fsAdvancedFilter.stale) return "Stale";
   if (fsAdvancedFilter.status === "pending") return "Pending Tasks";
   if (fsAdvancedFilter.status === "done") return "Completed";
-  if (fsAdvancedFilter.status === "archived") return "Archived";
   if (fsAdvancedFilter.colors.length === 1) {
     const c = fsAdvancedFilter.colors[0];
     return c.charAt(0).toUpperCase() + c.slice(1) + " Groups";
@@ -8655,8 +9177,9 @@ function fsCreateGroupCard(group) {
   card.className = "fs-group-card";
   if (fsSelectedGroups.has(String(groupId))) card.classList.add("selected");
   if (typeof fsIsGroupStale === "function" && fsIsGroupStale(group)) card.classList.add("stale");
-  if (group.status === "pending") card.classList.add("status-pending");
-  if (group.status === "done") card.classList.add("status-done");
+  const status = fsWorkflowStatus(group);
+  if (status === "pending") card.classList.add("status-pending");
+  if (status === "done") card.classList.add("status-done");
   card.id = "fs-group-" + groupId;
 
   const tabs = group.urls || group.tabs || [];
@@ -8983,7 +9506,7 @@ async function fsImportFromText(text) {
       urls: urls.map((u) => ({ url: u, title: u })),
       archivedAt: new Date().toISOString(),
       restoredAt: null,
-      status: "archived",
+      status: "pending",
     };
     // Save via the archive system — prepend to existing
     const current = Array.isArray(archive) ? archive : [];
@@ -9091,7 +9614,7 @@ async function fsImportBookmarkFolder(folderNode) {
       urls,
       archivedAt: new Date().toISOString(),
       restoredAt: null,
-      status: "archived",
+      status: "pending",
     };
     const current = Array.isArray(archive) ? archive : [];
     current.unshift(entry);
@@ -9672,7 +10195,7 @@ function fsIsGroupStale(group) {
   return Date.now() - new Date(ts).getTime() > thresholdMs;
 }
 
-async function fsArchiveAllStale() {
+async function fsMarkAllStaleDone() {
   const staleGroups = fsCachedGroups.filter(fsIsGroupStale);
   if (!staleGroups.length) {
     showToast("No stale sessions found");
@@ -9681,13 +10204,13 @@ async function fsArchiveAllStale() {
   for (const group of staleGroups) {
     const gid = group.taskThreadId || group.id;
     try {
-      await sendMessage("updateArchiveStatus", { taskThreadId: gid, status: "archived" });
+      await sendMessage("updateArchiveStatus", { taskThreadId: gid, status: "done" });
     } catch {
       // continue
     }
   }
   showToast(
-    staleGroups.length + " stale session" + (staleGroups.length !== 1 ? "s" : "") + " archived"
+    staleGroups.length + " stale session" + (staleGroups.length !== 1 ? "s" : "") + " marked done"
   );
   await fsLoadAndRender();
 }
@@ -9977,11 +10500,8 @@ function fsInitTopBarActions() {
         { label: "Tab Group Templates", action: fsShowTemplatesModal },
         { label: "Rename current window", action: fsRenameCurrentWindowLabel },
         { divider: true },
+        { label: "Mark stale sessions done", action: fsMarkAllStaleDone },
         { label: "Export workspace (JSON)", action: fsExportWorkspace },
-        {
-          label: "Archive stale sessions",
-          action: fsArchiveAllStale,
-        },
       ]);
     });
   }
@@ -10027,8 +10547,10 @@ async function initFullscreenUI() {
   fsInitCommandPalette();
   fsInitKeyboardNav();
   fsInitDragAndDrop();
+  fsInitNavigationMenu();
   fsInitTopBarActions();
   await fsLoadAndRender();
+  fsApplyFullscreenRoute();
   fsStartAgentPoll();
   await fsRenderTimeline();
 }
@@ -10306,5 +10828,13 @@ async function init() {
   }
 }
 
+if (typeof globalThis !== "undefined") {
+  globalThis.EquanautPrimeControlPlane = {
+    executePrimeRouterIntent,
+    getPrimeSelectedItemCatalog,
+    buildSidepanelGlobalContextCatalog,
+  };
+}
+
 // Start when DOM is ready
 document.addEventListener("DOMContentLoaded", init);