@shawnowen/comet-mcp 2.4.1 → 2.4.2

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // Comet Browser MCP Server
 // Claude Code ↔ Perplexity Comet bidirectional interaction
-// 25 tools: 9 browsing + 2 direct interaction + 1 tab groups + 4 lifecycle + 2 orchestration + 5 parity + 2 safe observe (observe + peek)
+// 26 tools: 9 browsing + 2 direct interaction + 1 tab groups + 4 lifecycle + 2 orchestration + 6 parity + 2 safe observe (observe + peek)
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
@@ -68,6 +68,7 @@ const BROWSING_TOOLS = new Set([
     "comet_pdf",
     "comet_scrape",
     "comet_network",
+    "comet_monitor",
     "comet_automate",
     "comet_domain",
 ]);
@@ -87,6 +88,7 @@ const BOUND_ROUTING_TOOLS = new Set([
     "comet_pdf",
     "comet_scrape",
     "comet_network",
+    "comet_monitor",
     "comet_automate",
     "comet_domain",
 ]);
@@ -202,6 +204,8 @@ import { emitLifecycleEvent, createMCPLifecycleEnvelope } from "../vendor/lifecy
 import { appendFileSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join, dirname } from "path";
+import { createHash } from "crypto";
+import { execFileSync } from "child_process";
 // Duplicate process detection (Spec 016, FR-010, T005)
 const PID_FILE_PATH = join(homedir(), ".claude", "comet-browser", "comet-mcp.pid");
 function checkDuplicateProcess() {
@@ -438,7 +442,8 @@ const TOOLS = [
             "Actions: list (all groups), list_tabs (all tabs with group info), create (new group from tab IDs), " +
             "update (rename/recolor/collapse), move (reorder), ungroup (remove tabs from group), delete (ungroup all tabs in a group), " +
             "save_group (persist tab URLs to archive), restore_group (reopen tabs from archive), archive_group (save + close tabs), " +
-            "list_archived (show all archived tab groups).",
+            "list_archived (show all archived tab groups), list_metadata (show extension metadata), " +
+            "update_metadata (update extension-owned descriptions, labels, archived records, and tab rows).",
         inputSchema: {
             type: "object",
             properties: {
@@ -456,6 +461,8 @@ const TOOLS = [
                         "restore_group",
                         "archive_group",
                         "list_archived",
+                        "list_metadata",
+                        "update_metadata",
                     ],
                     description: "The tab group operation to perform",
                 },
@@ -470,7 +477,7 @@ const TOOLS = [
                 },
                 title: {
                     type: "string",
-                    description: "Group title (for create, update)",
+                    description: "Group or metadata title (for create, update, archive update_metadata)",
                 },
                 color: {
                     type: "string",
@@ -487,12 +494,52 @@ const TOOLS = [
                 },
                 taskThreadId: {
                     type: "string",
-                    description: "Task thread ID (for save_group, restore_group, archive_group)",
+                    description: "Task thread ID (for save_group, restore_group, archive_group, archive and archive-tab update_metadata)",
                 },
                 closeTabs: {
                     type: "boolean",
                     description: "Close tabs after saving (for save_group; archive_group always closes)",
                 },
+                entityType: {
+                    type: "string",
+                    description: "Extension metadata entity type (for update_metadata)",
+                },
+                entityId: {
+                    type: "string",
+                    description: "Extension metadata entity ID (for update_metadata)",
+                },
+                sourceFamily: {
+                    type: "string",
+                    description: "Extension metadata source family (for update_metadata)",
+                },
+                windowId: {
+                    type: "string",
+                    description: "Window ID for window-label metadata updates",
+                },
+                activeWindowId: {
+                    type: "string",
+                    description: "Active window ID to include in update_metadata audit output",
+                },
+                policyTier: {
+                    type: "string",
+                    description: "Policy tier to include in update_metadata audit output",
+                },
+                description: {
+                    type: "string",
+                    description: "Canonical description to store (for update_metadata)",
+                },
+                label: {
+                    type: "string",
+                    description: "Window label to store (for update_metadata)",
+                },
+                status: {
+                    type: "string",
+                    description: "Archived task-thread status to store (for update_metadata)",
+                },
+                tabIndex: {
+                    type: "number",
+                    description: "Archived tab row index (for archive-tab update_metadata)",
+                },
             },
             required: ["action"],
         },
@@ -953,6 +1000,53 @@ const TOOLS = [
             required: ["action"],
         },
     },
+    {
+        name: "comet_monitor",
+        description: "Monitor the current page or a URL for content changes from the caller-owned Comet binding. " +
+            "Stores a SHA-256 baseline by monitor ID, compares later checks, reports line-level diffs, " +
+            "and can capture a screenshot or send a macOS notification on change. Bounded by count/interval.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "URL to navigate to before monitoring. If omitted, monitors the current page.",
+                },
+                selector: {
+                    type: "string",
+                    description: "Optional CSS selector to monitor instead of the full body text.",
+                },
+                id: {
+                    type: "string",
+                    description: "Stable monitor ID. Defaults to a hash of URL/current page and selector.",
+                },
+                once: {
+                    type: "boolean",
+                    description: "Check once and compare against the stored baseline. Defaults to true unless count is provided.",
+                },
+                interval: {
+                    type: "number",
+                    description: "Seconds between checks in continuous mode. Default: 60, max: 300.",
+                },
+                count: {
+                    type: "number",
+                    description: "Number of checks in continuous mode. Default: 10, max: 20.",
+                },
+                screenshot: {
+                    type: "boolean",
+                    description: "Capture a PNG screenshot when a change is detected.",
+                },
+                notify: {
+                    type: "boolean",
+                    description: "Send a macOS notification when a change is detected.",
+                },
+                maxLength: {
+                    type: "number",
+                    description: "Maximum captured content characters. Default: 20000.",
+                },
+            },
+        },
+    },
     {
         name: "comet_automate",
         description: "Execute a multi-step browser workflow. Each step is a tool+args object. Supports: " +
@@ -1076,11 +1170,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             isError: true,
                         };
                     }
