@shawnowen/comet-mcp 2.4.1 → 2.4.2

package/extension/session-logic.js

@@ -799,6 +799,28 @@
     return filtered;
   }
 
+  function normalizeArchiveWorkflowStatus(status) {
+    const raw = String(status || "")
+      .trim()
+      .toLowerCase();
+    if (raw === "done") return "done";
+    if (raw === "trashed") return "trashed";
+    return "pending";
+  }
+
+  function fsPartitionTaskthreadGroups(groups) {
+    const pending = [];
+    const done = [];
+
+    for (const group of Array.isArray(groups) ? groups : []) {
+      const status = normalizeArchiveWorkflowStatus(group?.status);
+      if (status === "pending") pending.push(group);
+      if (status === "done") done.push(group);
+    }
+
+    return { pending, done };
+  }
+
   // Extended filter engine for the full-screen filter bar
   function fsApplyAdvancedFilters(groups, opts) {
     let filtered = groups;
@@ -814,7 +836,10 @@
 
     // Status filter
     if (opts.status && opts.status !== "all") {
-      filtered = filtered.filter((g) => (g.status || "archived") === opts.status);
+      const expectedStatus = normalizeArchiveWorkflowStatus(opts.status);
+      filtered = filtered.filter(
+        (g) => normalizeArchiveWorkflowStatus(g.status) === expectedStatus
+      );
     }
 
     // Color filter (array of active colors)
@@ -927,8 +952,8 @@
           break;
         }
         case "status": {
-          sectionKey = group.status || "archived";
-          const statusLabels = { pending: "Pending", done: "Done", archived: "Archived" };
+          sectionKey = normalizeArchiveWorkflowStatus(group.status);
+          const statusLabels = { pending: "Pending", done: "Done", trashed: "Trashed" };
           sectionLabel = statusLabels[sectionKey] || sectionKey;
           break;
         }
@@ -1913,15 +1938,107 @@
     "restore",
     "archive",
     "rename",
+    "update_description",
+    "bulk_update_descriptions",
+    "rename_window",
+    "rename_group",
+    "rename_tab",
+    "rename_archive",
+    "update_task_status",
+    "save_snapshot",
+    "manage_selected_item",
     "mark_pending",
     "mark_done",
     "dispatch_to_fleet",
     "get_fleet_status",
     "open_orchestrator_url",
     "invoke_slash_command",
+    "bind_bwoa_session",
+    "snapshot_bwoa_window",
+    "delegate_bwoa_spoke",
+    "complete_bwoa_spoke",
   ]);
 
   const READ_ONLY_ROUTER_INTENTS = new Set(["inspect", "search", "get_fleet_status"]);
