@hachej/boring-workspace 0.1.53 → 0.1.55

package/dist/shared.d.ts

@@ -1,4 +1,5 @@
-export { C as CommandResult, U as UiBridge, a as UiCommand, b as UiState } from './ui-bridge-LeBuZqfA.js';
+export { C as CommandResult, a as UiCommand, b as UiState, W as WorkspaceBridge } from './ui-bridge-BbuUZ5iC.js';
+export { f as BridgeActorAttribution, g as BridgeActorKind, B as BridgeAuthContext, d as BridgeCallerClass, e as BridgeIdempotencyPolicy, h as BridgeRedactedActorRef, i as WorkspaceBridgeCallFailure, a as WorkspaceBridgeCallRequest, b as WorkspaceBridgeCallResponse, j as WorkspaceBridgeCallSuccess, c as WorkspaceBridgeError, k as WorkspaceBridgeErrorCode, l as WorkspaceBridgeFileAssetPointer, m as WorkspaceBridgeJsonValue, W as WorkspaceBridgeOperationDefinition, n as createWorkspaceBridgeError } from './workspace-bridge-rpc-A98RA5o6.js';
 export { C as CommandConfig, P as PaneProps, a as PanelConfig, b as PanelRegistration, S as SurfaceOpenRequest, c as SurfacePanelResolution, d as SurfaceResolverConfig, e as SurfaceResolverRegistration, W as WORKSPACE_OPEN_PATH_SURFACE_KIND, f as definePanel } from './surface-DmIalUmP.js';
 export { A as AgentTool, J as JSONSchema, T as ToolExecContext, a as ToolResult } from './agent-tool-CB0RQyx9.js';
 import 'react';

package/dist/shared.js

@@ -1,3 +1,31 @@
+// src/shared/workspace-bridge-rpc.ts
+var WorkspaceBridgeErrorCode = /* @__PURE__ */ ((WorkspaceBridgeErrorCode2) => {
+  WorkspaceBridgeErrorCode2["OpNotFound"] = "BRIDGE_OP_NOT_FOUND";
+  WorkspaceBridgeErrorCode2["DuplicateOp"] = "BRIDGE_DUPLICATE_OP";
+  WorkspaceBridgeErrorCode2["CallerNotAllowed"] = "BRIDGE_CALLER_NOT_ALLOWED";
+  WorkspaceBridgeErrorCode2["AuthRequired"] = "BRIDGE_AUTH_REQUIRED";
+  WorkspaceBridgeErrorCode2["CapabilityDenied"] = "BRIDGE_CAPABILITY_DENIED";
+  WorkspaceBridgeErrorCode2["ResourceScopeDenied"] = "BRIDGE_RESOURCE_SCOPE_DENIED";
+  WorkspaceBridgeErrorCode2["SchemaInvalid"] = "BRIDGE_SCHEMA_INVALID";
+  WorkspaceBridgeErrorCode2["OutputSchemaInvalid"] = "BRIDGE_OUTPUT_SCHEMA_INVALID";
+  WorkspaceBridgeErrorCode2["InputTooLarge"] = "BRIDGE_INPUT_TOO_LARGE";
+  WorkspaceBridgeErrorCode2["OutputTooLarge"] = "BRIDGE_OUTPUT_TOO_LARGE";
+  WorkspaceBridgeErrorCode2["Timeout"] = "BRIDGE_TIMEOUT";
+  WorkspaceBridgeErrorCode2["HandlerFailed"] = "BRIDGE_HANDLER_FAILED";
+  WorkspaceBridgeErrorCode2["IdempotencyRequired"] = "BRIDGE_IDEMPOTENCY_REQUIRED";
+  WorkspaceBridgeErrorCode2["IdempotencyConflict"] = "BRIDGE_IDEMPOTENCY_CONFLICT";
+  WorkspaceBridgeErrorCode2["ReplayRejected"] = "BRIDGE_REPLAY_REJECTED";
+  WorkspaceBridgeErrorCode2["RateLimited"] = "BRIDGE_RATE_LIMITED";
+  WorkspaceBridgeErrorCode2["InvalidToken"] = "BRIDGE_INVALID_TOKEN";
+  WorkspaceBridgeErrorCode2["ExpiredToken"] = "BRIDGE_EXPIRED_TOKEN";
+  WorkspaceBridgeErrorCode2["InvalidRequest"] = "BRIDGE_INVALID_REQUEST";
+  WorkspaceBridgeErrorCode2["UnsupportedRuntime"] = "BRIDGE_UNSUPPORTED_RUNTIME";
+  return WorkspaceBridgeErrorCode2;
+})(WorkspaceBridgeErrorCode || {});
+function createWorkspaceBridgeError(code, message, details) {
+  return details === void 0 ? { code, message } : { code, message, details };
+}
+
 // src/shared/types/surface.ts
 var WORKSPACE_OPEN_PATH_SURFACE_KIND = "workspace.open.path";
 