+                    // Spec 087 / FR-006, FR-007, FR-009 — load per-project config and
+                    // apply tab_group_prefix if set. Existing groups untouched (clarify.md C-2).
+                    const { readProjectConfig } = await import("./project-config.js");
+                    const { config: projectConfig, warnings: projectConfigWarnings } = readProjectConfig();
+                    let taskThreadIdIn = args?.taskThreadId || undefined;
+                    if (projectConfig.tab_group_prefix && taskThreadIdIn) {
+                        if (!taskThreadIdIn.startsWith(projectConfig.tab_group_prefix)) {
+                            taskThreadIdIn = projectConfig.tab_group_prefix + taskThreadIdIn;
+                        }
+                    }
                     // Spec 034: Use SessionRegistry for isolated, safe connections.
                     // NEVER closes existing tabs. NEVER kills the browser.
                     const session = await sessionRegistry.register({
                         agentId: args?.agentId || undefined,
-                        taskThreadId: args?.taskThreadId || undefined,
+                        taskThreadId: taskThreadIdIn,
                         url: args?.url || undefined,
                         tabGroupColor: args?.tabGroupColor || undefined,
                         port: 9222,
@@ -2349,12 +2453,47 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                     ],
                                 };
                             }
+                            case "list_metadata": {
+                                const metadata = await tabGroupsClient.listExtensionMetadata();
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Extension metadata:\n${JSON.stringify(metadata, null, 2)}`,
+                                        },
+                                    ],
+                                };
+                            }
+                            case "update_metadata": {
+                                const result = await tabGroupsClient.updateExtensionMetadata({
+                                    entityType: args?.entityType,
+                                    entityId: args?.entityId,
+                                    windowId: args?.windowId,
+                                    activeWindowId: args?.activeWindowId,
+                                    taskThreadId: args?.taskThreadId,
+                                    tabIndex: args?.tabIndex,
+                                    sourceFamily: args?.sourceFamily,
+                                    policyTier: args?.policyTier,
+                                    description: args?.description,
+                                    title: args?.title,
+                                    label: args?.label,
+                                    status: args?.status,
+                                });
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Updated extension metadata:\n${JSON.stringify(result, null, 2)}`,
+                                        },
+                                    ],
+                                };
+                            }
                             default:
                                 return {
                                     content: [
                                         {
                                             type: "text",
-                                            text: `Unknown action: ${action}. Use: list, list_tabs, create, update, move, ungroup, delete, save_group, restore_group, archive_group, list_archived`,
+                                            text: `Unknown action: ${action}. Use: list, list_tabs, create, update, move, ungroup, delete, save_group, restore_group, archive_group, list_archived, list_metadata, update_metadata`,
                                         },
                                     ],
                                     isError: true,
@@ -3259,6 +3398,171 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         ],
                     };
                 }
