@shawnowen/comet-mcp 2.3.1 → 2.4.2

package/dist/snapshot-capture.d.ts

@@ -0,0 +1,3 @@
+import type { AgentSession, TaskThreadSnapshot, SnapshotReason, TaskThreadStatus } from "./types.js";
+export declare function captureTaskThreadSnapshot(session: AgentSession, reason: SnapshotReason, taskStatus?: TaskThreadStatus): Promise<TaskThreadSnapshot>;
+//# sourceMappingURL=snapshot-capture.d.ts.map

package/dist/snapshot-capture.js

@@ -0,0 +1,91 @@
+// Snapshot Capture — Task Thread state preservation before automated closure (Spec 016, FR-003)
+// Captures all tabs, Sidecar threads, window metadata, and task status.
+// Atomic write: temp file → rename to prevent partial captures.
+// If capture fails, caller MUST NOT proceed with close (fail safe).
+import { writeFileSync, renameSync, mkdirSync } from "fs";
+import { join } from "path";
+import { loadBridgeConfig } from "./bridge-config.js";
+export async function captureTaskThreadSnapshot(session, reason, taskStatus = "abandoned") {
+    const config = loadBridgeConfig();
+    const tabs = [];
+    const sidecarThreads = [];
+    let windowMetadata = null;
+    // Query tabs in this session's tab group via extension messaging
+    try {
+        const { tabGroupsClient } = await import("./tab-groups.js");
+        const allTabs = await tabGroupsClient.listTabs();
+        // Filter to tabs in this session's tab group, or by ownership if no group (extension degradation)
+        const sessionTabs = session.tabGroupId !== null
+            ? allTabs.filter((t) => t.groupId === session.tabGroupId)
+            : allTabs.filter((t) => t.id === session.chromeTabId);
+        for (const tab of sessionTabs) {
+            tabs.push({
+                url: tab.url,
+                title: tab.title,
+                chromeTabId: tab.id,
+                targetId: session.targetId,
+                active: tab.active,
+            });
+            // Check if tab has a Sidecar thread (Perplexity assistant panel)
+            if (tab.url?.includes("perplexity.ai")) {
+                sidecarThreads.push({
+                    threadUrl: tab.url,
+                    parentTabUrl: tab.url,
+                    lastQuery: null,
+                });
+            }
+        }
+        // Capture window metadata
+        const groups = await tabGroupsClient.listGroups();
+        const sessionGroup = groups.find((g) => g.id === session.tabGroupId);
+        if (sessionGroup) {
+            windowMetadata = {
+                windowId: sessionGroup.windowId,
+                x: 0,
+                y: -1440,
+                width: 2560,
+                height: 1440,
+                displayIndex: 0,
+            };
+        }
+    }
+    catch (extErr) {
+        // Extension not available — capture what we can from CDP
+        console.warn(`[comet-bridge] Snapshot degraded for ${session.sessionKey}: extension unavailable (${extErr instanceof Error ? extErr.message : extErr})`);
+        tabs.push({
+            url: "unknown (extension unavailable)",
+            title: session.taskThreadId,
+            chromeTabId: session.chromeTabId ?? 0,
+            targetId: session.targetId,
+            active: true,
+        });
+    }
+    const snapshot = {
+        sessionKey: session.sessionKey,
+        agentId: session.agentId,
+        taskThreadId: session.taskThreadId,
+        capturedAt: new Date().toISOString(),
+        reason,
+        taskStatus,
+        tabs,
+        sidecarThreads,
+        windowMetadata,
+        tabGroupId: session.tabGroupId,
+        tabGroupColor: session.tabGroupColor,
+    };
+    // Atomic write: temp file → rename (T026)
+    const snapshotDir = config.cleanup.snapshotDir;
+    mkdirSync(snapshotDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const safeAgentId = session.agentId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const safeThreadId = session.taskThreadId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const filename = `${safeAgentId}_${safeThreadId}_${timestamp}.json`;
+    const finalPath = join(snapshotDir, filename);
+    const tempPath = finalPath + ".tmp";
+    // Write to temp file first — if this fails, no partial snapshot exists
+    writeFileSync(tempPath, JSON.stringify(snapshot, null, 2));
+    // Atomic rename — if this fails, temp file exists but final doesn't
+    renameSync(tempPath, finalPath);
+    return snapshot;
+}
+//# sourceMappingURL=snapshot-capture.js.map

package/dist/tab-group-archive.js

@@ -11,7 +11,9 @@ let writeQueue = Promise.resolve();
 function serialized(fn) {
     const prev = writeQueue;
     let resolve;
-    writeQueue = new Promise((r) => { resolve = r; });
+    writeQueue = new Promise((r) => {
+        resolve = r;
+    });
     return prev.then(fn).finally(() => resolve());
 }
 function resolveArchivePaths(archiveDir) {

package/dist/tab-groups.d.ts

@@ -15,6 +15,11 @@ export interface TabInfo {
     url: string;
     active: boolean;
 }
+export interface WindowTabInfo {
+    tabId: number;
+    windowId: number;
+    url: string;
+}
 export interface CreateGroupOptions {
     tabIds: number[];
     title?: string;
@@ -26,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;
@@ -37,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;
@@ -68,6 +89,8 @@ export declare class TabGroupsClient {
         groupId: number;
         group: TabGroup;
     }>;
+    /** Create a managed browser window locked to the top display fullscreen policy. */
+    createTopDisplayFullscreenWindowWithTab(url: string): Promise<WindowTabInfo>;
     /** Update an existing tab group's title, color, or collapsed state. */
     updateGroup(options: UpdateGroupOptions): Promise<TabGroup>;
     /** Move a tab group to a new position. */
@@ -76,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. */

package/dist/tab-groups.js

@@ -116,8 +116,7 @@ export class TabGroupsClient {
             returnByValue: true,
         });
         if (result.exceptionDetails) {
-            const msg = result.exceptionDetails.exception?.description ||
-                result.exceptionDetails.text;
+            const msg = result.exceptionDetails.exception?.description || result.exceptionDetails.text;
             throw new Error(`Extension eval error: ${msg}`);
         }
         return result.result.value;
@@ -163,7 +162,10 @@ export class TabGroupsClient {
         if (Object.keys(updateProps).length > 0) {
           await chrome.tabGroups.update(groupId, updateProps);
         }
-        const g = await chrome.tabGroups.get(groupId);
+        const enforced = await self.CometWindowPolicy.ensureOneGroupPerWindow(groupId, {
+          markChangedWindowManaged: true
+        });
+        const g = enforced?.group || (await chrome.tabGroups.get(groupId));
         return {
           groupId: g.id,
           group: {
@@ -174,6 +176,22 @@ export class TabGroupsClient {
       })()
     `);
     }
+    /** Create a managed browser window locked to the top display fullscreen policy. */
+    async createTopDisplayFullscreenWindowWithTab(url) {
+        return await this.evaluate(`
+      (async () => {
+        const win = await self.CometWindowPolicy.createTopDisplayFullscreenWindow({
+          url: ${JSON.stringify(url)}
+        });
+        const tab = win.tabs?.[0] || (await chrome.tabs.query({ windowId: win.id }))[0];
+        return {
+          tabId: tab.id,
+          windowId: win.id,
+          url: tab.url || tab.pendingUrl || ${JSON.stringify(url)}
+        };
+      })()
+    `);
+    }
     /** Update an existing tab group's title, color, or collapsed state. */
     async updateGroup(options) {
         const props = [];
@@ -225,6 +243,190 @@ export class TabGroupsClient {
       })()
     `);
     }
+    /** List extension-owned descriptions, window labels, archives, and selected metadata. */
+    async listExtensionMetadata() {
+        return await this.evaluate(`
+      (async () => {
+        const stored = await chrome.storage.local.get([
+          "sessionEntityDescriptions",
+          "sidebarSettings",
+          "archivedGroups",
+          "recentlyClosedGroups",
+          "fsSelectedGroups",
+          "fsSelectedTabs"
+        ]);
+        const normalizeArchiveWorkflowStatus = (status) => {
+          const raw = String(status || "").trim().toLowerCase();
+          if (raw === "done") return "done";
+          if (raw === "trashed") return "trashed";
+          return "pending";
+        };
+        const settings = stored.sidebarSettings || {};
+        const archives = Array.isArray(stored.archivedGroups) ? stored.archivedGroups : [];
+        return {
+          entityDescriptions: stored.sessionEntityDescriptions || {},
+          windowLabels: settings.windowLabels || {},
+          archives: archives.map((entry) => ({
+            taskThreadId: entry.taskThreadId || entry.id,
+            title: entry.title || entry.sessionName || "Untitled",
+            sessionName: entry.sessionName || null,
+            taskGoal: entry.taskGoal || null,
+            description: String(entry.description || entry.note || ""),
+            status: normalizeArchiveWorkflowStatus(entry.status),
+            rawStatus: entry.status || null,
+            tabCount: Array.isArray(entry.urls) ? entry.urls.length : 0,
+            urls: Array.isArray(entry.urls)
+              ? entry.urls.map((tab) => ({
+                  url: String(tab && tab.url ? tab.url : ""),
+                  title: String(tab && tab.title ? tab.title : ""),
+                  description: String(tab && tab.description ? tab.description : "")
+                }))
+              : [],
+            archivedAt: entry.archivedAt || null,
+            closedAt: entry.closedAt || null,
+            restoredAt: entry.restoredAt || null,
+            orchestratorUrl: entry.orchestratorUrl || null,
+            locked: !!entry.locked,
+            pinned: !!entry.pinned,
+            starred: !!entry.starred
+          })),
+          recentGroups: Array.isArray(stored.recentlyClosedGroups) ? stored.recentlyClosedGroups : [],
+          selectedItems: {
+            groups: Array.isArray(stored.fsSelectedGroups) ? stored.fsSelectedGroups : [],
+            tabs: Array.isArray(stored.fsSelectedTabs) ? stored.fsSelectedTabs : []
+          }
+        };
+      })()
+    `);
+    }
+    /** Update extension-owned metadata without touching native tab state. */
+    async updateExtensionMetadata(options) {
+        const payload = JSON.stringify(options || {});
+        return await this.evaluate(`
+      (async () => {
+        const input = ${payload};
+        const now = new Date().toISOString();
+        const entityType = String(input.entityType || "").toLowerCase();
+        const taskThreadId = String(input.taskThreadId || input.entityId || input.id || "");
+        const makeMetadataAudit = (target) => ({
+          intent: String(input.intent || input.action || "update_metadata"),
+          target,
+          activeWindow: {
+            windowId: String(input.activeWindowId || input.activeWindow?.windowId || "extension_service_worker")
+          },
+          policyTier: String(input.policyTier || "prime"),
+          status: "success",
+          createdAt: now
+        });
+        const coerceArchiveWorkflowStatusForWrite = (status) => {
+          const raw = String(status || "").trim().toLowerCase();
+          if (raw === "saved" || raw === "archived") return "pending";
+          if (raw === "pending" || raw === "done" || raw === "trashed") return raw;
+          throw new Error("Invalid status: " + status);
+        };
+
+        if (entityType === "window" || entityType === "window-label") {
+          const windowId = String(input.windowId || input.entityId || input.id || "");
+          if (!windowId) throw new Error("windowId is required for window metadata updates");
+          const stored = await chrome.storage.local.get("sidebarSettings");
+          const settings = stored.sidebarSettings || {};
+          settings.windowLabels = settings.windowLabels || {};
+          const existingWindowLabel = settings.windowLabels[windowId] || {};
+          const nextWindowLabel = { ...existingWindowLabel };
+          if (input.label !== undefined || input.title !== undefined) {
+            nextWindowLabel.label = String(input.label ?? input.title);
+          }
+          if (typeof nextWindowLabel.label !== "string") {
+            nextWindowLabel.label = String(nextWindowLabel.label ?? "");
+          }
+          settings.windowLabels[windowId] = {
+            ...nextWindowLabel,
+            source: "mcp_metadata",
+            updatedAt: now
+          };
+          await chrome.storage.local.set({ sidebarSettings: settings });
+          return {
+            updated: true,
+            entityType: "window-label",
+            windowId,
+            audit: makeMetadataAudit({ entityType: "window-label", windowId })
+          };
+        }
+
+        if (entityType === "archive" || entityType === "task-thread") {
+          if (!taskThreadId) throw new Error("taskThreadId is required for archive metadata updates");
+          const stored = await chrome.storage.local.get("archivedGroups");
+          const archive = Array.isArray(stored.archivedGroups) ? stored.archivedGroups : [];
+          const entry = archive.find((item) => String(item.taskThreadId || item.id) === taskThreadId);
+          if (!entry) throw new Error("Archive entry not found: " + taskThreadId);
+          let changed = false;
+          if (input.title !== undefined) {
+            entry.title = String(input.title);
+            changed = true;
+          }
+          if (input.description !== undefined) {
+            entry.description = String(input.description);
+            changed = true;
+          }
+          if (input.status !== undefined) {
+            if (entry.locked) throw new Error("Cannot change status of a locked entry");
+            entry.status = coerceArchiveWorkflowStatusForWrite(input.status);
+            entry.statusUpdatedAt = now;
+            changed = true;
+          }
+          if (changed) entry.updatedAt = now;
+          await chrome.storage.local.set({ archivedGroups: archive });
+          return {
+            updated: true,
+            entityType: "archive",
+            taskThreadId,
+            audit: makeMetadataAudit({ entityType: "archive", taskThreadId })
+          };
+        }
+
+        if (entityType === "archive-tab") {
+          if (!taskThreadId) throw new Error("taskThreadId is required for archive tab metadata updates");
+          const tabIndex = Number(input.tabIndex);
+          if (!Number.isInteger(tabIndex) || tabIndex < 0) throw new Error("tabIndex is required");
+          const stored = await chrome.storage.local.get("archivedGroups");
+          const archive = Array.isArray(stored.archivedGroups) ? stored.archivedGroups : [];
+          const entry = archive.find((item) => String(item.taskThreadId || item.id) === taskThreadId);
+          if (!entry) throw new Error("Archive entry not found: " + taskThreadId);
+          entry.urls = Array.isArray(entry.urls) ? entry.urls : [];
+          if (!entry.urls[tabIndex]) throw new Error("Archive tab not found: " + tabIndex);
+          if (input.title !== undefined) entry.urls[tabIndex].title = String(input.title);
+          if (input.description !== undefined) entry.urls[tabIndex].description = String(input.description);
+          await chrome.storage.local.set({ archivedGroups: archive });
+          return {
+            updated: true,
+            entityType: "archive-tab",
+            taskThreadId,
+            tabIndex,
+            audit: makeMetadataAudit({ entityType: "archive-tab", taskThreadId, tabIndex })
+          };
+        }
+
+        const entityId = String(input.entityId || input.id || "");
+        if (!entityType || !entityId) throw new Error("entityType and entityId are required");
+        const stored = await chrome.storage.local.get("sessionEntityDescriptions");
+        const descriptions = stored.sessionEntityDescriptions || {};
+        const key = entityType + ":" + entityId;
+        descriptions[key] = {
+          entityType,
+          entityId,
+          description: String(input.description ?? ""),
+          updatedAt: now
+        };
+        await chrome.storage.local.set({ sessionEntityDescriptions: descriptions });
+        return {
+          updated: true,
+          entityType,
+          entityId,
+          audit: makeMetadataAudit({ entityType, entityId })
+        };
+      })()
+    `);
+    }
     /** Create a single tab and return its ID. Used by ETT restore_group. */
     async createTab(url, active = false) {
         return await this.evaluate(`

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { CodexSessionIdentity, CodexWindowBinding } from "./window-bindings.js";
 export interface CDPTarget {
     id: string;
     type: string;
@@ -41,6 +42,8 @@ export interface CometState {
     port: number;
     currentUrl?: string;
     activeTabId?: string;
+    profileId?: string;
+    profileOwner?: "agent" | "human" | "shared_legacy" | "unknown";
 }
 export interface NetworkIdleResult {
     idle: boolean;
@@ -67,4 +70,238 @@ export interface TabInfo {
     url: string;
     active: boolean;
 }
+export type AgentActivityStatus = "active" | "idle" | "orphaned";
+export interface ObserverAgentStatus {
+    agentId: string;
+    agentType: string;
+    label: string;
+    status: AgentActivityStatus;
+    lastHeartbeat: string;
+    lastActivity: string | null;
+    idleSince: string | null;
+}
+export interface ObserverTabInfo {
+    id: string;
+    url: string;
+    title: string;
+    loadState: "complete" | "loading" | "error";
+    thumbnail: string | null;
+}
+export interface ObserverBindingInfo {
+    bindingId: string;
+    codexSessionId: string;
+    projectThreadId: string;
+    repoSlug: string;
+    worktreePath: string;
+    branchName: string;
+    sessionKey: string;
+    role: CodexSessionIdentity["role"];
+    sidecarContextKey: string;
+    status: CodexWindowBinding["status"];
+    windowId: number;
+    tabGroupId: number | null;
+    targetId: string | null;
+    runIds: string[];
+    updatedAt: string;
+}
+export interface ObserverWindowBindingInfo {
+    windowId: number;
+    binding: ObserverBindingInfo | null;
+    bindingStatus: CodexWindowBinding["status"] | "unbound";
+}
+export interface ObserverTabGroupInfo {
+    id: number;
+    title: string;
+    color: string;
+    collapsed: boolean;
+    windowId: number;
+    tabs: ObserverTabInfo[];
+    tabCount: number;
+    agent: ObserverAgentStatus | null;
+    binding: ObserverBindingInfo | null;
+    bindingStatus: CodexWindowBinding["status"] | "unbound";
+}
+export interface BrowserHealth {
+    running: boolean;
+    cdpConnected: boolean;
+    extensionAvailable: boolean;
+    tabCount: number;
+    groupCount: number;
+}
+export interface BrowserSnapshot {
+    timestamp: string;
+    browser: BrowserHealth;
+    groups: ObserverTabGroupInfo[];
+    ungroupedTabs: ObserverTabInfo[];
+    windows: ObserverWindowBindingInfo[];
+    bindings: ObserverBindingInfo[];
+    totalTabs: number;
+    totalGroups: number;
+}
+export interface ObserverFilters {
+    group?: string;
+    agentId?: string;
+    urlPattern?: string;
+    thumbnails?: boolean;
+    codexIdentity?: CodexSessionIdentity;
+}
+export interface AgentRegistryEntry {
+    agentId: string;
+    agentType: string;
+    label: string;
+    lane: number;
+    status: string;
+    taskGroup: string | null;
+    tabGroupId: number | null;
+    tabGroupColor: string | null;
+    currentUrl: string | null;
+    taskDescription: string | null;
+    startedAt: string | null;
+    lastHeartbeat: string;
+    completedAt: string | null;
+    errorMessage: string | null;
+    capabilities?: string[];
+}
+export interface AgentRegistry {
+    schema: string;
+    lastUpdated: string;
+    agents: Record<string, AgentRegistryEntry>;
+}
+export type ConsumerRole = "orchestrator" | "subagent";
+export type ErrorEventType = "PERPLEXITY_VOICE_MODE" | "PERPLEXITY_IDLE_NO_NAV" | "PERPLEXITY_CONTEXT_BLEED" | "BROWSER_CRASH" | "CRASH_LOOP_CAP" | "CDP_DISCONNECT" | "ORPHAN_DETECTED" | "ORPHAN_REAPED" | "DUPLICATE_PROCESS" | "PROTOCOL_VIOLATION";
+export type ErrorSeverity = "critical" | "operational" | "warning";
+export type AlertRoutingTarget = "operator-direct" | "orchestrator-first" | "orchestrator-only";
+export interface DeliveryStatus {
+    macosNotification: boolean;
+    logFile: boolean;
+    mcpQueue: boolean;
+}
+export interface ErrorEvent {
+    id: string;
+    timestamp: string;
+    type: ErrorEventType;
+    severity: ErrorSeverity;
+    consumerId: string | null;
+    sessionKey: string | null;
+    message: string;
+    context: Record<string, unknown>;
+    suggestedAction: string;
+    delivered: DeliveryStatus;
+}
+export interface AlertRouting {
+    critical: AlertRoutingTarget;
+    operational: AlertRoutingTarget;
+    warning: AlertRoutingTarget;
+}
+export interface RoleConfig {
+    operatorId: string;
+    orchestratorAgentId: string | null;
+}
+export interface BridgeConfig {
+    version: string;
+    cleanup: {
+        orphanThresholdMinutes: number;
+        snapshotBeforeClose: boolean;
+        snapshotDir: string;
+    };
+    crashRecovery: {
+        maxRestarts: number;
+        windowMinutes: number;
+        autoRestart: boolean;
+        crashHistoryPath: string;
+    };
+    alerts: {
+        logPath: string;
+        macosNotifications: boolean;
+        mcpErrorQueue: boolean;
+        routing: AlertRouting;
+    };
+    roles: RoleConfig;
+    protocolEnforcement: {
+        requireConnectBeforeBrowse: boolean;
+        warnMissingTabGroup: boolean;
+    };
+}
+export interface TabSnapshot {
+    url: string;
+    title: string;
+    chromeTabId: number;
+    targetId: string;
+    active: boolean;
+}
+export interface SidecarSnapshot {
+    threadUrl: string;
+    parentTabUrl: string;
+    lastQuery: string | null;
+}
+export interface WindowMetadata {
+    windowId: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    displayIndex: number;
+}
+export type SnapshotReason = "orphan-cleanup" | "completion" | "crash" | "manual";
+export type TaskThreadStatus = "success" | "failed" | "abandoned" | "in-progress";
+export interface TaskThreadSnapshot {
+    sessionKey: string;
+    agentId: string;
+    taskThreadId: string;
+    capturedAt: string;
+    reason: SnapshotReason;
+    taskStatus: TaskThreadStatus;
+    tabs: TabSnapshot[];
+    sidecarThreads: SidecarSnapshot[];
+    windowMetadata: WindowMetadata | null;
+    tabGroupId: number | null;
+    tabGroupColor: TabGroupColor;
+}
+export type SessionStatus = "active" | "disconnecting" | "orphaned";
+export interface AgentSession {
+    agentId: string;
+    taskThreadId: string;
+    sessionKey: string;
+    targetId: string;
+    chromeTabId: number | null;
+    tabGroupId: number | null;
+    tabGroupColor: TabGroupColor;
+    createdAt: number;
+    lastActivity: number;
+    status: SessionStatus;
+    role: ConsumerRole | null;
+    sessionName?: string;
+    taskGoal?: string;
+    orchestratorUrl?: string;
+    parentSessionId?: string | null;
+    codexIdentity?: CodexSessionIdentity;
+    codexBinding?: CodexWindowBinding;
+    profileId?: string;
+    profileOwner?: "agent" | "human" | "shared_legacy" | "unknown";
+    profileAlias?: string | null;
+}
+export interface ManifestEntry {
+    sessionKey: string;
+    agentId: string;
+    taskThreadId: string;
+    targetId: string;
+    tabGroupId: number | null;
+    createdAt: number;
+    lastActivity: number;
+    pid: number;
+    sessionName?: string;
+    taskGoal?: string;
+    orchestratorUrl?: string;
+    role?: "orchestrator" | "subagent";
+    parentSessionId?: string | null;
+    codexIdentity?: CodexSessionIdentity;
+    codexBinding?: CodexWindowBinding;
+    profileId?: string;
+    profileOwner?: "agent" | "human" | "shared_legacy" | "unknown";
+    profileAlias?: string | null;
+}
+export interface SessionManifest {
+    sessions: ManifestEntry[];
+    lastUpdated: number;
+}
 //# sourceMappingURL=types.d.ts.map