+  const BWOA_DEFAULT_SPACE_URL =
+    "https://www.perplexity.ai/spaces/hub-browser-agent-window-all-t-dcF8yEn2RFejcQJxYBf3Zg";
+
+  const BWOA_MUTATING_INTENTS = new Set([
+    "bind_bwoa_session",
+    "snapshot_bwoa_window",
+    "delegate_bwoa_spoke",
+    "complete_bwoa_spoke",
+  ]);
+
+  function normalizeRole(value) {
+    return String(value || "")
+      .trim()
+      .toLowerCase()
+      .replace(/[\s-]+/g, "_");
+  }
+
+  function isPrimeRouterActor(data) {
+    const principal = data?.principal || {};
+    const activeWindowScope = data?.activeWindowScope || {};
+    const roles = [
+      data?.actorRole,
+      data?.role,
+      data?.actor,
+      principal.role,
+      principal.actorRole,
+      activeWindowScope.actorRole,
+    ].map(normalizeRole);
+    return (
+      data?.prime === true ||
+      principal.prime === true ||
+      roles.includes("prime") ||
+      roles.includes("equanaut_prime") ||
+      roles.includes("equanautprime")
+    );
+  }
+
+  function isExtensionOwnedMetadataTarget(target) {
+    const source = String(target?.sourceFamily || target?.source || "").toLowerCase();
+    const entityType = String(target?.entityType || target?.type || "").toLowerCase();
+    return !!(
+      target?.extensionOwned === true ||
+      target?.extensionManaged === true ||
+      target?.managedByExtension === true ||
+      [
+        "archived",
+        "archive",
+        "recent",
+        "saved",
+        "unified",
+        "selected",
+        "selected_item",
+        "task-thread",
+        "task_thread",
+        "gateway",
+      ].includes(source) ||
+      [
+        "archive",
+        "archive-tab",
+        "recent-window",
+        "recent-tab",
+        "selected-item",
+        "task-thread",
+        "window-label",
+      ].includes(entityType)
+    );
+  }
+
+  function isPrimeLiveTargetVerified(target) {
+    const owner = normalizeRole(target?.profileOwner || target?.owner);
+    const displayRole = normalizeRole(target?.displayRole);
+    if (owner !== "agent") return false;
+    return !!(
+      displayRole === "top_agents" ||
+      target?.extensionOwned === true ||
+      target?.extensionManaged === true ||
+      target?.managedByExtension === true
+    );
+  }
 
   function isCapabilityUsable(capability) {
     return !!(
@@ -2027,6 +2144,38 @@
     return record.status || record.taskStatus || record.state || fallback || "unknown";
   }
 
+  function catalogPrimeOperationsForSource(sourceFamily) {
+    const source = String(sourceFamily || "").toLowerCase();
+    if (source === "live") {
+      return [
+        "inspect",
+        "search",
+        "update_description",
+        "bulk_update_descriptions",
+        "rename_window",
+        "rename_group",
+        "rename_tab",
+        "save_snapshot",
+      ];
+    }
+    if (["archived", "archive", "recent", "saved", "unified", "selected"].includes(source)) {
+      return [
+        "inspect",
+        "search",
+        "update_description",
+        "bulk_update_descriptions",
+        "rename_archive",
+        "rename_tab",
+        "update_task_status",
+        "manage_selected_item",
+      ];
+    }
+    if (source === "gateway") {
+      return ["inspect", "search", "update_description"];
+    }
+    return ["inspect", "search"];
+  }
+
   function normalizeCatalogRecord(record, sourceFamily, index) {
     const source = sourceFamily || "unknown";
     const nativeId =
@@ -2060,10 +2209,461 @@
         record.closedAt ||
         null,
       allowedOperations: ["inspect", "search"],
+      primeAllowedOperations: catalogPrimeOperationsForSource(source),
+      extensionOwned: record.extensionOwned !== false,
       readOnly: true,
     };
   }
 