+                case "comet_monitor": {
+                    const monitorUrl = args?.url;
+                    const monitorSelector = args?.selector;
+                    const monitorIdArg = args?.id;
+                    const monitorOnce = args?.once !== false && args?.count === undefined;
+                    const monitorIntervalSec = Math.max(1, Math.min(args?.interval || 60, 300));
+                    const monitorCount = monitorOnce
+                        ? 1
+                        : Math.max(1, Math.min(args?.count || 10, 20));
+                    const monitorScreenshot = args?.screenshot || false;
+                    const monitorNotify = args?.notify || false;
+                    const monitorMaxLength = Math.max(1000, Math.min(args?.maxLength || 20000, 100000));
+                    if (monitorUrl) {
+                        await cometClient.navigate(monitorUrl, true, true);
+                    }
+                    const outputRoot = join(homedir(), ".Codex", "comet-browser", "output");
+                    const scrapedDir = join(outputRoot, "scraped");
+                    const screenshotDir = join(outputRoot, "screenshots");
+                    mkdirSync(scrapedDir, { recursive: true });
+                    mkdirSync(screenshotDir, { recursive: true });
+                    async function captureMonitorState() {
+                        const result = await cometClient.evaluate(`
+              (() => {
+                const selector = ${monitorSelector ? safeSelector(monitorSelector) : "null"};
+                const node = selector ? document.querySelector(selector) : document.body;
+                const content = node ? ((node.innerText || node.textContent || '').trim()) : '';
+                return {
+                  title: document.title,
+                  url: window.location.href,
+                  selector,
+                  content: content.slice(0, ${monitorMaxLength})
+                };
+              })()
+            `);
+                        const value = (result.result.value || {});
+                        const content = value.content || "";
+                        return {
+                            title: value.title || "",
+                            url: value.url || monitorUrl || "",
+                            selector: value.selector || monitorSelector || null,
+                            content,
+                            hash: createHash("sha256").update(content).digest("hex"),
+                            timestamp: new Date().toISOString(),
+                        };
+                    }
+                    const firstState = await captureMonitorState();
+                    const monitorId = monitorIdArg ||
+                        createHash("sha256")
+                            .update(`${firstState.url}:${firstState.selector || ""}`)
+                            .digest("hex")
+                            .slice(0, 12);
+                    const stateFile = join(scrapedDir, `monitor-${monitorId}-state.json`);
+                    const previousState = readJsonSafe(stateFile);
+                    function diffLines(previousContent, currentContent) {
+                        const previousLines = previousContent.split("\n").filter(Boolean);
+                        const currentLines = currentContent.split("\n").filter(Boolean);
+                        return {
+                            added: currentLines.filter((line) => !previousLines.includes(line)).slice(0, 20),
+                            removed: previousLines.filter((line) => !currentLines.includes(line)).slice(0, 20),
+                        };
+                    }
+                    async function saveScreenshotOnChange(changeIndex) {
+                        if (!monitorScreenshot)
+                            return null;
+                        const shot = await cometClient.screenshot("png");
+                        const shotPath = join(screenshotDir, `monitor-${monitorId}-change-${changeIndex}.png`);
+                        writeFileSync(shotPath, Buffer.from(shot.data, "base64"));
+                        return shotPath;
+                    }
+                    function notifyOnChange(message) {
+                        if (!monitorNotify)
+                            return null;
+                        try {
+                            execFileSync("osascript", [
+                                "-e",
+                                `display notification ${JSON.stringify(message)} with title "Comet Monitor"`,
+                            ]);
+                            return "sent";
+                        }
+                        catch (err) {
+                            return `failed: ${err instanceof Error ? err.message : String(err)}`;
+                        }
+                    }
+                    if (monitorOnce) {
+                        const changed = Boolean(previousState && previousState.hash !== firstState.hash);
+                        const diff = changed && previousState?.content
+                            ? diffLines(previousState.content, firstState.content)
+                            : { added: [], removed: [] };
+                        const screenshotPath = changed ? await saveScreenshotOnChange(1) : null;
+                        const notification = changed ? notifyOnChange(`Page changed: ${firstState.url}`) : null;
+                        writeFileSync(stateFile, JSON.stringify(firstState, null, 2));
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        monitorId,
+                                        mode: "once",
+                                        status: previousState ? (changed ? "changed" : "unchanged") : "baseline",
+                                        url: firstState.url,
+                                        selector: firstState.selector,
+                                        timestamp: firstState.timestamp,
+                                        hash: firstState.hash,
+                                        previousHash: previousState?.hash || null,
+                                        contentLength: firstState.content.length,
+                                        stateFile,
+                                        screenshotPath,
+                                        notification,
+                                        diff,
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    const changes = [];
+                    let previous = previousState || firstState;
+                    if (!previousState) {
+                        writeFileSync(stateFile, JSON.stringify(firstState, null, 2));
+                    }
+                    for (let index = 0; index < monitorCount; index++) {
+                        const current = index === 0 ? firstState : await captureMonitorState();
+                        const changed = previous.hash !== current.hash;
+                        if (changed) {
+                            const changeIndex = changes.length + 1;
+                            const screenshotPath = await saveScreenshotOnChange(changeIndex);
+                            const notification = notifyOnChange(`Page changed: ${current.url}`);
+                            changes.push({
+                                check: index + 1,
+                                timestamp: current.timestamp,
+                                hash: current.hash,
+                                previousHash: previous.hash,
+                                screenshotPath,
+                                notification,
+                                diff: diffLines(previous.content, current.content),
+                            });
+                            writeFileSync(stateFile, JSON.stringify(current, null, 2));
+                        }
+                        previous = current;
+                        if (index < monitorCount - 1) {
+                            await new Promise((resolve) => setTimeout(resolve, monitorIntervalSec * 1000));
+                        }
+                    }
+                    const logFile = join(scrapedDir, `monitor-${monitorId}-log-${Date.now()}.json`);
+                    const summary = {
+                        monitorId,
+                        mode: "continuous",
+                        url: firstState.url,
+                        selector: firstState.selector,
+                        checks: monitorCount,
+                        intervalSeconds: monitorIntervalSec,
+                        changesDetected: changes.length,
+                        stateFile,
+                        logFile,
+                        changes,
+                    };
+                    writeFileSync(logFile, JSON.stringify(summary, null, 2));
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(summary, null, 2),
+                            },
+                        ],
+                    };
+                }
                 case "comet_automate": {
                     const autoSteps = args?.steps;
                     const autoVerbose = args?.verbose || false;

package/dist/project-config.d.ts

@@ -0,0 +1,46 @@
+export interface ProjectConfig {
+    /** Owning organization (HH, SVF, BR, Personal, Equa, ...). Used by skills for confirmation prompts. */
+    organization?: string;
+    /** Comet profile name. Defaults to "oe" per constitution Article I. */
+    default_profile?: string;
+    /** Whitelist of entity-specific skill names to surface in this project. */
+    entity_skills?: string[];
+    /** Enabled domain playbooks for comet_domain. */
+    domain_playbooks?: ("qbo" | "mercury" | "salt" | "github" | "google")[];
+    /** Prepended to new tab-group titles created by comet_connect. Existing groups untouched. */
+    tab_group_prefix?: string;
+    /** Drive root for this project's outputs. */
+    google_drive_root?: string;
+    /** Pin for @shawnowen/comet-mcp version. Empty / absent → latest. */
+    mcp_pin?: string;
+}
+/**
+ * Walk up from `cwd` to either a directory containing `.comet/config.json`,
+ * the user's $HOME (boundary), or filesystem root. Returns the absolute path
+ * to the config file, or null.
+ */
+export declare function discoverProjectConfigPath(cwd?: string): string | null;
+/** Clear the discovery cache. Test-only / on cwd change. */
+export declare function clearProjectConfigCache(): void;
+/**
+ * Validate a parsed config object. Returns the cleaned config + a list of
+ * warning strings for any keys that were ignored. Unknown keys are warned
+ * about but do not cause failure.
+ */
+export declare function validateProjectConfig(raw: unknown): {
+    config: ProjectConfig;
+    warnings: string[];
+};
+/**
+ * Read and validate the project config. Returns an empty config + warnings if
+ * the file is absent, unreadable, or invalid JSON. NEVER throws.
+ *
+ * Per Spec 087 U-1 / clarify.md C-1 (revised): re-reads on every call.
+ * Discovery (walking up from cwd) IS cached by cwd; file contents are NOT.
+ */
+export declare function readProjectConfig(cwd?: string): {
+    config: ProjectConfig;
+    path: string | null;
+    warnings: string[];
+};
+//# sourceMappingURL=project-config.d.ts.map

package/dist/project-config.js

@@ -0,0 +1,166 @@
+// Spec 087 / T040 / FR-006, FR-007, FR-008, FR-009
+//
+// Per-project configuration loader. Reads <project_root>/.comet/config.json
+// when present, validates against a small schema, and re-reads on each access
+// (mirrors bridge-config.ts pattern — no per-session caching of file contents).
+//
+// Discovery: walks upward from cwd to repo root or $HOME, looking for .comet/config.json.
+// Caches only the discovered PATH for the session, not the file contents.
+//
+// All fields optional. Backwards-compatible: absent config = pre-Spec 087 behavior.
+import { readFileSync, existsSync, statSync } from "fs";
+import { homedir } from "os";
+import { join, resolve, sep } from "path";
+const VALID_PLAYBOOKS = new Set(["qbo", "mercury", "salt", "github", "google"]);
+let discoveryCache = null;
+/**
+ * Walk up from `cwd` to either a directory containing `.comet/config.json`,
+ * the user's $HOME (boundary), or filesystem root. Returns the absolute path
+ * to the config file, or null.
+ */
+export function discoverProjectConfigPath(cwd = process.cwd()) {
+    // Cache discovery by cwd — file contents are NOT cached.
+    if (discoveryCache && discoveryCache.cwd === cwd) {
+        return discoveryCache.path;
+    }
+    const home = homedir();
+    let dir = resolve(cwd);
+    let result = null;
+    while (true) {
+        const candidate = join(dir, ".comet", "config.json");
+        if (existsSync(candidate)) {
+            try {
+                if (statSync(candidate).isFile()) {
+                    result = candidate;
+                    break;
+                }
+            }
+            catch {
+                // unreadable: keep walking
+            }
+        }
+        if (dir === home || dir === sep || dir === resolve(dir, ".."))
+            break;
+        dir = resolve(dir, "..");
+    }
+    discoveryCache = { cwd, path: result };
+    return result;
+}
+/** Clear the discovery cache. Test-only / on cwd change. */
+export function clearProjectConfigCache() {
+    discoveryCache = null;
+}
+/**
+ * Validate a parsed config object. Returns the cleaned config + a list of
+ * warning strings for any keys that were ignored. Unknown keys are warned
+ * about but do not cause failure.
+ */
+export function validateProjectConfig(raw) {
+    const warnings = [];
+    const config = {};
+    if (raw == null || typeof raw !== "object") {
+        warnings.push("project-config: root must be an object — falling back to defaults");
+        return { config, warnings };
+    }
+    const obj = raw;
+    const known = new Set([
+        "organization",
+        "default_profile",
+        "entity_skills",
+        "domain_playbooks",
+        "tab_group_prefix",
+        "google_drive_root",
+        "mcp_pin",
+    ]);
+    for (const key of Object.keys(obj)) {
+        if (!known.has(key)) {
+            warnings.push(`project-config: unknown key '${key}' ignored`);
+        }
+    }
+    if (typeof obj.organization === "string" && obj.organization.length <= 32) {
+        config.organization = obj.organization;
+    }
+    else if (obj.organization !== undefined) {
+        warnings.push("project-config: 'organization' must be a string ≤ 32 chars — ignored");
+    }
+    if (typeof obj.default_profile === "string" && /^[a-z0-9_-]{1,16}$/.test(obj.default_profile)) {
+        config.default_profile = obj.default_profile;
+    }
+    else if (obj.default_profile !== undefined) {
+        warnings.push("project-config: 'default_profile' must match /^[a-z0-9_-]{1,16}$/ — falling back to 'oe'");
+    }
+    if (Array.isArray(obj.entity_skills) && obj.entity_skills.every((x) => typeof x === "string")) {
+        config.entity_skills = obj.entity_skills;
+    }
+    else if (obj.entity_skills !== undefined) {
+        warnings.push("project-config: 'entity_skills' must be string[] — ignored");
+    }
+    if (Array.isArray(obj.domain_playbooks)) {
+        const valid = [];
+        for (const item of obj.domain_playbooks) {
+            if (typeof item === "string" && VALID_PLAYBOOKS.has(item)) {
+                valid.push(item);
+            }
+            else {
+                warnings.push(`project-config: unknown domain_playbook '${item}' ignored`);
+            }
+        }
+        if (valid.length > 0)
+            config.domain_playbooks = valid;
+    }
+    else if (obj.domain_playbooks !== undefined) {
+        warnings.push("project-config: 'domain_playbooks' must be string[] — ignored");
+    }
+    if (typeof obj.tab_group_prefix === "string" &&
+        obj.tab_group_prefix.length <= 16 &&
+        !/[,:]/.test(obj.tab_group_prefix)) {
+        config.tab_group_prefix = obj.tab_group_prefix;
+    }
+    else if (obj.tab_group_prefix !== undefined) {
+        warnings.push("project-config: 'tab_group_prefix' must be ≤ 16 chars with no comma or colon — ignored");
+    }
+    if (typeof obj.google_drive_root === "string" &&
+        (obj.google_drive_root.startsWith("drive://") ||
+            obj.google_drive_root.startsWith("https://drive.google.com/"))) {
+        config.google_drive_root = obj.google_drive_root;
+    }
+    else if (obj.google_drive_root !== undefined) {
+        warnings.push("project-config: 'google_drive_root' must start with drive:// or https://drive.google.com/ — ignored");
+    }
+    if (typeof obj.mcp_pin === "string" && /^\d+\.\d+\.\d+(-[A-Za-z0-9.-]+)?$/.test(obj.mcp_pin)) {
+        config.mcp_pin = obj.mcp_pin;
+    }
+    else if (obj.mcp_pin !== undefined) {
+        warnings.push("project-config: 'mcp_pin' must be a semver string — ignored");
+    }
+    return { config, warnings };
+}
+/**
+ * Read and validate the project config. Returns an empty config + warnings if
+ * the file is absent, unreadable, or invalid JSON. NEVER throws.
+ *
+ * Per Spec 087 U-1 / clarify.md C-1 (revised): re-reads on every call.
+ * Discovery (walking up from cwd) IS cached by cwd; file contents are NOT.
+ */
+export function readProjectConfig(cwd = process.cwd()) {
+    const path = discoverProjectConfigPath(cwd);
+    if (!path) {
+        return { config: {}, path: null, warnings: [] };
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (err) {
+        return {
+            config: {},
+            path,
+            warnings: [
+                `project-config: failed to parse ${path} — ${err.message} — falling back to defaults`,
+            ],
+        };
+    }
+    const { config, warnings } = validateProjectConfig(raw);
+    return { config, path, warnings };
+}
+//# sourceMappingURL=project-config.js.map

package/dist/tab-groups.d.ts

@@ -31,6 +31,22 @@ export interface UpdateGroupOptions {
     color?: TabGroupColor;
     collapsed?: boolean;
 }
+export interface ExtensionMetadataUpdateOptions {
+    entityType?: string;
+    entityId?: string | number;
+    windowId?: string | number;
+    activeWindowId?: string | number;
+    id?: string | number;
+    taskThreadId?: string;
+    tabIndex?: number;
+    sourceFamily?: string;
+    intent?: string;
+    policyTier?: string;
+    description?: string;
+    title?: string;
+    label?: string;
+    status?: string;
+}
 export interface TabGroupArchiveEntry {
     taskThreadId: string;
     title: string;
@@ -42,7 +58,7 @@ export interface TabGroupArchiveEntry {
     }[];
     archivedAt: string;
     restoredAt?: string;
-    status: "saved" | "archived";
+    status: "pending" | "done" | "trashed" | "saved" | "archived";
 }
 export declare class TabGroupsClient {
     private client;
@@ -83,6 +99,10 @@ export declare class TabGroupsClient {
     ungroupTabs(tabIds: number[]): Promise<void>;
     /** List all tabs with their groupId (−1 = ungrouped). */
     listTabs(): Promise<TabInfo[]>;
+    /** List extension-owned descriptions, window labels, archives, and selected metadata. */
+    listExtensionMetadata(): Promise<Record<string, unknown>>;
+    /** Update extension-owned metadata without touching native tab state. */
+    updateExtensionMetadata(options: ExtensionMetadataUpdateOptions): Promise<Record<string, unknown>>;
     /** Create a single tab and return its ID. Used by ETT restore_group. */
     createTab(url: string, active?: boolean): Promise<number>;
     /** Close multiple tabs by ID. Used by ETT archive_group. */