@@ -20,6 +48,8 @@ function safeCapture(telemetry, event) {
 }
 export {
   WORKSPACE_OPEN_PATH_SURFACE_KIND,
+  WorkspaceBridgeErrorCode,
+  createWorkspaceBridgeError,
   definePanel,
   noopTelemetry,
   safeCapture

package/dist/testing.js

@@ -1,7 +1,7 @@
 import { jsx as Ba } from "react/jsx-runtime";
 import * as Pa from "react";
 import { createElement as is, useMemo as wn, useLayoutEffect as us, isValidElement as ss, cloneElement as ds, useSyncExternalStore as Gi } from "react";
-import { i as cs, r as fs, q as ps } from "./WorkspaceProvider-CrOT4ab7.js";
+import { i as cs, w as fs, v as ps } from "./WorkspaceProvider-DF90RUdU.js";
 import { d as ms } from "./panel-DnvDNQac.js";
 import * as bs from "react-dom/test-utils";
 import ka from "react-dom";

package/dist/{ui-bridge-LeBuZqfA.d.ts → ui-bridge-BbuUZ5iC.d.ts}

@@ -1,6 +1,7 @@
 interface UiBridge {
     getState(): Promise<UiState | null>;
     setState(state: UiState): Promise<void>;
+    /** Canonical UI command dispatch method. */
     postCommand(cmd: UiCommand): Promise<CommandResult>;
     subscribeCommands(handler: (cmd: UiCommand & {
         seq: number;
@@ -9,6 +10,10 @@ interface UiBridge {
         seq: number;
     }>>;
 }
+type WorkspaceBridge = UiBridge & {
+    /** @deprecated Use postCommand. Kept as a compatibility alias for WorkspaceBridge RPC callers. */
+    emitUiEffect(cmd: UiCommand): Promise<CommandResult>;
+};
 type UiState = Record<string, unknown>;
 type UiCommand = {
     kind: 'openFile';
@@ -68,4 +73,4 @@ interface CommandResult {
     };
 }
 
-export type { CommandResult as C, UiBridge as U, UiCommand as a, UiState as b };
+export type { CommandResult as C, UiBridge as U, WorkspaceBridge as W, UiCommand as a, UiState as b };

package/dist/workspace-bridge-rpc-A98RA5o6.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Platform-neutral WorkspaceBridge RPC contracts.
+ *
+ * This file is imported by both browser and server bundles. Keep it free of
+ * Node-only types/imports and keep stable bridge error codes centralized here.
+ */
+/**
+ * Canonical WorkspaceBridge runtime env var names. Defined in this browser- and
+ * server-safe module so the producer (server runtimeEnv injection) and the
+ * consumer (bridge-client SDK) share one source of truth and cannot drift on
+ * string equality.
+ */
+declare const WORKSPACE_BRIDGE_URL_ENV = "BORING_WORKSPACE_BRIDGE_URL";
+declare const WORKSPACE_BRIDGE_TOKEN_ENV = "BORING_WORKSPACE_BRIDGE_TOKEN";
+declare const WORKSPACE_BRIDGE_TOKEN_URL_ENV = "BORING_WORKSPACE_BRIDGE_TOKEN_URL";
+declare const WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV = "BORING_WORKSPACE_BRIDGE_REFRESH_TOKEN";
+declare const WORKSPACE_BRIDGE_DISABLED_ENV = "BORING_WORKSPACE_BRIDGE_DISABLED";
+type BridgeCallerClass = "browser" | "runtime" | "server";
+type BridgeActorKind = "human" | "agent" | "system" | "service";
+interface BridgeRedactedActorRef {
+    /** Redacted, stable-enough label for logs/audit. Never a bearer token. */
+    label: string;
+    /** Optional non-secret stable id when the auth adapter has one. */
+    id?: string;
+}
+interface BridgeActorAttribution {
+    actorKind: BridgeActorKind;
+    performedBy?: BridgeRedactedActorRef;
+    onBehalfOf?: BridgeRedactedActorRef;
+}
+interface BridgeAuthContext {
+    callerClass: BridgeCallerClass;
+    workspaceId: string;
+    sessionId?: string;
+    pluginId?: string;
+    capabilities: readonly string[];
+    actor: BridgeActorAttribution;
+    tokenId?: string;
+    expiresAt?: string;
+}
+type BridgeIdempotencyPolicy = "none" | "required" | "request-id";
+interface WorkspaceBridgeOperationDefinition<TInput = unknown, TOutput = unknown> {
+    op: string;
+    version: number;
+    owner: string;
+    callerClassesAllowed: readonly BridgeCallerClass[];
+    requiredCapabilities: readonly string[];
+    /**
+     * Allow a caller authenticated for one workspace to invoke this operation on
+     * a registry owned by another workspace. Keep false/omitted for normal
+     * tenant-scoped operations; cross-workspace ops must perform their own
+     * explicit resource authorization.
+     */
+    allowCrossWorkspace?: boolean;
+    inputSchema: unknown;
+    outputSchema?: unknown;
+    timeoutMs: number;
+    maxInputBytes: number;
+    maxOutputBytes: number;
+    idempotencyPolicy: BridgeIdempotencyPolicy;
+    /** Type anchors only; no runtime value should be supplied. */
+    readonly __inputType?: TInput;
+    readonly __outputType?: TOutput;
+}
+interface WorkspaceBridgeCallRequest<TInput = unknown> {
+    op: string;
+    input: TInput;
+    requestId?: string;
+    idempotencyKey?: string;
+}
+interface WorkspaceBridgeCallSuccess<TOutput = unknown> {
+    ok: true;
+    op: string;
+    requestId: string;
+    output: TOutput;
+}
+interface WorkspaceBridgeCallFailure {
+    ok: false;
+    op: string;
+    requestId?: string;
+    error: WorkspaceBridgeError;
+}
+type WorkspaceBridgeCallResponse<TOutput = unknown> = WorkspaceBridgeCallSuccess<TOutput> | WorkspaceBridgeCallFailure;
+declare enum WorkspaceBridgeErrorCode {
+    OpNotFound = "BRIDGE_OP_NOT_FOUND",
+    DuplicateOp = "BRIDGE_DUPLICATE_OP",
+    CallerNotAllowed = "BRIDGE_CALLER_NOT_ALLOWED",
+    AuthRequired = "BRIDGE_AUTH_REQUIRED",
+    CapabilityDenied = "BRIDGE_CAPABILITY_DENIED",
+    ResourceScopeDenied = "BRIDGE_RESOURCE_SCOPE_DENIED",
+    SchemaInvalid = "BRIDGE_SCHEMA_INVALID",
+    OutputSchemaInvalid = "BRIDGE_OUTPUT_SCHEMA_INVALID",
+    InputTooLarge = "BRIDGE_INPUT_TOO_LARGE",
+    OutputTooLarge = "BRIDGE_OUTPUT_TOO_LARGE",
+    Timeout = "BRIDGE_TIMEOUT",
+    HandlerFailed = "BRIDGE_HANDLER_FAILED",
+    IdempotencyRequired = "BRIDGE_IDEMPOTENCY_REQUIRED",
+    IdempotencyConflict = "BRIDGE_IDEMPOTENCY_CONFLICT",
+    ReplayRejected = "BRIDGE_REPLAY_REJECTED",
+    RateLimited = "BRIDGE_RATE_LIMITED",
+    InvalidToken = "BRIDGE_INVALID_TOKEN",
+    ExpiredToken = "BRIDGE_EXPIRED_TOKEN",
+    InvalidRequest = "BRIDGE_INVALID_REQUEST",
+    UnsupportedRuntime = "BRIDGE_UNSUPPORTED_RUNTIME"
+}
+interface WorkspaceBridgeError {
+    code: WorkspaceBridgeErrorCode;
+    message: string;
+    details?: Record<string, unknown>;
+}
+declare function createWorkspaceBridgeError(code: WorkspaceBridgeErrorCode, message: string, details?: Record<string, unknown>): WorkspaceBridgeError;
+interface WorkspaceBridgeFileAssetPointer {
+    kind: "file-asset";
+    /** Workspace-relative path validated by the Workspace adapter/file route. */
+    path: string;
+    contentType: string;
+    byteLength?: number;
+    rawUrl?: string;
+}
+type WorkspaceBridgeJsonValue = null | boolean | number | string | WorkspaceBridgeJsonValue[] | {
+    [key: string]: WorkspaceBridgeJsonValue;
+};
+
+export { type BridgeAuthContext as B, type WorkspaceBridgeOperationDefinition as W, type WorkspaceBridgeCallRequest as a, type WorkspaceBridgeCallResponse as b, type WorkspaceBridgeError as c, type BridgeCallerClass as d, type BridgeIdempotencyPolicy as e, type BridgeActorAttribution as f, type BridgeActorKind as g, type BridgeRedactedActorRef as h, type WorkspaceBridgeCallFailure as i, type WorkspaceBridgeCallSuccess as j, WorkspaceBridgeErrorCode as k, type WorkspaceBridgeFileAssetPointer as l, type WorkspaceBridgeJsonValue as m, createWorkspaceBridgeError as n, WORKSPACE_BRIDGE_DISABLED_ENV as o, WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV as p, WORKSPACE_BRIDGE_TOKEN_ENV as q, WORKSPACE_BRIDGE_TOKEN_URL_ENV as r, WORKSPACE_BRIDGE_URL_ENV as s };

package/dist/workspace.css

@@ -1239,6 +1239,9 @@
   :root, :host {
     --font-sans: var(--boring-font-sans);
     --font-mono: var(--boring-font-mono);
+    --color-amber-300: oklch(87.9% 0.169 91.605);
+    --color-amber-500: oklch(76.9% 0.188 70.08);
+    --color-amber-700: oklch(55.5% 0.163 48.998);
     --color-black: #000;
     --color-white: #fff;
     --spacing: 0.25rem;
@@ -1817,6 +1820,9 @@
   .min-w-0 {
     min-width: calc(var(--spacing) * 0);
   }
+  .min-w-4 {
+    min-width: calc(var(--spacing) * 4);
+  }
   .min-w-32 {
     min-width: calc(var(--spacing) * 32);
   }
@@ -2095,6 +2101,12 @@
   .bg-\[color\:var\(--accent\)\] {
     background-color: var(--accent);
   }
+  .bg-\[color\:var\(--accent\)\]\/12 {
+    background-color: var(--accent);
+    @supports (color: color-mix(in lab, red, red)) {
+      background-color: color-mix(in oklab, var(--accent) 12%, transparent);
+    }
+  }
   .bg-\[color\:var\(--accent-soft\)\] {
     background-color: var(--accent-soft);
   }
@@ -2104,6 +2116,15 @@
   .bg-accent {
     background-color: var(--boring-accent);
   }
+  .bg-amber-500 {
+    background-color: var(--color-amber-500);
+  }
+  .bg-amber-500\/12 {
+    background-color: color-mix(in srgb, oklch(76.9% 0.188 70.08) 12%, transparent);
+    @supports (color: color-mix(in lab, red, red)) {
+      background-color: color-mix(in oklab, var(--color-amber-500) 12%, transparent);
+    }
+  }
   .bg-background {
     background-color: var(--boring-background);
   }
@@ -2185,6 +2206,9 @@
   .bg-muted {
     background-color: var(--boring-muted);
   }
+  .bg-muted-foreground {
+    background-color: var(--boring-muted-foreground);
+  }
   .bg-muted\/30 {
     background-color: var(--boring-muted);
     @supports (color: color-mix(in lab, red, red)) {
@@ -2371,6 +2395,9 @@
     font-size: var(--text-xs);
     line-height: var(--tw-leading, var(--text-xs--line-height));
   }
+  .text-\[9\.5px\] {
+    font-size: 9.5px;
+  }
   .text-\[10\.5px\] {
     font-size: 10.5px;
   }
@@ -2466,6 +2493,9 @@
   .text-accent-foreground {
     color: var(--boring-accent-foreground);
   }
+  .text-amber-700 {
+    color: var(--color-amber-700);
+  }
   .text-background {
     color: var(--boring-background);
   }
@@ -3197,6 +3227,11 @@
       background-color: transparent;
     }
   }
+  .dark\:text-amber-300 {
+    &:is(.dark *) {
+      color: var(--color-amber-300);
+    }
+  }
   .\[\&_\[role\=treeitem\]\]\:\!indent-0 {
     & [role=treeitem] {
       text-indent: calc(var(--spacing) * 0) !important;

package/dist/workspace.d.ts

@@ -575,6 +575,8 @@ export declare interface DispatchContext {
      * silently dropped.
      */
     enqueue?: (run: (surface: SurfaceShellApi) => void) => void;
+    /** Optional host policy hook for surface requests that are only relevant in a visible/open context. */
+    shouldOpenSurface?: (request: SurfaceOpenRequest) => boolean;
 }
 
 export declare function DockviewShell({ layout, persistedLayout, onReady, onLayoutChange, allowedPanels, className, prefixHeaderActions, rightHeaderActions, watermarkComponent, }: DockviewShellProps): JSX.Element;
@@ -634,6 +636,10 @@ export declare function emitAgentData(part: unknown): void;
 
 export declare function emitFilesystemAgentFileChange(part: unknown): void;
 
+export declare function emitWorkspaceAttentionAction(detail: WorkspaceAttentionActionDetail): void;
+
+export declare function emitWorkspaceComposerStop(detail: WorkspaceComposerStopDetail): void;
+
 export declare function EmptyPane({ className, onOpenFile }: EmptyPaneProps): JSX.Element;
 
 export declare interface EmptyPaneProps {
@@ -1000,6 +1006,10 @@ export declare interface IdeLayoutProps {
     className?: string;
 }
 
+export declare function isWorkspaceComposerStopDetail(value: unknown): value is WorkspaceComposerStopDetail;
+
+export declare function isWorkspaceComposerStopReason(value: unknown): value is WorkspaceComposerStopReason;
+
 export declare type JSONSchema = Record<string, unknown>;
 
 export declare interface LayoutConfig {
@@ -1341,6 +1351,8 @@ export declare interface PluginProviderProps {
     authHeaders?: Record<string, string>;
     onAuthError?: (statusCode: number) => void;
     apiTimeout?: number;
+    activeSessionId?: string | null;
+    openSessionIds?: readonly string[];
     children: ReactNode;
 }
 
@@ -1904,6 +1916,15 @@ export declare type WorkbenchLeftTabId = string;
 
 declare const WORKSPACE_AGENT_DATA_EVENT = "workspace:agent.data";
 
+export declare const WORKSPACE_ATTENTION_ACTION_EVENT: "boring-workspace:attention-action";
+
+export declare const WORKSPACE_COMPOSER_STOP_EVENT: "boring:workspace-composer-stop";
+
+export declare const WORKSPACE_COMPOSER_STOP_REASONS: {
+    readonly sessionSwitch: "session-switch";
+    readonly userStop: "user-stop";
+};
+
 declare const WORKSPACE_EDITOR_SAVE_END_EVENT = "workspace:editor.save.end";
 
 declare const WORKSPACE_EDITOR_SAVE_START_EVENT = "workspace:editor.save.start";
@@ -1914,6 +1935,8 @@ declare const WORKSPACE_PANEL_CLOSE_EVENT = "workspace:panel.close";
 
 declare const WORKSPACE_PANEL_UPDATE_EVENT = "workspace:panel.update";
 
+export declare const WORKSPACE_SURFACE_OPEN_SKIPPED_EVENT = "boring-workspace:surface-open-skipped";
+
 declare const WORKSPACE_UI_COMMAND_EVENT = "workspace:ui.command";
 
 export declare interface WorkspaceActions {
@@ -1934,17 +1957,27 @@ export declare interface WorkspaceActions {
     resetLayout: () => void;
 }
 
+export declare type WorkspaceAttentionActionDetail = {
+    blockerId: string;
+    actionId: string;
+    blocker: WorkspaceAttentionBlocker;
+    sessionId?: string;
+};
+
 export declare type WorkspaceAttentionBlocker = {
     id: string;
+    /** Plugin/domain-specific reason, e.g. "ask-user.question" or "pr-review.review". */
     reason: string;
     surfaceKind?: string;
     target?: string;
     label?: string;
     sessionId?: string;
+    /** Optional generic session-row badge contributed by the plugin that owns this attention. */
+    sessionBadge?: WorkspaceAttentionSessionBadge;
     actions?: WorkspaceAttentionBlockerAction[];
 };
 
-declare type WorkspaceAttentionBlockerAction = {
+export declare type WorkspaceAttentionBlockerAction = {
     id: string;
     label: string;
 };
@@ -1955,6 +1988,19 @@ export declare interface WorkspaceAttentionContextValue {
     removeBlocker: (id: string) => void;
 }
 
+export declare type WorkspaceAttentionSessionBadge = {
+    /** Stable badge kind for data attributes and plugin-specific styling hooks. */
+    kind: string;
+    /** Short text rendered on the session row, e.g. "question", "review", "approval". */
+    label: string;
+    /** Visual tone only; semantics are owned by the plugin-specific kind/reason. */
+    tone?: "attention" | "danger" | "neutral" | "warning";
+    /** Higher priority wins when several plugins mark the same session. */
+    priority?: number;
+};
+
+export declare function workspaceAttentionSessionBadgeForBlocker(blocker: Pick<WorkspaceAttentionBlocker, "reason" | "sessionBadge">): WorkspaceAttentionSessionBadge | null;
+
 export declare interface WorkspaceBridge {
     getOpenPanels(): PanelState[];
     getActiveFile(): string | null;
@@ -1997,6 +2043,22 @@ export declare interface WorkspaceChatPanelProps extends PiChatPanelProps<Worksp
     closeWorkbench?: () => void;
 }
 
+export declare function workspaceComposerStopAppliesToSession(detail: unknown, sessionId: string, options?: WorkspaceComposerStopMatchOptions): boolean;
+
+export declare type WorkspaceComposerStopDetail = {
+    sessionId?: string;
+    reason: WorkspaceComposerStopReason;
+};
+
+export declare type WorkspaceComposerStopMatchOptions = {
+    fallbackSessionId?: string | null;
+    ignoredReasons?: readonly WorkspaceComposerStopReason[];
+};
+
+export declare type WorkspaceComposerStopReason = typeof WORKSPACE_COMPOSER_STOP_REASONS[keyof typeof WORKSPACE_COMPOSER_STOP_REASONS];
+
+export declare function workspaceComposerStopTargetSessionId(detail: unknown, fallbackSessionId?: string | null): string | undefined;
+
 export declare interface WorkspaceContextValue {
     chatPanel: WorkspaceChatPanelComponent | null;
     registeredPlugins: RegisteredPluginMeta[];
@@ -2134,7 +2196,7 @@ export declare interface WorkspacePluginEventMap {
     };
 }
 
-export declare function WorkspaceProvider({ children, chatPanel, plugins, excludeDefaults, panels, commands, catalogs, capabilities, apiBaseUrl, authHeaders, apiTimeout, defaultTheme, onThemeChange, workspaceId, workspaceLabel, appTitle, storageKey, persistenceEnabled, manageDocumentTitle, bridgeEndpoint, onAuthError, onOpenFile, debug, frontPluginHotReload, fullPageBasePath, }: WorkspaceProviderProps): JSX.Element;
+export declare function WorkspaceProvider({ children, chatPanel, plugins, excludeDefaults, panels, commands, catalogs, capabilities, apiBaseUrl, authHeaders, apiTimeout, activeSessionId, openSessionIds, defaultTheme, onThemeChange, workspaceId, workspaceLabel, appTitle, storageKey, persistenceEnabled, manageDocumentTitle, bridgeEndpoint, onAuthError, onOpenFile, debug, frontPluginHotReload, fullPageBasePath, }: WorkspaceProviderProps): JSX.Element;
 
 export declare interface WorkspaceProviderProps {
     children: ReactNode;
@@ -2153,6 +2215,10 @@ export declare interface WorkspaceProviderProps {
     authHeaders?: Record<string, string>;
     /** Per-request timeout for the data layer's FetchClient, in ms. */
     apiTimeout?: number;
+    /** Active chat/session scope shared with plugin providers that need session-scoped data. */
+    activeSessionId?: string | null;
+    /** Session ids that are currently open in chat panes, for plugins that must avoid opening closed-session UI. */
+    openSessionIds?: readonly string[];
     defaultTheme?: "light" | "dark" | undefined;
     onThemeChange?: (theme: "light" | "dark") => void;
     workspaceId?: string;