+  function normalizeBwoaStatus(value) {
+    const status = normalizeRole(value || "active");
+    if (
+      ["active", "pending", "running", "paused", "completed", "stale", "failed"].includes(status)
+    ) {
+      return status;
+    }
+    return "active";
+  }
+
+  function normalizeTrackedUrl(record, index) {
+    const url = String(record?.url || record?.href || "").trim();
+    return {
+      id: String(record?.id || record?.bookmarkId || record?.tabId || `url-${index + 1}`),
+      title: String(record?.title || record?.name || url || "Untitled"),
+      url,
+      source: String(record?.source || record?.sourceFamily || "tracked"),
+      taskThreadId: stringOrNull(record?.taskThreadId || record?.threadId),
+      description: normalizeEntityDescription(record),
+    };
+  }
+
+  function normalizeBwoaSpoke(record, index) {
+    return {
+      id: String(record?.id || record?.agentId || `spoke-${index + 1}`),
+      agentId: stringOrNull(record?.agentId || record?.id),
+      taskThreadId: stringOrNull(record?.taskThreadId || record?.threadId),
+      threadUrl: stringOrNull(record?.threadUrl || record?.url || record?.orchestratorUrl),
+      goal: String(record?.goal || record?.taskGoal || record?.title || ""),
+      successBenchmark: String(record?.successBenchmark || record?.benchmark || ""),
+      status: normalizeBwoaStatus(record?.status || "pending"),
+      successScore:
+        record?.successScore === undefined || record?.successScore === null
+          ? null
+          : Number(record.successScore),
+      finalSummary: String(record?.finalSummary || record?.summary || ""),
+      logsReference: stringOrNull(record?.logsReference || record?.logRef || record?.threadUrl),
+    };
+  }
+
+  function normalizeBwoaTab(record, index) {
+    return {
+      id: String(record?.id || record?.tabId || `tab-${index + 1}`),
+      tabId: record?.tabId === undefined ? null : Number(record.tabId),
+      groupId: record?.groupId === undefined ? null : Number(record.groupId),
+      windowId: record?.windowId === undefined ? null : Number(record.windowId),
+      title: String(record?.title || record?.url || "Untitled"),
+      url: stringOrNull(record?.url),
+      active: !!record?.active,
+      pinned: !!record?.pinned,
+      description: normalizeEntityDescription(record),
+      taskThreadId: stringOrNull(record?.taskThreadId || record?.threadId),
+    };
+  }
+
+  function normalizeBwoaGroup(record, index) {
+    const tabs = Array.isArray(record?.tabs) ? record.tabs : [];
+    return {
+      id: String(record?.id || record?.groupId || `group-${index + 1}`),
+      groupId: record?.groupId === undefined ? record?.id || null : Number(record.groupId),
+      windowId: record?.windowId === undefined ? null : Number(record.windowId),
+      title: String(record?.title || record?.name || "Untitled Group"),
+      color: String(record?.color || "grey"),
+      status: normalizeBwoaStatus(record?.status || "active"),
+      description: normalizeEntityDescription(record),
+      taskThreadId: stringOrNull(record?.taskThreadId || record?.threadId),
+      tabs: tabs.map((tab, tabIndex) => normalizeBwoaTab(tab, tabIndex)),
+    };
+  }
+
+  function buildBwoaWindowHubSession(input) {
+    const data = input || {};
+    const now = data.updatedAt || data.lastSnapshotAt || data.createdAt || new Date().toISOString();
+    const epoaSessionId = String(data.epoaSessionId || data.primeSessionId || "").trim();
+    const windowId =
+      data.windowId === undefined || data.windowId === null || data.windowId === ""
+        ? null
+        : Number(data.windowId);
+    const taskThreadId = String(data.taskThreadId || data.threadId || "").trim();
+    const groups = (Array.isArray(data.tabGroups) ? data.tabGroups : data.groups || []).map(
+      (group, index) => normalizeBwoaGroup(group, index)
+    );
+    const openTabs = (Array.isArray(data.openTabs) ? data.openTabs : data.tabs || []).map(
+      (tab, index) => normalizeBwoaTab(tab, index)
+    );
+
+    return {
+      schemaVersion: "bwoa.window-hub-session.v1",
+      id: String(
+        data.id ||
+          data.sessionKey ||
+          [
+            "bwoa",
+            epoaSessionId || "unbound-prime",
+            windowId === null ? "window-unknown" : `window-${windowId}`,
+          ].join(":")
+      ),
+      epoaSessionId,
+      bwoaSpaceUrl: String(data.bwoaSpaceUrl || data.spaceUrl || BWOA_DEFAULT_SPACE_URL),
+      windowId,
+      windowOrdinal: Number(data.windowOrdinal || data.windowNumber || 1),
+      tabGroupId:
+        data.tabGroupId === undefined || data.tabGroupId === null || data.tabGroupId === ""
+          ? null
+          : Number(data.tabGroupId),
+      taskThreadId,
+      agentId: String(data.agentId || "bwoa-window-hub"),
+      status: normalizeBwoaStatus(data.status || "active"),
+      name: String(data.name || data.title || "Window Hub Orchestrator"),
+      description: normalizeEntityDescription(data),
+      bookmarkedUrls: (data.bookmarkedUrls || data.bookmarks || []).map(normalizeTrackedUrl),
+      trackedUrls: (data.trackedUrls || []).map(normalizeTrackedUrl),
+      tabGroups: groups,
+      openTabs,
+      spawnedSpokes: (data.spawnedSpokes || data.spokes || []).map(normalizeBwoaSpoke),
+      lastSnapshotAt: now,
+      createdAt: data.createdAt || now,
+      updatedAt: now,
+      auditTrail: Array.isArray(data.auditTrail) ? data.auditTrail : [],
+    };
+  }
+
+  function countBwoaWindowHubSession(session) {
+    const data = session || {};
+    const groups = Array.isArray(data.tabGroups) ? data.tabGroups : [];
+    const openTabs = Array.isArray(data.openTabs) ? data.openTabs : [];
+    const groupTabs = groups.reduce(
+      (sum, group) => sum + (Array.isArray(group.tabs) ? group.tabs.length : 0),
+      0
+    );
+    return {
+      tabGroups: groups.length,
+      openTabs: openTabs.length || groupTabs,
+      bookmarkedUrls: (data.bookmarkedUrls || []).length,
+      trackedUrls: (data.trackedUrls || []).length,
+      spawnedSpokes: (data.spawnedSpokes || []).length,
+      activeSpokes: (data.spawnedSpokes || []).filter((spoke) =>
+        ["active", "running", "pending"].includes(normalizeBwoaStatus(spoke.status))
+      ).length,
+    };
+  }
+
+  function buildBwoaDelegationEnvelope(input) {
+    const data = input || {};
+    const session = buildBwoaWindowHubSession(data.session || data);
+    const goal = String(data.goal || data.taskGoal || "").trim();
+    const taskThreadId = String(data.taskThreadId || session.taskThreadId || "").trim();
+    return {
+      schemaVersion: "bwoa.delegation-envelope.v1",
+      goal,
+      successBenchmark: String(data.successBenchmark || data.benchmark || ""),
+      windowId: session.windowId,
+      windowOrdinal: session.windowOrdinal,
+      taskThreadId,
+      allowedTargets: Array.isArray(data.allowedTargets)
+        ? data.allowedTargets
+        : [
+            {
+              entityType: "window",
+              windowId: session.windowId,
+              scope: "bwoa_window",
+            },
+          ],
+      requiredReportFormat:
+        data.requiredReportFormat ||
+        "Session Report with deployed spokes, benchmark, final output summary, success score, pass/fail status, and logs reference.",
+      bwoaSpaceUrl: session.bwoaSpaceUrl,
+      createdAt: data.createdAt || new Date().toISOString(),
+    };
+  }
+
+  function normalizeBwoaConfigItem(record, index, fallbackKind) {
+    const value = record || {};
+    const id = value.id || value.name || value.path || value.url || `${fallbackKind}-${index + 1}`;
+    return {
+      id: String(id),
+      kind: String(value.kind || fallbackKind),
+      name: String(value.name || value.title || id),
+      purpose: String(value.purpose || value.description || ""),
+      required: value.required !== false,
+    };
+  }
+
+  function buildBwoaWindowHubConfiguration(input) {
+    const data = input || {};
+    const session = buildBwoaWindowHubSession(data.session || data);
+    const windowOrdinal = Number(data.windowOrdinal || session.windowOrdinal || 1);
+    const spaceUrl = String(data.bwoaSpaceUrl || data.spaceUrl || session.bwoaSpaceUrl);
+    const defaultConnections = [
+      {
+        id: "epoa-control-channel",
+        kind: "conversation",
+        name: "EPOA to BWOA direct channel",
+        purpose:
+          "Codex Prime sends only compact session envelopes, delegation envelopes, and report requests.",
+      },
+      {
+        id: "bwoa-perplexity-space",
+        kind: "space",
+        name: "Hub Browser Agent Window All Tabs",
+        purpose: spaceUrl,
+      },
+      {
+        id: "comet-bridge",
+        kind: "mcp",
+        name: "Comet-Bridge",
+        purpose:
+          "Authoritative browser control, tab group inventory, lifecycle metadata, and top-display window binding.",
+      },
+      {
+        id: "task-thread-registry",
+        kind: "metadata",
+        name: "Task Thread Registry",
+        purpose: "Joins BWOA hub state to spawned spoke work and completion reports.",
+      },
+    ];
+    const defaultSkills = [
+      "bwoa-window-hub",
+      "comet-browser-control-toolkit",
+      "comet-connect",
+      "comet-workspace",
+      "comet-task-threads",
+      "comet-delegate",
+      "comet-session",
+      "comet-skill-inventory",
+      "15-comet-review",
+    ].map((name) => ({
+      id: name,
+      kind: "skill",
+      name,
+      purpose: "BWOA browser orchestration surface",
+    }));
+    const defaultFiles = [
+      "codex-comet-browser-control-toolkit/skills/bwoa-window-hub/SKILL.md",
+      "codex-comet-browser-control-toolkit/commands/bwoa-window-hub.md",
+      "docs/BWOA-WINDOW-HUB-ORCHESTRATOR.md",
+      "comet-mcp/extension/session-logic.js",
+      "test/bwoa-window-hub-session.test.mjs",
+      "specs/086-branch-window-hub/contracts/bwoa-window-hub-session.md",
+      "specs/086-branch-window-hub/quickstart.md",
+    ].map((path) => ({
+      id: path,
+      kind: "file",
+      name: path,
+      purpose: "Source-level BWOA contract evidence",
+    }));
+
+    return {
+      schemaVersion: "bwoa.window-hub-configuration.v1",
+      id: String(data.id || `bwoa-window-${windowOrdinal}-configuration`),
+      role: "browser_window_orchestrator_agent",
+      windowOrdinal,
+      bwoaSpaceUrl: spaceUrl,
+      profileOwner: "agent",
+      displayRole: "top_agents",
+      primaryMode: String(data.primaryMode || "Computer"),
+      planningMode: String(data.planningMode || "Orchestrator"),
+      settings: {
+        oneWindowPerHub: true,
+        oneManagedTabGroupPerWindow: true,
+        preserveOpenTabs: true,
+        preserveTrackedUrls: true,
+        snapshotCadence: ["bind", "pre_delegate", "post_delegate", "complete", "handoff"],
+        authoritativeState: ["extension_storage", "mcp_metadata", "snapshots", "task_threads"],
+        prohibitedAutomation: ["chrome", "puppeteer", "playwright_keyboard", "codex_browser"],
+        ...(data.settings || {}),
+      },
+      connections: (data.connections || defaultConnections).map((item, index) =>
+        normalizeBwoaConfigItem(item, index, "connection")
+      ),
+      requiredSkills: (data.requiredSkills || defaultSkills).map((item, index) =>
+        normalizeBwoaConfigItem(item, index, "skill")
+      ),
+      requiredFiles: (data.requiredFiles || defaultFiles).map((item, index) =>
+        normalizeBwoaConfigItem(item, index, "file")
+      ),
+      instructionBlocks: data.instructionBlocks || [
+        "Bind one Codex/EPOA session to one BWOA Space and one top-display Comet window.",
+        "Snapshot tab groups, open tabs, bookmarked URLs, and tracked URLs before delegating spoke work.",
+        "Delegate only bounded spoke goals with success benchmarks and allowed targets.",
+        "Return the required Session Report upward to EPOA after every spoke completes or blocks.",
+      ],
+      threadProtocol: {
+        epoaToBwoa: "bwoa.delegation-envelope.v1",
+        bwoaState: "bwoa.window-hub-session.v1",
+        bwoaToEpoa: "Session Report",
+        bwoaToSpoke: "bounded task-thread with benchmark, allowed targets, and logs reference",
+        ...(data.threadProtocol || {}),
+      },
+      session,
+    };
+  }
+
+  function safeBwoaJson(value) {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch (_err) {
+      return "{}";
+    }
+  }
+
+  function buildBwoaEpoaHandoffPrompt(input) {
+    const data = input || {};
+    const session = buildBwoaWindowHubSession(data.session || data);
+    const configuration = buildBwoaWindowHubConfiguration({
+      ...data,
+      session,
+    });
+    const goal = String(
+      data.goal ||
+        "Bind this BWOA Space to the current EPOA session and maintain Window #1 browser task context."
+    ).trim();
+    return [
+      "# EPOA to BWOA Handoff",
+      "",
+      `Goal: ${goal}`,
+      "",
+      "You are BWOA, the Browser Window Orchestrator Agent for Window #1. Treat Codex/EPOA as the only upstream orchestrator for this browser-window hub.",
+      "",
+      "Required operating rules:",
+      "- Keep this Perplexity Space as the conversational surface only.",
+      "- Keep durable state in Comet-Bridge extension storage, MCP metadata, snapshots, and task-thread records.",
+      "- Preserve tab groups, open tabs, bookmarked URLs, and tracked URLs for the full task lifecycle.",
+      "- Delegate bounded browser work to spoke task threads only through the delegation envelope.",
+      "- Return the required Session Report to EPOA after every spoke completes or blocks.",
+      "- Do not mutate human-owned or bottom-display browser targets.",
+      "- Do not replace Comet-Bridge with Chrome, Puppeteer, Playwright-as-keyboard, or Codex Browser.",
+      "",
+      "Configuration:",
+      "```json",
+      safeBwoaJson(configuration),
+      "```",
+      "",
+      "Current BWOA session:",
+      "```json",
+      safeBwoaJson(session),
+      "```",
+    ].join("\n");
+  }
+
+  function buildBwoaSpokePrompt(input) {
+    const data = input || {};
+    const envelope = buildBwoaDelegationEnvelope(data.envelope || data);
+    return [
+      "# BWOA to Spoke Delegation",
+      "",
+      `Goal: ${envelope.goal || "Complete the delegated browser task."}`,
+      `Success Benchmark: ${envelope.successBenchmark || "Meet the delegated success criteria."}`,
+      `Window Scope: Window #${envelope.windowOrdinal} (${envelope.windowId || "unbound"})`,
+      `Task Thread: ${envelope.taskThreadId || "unbound"}`,
+      "",
+      "Allowed targets:",
+      "```json",
+      safeBwoaJson(envelope.allowedTargets),
+      "```",
+      "",
+      "Delegation envelope:",
+      "```json",
+      safeBwoaJson(envelope),
+      "```",
+      "",
+      "Return exactly this report shape to BWOA/EPOA:",
+      "",
+      "### Session Report: <task or goal>",
+      "- **Spoke Agent(s) Deployed:** <ids or none>",
+      "- **Success Benchmark:** <1-2 sentences>",
+      "- **Final Output Summary:** <compressed result>",
+      "- **Success Score:** <0-100>%",
+      "- **Status:** <PASS|FAIL>",
+      "- **Logs Reference:** <thread URL or record id>",
+    ].join("\n");
+  }
+
+  function validateBwoaRouterIntent(input) {
+    const data = input || {};
+    const intent = String(data.intent || "");
+    if (!BWOA_MUTATING_INTENTS.has(intent)) return null;
+
+    const activeWindowScope = data.activeWindowScope || {};
+    const target = data.target || {};
+    const policyTier = isPrimeRouterActor(data) ? "prime" : "normal";
+
+    if (policyTier !== "prime") {
+      return denyRouterIntent(
+        intent,
+        "BWOA_PRIME_REQUIRED",
+        "BWOA session mutation requires Equanaut Prime or EPOA authority.",
+        activeWindowScope,
+        policyTier
+      );
+    }
+
+    if (normalizeRole(target.profileOwner) === "human") {
+      return denyRouterIntent(
+        intent,
+        "HUMAN_PROFILE_DENIED",
+        "BWOA cannot mutate human-owned browser state.",
+        activeWindowScope,
+        policyTier
+      );
+    }
+
+    const targetDisplayRole = normalizeRole(target.displayRole);
+    if (targetDisplayRole === "primary_user" || targetDisplayRole === "bottom_user") {
+      return denyRouterIntent(
+        intent,
+        "BOTTOM_DISPLAY_MUTATION_DENIED",
+        "BWOA targets must remain in the top-display agent workspace.",
+        activeWindowScope,
+        policyTier
+      );
+    }
+
+    const session = buildBwoaWindowHubSession(data.session || target);
+    const activeWindowId = activeWindowScope.windowId ? String(activeWindowScope.windowId) : "";
+    const targetWindowId =
+      session.windowId === null ? String(target.windowId || "") : String(session.windowId);
+    if (targetWindowId && activeWindowId && targetWindowId !== activeWindowId) {
+      if (!isPrimeLiveTargetVerified({ ...target, windowId: targetWindowId })) {
+        return denyRouterIntent(
+          intent,
+          "BWOA_TARGET_UNVERIFIED",
+          "BWOA cross-window mutation requires verified top-display agent ownership.",
+          activeWindowScope,
+          policyTier
+        );
+      }
+    }
+
+    return {
+      intent,
+      target,
+      session,
+      scope: "bwoa_window_hub",
+      mutation: true,
+      requiresConfirmation: false,
+      preview: data.preview || `${intent} for Window #${session.windowOrdinal}`,
+      audit: {
+        requestedBy: "equanaut_prime",
+        activeWindowId: activeWindowId || "unknown",
+        targetWindowId: targetWindowId || "unknown",
+        policyTier,
+        reason: data.reason || "bwoa_orchestration",
+        createdAt: new Date().toISOString(),
+      },
+      allowed: true,
+    };
+  }
+
   function normalizeFleetRecord(record, index) {
     const base = normalizeCatalogRecord(record, "fleet", index);
     return {
@@ -2094,6 +2694,18 @@
     const gatewayTools = (data.gatewayTools || []).map((r, i) =>
       normalizeCatalogRecord(r, "gateway", i)
     );
+    const selectedItems = (data.selectedItems || []).map((r, i) =>
+      normalizeCatalogRecord(r, "selected", i)
+    );
+    const lifecycleBindings = (data.lifecycleBindings || []).map((r, i) =>
+      normalizeCatalogRecord(r, "lifecycle", i)
+    );
+    const windowLabels = (data.windowLabels || []).map((r, i) =>
+      normalizeCatalogRecord(r, "window-label", i)
+    );
+    const descriptions = (data.descriptions || []).map((r, i) =>
+      normalizeCatalogRecord(r, "description", i)
+    );
     const slashCommands = Array.isArray(data.slashCommands)
       ? buildEquanautSlashCommandCatalog(data.slashCommands)
       : buildEquanautSlashCommandCatalog();
@@ -2108,6 +2720,10 @@
       unifiedThreads,
       fleetMembers,
       gatewayTools,
+      selectedItems,
+      lifecycleBindings,
+      windowLabels,
+      descriptions,
       slashCommands,
       plugins,
       freshness: {
@@ -2129,6 +2745,10 @@
       gatewayTools: (c.gatewayTools || []).length,
       slashCommands: (c.slashCommands || []).length,
       plugins: (c.plugins || []).length,
+      selectedItems: (c.selectedItems || []).length,
+      lifecycleBindings: (c.lifecycleBindings || []).length,
+      windowLabels: (c.windowLabels || []).length,
+      descriptions: (c.descriptions || []).length,
     };
   }
 
@@ -2174,7 +2794,7 @@
     };
   }
 
