@shawnowen/comet-mcp 2.3.1 → 2.4.1

package/dist/comet-ai.d.ts

@@ -1,4 +1,7 @@
+import { CometCDPClient } from "./cdp-client.js";
 export declare class CometAI {
+    private cdp;
+    constructor(cdpClient?: CometCDPClient);
     /**
      * Find the first matching element from a list of selectors
      */
@@ -26,6 +29,18 @@ export declare class CometAI {
         hasStopButton: boolean;
         agentBrowsingUrl: string;
     }>;
+    /**
+     * Detect voice/listening mode — Perplexity entered microphone mode instead of processing text.
+     */
+    detectVoiceMode(): Promise<boolean>;
+    /**
+     * Detect IDLE without navigation — task returned IDLE but never left the Perplexity home page.
+     */
+    detectIdleNoNavigation(initialUrl?: string): Promise<boolean>;
+    /**
+     * Detect context bleed — response content URL doesn't match the requested URL.
+     */
+    detectContextBleed(requestedUrl?: string): Promise<boolean>;
     /**
      * Stop the current agent task
      */

package/dist/comet-ai.js

@@ -1,21 +1,25 @@
 // Comet AI interaction module
 // Handles sending prompts to Comet's AI assistant and reading responses
-import { cometClient } from "./cdp-client.js";
+import { cometClient as globalCometClient } from "./cdp-client.js";
 // Input selectors - contenteditable div is primary for Perplexity
 const INPUT_SELECTORS = [
     '[contenteditable="true"]',
     'textarea[placeholder*="Ask"]',
     'textarea[placeholder*="Search"]',
-    'textarea',
+    "textarea",
     'input[type="text"]',
 ];
 export class CometAI {
+    cdp;
+    constructor(cdpClient) {
+        this.cdp = cdpClient || globalCometClient;
+    }
     /**
      * Find the first matching element from a list of selectors
      */
     async findInputElement() {
         for (const selector of INPUT_SELECTORS) {
-            const result = await cometClient.evaluate(`
+            const result = await this.cdp.evaluate(`
         document.querySelector(${JSON.stringify(selector)}) !== null
       `);
             if (result.result.value === true) {
@@ -33,7 +37,7 @@ export class CometAI {
             throw new Error("Could not find input element. Navigate to Perplexity first.");
         }
         // Use execCommand for contenteditable elements (works with React/Vue)
-        const result = await cometClient.evaluate(`
+        const result = await this.cdp.evaluate(`
       (() => {
         const el = document.querySelector('[contenteditable="true"]');
         if (el) {
@@ -59,16 +63,16 @@ export class CometAI {
         }
         // Submit the prompt
         await this.submitPrompt();
-        return `Prompt sent: "${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}"`;
+        return `Prompt sent: "${prompt.substring(0, 50)}${prompt.length > 50 ? "..." : ""}"`;
     }
     /**
      * Submit the current prompt
      */
     async submitPrompt() {
         // Wait for React to process the typed content
-        await new Promise(resolve => setTimeout(resolve, 500));
+        await new Promise((resolve) => setTimeout(resolve, 500));
         // Verify text was typed before attempting submit
-        const hasContent = await cometClient.evaluate(`
+        const hasContent = await this.cdp.evaluate(`
       (() => {
         const el = document.querySelector('[contenteditable="true"]');
         if (el && el.innerText.trim().length > 0) return true;
@@ -81,17 +85,17 @@ export class CometAI {
             throw new Error("Prompt text not found in input - typing may have failed");
         }
         // Strategy 1: Use Enter key (most reliable for Perplexity)
-        await cometClient.evaluate(`
+        await this.cdp.evaluate(`
       (() => {
         const el = document.querySelector('[contenteditable="true"]') ||
                    document.querySelector('textarea');
         if (el) el.focus();
       })()
     `);
-        await cometClient.pressKey("Enter");
-        await new Promise(resolve => setTimeout(resolve, 500));
+        await this.cdp.pressKey("Enter");
+        await new Promise((resolve) => setTimeout(resolve, 500));
         // Check if submission worked
-        const submitted = await cometClient.evaluate(`
+        const submitted = await this.cdp.evaluate(`
       (() => {
         const el = document.querySelector('[contenteditable="true"]');
         if (el && el.innerText.trim().length < 5) return true;
@@ -102,7 +106,7 @@ export class CometAI {
         if (submitted.result.value)
             return;
         // Strategy 2: Click submit button
-        await cometClient.evaluate(`
+        await this.cdp.evaluate(`
       (() => {
         const selectors = [
           'button[aria-label*="Submit"]',
@@ -156,8 +160,8 @@ export class CometAI {
       })()
     `);
         // Final check and retry with Enter if still not submitted
-        await new Promise(resolve => setTimeout(resolve, 500));
-        const finalCheck = await cometClient.evaluate(`
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        const finalCheck = await this.cdp.evaluate(`
       (() => {
         const el = document.querySelector('[contenteditable="true"]');
         if (el && el.innerText.trim().length < 5) return true;
@@ -168,7 +172,7 @@ export class CometAI {
     `);
         if (!finalCheck.result.value) {
             // Last resort: try Enter one more time
-            await cometClient.pressKey("Enter");
+            await this.cdp.pressKey("Enter");
         }
     }
     /**
@@ -180,7 +184,7 @@ export class CometAI {
             throw new Error("Could not find input element. Navigate to Perplexity first.");
         }
         // Focus and clear the input
-        await cometClient.evaluate(`
+        await this.cdp.evaluate(`
       (() => {
         const el = document.querySelector('[contenteditable="true"]');
         if (el) {
@@ -199,7 +203,7 @@ export class CometAI {
     `);
         // Type the shortcut command
         const shortcutCmd = `/${shortcut}`;
-        await cometClient.evaluate(`
+        await this.cdp.evaluate(`
       (() => {
         const el = document.querySelector('[contenteditable="true"]');
         if (el) {
@@ -218,13 +222,13 @@ export class CometAI {
       })()
     `);
         // Wait for shortcut dropdown/autocomplete to appear
-        await new Promise(resolve => setTimeout(resolve, 800));
+        await new Promise((resolve) => setTimeout(resolve, 800));
         // Press Enter to select the shortcut
-        await cometClient.pressKey("Enter");
+        await this.cdp.pressKey("Enter");
         // If context is provided, type it after a brief pause
         if (context) {
-            await new Promise(resolve => setTimeout(resolve, 500));
-            await cometClient.evaluate(`
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            await this.cdp.evaluate(`
         (() => {
           const el = document.querySelector('[contenteditable="true"]');
           if (el) {
@@ -250,26 +254,25 @@ export class CometAI {
       `);
         }
         // Submit
-        await new Promise(resolve => setTimeout(resolve, 300));
-        await cometClient.pressKey("Enter");
-        return `Shortcut /${shortcut} sent${context ? ` with context: "${context.substring(0, 50)}${context.length > 50 ? '...' : ''}"` : ''}`;
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        await this.cdp.pressKey("Enter");
+        return `Shortcut /${shortcut} sent${context ? ` with context: "${context.substring(0, 50)}${context.length > 50 ? "..." : ""}"` : ""}`;
     }
     /**
      * Get current agent status and progress (for polling)
      */
     async getAgentStatus() {
-        // Get browsing URL from agent's tab
-        let agentBrowsingUrl = '';
+        // Report the bound tab URL only. Global target scans can leak another
+        // agent's authenticated workflow into this session's status.
+        let agentBrowsingUrl = "";
         try {
-            const tabs = await cometClient.listTabsCategorized();
-            if (tabs.agentBrowsing) {
-                agentBrowsingUrl = tabs.agentBrowsing.url;
-            }
+            const urlResult = await this.cdp.safeEvaluate("window.location.href");
+            agentBrowsingUrl = urlResult.result.value || "";
         }
         catch {
             // Continue without URL
         }
-        const result = await cometClient.safeEvaluate(`
+        const result = await this.cdp.safeEvaluate(`
       (() => {
         const body = document.body.innerText;
 
@@ -285,7 +288,9 @@ export class CometAI {
           }
         }
 
-        const hasLoadingSpinner = document.querySelector('[class*="animate-spin"], [class*="animate-pulse"]') !== null;
+        // Scope spinner detection to response content area only (not page-wide UI)
+        const responseArea = document.querySelector('main') || document.body;
+        const hasLoadingSpinner = responseArea.querySelector('[class*="animate-spin"], [class*="animate-pulse"]') !== null;
         const hasStepsCompleted = /\\d+ steps? completed/i.test(body);
         const hasFinishedMarker = body.includes('Finished') && !hasActiveStopButton;
         const hasReviewedSources = /Reviewed \\d+ sources?/i.test(body);
@@ -300,18 +305,18 @@ export class CometAI {
         ];
         const hasWorkingText = workingPatterns.some(p => body.includes(p));
 
-        // Determine status
+        // Determine status — prioritize positive completion signals
         let status = 'idle';
-        if (hasActiveStopButton || hasLoadingSpinner) {
-          status = 'working';
+        if (hasAskFollowUp && hasProseContent && !hasActiveStopButton) {
+          status = 'completed';
         } else if (hasStepsCompleted || hasFinishedMarker) {
           status = 'completed';
         } else if (hasReviewedSources && !hasWorkingText) {
           status = 'completed';
+        } else if (hasActiveStopButton || hasLoadingSpinner) {
+          status = 'working';
         } else if (hasWorkingText) {
           status = 'working';
-        } else if (hasAskFollowUp && hasProseContent && !hasActiveStopButton) {
-          status = 'completed';
         }
 
         // Extract steps
@@ -368,11 +373,82 @@ export class CometAI {
             agentBrowsingUrl,
         };
     }
+    // ---- Failure Detection Heuristics (Spec 016, FR-002, T014-T016) ----
+    /**
+     * Detect voice/listening mode — Perplexity entered microphone mode instead of processing text.
+     */
+    async detectVoiceMode() {
+        try {
+            const result = await this.cdp.safeEvaluate(`
+        (() => {
+          const body = document.body.innerText;
+          // Check for "Listening..." text which appears in voice mode
+          if (body.includes('Listening...') || body.includes('Listening…')) return true;
+          // Check for active microphone UI elements
+          const micButtons = document.querySelectorAll('button[aria-label*="microphone" i], button[aria-label*="voice" i], button[aria-label*="listen" i]');
+          for (const btn of micButtons) {
+            if (btn.classList.contains('active') || btn.getAttribute('aria-pressed') === 'true') return true;
+          }
+          return false;
+        })()
+      `);
+            return result.result.value === true;
+        }
+        catch (err) {
+            console.warn(`[comet-bridge] Voice mode detection failed: ${err instanceof Error ? err.message : err}`);
+            return false;
+        }
+    }
+    /**
+     * Detect IDLE without navigation — task returned IDLE but never left the Perplexity home page.
+     */
+    async detectIdleNoNavigation(initialUrl) {
+        try {
+            const result = await this.cdp.safeEvaluate(`window.location.href`);
+            const currentUrl = result.result.value;
+            // If still on Perplexity home/search and status is idle, no navigation occurred
+            const isPerplexityHome = currentUrl === "https://www.perplexity.ai/" ||
+                currentUrl === "https://www.perplexity.ai" ||
+                currentUrl?.endsWith("/home");
+            if (isPerplexityHome)
+                return true;
+            // If we have an initial URL and it hasn't changed, no navigation occurred
+            if (initialUrl && currentUrl === initialUrl)
+                return true;
+            return false;
+        }
+        catch (err) {
+            console.warn(`[comet-bridge] Idle/no-navigation detection failed: ${err instanceof Error ? err.message : err}`);
+            return false;
+        }
+    }
+    /**
+     * Detect context bleed — response content URL doesn't match the requested URL.
+     */
+    async detectContextBleed(requestedUrl) {
+        if (!requestedUrl)
+            return false;
+        try {
+            const status = await this.getAgentStatus();
+            // If the response mentions browsing a different URL than requested, it's context bleed
+            if (status.agentBrowsingUrl && requestedUrl) {
+                const requested = new URL(requestedUrl).hostname;
+                const actual = new URL(status.agentBrowsingUrl).hostname;
+                if (requested !== actual)
+                    return true;
+            }
+            return false;
+        }
+        catch (err) {
+            console.warn(`[comet-bridge] Context bleed detection failed: ${err instanceof Error ? err.message : err}`);
+            return false;
+        }
+    }
     /**
      * Stop the current agent task
      */
     async stopAgent() {
-        const result = await cometClient.evaluate(`
+        const result = await this.cdp.evaluate(`
       (() => {
         // Try aria-label buttons first
         for (const btn of document.querySelectorAll('button[aria-label*="Stop"], button[aria-label*="Cancel"]')) {

package/dist/delegate-binding.d.ts

@@ -0,0 +1,19 @@
+import { type CodexIdentityInput, type CodexWindowBinding, type CodexWindowBindingStore } from "./window-bindings.js";
+export interface DelegateBindingInput extends CodexIdentityInput {
+    taskId: string;
+    threadId: string;
+    agentId: string;
+    currentBinding?: CodexWindowBinding | null;
+    bindingId?: string;
+    windowId?: number;
+    tabGroupId?: number | null;
+    targetId?: string | null;
+}
+export interface DelegateBindingDispatch {
+    bindingId: string | null;
+    windowId: number | null;
+    tabGroupId: number | null;
+    dispatchStatus: string;
+}
+export declare function createOrReuseDelegateBinding(input: DelegateBindingInput, store?: CodexWindowBindingStore): Promise<DelegateBindingDispatch>;
+//# sourceMappingURL=delegate-binding.d.ts.map

package/dist/delegate-binding.js

@@ -0,0 +1,73 @@
+import { deriveCodexSessionIdentity, windowBindingStore, } from "./window-bindings.js";
+function numericValue(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+export async function createOrReuseDelegateBinding(input, store = windowBindingStore) {
+    const currentBinding = input.currentBinding ?? null;
+    if (input.bindingId) {
+        const binding = await store.addRunId(input.bindingId, input.taskId);
+        return {
+            bindingId: binding.bindingId,
+            windowId: binding.windowId,
+            tabGroupId: binding.tabGroupId,
+            dispatchStatus: "binding-reused",
+        };
+    }
+    if (currentBinding &&
+        input.windowId === undefined &&
+        input.tabGroupId === undefined &&
+        input.targetId === undefined) {
+        const persisted = await store.get(currentBinding.bindingId);
+        if (persisted) {
+            const binding = await store.addRunId(currentBinding.bindingId, input.taskId);
+            return {
+                bindingId: binding.bindingId,
+                windowId: binding.windowId,
+                tabGroupId: binding.tabGroupId,
+                dispatchStatus: "binding-reused",
+            };
+        }
+    }
+    const windowId = numericValue(input.windowId) ?? currentBinding?.windowId;
+    if (windowId === undefined) {
+        return {
+            bindingId: null,
+            windowId: null,
+            tabGroupId: null,
+            dispatchStatus: "binding-unavailable: windowId required",
+        };
+    }
+    const identity = deriveCodexSessionIdentity({
+        ...input,
+        strict: input.strict === true,
+        fallbackAgentId: input.agentId,
+        fallbackTaskThreadId: input.threadId,
+    });
+    const bindingResult = await store.createOrReuse({
+        ...identity,
+        windowId,
+        tabGroupId: numericValue(input.tabGroupId) ??
+            currentBinding?.tabGroupId ??
+            (typeof input.tabGroupId === "number" ? input.tabGroupId : null),
+        targetId: input.targetId ?? currentBinding?.targetId ?? null,
+        runIds: [input.taskId],
+        profileId: currentBinding?.profileId ?? "agent",
+        profileAlias: currentBinding?.profileAlias ?? "oe",
+        profileOwner: currentBinding?.profileOwner ?? "agent",
+        sidecarContextKey: currentBinding?.sidecarContextKey,
+    });
+    return {
+        bindingId: bindingResult.binding.bindingId,
+        windowId: bindingResult.binding.windowId,
+        tabGroupId: bindingResult.binding.tabGroupId,
+        dispatchStatus: `binding-${bindingResult.action}`,
+    };
+}
+//# sourceMappingURL=delegate-binding.js.map

package/dist/discovery/capability-entry.d.ts

@@ -0,0 +1,215 @@
+/**
+ * capability-entry.ts
+ * Core type definitions for the Comet Discovery Layer (Spec 042).
+ * All types are derived from data-model.md and capability-entry.schema.json.
+ * No runtime logic — pure type declarations + tagged unions.
+ */
+/** Which canonical source owns a capability entry. */
+export type SourceLayer = "mcp" | "plugin" | "extension";
+/** Rank order for dedup: plugin (3) > extension (2) > mcp (1). */
+export declare const SOURCE_LAYER_RANK: Record<SourceLayer, number>;
+/**
+ * Safety classification — reused verbatim from docs/TOOL-SAFETY-REFERENCE.md.
+ * No default, no UNKNOWN class. Every capability must have exactly one.
+ *
+ * SAFE     — Read-only, zero side effects, no session required.
+ * SESSION  — Requires an active Comet CDP session; scoped to the calling agent's tab group.
+ * CAUTION  — Cross-session side effects possible; requires explicit multi-agent awareness.
+ */
+export type SafetyClass = "SAFE" | "SESSION" | "CAUTION";
+export type Precondition = {
+    kind: "cdp_session";
+    note: string;
+} | {
+    kind: "profile";
+    value: "oe" | "moon";
+} | {
+    kind: "task_group";
+    note: string;
+} | {
+    kind: "task_thread";
+    note: string;
+} | {
+    kind: "free";
+    note: string;
+};
+export type Invocation = {
+    kind: "native";
+    /** Name of the existing MCP tool — pass-through, no behavior change (FR-009). */
+    toolName: string;
+} | {
+    kind: "guide";
+    /** Claude Code Skill name (e.g. "comet-browse"). */
+    skill: string;
+    /** Args to pass to Skill(). */
+    normalizedArgs: Record<string, unknown>;
+    /** Human hint: "Invoke via Skill('comet-browse') with these args." */
+    nextStepHint: string;
+} | {
+    kind: "cdp";
+    /** Chrome DevTools Protocol method string. */
+    method: string;
+    params?: Record<string, unknown>;
+} | {
+    kind: "filesystem";
+    path: string;
+    mode: "read" | "signal";
+} | {
+    kind: "cli";
+    command: string;
+    args: string[];
+};
+/**
+ * One CapabilityEntry per source-side definition.
+ * A plugin command that wraps a native MCP tool produces TWO entries sharing a canonicalId.
+ */
+export interface CapabilityEntry {
+    /**
+     * Globally unique tool-facing identifier.
+     * Native: existing tool name (e.g. "comet_screenshot").
+     * Plugin: "plugin_<slug>".
+     * Extension: "ext_<slug>".
+     * Regex: /^[a-z][a-z0-9_]{2,63}$/
+     */
+    name: string;
+    /** Which canonical source owns this entry. */
+    sourceLayer: SourceLayer;
+    /**
+     * Repo-relative path + optional #fragment pointing to the canonical definition.
+     * e.g. "comet-mcp/src/index.ts#tool_comet_screenshot"
+     */
+    sourcePath: string;
+    /**
+     * Shared identity key for dedup grouping across layers.
+     * Entries sharing a canonicalId form a CapabilityGroup.
+     * Regex: /^[a-z][a-z0-9_-]{2,63}$/
+     */
+    canonicalId: string;
+    /**
+     * Human-readable verb-phrase description.
+     * Template: "<verb> <object> [<modifier>]. Source: <layer>. Safety: <class>."
+     * Min 24 chars, max 400 chars.
+     */
+    description: string;
+    /**
+     * At least 3 lowercase keywords capturing common search intents.
+     * Drives natural-language ToolSearch ranking (FR-006, SC-002).
+     */
+    intentKeywords: string[];
+    /**
+     * Safety class — must be set; no default.
+     * Reused verbatim from docs/TOOL-SAFETY-REFERENCE.md.
+     */
+    safety: SafetyClass;
+    /**
+     * Prerequisites the agent must satisfy before calling this tool.
+     * May be empty array, never missing.
+     */
+    preconditions: Precondition[];
+    /**
+     * JSON Schema draft 2020-12 fragment for the tool's arguments.
+     * Empty schema `{ type: "object", properties: {} }` is valid.
+     */
+    argsSchema: Record<string, unknown>;
+    /**
+     * True iff this capability has no agent-reachable programmatic entry point
+     * and is deliberately excluded from virtual-tool registration.
+     * MUST be accompanied by a matching HumanOnlyException.
+     */
+    humanOnly: boolean;
+    /** Determines what the virtual MCP tool body returns or dispatches. */
+    invocation: Invocation;
+    /**
+     * The `name` of the paired entry in this entry's CapabilityGroup, or null for singletons.
+     */
+    crossRef: string | null;
+    /**
+     * True for the highest-layer entry in a group (plugin > extension > mcp).
+     * Singletons are always recommended: true.
+     */
+    recommended: boolean;
+    /** For non-recommended entries: "lower-level". For recommended: null. */
+    alternativeLabel: "lower-level" | null;
+}
+/**
+ * Transient collection of CapabilityEntry instances sharing a canonicalId.
+ * Emits exactly one "recommended" virtual tool and up to one "alternative (lower-level)".
+ */
+export interface CapabilityGroup {
+    canonicalId: string;
+    /** Highest-layer member (plugin > extension > mcp). */
+    recommendedEntry: CapabilityEntry;
+    /** Lowest-layer member when distinct from recommendedEntry. null for singletons. */
+    alternativeEntry: CapabilityEntry | null;
+    /**
+     * Intermediate members NOT registered as virtual tools.
+     * Still listed for traceability under the recommended entry's alternates.
+     */
+    suppressedEntries: CapabilityEntry[];
+}
+export interface HumanOnlyException {
+    /** Must equal the canonicalId of a capability with humanOnly: true. */
+    name: string;
+    /** Why no programmatic entry point exists. Min 24 chars. */
+    reason: string;
+    /** GitHub handle (@username) or team (@org/team). */
+    owner: string;
+    /** Plan to make this capability agent-accessible, or null if genuinely blocked. */
+    enhancementPath: string | null;
+    /** ISO 8601 date string. Staleness warning fires if older than 90 days. */
+    lastReviewed: string;
+}
+export interface SourceError {
+    /** Which source layer failed. */
+    source: SourceLayer;
+    /** Human-readable reason. */
+    reason: string;
+    /** Original error, if any. */
+    originalError?: unknown;
+}
+export type DriftStatus = "pass" | "warn" | "fail";
+export interface DriftReport {
+    generatedAt: string;
+    emittedBy: "ci" | "session-start";
+    available: SourceLayer[];
+    unavailable: Array<{
+        source: SourceLayer;
+        reason: string;
+    }>;
+    capabilityCount: number;
+    virtualToolCount: number;
+    /** canonicalIds in canonical source but missing from registry → hard failure. */
+    missingFromRegistry: string[];
+    /** Virtual tool names in registry with no canonical source → hard failure. */
+    extrasInRegistry: string[];
+    /** Entry names missing safety field → hard failure. */
+    safetyGaps: string[];
+    /** humanOnly: true capabilities lacking a matching exception → hard failure. */
+    humanOnlyDangling: string[];
+    /** Exception names that don't resolve to any humanOnly: true capability → hard failure. */
+    exceptionsDangling: string[];
+    /** Exceptions with lastReviewed older than review window → warning only. */
+    exceptionsStale: string[];
+    status: DriftStatus;
+}
+export interface GoldenQueryResult {
+    query: string;
+    expectedCanonicalId: string;
+    top5Names: string[];
+    hit: boolean;
+}
+export interface CoverageReport {
+    sources: Record<SourceLayer, number>;
+    totalCapabilities: number;
+    coverageRatio: number;
+    goldenQueries: GoldenQueryResult[];
+    top5HitRate: number;
+    metadataCompleteness: number;
+}
+/** Minimal MCP tool definition shape accepted by the comet-mcp Server. */
+export interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+//# sourceMappingURL=capability-entry.d.ts.map

package/dist/discovery/capability-entry.js

@@ -0,0 +1,13 @@
+/**
+ * capability-entry.ts
+ * Core type definitions for the Comet Discovery Layer (Spec 042).
+ * All types are derived from data-model.md and capability-entry.schema.json.
+ * No runtime logic — pure type declarations + tagged unions.
+ */
+/** Rank order for dedup: plugin (3) > extension (2) > mcp (1). */
+export const SOURCE_LAYER_RANK = {
+    plugin: 3,
+    extension: 2,
+    mcp: 1,
+};
+//# sourceMappingURL=capability-entry.js.map