@wrongstack/webui-server 0.313.0 → 0.316.1

package/dist/server/agent-roster-handlers.d.ts

@@ -25,11 +25,11 @@ import type { WSServerMessage } from './types.js';
  * embedded and standalone routers can supply this from the active agent
  * context (`agent.ctx.provider` / `agent.ctx.model`).
  */
-export interface AgentRosterLlm {
+interface AgentRosterLlm {
     provider: Provider;
     model: string;
 }
-export interface AgentRosterHandlerOptions {
+interface AgentRosterHandlerOptions {
     projectRoot: string | (() => string);
     /**
      * Resolves the LLM used to synthesize consolidations directly on the server,
@@ -60,4 +60,5 @@ export declare class AgentRosterWSHandler {
     /** Handle an incoming client message. Returns a response payload. */
     handleMessage(_ws: WebSocket, type: string, payload: unknown): Promise<WSServerMessage>;
 }
+export {};
 //# sourceMappingURL=agent-roster-handlers.d.ts.map

package/dist/server/backend-services.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPipelines, Context } from '@wrongstack/core/agent';
+import { type AgentPipelines, Context } from '@wrongstack/core/agent';
 import type { CollaborationBus, ObservableBrainArbiter } from '@wrongstack/core/coordination';
 import type { AutoCompactionMiddleware, BrainAutoRisk, BrainRuntime } from '@wrongstack/core/execution';
 import type { DefaultTokenCounter } from '@wrongstack/core/infrastructure';
@@ -58,6 +58,21 @@ interface AgentServicesInput {
     sessionGetter: () => Session;
     /** Read-only session reader (collab replay-on-join). */
     sessionReader: SessionReader;
+    /**
+     * True while `sessionId` has an in-flight run. Consulted before evicting a
+     * session agent: the registry is capped at the tab limit, so without this a
+     * fifth lookup would drop a tab that is mid-turn and strand its transcript.
+     */
+    isRunActive?: ((sessionId: string) => boolean) | undefined;
+    /**
+     * Is any connected surface still showing `sessionId`?
+     *
+     * Also consulted before eviction, and it decides WHICH agent goes. Insertion
+     * order alone picks the oldest, which is routinely a tab the user still has
+     * open, while the agent of a tab they closed minutes ago survives because it
+     * was created later.
+     */
+    isDisplayed?: ((sessionId: string) => boolean) | undefined;
     /** Annotations store (collab notes). */
     annotationsStore: AnnotationsStore;
     /**
@@ -73,6 +88,22 @@ interface AgentServices {
     autoCompactor: AutoCompactionMiddleware | undefined;
     toolExecutor: ToolExecutor;
     agent: Agent;
+    getAgent?: (sessionId?: string) => Agent;
+    /**
+     * The Agent for a session WITHOUT creating one. Read-only callers (status
+     * logging, introspection, "can this host serve that id") must use this:
+     * `getAgent` creates, so asking about a stale id materialised an agent and
+     * could evict a live tab's.
+     */
+    peekAgent?: (sessionId?: string) => Agent | undefined;
+    /** Conversations holding a live agent — see `WebuiDeps.sessionAgentIds`. */
+    sessionAgentIds?: () => string[];
+    /** Does this host already hold an open journal writer for that session? */
+    isSessionLive?: (sessionId: string) => boolean;
+    /** Drain every open tab's journal synchronously — fatal-exit salvage. */
+    flushSessionJournalsSync?: () => void;
+    /** End + close the journals of every tab that is not the leader's. */
+    closeSessionJournals?: () => Promise<void>;
     permissionPolicy: PermissionPolicy;
     pipelines: AgentPipelines;
     brain: ObservableBrainArbiter;
@@ -86,6 +117,7 @@ interface AgentServices {
         kind: string;
         question: string;
         outcome: string;
+        sessionId?: string | undefined;
     }>;
     brainMonitor: BrainMonitor;
     /** LIVE persistent decision ledger (undefined when disabled). Read via the

package/dist/server/boot.d.ts

@@ -2,7 +2,7 @@ import { type DefaultLogger } from '@wrongstack/core/infrastructure';
 import type { DefaultSecretVault } from '@wrongstack/core/security';
 import type { Config } from '@wrongstack/core/types';
 import type { WstackPaths } from '@wrongstack/core/utils';
-export interface BootResult {
+interface BootResult {
     config: Config;
     vault: DefaultSecretVault;
     globalConfigPath: string;
@@ -19,4 +19,5 @@ export interface BootResult {
  */
 export declare function bootConfig(): Promise<BootResult>;
 export declare function patchConfig(config: Config, updates: Partial<Config>): Config;
+export {};
 //# sourceMappingURL=boot.d.ts.map

package/dist/server/brain-handlers.d.ts

@@ -18,6 +18,13 @@ export interface BrainLogEntry {
     kind: string;
     question: string;
     outcome: string;
+    /**
+     * The session the decision was about. The Brain is project-wide, but each
+     * decision concerns one session's tool call — a tab asking `/brain` wants
+     * ITS decisions, not an unlabelled mixture of every open tab's.
+     * Undefined for decisions that named no session.
+     */
+    sessionId?: string | undefined;
 }
 export interface BrainTransportContext {
     send: (ws: WebSocket, message: WSServerMessage) => void;
@@ -39,9 +46,19 @@ export interface BrainHandlerContext extends BrainTransportContext {
     /** Read the active session id for brain.ask requests. */
     getSessionId?: (() => string | undefined) | undefined;
 }
-export declare function handleBrainStatus(ctx: BrainHandlerContext, ws: WebSocket): void;
+export declare function handleBrainStatus(ctx: BrainHandlerContext, ws: WebSocket, sessionId?: string | undefined): void;
 export declare function handleBrainConfigGet(ctx: BrainHandlerContext, ws: WebSocket): void;
-export declare function handleBrainConfigSet(ctx: BrainHandlerContext, ws: WebSocket, payload: unknown): Promise<void>;
-export declare function handleBrainRisk(ctx: BrainHandlerContext, ws: WebSocket, level: string): void;
-export declare function handleBrainAsk(ctx: BrainHandlerContext, ws: WebSocket, question: string | undefined): Promise<void>;
+export declare function handleBrainConfigSet(ctx: BrainHandlerContext, ws: WebSocket, payload: unknown, 
+/** The tab that changed the setting — the follow-up status is stamped for it. */
+sessionId?: string | undefined): Promise<void>;
+export declare function handleBrainRisk(ctx: BrainHandlerContext, ws: WebSocket, level: string, sessionId?: string | undefined): void;
+export declare function handleBrainAsk(ctx: BrainHandlerContext, ws: WebSocket, question: string | undefined, 
+/**
+ * The tab that asked. `ctx.getSessionId()` is the runtime's session — with
+ * four tabs open that is the one the runtime last switched to, so a
+ * background tab's `/brain ask` was attributed to another session, filed
+ * under its decisions, and answered with a stamp the asking tab's own
+ * session gate then dropped.
+ */
+sessionId?: string | undefined): Promise<void>;
 //# sourceMappingURL=brain-handlers.d.ts.map

package/dist/server/chimera-routes.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Chimera review-report routes — the session-scoped and project-wide view
+ * of persisted Chimera review reports, findings, and event journals.
+ *
+ * Wire shape:
+ *   client → `chimera.reports.list`       { sessionId?: string, all?: boolean, lifecycle?: string, limit?: number }
+ *   server → `chimera.reports`            { sessionId, reports: [...] }
+ *   client → `chimera.report.get`         { reportId }
+ *   server → `chimera.report.detail`      { report, findings, events, error?: string }
+ *   client → `chimera.report.transition`  { reportId, to, reason?: string }
+ *   server → `chimera.report.updated`     { reportId, lifecycle, success: boolean, error?: string }
+ *   client → `chimera.report.add_note`    { reportId, note: string }
+ *   server → `chimera.report.note_added`  { reportId, success: boolean, error?: string }
+ *   client → `chimera.finding.transition` { findingId, to, outcome?: string, reason?: string }
+ *   server → `chimera.finding.updated`    { findingId, status, success: boolean, error?: string }
+ */
+import { type ChimeraFinding, type FindingLifecycleEvent, type ReviewReport, type ReviewReportCounts, type ReviewReportEvent } from '@wrongstack/core/plugin';
+import type { WebSocket } from 'ws';
+import type { WSClientMessage } from './types.js';
+export interface ChimeraRouteHandlers {
+    listReports: (ws: WebSocket, msg: WSClientMessage) => Promise<void>;
+    getReport?: ((ws: WebSocket, msg: WSClientMessage) => Promise<void>) | undefined;
+    transitionReport?: ((ws: WebSocket, msg: WSClientMessage) => Promise<void>) | undefined;
+    addReportNote?: ((ws: WebSocket, msg: WSClientMessage) => Promise<void>) | undefined;
+    transitionFinding?: ((ws: WebSocket, msg: WSClientMessage) => Promise<void>) | undefined;
+}
+export declare function handleChimeraRoute(ws: WebSocket, msg: WSClientMessage, handlers: ChimeraRouteHandlers): Promise<boolean>;
+/** One report row on the wire. */
+export interface ChimeraReportSummary {
+    reportId: string;
+    sessionId: string;
+    agentId?: string | undefined;
+    reviewedAt: string;
+    reviewerModel?: string | undefined;
+    source?: string | undefined;
+    reviewStatus?: 'success' | 'failed' | undefined;
+    lifecycleStatus: string;
+    counts?: ReviewReportCounts | undefined;
+    totalFindings: number;
+    fileCount?: number | undefined;
+    durationSeconds?: number | undefined;
+    cascadeDepth?: number | undefined;
+    evidenceStatus?: string | undefined;
+    /** Mirrors `pending`: the client backfills cards for actionable rows. */
+    hasActionableFindings: boolean;
+}
+/**
+ * A report still asks for attention until its findings are closed out.
+ * `completed`/`skipped` are terminal: nobody needs to be nudged about them.
+ */
+export declare function isPendingChimeraReport(report: {
+    lifecycle: string;
+    totalFindings: number;
+}): boolean;
+/**
+ * List one session's pending persisted review reports, newest first.
+ * Pure over the store — unit-testable without a WebSocket.
+ */
+export declare function listChimeraReportsForSession(projectDir: string, sessionId: string, limit?: number): Promise<ChimeraReportSummary[]>;
+/**
+ * Query all reports across sessions with optional filters.
+ */
+export declare function queryAllChimeraReports(projectDir: string, opts?: {
+    sessionId?: string | undefined;
+    lifecycle?: string | undefined;
+    limit?: number | undefined;
+}): Promise<ChimeraReportSummary[]>;
+/** Finding with its lifecycle events attached for detail view. */
+export interface FindingWithEvents {
+    finding: ChimeraFinding;
+    events: FindingLifecycleEvent[];
+}
+/** Full report detail payload. */
+export interface ChimeraReportDetail {
+    report: ReviewReport | null;
+    findings: FindingWithEvents[];
+    events: ReviewReportEvent[];
+}
+/** Build the route handlers. `projectDir` is read lazily: project switches re-root it. */
+export declare function createChimeraRouteHandlers(deps: {
+    projectDir: () => string;
+    send: (ws: WebSocket, msg: {
+        type: string;
+        payload: unknown;
+    }) => void;
+    log?: ((message: string) => void) | undefined;
+}): ChimeraRouteHandlers;
+//# sourceMappingURL=chimera-routes.d.ts.map

package/dist/server/codebase-index-server-control.d.ts

@@ -2,7 +2,7 @@ import type { TrustBoundary } from '@wrongstack/core/security';
 import type { Logger } from '@wrongstack/core/types';
 import type { WebSocket } from 'ws';
 import type { WSClientMessage, WSServerMessage } from './types.js';
-export interface CodebaseIndexServerControlDeps {
+interface CodebaseIndexServerControlDeps {
     trustBoundary: TrustBoundary;
     logger?: Logger | undefined;
     getProjectRoot(): string;
@@ -12,4 +12,5 @@ export interface CodebaseIndexServerControlDeps {
 }
 /** Handle the WebSocket control message that stops this project's index server. */
 export declare function handleCodebaseIndexServerControl(ws: WebSocket, message: WSClientMessage, deps: CodebaseIndexServerControlDeps): Promise<boolean>;
+export {};
 //# sourceMappingURL=codebase-index-server-control.d.ts.map

package/dist/server/codebase-indexing.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from '@wrongstack/core/agent';
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { IndexingConfig, Logger } from '@wrongstack/core/types';
-export interface WebUICodebaseIndexingDeps {
+interface WebUICodebaseIndexingDeps {
     config: {
         indexing?: IndexingConfig | undefined;
     };
@@ -10,9 +10,10 @@ export interface WebUICodebaseIndexingDeps {
     logger: Logger;
     events?: EventBus | undefined;
 }
-export interface WebUICodebaseIndexing {
+interface WebUICodebaseIndexing {
     onFileWritten(filePath: string): void;
     dispose(): void;
 }
 export declare function setupWebUICodebaseIndexing(deps: WebUICodebaseIndexingDeps): WebUICodebaseIndexing;
+export {};
 //# sourceMappingURL=codebase-indexing.d.ts.map

package/dist/server/codemap-cache.d.ts

@@ -1,8 +1,3 @@
-export interface CodemapCacheEntry {
-    version: string;
-    /** Pre-serialized JSON body — avoids re-stringify on cache hits. */
-    body: string;
-}
 /**
  * Filesystem fingerprint of the index DB used as the cache generation key.
  *

package/dist/server/codemap-handlers.d.ts

@@ -11,7 +11,7 @@
  *   GET /api/codemap/symbols?file=<path>            — symbol-level graph for one file
  */
 import type * as http from 'node:http';
-export interface CodemapHandlerDeps {
+interface CodemapHandlerDeps {
     projectRoot: string;
     /** Optional index directory override (tests, custom wiring). */
     indexDir?: string | undefined;
@@ -22,4 +22,5 @@ export declare function handleCodemapPackages(res: http.ServerResponse, deps: Co
 export declare function handleCodemapFiles(res: http.ServerResponse, deps: CodemapHandlerDeps, pkg: string): Promise<void>;
 /** GET /api/codemap/symbols?file=<path> — symbol-level graph within a file. */
 export declare function handleCodemapSymbols(res: http.ServerResponse, deps: CodemapHandlerDeps, file: string): Promise<void>;
+export {};
 //# sourceMappingURL=codemap-handlers.d.ts.map

package/dist/server/collab/controller.d.ts

@@ -2,8 +2,6 @@ import type { WebSocket } from 'ws';
 import type { WSServerMessage } from '../types.js';
 import type { CollabContext } from './collab-context.js';
 import type { CollabFeature } from './dispatcher.js';
-/** How long the middleware waits before auto-resuming (mirrors the middleware default). */
-export declare const PAUSE_TIMEOUT_MS = 60000;
 /**
  * Controller flow, Phase 3 (6A-2). Moved verbatim from
  * CollaborationWebSocketHandler: pause/resume/grant_control guards and

package/dist/server/collab/session-registry.d.ts

@@ -13,7 +13,7 @@ export interface Participant {
     joinedAt: string;
 }
 /** One removal produced by `removeBySocket`, with leave-choreography facts. */
-export interface SocketRemoval {
+interface SocketRemoval {
     sessionId: string;
     participant: Participant;
     /** True when this removal emptied the session bucket (no broadcast due). */
@@ -71,4 +71,5 @@ export declare class CollabSessionRegistry {
     sessionIdOfParticipant(participantId: string): string | null;
     clear(): void;
 }
+export {};
 //# sourceMappingURL=session-registry.d.ts.map

package/dist/server/connection-handler.d.ts

@@ -10,7 +10,7 @@ import type { SpecsWebSocketHandler } from './specs-ws-handler.js';
 import type { TerminalWebSocketHandler } from './terminal-ws-handler.js';
 import type { ConnectedClient, WSClientMessage } from './types.js';
 import type { WorktreeWebSocketHandler } from './worktree-ws-handler.js';
-export interface ConnectionHandlerOptions {
+interface ConnectionHandlerOptions {
     getSessionId(): string;
     sessionStartPayload(): Promise<Record<string, unknown>>;
     tokenCounter: TokenCounter;
@@ -39,4 +39,5 @@ export interface ConnectionHandlerOptions {
     onSecurityRejection?: (event: import('./connection-lifecycle.js').SecurityRejectionEvent) => void;
 }
 export declare function createConnectionHandler(options: ConnectionHandlerOptions): (ws: WebSocket) => void;
+export {};
 //# sourceMappingURL=connection-handler.d.ts.map

package/dist/server/connections/auto-healer.d.ts

@@ -18,10 +18,8 @@ import type { ConnectionHealthService, ConnectionsHealthReport, ServiceActionRes
  * damaged rows) and should also never trigger a restart.
  */
 export declare const AUTO_HEAL_ENV_FLAG = "WRONGSTACK_AUTO_HEAL_SERVICES";
-export declare const AUTO_HEAL_DEFAULT_INTERVAL_MS = 30000;
 export declare const AUTO_HEAL_DEFAULT_COOLDOWN_MS: number;
-export declare const AUTO_HEAL_DEFAULT_MAX_ATTEMPTS = 3;
-export interface AutoHealServiceState {
+interface AutoHealServiceState {
     lastAttemptAt: number | null;
     consecutiveFailures: number;
     lastSuccess: boolean | null;
@@ -39,13 +37,13 @@ export interface AutoHealStatusEvent {
     /** 1-based attempt number within the current failure streak. */
     attempt: number;
 }
-export interface AutoHealSnapshot {
+interface AutoHealSnapshot {
     enabled: boolean;
     running: boolean;
     lastTickAt: number | null;
     services: Record<string, AutoHealServiceState>;
 }
-export interface AutoHealerOptions {
+interface AutoHealerOptions {
     projectRoot: () => string;
     indexDir: () => string | undefined;
     /** Policy boundary. When absent, auto-heal refuses to act (same rule as the manual WS path). */
@@ -67,7 +65,7 @@ export interface AutoHealerOptions {
     cooldownMs?: number;
     maxAttempts?: number;
 }
-export interface AutoHealer {
+interface AutoHealer {
     start(): void;
     stop(): void;
     /**
@@ -82,4 +80,5 @@ export interface AutoHealer {
 }
 export declare function isAutoHealEnabled(): boolean;
 export declare function createAutoHealer(options: AutoHealerOptions): AutoHealer;
+export {};
 //# sourceMappingURL=auto-healer.d.ts.map

package/dist/server/connections/collector.d.ts

@@ -4,12 +4,9 @@ export declare function collectConnectionsHealth(options: {
     indexDir?: string | undefined;
     backend: ConnectionsHealthReport['backend'];
 }): Promise<ConnectionsHealthReport>;
-export declare function webuiHealth(backend: ConnectionsHealthReport['backend']): ConnectionHealthService;
-export declare function sessionCatalogHealth(projectRoot: string): Promise<ConnectionHealthService>;
 export declare function chronicleHealth(projectRoot: string): Promise<ConnectionHealthService>;
 export declare function codebaseIndexHealth(projectRoot: string, indexDir?: string): Promise<ConnectionHealthService>;
 export declare function sageHealth(projectRoot: string): Promise<ConnectionHealthService>;
 export declare function kanbanHealth(projectRoot: string): Promise<ConnectionHealthService>;
 export declare function mailboxHealth(projectRoot: string): Promise<ConnectionHealthService>;
-export declare function governanceHealth(projectRoot: string): Promise<ConnectionHealthService>;
 //# sourceMappingURL=collector.d.ts.map

package/dist/server/connections/helpers.d.ts

@@ -1,6 +1,4 @@
 import type { ConnectionHealthService } from './types.js';
-export declare const RESTART_POLL_INTERVAL_MS = 250;
-export declare const RESTART_DEADLINE_MS = 3000;
 /**
  * Raw socket probe — checks if anything is listening on an IPC endpoint
  * (Unix domain socket or Windows named pipe) without sending protocol frames.

package/dist/server/connections/service-actions.d.ts

@@ -6,11 +6,7 @@ export declare function executeServiceAction(serviceId: ConnectionHealthService[
 export declare function killKanbanServer(projectRoot: string, action: 'shutdown' | 'restart'): Promise<ServiceActionResult>;
 export declare function restartKanbanServer(projectRoot: string): Promise<ServiceActionResult>;
 export declare function killSageServer(projectRoot: string, action: 'shutdown' | 'restart'): Promise<ServiceActionResult>;
-export declare function restartSageServer(projectRoot: string): Promise<ServiceActionResult>;
 export declare function killChronicleServer(projectRoot: string, action: 'shutdown' | 'restart'): Promise<ServiceActionResult>;
-export declare function restartChronicleServer(projectRoot: string): Promise<ServiceActionResult>;
 export declare function killCodebaseIndexServer(projectRoot: string, indexDir: string | undefined, action: 'shutdown' | 'restart'): Promise<ServiceActionResult>;
-export declare function restartCodebaseIndexServer(projectRoot: string, indexDir: string | undefined): Promise<ServiceActionResult>;
 export declare function killMailboxServer(projectRoot: string, action: 'shutdown' | 'restart'): Promise<ServiceActionResult>;
-export declare function restartMailboxServer(projectRoot: string): Promise<ServiceActionResult>;
 //# sourceMappingURL=service-actions.d.ts.map

package/dist/server/content-routes.d.ts

@@ -7,7 +7,12 @@ export interface ContentRouteContext {
     getProjectRoot: () => string;
     getSkillsContext: () => SkillsContext;
     getPromptsContext: () => PromptsContext;
-    getDesignContext: () => DesignContext;
+    /**
+     * The design kit is pinned on a conversation's own meta, so the tab that
+     * picked it is the one whose prompts carry it. Without the id every pick
+     * landed on the leader — tab 3 choosing a kit re-styled tab 1's next turn.
+     */
+    getDesignContext: (sessionId?: string | undefined) => DesignContext;
     onFileWritten?: ((filePath: string) => void) | undefined;
 }
 /** Canonical file/skill/prompt/design routing shared by every WebUI host. */

package/dist/server/conversation-operations.d.ts

@@ -18,13 +18,29 @@ export interface ConversationRunControl {
     abort(ws: WebSocket, sessionId: string): void;
 }
 export interface ConversationOperationsContext {
-    getAgent: () => Agent;
+    getAgent: (sessionId?: string) => Agent;
     getSessionId: () => string;
+    hasSession?: ((id: string) => boolean) | undefined;
     runControl: ConversationRunControl;
     pendingConfirms: Map<string, PendingConfirm>;
     send: (ws: WebSocket, message: OutboundMessage) => void;
     notifyAbort: (ws: WebSocket, message: OutboundMessage) => void;
-    getMaxIterations?: () => number | undefined;
+    /**
+     * The iteration ceiling for ONE session.
+     *
+     * `maxIterations` is a per-tab preference (it sits on the session's own
+     * context meta, like autonomy and yolo), so reading it off the shared root
+     * context handed every tab whichever value the runtime's current session
+     * happened to hold — a run in tab 3 capped by a number the user set in tab 1.
+     */
+    getMaxIterations?: (sessionId?: string) => number | undefined;
+    /**
+     * Serialiser shared with the session handlers. Run setup is wrapped in it so
+     * a turn can never start on a context that a concurrent session.new /
+     * session.resume is halfway through re-pointing. Defaults to running the
+     * callback directly when the host does not wire one.
+     */
+    withSessionTransition?: (<T>(operation: () => Promise<T>) => Promise<T>) | undefined;
     busyPhase?: string;
     busyMessage?: string;
 }

package/dist/server/deadcode-handlers.d.ts

@@ -1,8 +1,9 @@
 import type * as http from 'node:http';
-export interface DeadCodeHandlerDeps {
+interface DeadCodeHandlerDeps {
     projectRoot: string;
     indexDir?: string | undefined;
 }
 export declare function handleDeadCodeScan(res: http.ServerResponse, deps: DeadCodeHandlerDeps, req: http.IncomingMessage): Promise<void>;
 export declare function handleDeadCodeActionPlan(res: http.ServerResponse, _deps: DeadCodeHandlerDeps, req: http.IncomingMessage): Promise<void>;
+export {};
 //# sourceMappingURL=deadcode-handlers.d.ts.map

package/dist/server/design-handlers.d.ts

@@ -21,6 +21,12 @@ export interface DesignContext {
     agentMeta?: {
         meta: Record<string, unknown>;
     } | undefined;
+    /**
+     * The session that sent the request, when it stamped one. Echoed on every
+     * response so the gallery can drop a late reply that belongs to another
+     * tab — without it, tab A's slow `design.list` overwrote tab B's kit view.
+     */
+    sessionId?: string | undefined;
 }
 export declare function handleDesignList(ws: WebSocket, ctx: DesignContext): Promise<void>;
 export declare function handleDesignState(ws: WebSocket, ctx: DesignContext): Promise<void>;

package/dist/server/discover-mailbox-bridge.d.ts

@@ -1,4 +1,4 @@
-export interface MailboxBridgeParams {
+interface MailboxBridgeParams {
     projectRoot: string;
     config: {
         features?: {
@@ -28,4 +28,5 @@ export interface MailboxBridgeParams {
  * project was overhead nobody collected on. Opt in with 'auto'.
  */
 export declare function discoverMailboxBridgeForWebui(params: MailboxBridgeParams): Promise<void>;
+export {};
 //# sourceMappingURL=discover-mailbox-bridge.d.ts.map