-  function denyRouterIntent(intent, code, message, activeWindowScope) {
+  function denyRouterIntent(intent, code, message, activeWindowScope, policyTier = "normal") {
     return {
       intent,
       scope: "denied",
@@ -2185,6 +2805,7 @@
       audit: {
         requestedBy: "sidepanel",
         activeWindowId: activeWindowScope?.windowId || "unknown",
+        policyTier,
         createdAt: new Date().toISOString(),
       },
       allowed: false,
@@ -2197,16 +2818,22 @@
     const target = data.target || {};
     const activeWindowScope = data.activeWindowScope || {};
     const activeWindowId = activeWindowScope.windowId ? String(activeWindowScope.windowId) : "";
+    const isPrime = isPrimeRouterActor(data);
+    const policyTier = isPrime ? "prime" : "normal";
 
     if (!SUPPORTED_ROUTER_INTENTS.includes(intent)) {
       return denyRouterIntent(
         intent || "unknown",
         "UNSUPPORTED_INTENT",
         `Unsupported router intent: ${intent || "unknown"}`,
-        activeWindowScope
+        activeWindowScope,
+        policyTier
       );
     }
 
+    const bwoaDecision = validateBwoaRouterIntent(data);
+    if (bwoaDecision) return bwoaDecision;
+
     const mutation = !READ_ONLY_ROUTER_INTENTS.has(intent);
     if (!mutation) {
       return {
@@ -2219,57 +2846,78 @@
         audit: {
           requestedBy: "sidepanel",
           activeWindowId: activeWindowId || "unknown",
+          policyTier,
           createdAt: new Date().toISOString(),
         },
         allowed: true,
       };
     }
 
-    if (activeWindowScope.profileOwner === "human" || target.profileOwner === "human") {
+    if (
+      normalizeRole(activeWindowScope.profileOwner) === "human" ||
+      normalizeRole(target.profileOwner) === "human"
+    ) {
       return denyRouterIntent(
         intent,
         "HUMAN_PROFILE_DENIED",
-        "Normal agents cannot mutate human-owned browser profile or window state.",
-        activeWindowScope
+        "Agents cannot mutate human-owned browser profile or window state.",
+        activeWindowScope,
+        policyTier
       );
     }
 
-    if (target.displayRole === "primary_user" || target.displayRole === "bottom_user") {
+    const targetDisplayRole = normalizeRole(target.displayRole);
+    if (targetDisplayRole === "primary_user" || targetDisplayRole === "bottom_user") {
       return denyRouterIntent(
         intent,
         "BOTTOM_DISPLAY_MUTATION_DENIED",
-        "Normal agents cannot mutate bottom-display user browser windows.",
-        activeWindowScope
+        "Agents cannot mutate primary or bottom-display user browser windows.",
+        activeWindowScope,
+        policyTier
       );
     }
 
     const targetWindowId = target.windowId ? String(target.windowId) : "";
     const allowOtherWindow =
       activeWindowScope.mutationPolicy && activeWindowScope.mutationPolicy.allowOtherWindowMutation;
-    if (
+    const crossWindowMutation = !!(
       targetWindowId &&
       activeWindowId &&
-      targetWindowId !== activeWindowId &&
-      !allowOtherWindow
-    ) {
-      return denyRouterIntent(
-        intent,
-        "OTHER_WINDOW_MUTATION_DENIED",
-        "Normal sidepanel requests may mutate only the active sidepanel window. Open or rebind the target first.",
-        activeWindowScope
-      );
+      targetWindowId !== activeWindowId
+    );
+    if (crossWindowMutation && !allowOtherWindow) {
+      if (isPrime && isPrimeLiveTargetVerified(target)) {
+        // Prime may continue after verified top-display or extension-managed ownership.
+      } else if (isPrime) {
+        return denyRouterIntent(
+          intent,
+          "PRIME_TARGET_UNVERIFIED",
+          "Equanaut Prime cross-window live mutation requires top-display agent ownership or extension-managed target proof.",
+          activeWindowScope,
+          policyTier
+        );
+      } else {
+        return denyRouterIntent(
+          intent,
+          "OTHER_WINDOW_MUTATION_DENIED",
+          "Normal sidepanel requests may mutate only the active sidepanel window. Open or rebind the target first.",
+          activeWindowScope,
+          policyTier
+        );
+      }
     }
 
     if (
       ["open", "restore", "open_orchestrator_url"].includes(intent) &&
       activeWindowScope.displayRole &&
-      activeWindowScope.displayRole !== "top_agents"
+      normalizeRole(activeWindowScope.displayRole) !== "top_agents"
     ) {
       return denyRouterIntent(
         intent,
         "TOP_DISPLAY_REQUIRED",
         "Open and restore actions must use the top-display agent workspace.",
-        activeWindowScope
+        activeWindowScope,
+        policyTier
       );
     }
 
@@ -2280,21 +2928,31 @@
           intent,
           "FLEET_TARGET_UNAVAILABLE",
           "Dispatch requires a live or reachable fleet target.",
-          activeWindowScope
+          activeWindowScope,
+          policyTier
         );
       }
     }
 
+    const extensionOwnedMetadata = isExtensionOwnedMetadataTarget(target);
+    const scope =
+      intent === "dispatch_to_fleet"
+        ? "fleet"
+        : isPrime && (extensionOwnedMetadata || crossWindowMutation)
+          ? "prime_global"
+          : "active_window";
+
     return {
       intent,
       target,
-      scope: intent === "dispatch_to_fleet" ? "fleet" : "active_window",
+      scope,
       mutation: true,
       requiresConfirmation: !!data.requiresConfirmation,
       preview: data.preview || `${intent} ${target.title || target.id || "target"}`,
       audit: {
         requestedBy: "sidepanel",
         activeWindowId: activeWindowId || "unknown",
+        policyTier,
         reason: data.reason || "user_request",
         createdAt: new Date().toISOString(),
       },
@@ -2307,6 +2965,8 @@
     fsFuzzyMatch,
     fsFormatEventDescription,
     fsApplyFilters,
+    normalizeArchiveWorkflowStatus,
+    fsPartitionTaskthreadGroups,
     fsApplyAdvancedFilters,
     fsSortGroups,
     fsGroupBy,
@@ -2357,13 +3017,24 @@
     groupAndSortForDeletion,
     SUPPORTED_ROUTER_INTENTS,
     selectEquanautRouterRoute,
+    isPrimeRouterActor,
+    isExtensionOwnedMetadataTarget,
+    isPrimeLiveTargetVerified,
     normalizeEntityDescription,
     normalizeCatalogRecord,
     buildGlobalContextCatalog,
     countGlobalContextCatalog,
     buildAgentContextEnvelope,
+    buildBwoaWindowHubSession,
+    countBwoaWindowHubSession,
+    buildBwoaDelegationEnvelope,
+    buildBwoaWindowHubConfiguration,
+    buildBwoaEpoaHandoffPrompt,
+    buildBwoaSpokePrompt,
+    validateBwoaRouterIntent,
     validateRouterIntent,
     DEFAULT_DOMAIN_DISPLAY_MAP,
+    BWOA_DEFAULT_SPACE_URL,
   };
 
   // Browser: register on globalThis