@wrongstack/webui-server 0.313.1 → 0.316.2

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

@@ -9,7 +9,7 @@
  *   case 'files.tree': return handleFilesTree(ws, msg, projectRoot);
  */
 import type { WebSocket } from 'ws';
-export interface FilesWriteOptions {
+interface FilesWriteOptions {
     onWritten?: ((filePath: string) => void | Promise<void>) | undefined;
 }
 /**
@@ -23,7 +23,9 @@ export declare function handleFilesTree(ws: WebSocket, msg: unknown, projectRoot
 /**
  * Read a file's content for the Monaco editor.
  *
- * Guards against path traversal (`../` escapes). Responds with
+ * Guards against path traversal (`../` escapes) and, mirroring
+ * handleGitDiff, refuses oversized (over 2 MB) and binary files by replying
+ * with a `tooLarge` / `binary` flag instead of content. Responds with
  * `{ type: 'files.read', payload: { filePath, content } }`.
  */
 export declare function handleFilesRead(ws: WebSocket, msg: unknown, projectRoot: string): Promise<void>;
@@ -79,4 +81,5 @@ export declare function handleFilesRename(ws: WebSocket, msg: unknown, projectRo
  * Responds with `{ type: 'files.moved', payload: { srcPath, destPath, success } }`.
  */
 export declare function handleFilesMove(ws: WebSocket, msg: unknown, projectRoot: string): Promise<void>;
+export {};
 //# sourceMappingURL=file-handlers.d.ts.map

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

@@ -31,6 +31,21 @@ export interface GitChangedFile {
     /** True when the change is at least partly staged. */
     staged: boolean;
 }
+/**
+ * Compute the repo-relative prefix for a project root, normalized to
+ * forward slashes with a trailing separator ('' when the project root IS
+ * the repo root, or either side is unknown/escapes the repo).
+ *
+ * `git status --porcelain` always reports paths relative to the REPOSITORY
+ * root, while `files.tree` node paths are relative to the PROJECT root.
+ * When a subdirectory of the repo is opened as the project (e.g.
+ * `packages/webui`), git paths like `packages/webui/src/a.ts` carry a
+ * prefix the tree never emits — every explorer git badge would silently
+ * miss. Prepending this prefix to tree-relative paths aligns the two
+ * bases; separator normalization keeps it valid on Windows where
+ * `rev-parse --show-toplevel` may print either separator style.
+ */
+export declare function repoRelativePrefix(repoRoot: string, projectRoot: string): string;
 /**
  * Read the working-tree change set (everything that differs from HEAD:
  * staged, unstaged, and untracked) and broadcast a `git.changes` message.
@@ -52,4 +67,8 @@ export declare function handleGitChanges(ws: WebSocket, projectRoot: string): Pr
  * are reported with a flag instead of content so the client can show a notice.
  */
 export declare function handleGitDiff(ws: WebSocket, projectRoot: string, path: string): Promise<void>;
+export declare function handleGitStage(ws: WebSocket, projectRoot: string, paths: string[]): Promise<void>;
+export declare function handleGitUnstage(ws: WebSocket, projectRoot: string, paths: string[]): Promise<void>;
+export declare function handleGitDiscard(ws: WebSocket, projectRoot: string, paths: string[]): Promise<void>;
+export declare function handleGitCommit(ws: WebSocket, projectRoot: string, message: string): Promise<void>;
 //# sourceMappingURL=git-handlers.d.ts.map

package/dist/server/governance-runtime.d.ts

@@ -11,7 +11,7 @@ interface WebUiGovernanceDependencies {
     readonly load: () => Promise<GovernanceBootstrapModule>;
     readonly createMutationBridge: typeof createGovernanceMutationSnapshotBridge;
 }
-export interface WebUiGovernanceRuntimeHandle {
+interface WebUiGovernanceRuntimeHandle {
     installToolBoundary(pipelines: AgentPipelines): void;
     close(): Promise<GovernanceRuntimeBootstrapCloseResult>;
 }

package/dist/server/handlers.js

@@ -214,12 +214,6 @@ async function handleTaskUpdate(ctx, ws, payload) {
 }
 async function handlePlanGet(ctx, ws) {
   const planPath = planPathOf(ctx);
-  const emptySnapshot = () => ({
-    version: 1,
-    sessionId: currentSessionId(ctx),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    items: []
-  });
   if (!planPath) {
     ctx.send(ws, {
       type: "plan.updated",
@@ -231,15 +225,18 @@ async function handlePlanGet(ctx, ws) {
     return;
   }
   try {
-    const plan = await loadPlan(planPath);
+    let plan = await loadPlan(planPath);
+    if (!plan) {
+      plan = await mutatePlan(planPath, currentSessionId(ctx), (current) => current);
+    }
     ctx.send(ws, {
       type: "plan.updated",
-      payload: sessionPayload(ctx, { plan: plan ?? emptySnapshot() })
+      payload: sessionPayload(ctx, { plan })
     });
   } catch {
     ctx.send(ws, {
       type: "plan.updated",
-      payload: sessionPayload(ctx, { plan: emptySnapshot() })
+      payload: sessionPayload(ctx, { plan: emptyPlan(currentSessionId(ctx)) })
     });
   }
 }

package/dist/server/http-server/analytics-handler.d.ts

@@ -22,8 +22,6 @@ export interface AnalyticsEvent {
     sessionId?: string | undefined;
     userAgent?: string | undefined;
 }
-export declare const ANALYTICS_MAX_BODY_BYTES: number;
-export declare const ANALYTICS_MAX_EVENT_BYTES: number;
 /** POST /api/analytics — ingest a batch of events from the frontend. */
 export declare function handleApiAnalyticsPost(res: http.ServerResponse, req: http.IncomingMessage): Promise<void>;
 /** GET /api/analytics — retrieve the last N events (debug/export). */

package/dist/server/http-server/security-helpers.d.ts

@@ -1,22 +1,16 @@
 import type * as http from 'node:http';
 export declare const MIME_TYPES: Record<string, string>;
-export declare function escapeHtmlAttr(value: string): string;
 export declare function injectWsConfig(html: string, opts: {
     publicWsUrl?: string | undefined;
 }): string;
-export declare function firstHeader(value: string | string[] | undefined): string | undefined;
 export declare const WS_TOKEN_COOKIE = "ws_token";
 export declare const WS_TOKEN_COOKIE_SECURE = "__Host-ws_token";
-export declare function wsTokenCookie(token: string, secure: boolean): string;
 export declare function setAuthCookieHeaders(res: http.ServerResponse, token: string, secure: boolean): void;
 export declare function setStaticSecurityHeaders(res: http.ServerResponse): void;
 export declare function requestToken(req: http.IncomingMessage, url: URL, opts?: {
     allowQuery?: boolean;
 }): string | undefined;
 export declare function isLoopbackPeer(req: http.IncomingMessage): boolean;
-export declare function formatCspHostname(hostname: string): string;
-export declare function cspSourceFromUrl(rawUrl: string): string | undefined;
-export declare const EXTRA_SCRIPT_SOURCES: readonly string[];
 export declare function buildCspHeader(publicWsUrl?: string | undefined, host?: string, port?: number): string;
 export declare function isInsideDist(candidate: string, distDir: string): boolean;
 export declare function decodeSessionId(segment: string): string;

package/dist/server/http-server/vector-memory-handlers.d.ts

@@ -8,24 +8,7 @@
 import type * as http from 'node:http';
 import type { VectorMemoryStore } from '@wrongstack/vector-memory';
 import type { MemoryPort } from '@wrongstack/core/types';
-export interface VectorMemoryStatusResponse {
-    enabled: boolean;
-    storePath?: string | undefined;
-    modelCacheDir?: string | undefined;
-    providerId?: string | undefined;
-    modelId?: string | undefined;
-    dimensions?: number | undefined;
-    entries?: number | undefined;
-    vectors?: number | undefined;
-    providers?: string[] | undefined;
-    cache?: {
-        entries: number;
-        providers: number;
-        totalUseCount: number;
-        oldestLastUsedAt: string | null;
-    } | undefined;
-}
-export interface VectorMemorySearchHit {
+interface VectorMemorySearchHit {
     id: string;
     score: number;
     text: string;
@@ -44,18 +27,6 @@ export interface VectorMemorySearchResponse {
      */
     similarity?: number[][] | undefined;
 }
-/** Shape the store exposes. Kept narrow so we don't leak the full class. */
-export interface VectorMemorySnapshot {
-    storePath?: string | undefined;
-    modelCacheDir?: string | undefined;
-    stats: {
-        entries: number;
-        vectors: number;
-        providers: string[];
-        modelId: string;
-        dimensions: number;
-    };
-}
 /** Handle `GET /api/vector-memory/status`. */
 export declare function handleVectorMemoryStatus(res: http.ServerResponse, getStore: () => VectorMemoryStore | undefined, opts?: {
     projectRoot?: string;
@@ -67,32 +38,6 @@ export declare function handleVectorMemorySearch(res: http.ServerResponse, url:
 export declare function handleVectorMemoryStore(res: http.ServerResponse, req: http.IncomingMessage, getStore: () => VectorMemoryStore | undefined): Promise<void>;
 /** Handle `DELETE /api/vector-memory/store/:id`. */
 export declare function handleVectorMemoryForget(res: http.ServerResponse, url: URL, getStore: () => VectorMemoryStore | undefined): Promise<void>;
-export interface MemorySearchHit {
-    id: string;
-    text: string;
-    kind: string;
-    status: string;
-    tags: string[];
-    /** Per-channel score breakdown — null on the side that didn't contribute. */
-    lexicalScore: number | null;
-    vectorScore: number | null;
-    /** RRF-style combined score, monotonically higher = better. */
-    finalScore: number;
-    /** Which channel(s) produced this hit. */
-    source: 'lexical' | 'vector' | 'both';
-}
-export interface MemorySearchResponse {
-    hits: MemorySearchHit[];
-    count: number;
-    /**
-     * Where the score breakdown came from. `breakdown` means the rich
-     * variant was used (vector channel was wired); `lexical` means the
-     * fallback synthesized a position-derived score because the surface
-     * doesn't ship `searchSageWithBreakdown`. The UI branches on this to
-     * decide whether to show a dual-column score card or a single column.
-     */
-    channel: 'breakdown' | 'lexical';
-}
 /**
  * Handle `GET /api/memory/search?q=…&limit=…&explain=1`.
  *
@@ -105,4 +50,5 @@ export interface MemorySearchResponse {
  * `channel: 'lexical'` so the caller can branch.
  */
 export declare function handleMemorySearch(res: http.ServerResponse, url: URL, getStore: () => MemoryPort | undefined): Promise<void>;
+export {};
 //# sourceMappingURL=vector-memory-handlers.d.ts.map

package/dist/server/index.d.ts

@@ -13,6 +13,7 @@ export { bootConfig, patchConfig } from './boot.js';
 export { type BrainHandlerContext, type BrainLogEntry, type BrainTransportContext, handleBrainAsk, handleBrainConfigGet, handleBrainConfigSet, handleBrainRisk, handleBrainStatus, } from './brain-handlers.js';
 export type { BrainRouteHandlers } from './brain-routes.js';
 export { handleBrainRoute } from './brain-routes.js';
+export { type ChimeraReportDetail, type ChimeraReportSummary, type ChimeraRouteHandlers, createChimeraRouteHandlers, type FindingWithEvents, handleChimeraRoute, listChimeraReportsForSession, queryAllChimeraReports, } from './chimera-routes.js';
 export { type ChronicleRouteContext, handleChronicleRoute, } from './chronicle-routes.js';
 export { createWebuiClientPresence, type WebuiClientPresence, type WebuiClientPresenceDeps, type WebuiHqConnection, type WebuiHqConnectionOptions, } from './client-presence.js';
 export { type ClientTransportRouteHandlers, handleClientTransportRoute, } from './client-transport-routes.js';
@@ -38,7 +39,7 @@ export { createEternalSubscription, type EternalBroadcast, type EternalSubscribe
 export { handleFilesCreate, handleFilesDelete, handleFilesList, handleFilesMove, handleFilesRead, handleFilesRename, handleFilesSkeleton, handleFilesTree, handleFilesWrite, } from './file-handlers.js';
 export { isHiddenEntry, rankFiles, SKIP_DIRS } from './file-picker.js';
 export { type EnsureDistDeps, ensureDistDir, findInstalledPackageJson, type ResolveDistOptions, resolveDistDir, type StaticServeDeps, type StaticServeHandle, type StaticServeOptions, startStaticServe, } from './frontend-static-serve.js';
-export { handleGitChanges, handleGitDiff, handleGitInfo } from './git-handlers.js';
+export { handleGitChanges, handleGitCommit, handleGitDiff, handleGitDiscard, handleGitInfo, handleGitStage, handleGitUnstage, repoRelativePrefix, } from './git-handlers.js';
 export { handleGoalGet } from './goal-handlers.js';
 export type { GoalRouteHandlers } from './goal-routes.js';
 export { handleGoalRoute } from './goal-routes.js';
@@ -76,10 +77,10 @@ export { formatExternalAccessUrls, getExternalAddresses, type NetworkAddress, }
 export { browserOpenCommand, openBrowser } from './open-browser.js';
 export { isPathInside, resolveWorkingDirInsideProject } from './path-containment.js';
 export type { ConfirmDecision, PendingConfirm } from './pending-confirms.js';
-export { isDestructivePendingConfirm, resolveAllPendingConfirms, resolveYoloEligiblePendingConfirms, } from './pending-confirms.js';
+export { isDestructivePendingConfirm, resolveAllPendingConfirms, resolvePendingConfirmsForSession, resolveYoloEligiblePendingConfirms, } from './pending-confirms.js';
 export { findFreePort, getSurfaceDefaultPorts, isPortFree, isStrictPort, listenWithRetry, SURFACE_DEFAULT_PORTS, type SurfaceKind, surfaceLabel, } from './port-utils.js';
 export { type ConfigWriteLockHolder, PREF_KEYS, type PrefHelperDeps, persistPrefsToConfig, prefSnapshot, } from './pref-helpers.js';
-export { handleAutonomySwitch, handlePrefsGet, handlePrefsUpdate, type PrefsHandlerContext, } from './prefs-handlers.js';
+export { handleAutonomySwitch, handlePrefsGet, handlePrefsUpdate, handleSystemPromptGet, type PrefsHandlerContext, SESSION_SCOPED_PREF_KEYS, } from './prefs-handlers.js';
 export { createPrefsRouteHandlers, handlePrefsRoute, type PrefsRouteHandlers, } from './prefs-routes.js';
 export { handleProcessKill, handleProcessKillAll, handleProcessList, } from './process-handlers.js';
 export { handleProcessRoute, type ProcessRouteHandlers } from './process-routes.js';
@@ -103,9 +104,11 @@ export { SddBoardWebSocketHandler } from './sdd-board-ws-handler.js';
 export { handleSddWizardRoute, type SddWizardRouteHandlers } from './sdd-wizard-routes.js';
 export { buildSddWizardDeps, type SddWizardWiringOptions, type StartSddRunFromGraphConfig, type StartSddRunFromGraphDeps, startSddRunFromGraph, } from './sdd-wizard-wiring.js';
 export { type SddWizardDeps, SddWizardWebSocketHandler } from './sdd-wizard-ws-handler.js';
+export { createSessionAgentRegistry, type SessionAgentRegistry, type SessionAgentRegistryOptions, } from './session-agent-registry.js';
 export { cleanupOwnerlessEmptySessions, DEFAULT_EMPTY_SESSION_CLEANUP_INTERVAL_MS, EMPTY_SESSION_CLEANUP_INTERVAL_ENV, resolveEmptySessionCleanupInterval, scheduleOwnerlessEmptySessionCleanup, } from './session-cleanup-scheduler.js';
 export { deleteWebUISession } from './session-deletion.js';
-export { createSessionHandlers, type SessionHandlersContext } from './session-handlers.js';
+export { collectDisplayedSessionIds, createSessionHandlers, createSessionTransitionGate, type SessionHandlersContext, } from './session-handlers.js';
+export { type AgentSessionPayload, type AgentVirtualSessionLike, buildAgentSessionsPayload, type LoadAgentSessions, } from './session-agent-sessions.js';
 export { type SessionHistoryWireEntry, toSessionHistoryEntries, toSessionHistoryEntry, } from './session-history.js';
 export type { SessionRouteHandlers } from './session-routes.js';
 export { handleSessionRoute } from './session-routes.js';
@@ -118,15 +121,19 @@ export { handleSpecsRoute, type SpecsRouteHandlers } from './specs-routes.js';
 export { SpecsWebSocketHandler } from './specs-ws-handler.js';
 export { startWebUI } from './start-webui.js';
 export { createStreamCoalescer, type StreamCoalescer, type StreamCoalescerDeps, type ToolProgressPayload, } from './stream-coalescer.js';
+export { buildSystemPromptInfo, type SystemPromptInfoPayload, type SystemPromptSurface, type SystemPromptVariantInfo, unavailableSystemPromptInfo, } from './system-prompt-handlers.js';
+export { rebuildSystemPrompt, type SystemPromptRebuildDeps, } from './system-prompt-rebuild.js';
+export { type DashboardConsoleTarget, type DashboardSessionRow, type DashboardStdout, isWebUIVerboseEnv, prettifyStructuredLine, renderSessionPanelLines, startTerminalDashboard, type TerminalDashboard, type TerminalDashboardOptions, } from './terminal-dashboard.js';
 export { TerminalWebSocketHandler } from './terminal-ws-handler.js';
 export { type ContextBreakdown, estimateContextBreakdown, estimateTokens, type MessageTokenEntry, messagePreview, messageTokens, stringifyContent, type ToolTokenEntry, } from './token-estimator.js';
 export type { BackendServices, ConnectedClient, WebUIOptions, WSClientMessage, WSServerMessage, } from './types.js';
 export { type CostRates, computeUsageCost, getCostRates, type TokenUsage, } from './usage-cost.js';
+export { buildSessionRows, formatSessionRowsBlock, type StatusSessionInfo, startWebUILiveStatusLogger, type WebUILiveStatusLoggerOptions, } from './webui-status-logger.js';
 export { createWorklistRouteHandlers, handleWorklistRoute, type WorklistRouteContext, type WorklistRouteHandlers, } from './worklist-routes.js';
 export { handleWorktreeRoute, type WorktreeRouteHandlers } from './worktree-routes.js';
 export { WorktreeWebSocketHandler } from './worktree-ws-handler.js';
 export { extractToken, extractTokenFromCookie, hostHeaderOk, isLoopbackBind, isLoopbackHostname, isWildcardBind, tokenMatches, type VerifyClientInput, verifyClient, } from './ws-auth.js';
 export { validateAutonomySwitchPayload, validateBrainAskPayload, validateBrainRiskPayload, validateContextModeCreatePayload, validateContextModeDeletePayload, validateContextModeSwitchPayload, validateContextModeUpdatePayload, validateGitDiffPayload, validateMailboxAgentsPayload, validateMailboxMessagesPayload, validateMailboxPurgePayload, validateModelSwitchPayload, validateModeSwitchPayload, validatePlanTemplateUsePayload, validatePrefsUpdatePayload, validateProcessKillPayload, validateProjectsAddPayload, validateProjectsSelectPayload, validateShellOpenPayload, validateSkillsCreatePayload, validateSkillsEditPayload, validateWorkingDirSetPayload, } from './ws-payload-validation.js';
-export { broadcast, buildWebUIAccessUrl, envFlag, errMessage, generateAuthToken, hostForBrowserUrl, resolveAuthToken, send, sendResult, sendSerialized, WEBUI_WS_MAX_BUFFERED_BYTES, } from './ws-utils.js';
+export { broadcast, buildWebUIAccessUrl, clientWantsSession, envFlag, errMessage, generateAuthToken, hostForBrowserUrl, resolveAuthToken, send, sendResult, sendSerialized, WEBUI_WS_MAX_BUFFERED_BYTES, } from './ws-utils.js';
 export { createZipBuffer, readZipEntries, type ZipEntryInput } from './zip.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -3,7 +3,23 @@ import type { Config, ConfigStore, ModelsRegistry } from '@wrongstack/core/types
 import type { WebSocket } from 'ws';
 import type { WSClientMessage, WSServerMessage } from './types.js';
 export interface IntrospectionRouteContext {
+    /** The runtime's agent — the fallback when the host has no registry. */
     agent: Agent;
+    /**
+     * Resolve the agent that owns ONE session.
+     *
+     * `diag.get`, `stats.get` and `side_effects.list` describe a single
+     * conversation: its token counter, its message count, its side effects. The
+     * runtime's `agent` is the session it last SWITCHED to, which with four tabs
+     * open is a different tab from the asking one as often as not — so a
+     * background tab asking for its stats was answered with the foreground's
+     * numbers, stamped with the foreground's id (and then dropped by the
+     * browser's own session filter, leaving the panel blank).
+     *
+     * Hosts with a per-session agent registry pass this; single-session hosts
+     * omit it and keep exactly their old behaviour.
+     */
+    getAgent?: ((sessionId?: string) => Agent | undefined) | undefined;
     modelsRegistry?: ModelsRegistry | undefined;
     configStore?: ConfigStore | undefined;
     getConfig: () => Config;

package/dist/server/kanban-contract-routes.d.ts

@@ -1,8 +1,26 @@
+/**
+ * WebSocket routes for the card contract map.
+ *
+ * The three WebUI contract panels (`KanbanContractGraphPanel`,
+ * `KanbanContractGraphDashboard`, `KanbanContractGraphView`) render
+ * `board.contractGraph` and have always shown the empty state, because no
+ * surface could write one: the domain API existed and sat on the IPC wire
+ * allowlist, but nothing called it. These routes are the human half of closing
+ * that; `packages/tools/src/kanban-contract-actions.ts` is the agent half.
+ *
+ * Every mutation broadcasts the updated board so the open panels repaint,
+ * matching how the other kanban write routes behave.
+ */
+import type { Context } from '@wrongstack/core/agent';
 import type { WebSocket } from 'ws';
 import type { WSServerMessage } from './types.js';
-export interface KanbanContractRouteContext {
+interface KanbanContractRouteContext {
     projectRoot: string;
+    context?: Context | undefined;
+    /** Tab that sent the request — the session every emitted event belongs to. */
+    requestSessionId?: string | undefined;
     broadcast?: ((msg: WSServerMessage) => void) | undefined;
 }
 export declare function handleKanbanContractRoute(ws: WebSocket, type: string, payload: Record<string, unknown> | undefined, ctx: KanbanContractRouteContext): Promise<boolean>;
+export {};
 //# sourceMappingURL=kanban-contract-routes.d.ts.map

package/dist/server/kanban-decomposition-routes.d.ts

@@ -1,10 +1,13 @@
 import type { Context } from '@wrongstack/core/agent';
 import type { WebSocket } from 'ws';
 import type { WSServerMessage } from './types.js';
-export interface KanbanDecompositionRouteContext {
+interface KanbanDecompositionRouteContext {
     projectRoot: string;
     context?: Context | undefined;
+    /** Tab that sent the request — the session every emitted event belongs to. */
+    requestSessionId?: string | undefined;
     broadcast?: ((msg: WSServerMessage) => void) | undefined;
 }
 export declare function handleKanbanDecompositionRoute(ws: WebSocket, type: string, payload: Record<string, unknown> | undefined, ctx: KanbanDecompositionRouteContext): Promise<boolean>;
+export {};
 //# sourceMappingURL=kanban-decomposition-routes.d.ts.map

package/dist/server/kanban-dispatch.d.ts

@@ -28,6 +28,8 @@ export type KanbanTaskDispatcher = (description: string, opts?: {
 export interface KanbanDispatchContext {
     projectRoot: string;
     context?: Context | undefined;
+    /** Tab that asked for the dispatch — the session that owns the work. */
+    requestSessionId?: string | undefined;
     broadcast?: ((message: WSServerMessage) => void) | undefined;
     dispatchTask?: KanbanTaskDispatcher | undefined;
 }

package/dist/server/kanban-route-helpers.d.ts

@@ -6,11 +6,32 @@ export interface KanbanRouteHelperContext {
     projectRoot: string;
     context?: Context | undefined;
     broadcast?: ((msg: WSServerMessage) => void) | undefined;
+    /**
+     * The session of the tab that sent THIS message.
+     *
+     * Board contents are addressed by `boardId`, so they never crossed tabs —
+     * but every activity entry and presence ping was stamped with
+     * `context.session`, the session the runtime last switched to. With four
+     * tabs open, tab 3 moving a card was recorded as tab 1's work. Set per
+     * message by `handleKanbanRoute`; absent on single-session hosts, where the
+     * runtime session is the only answer there is.
+     */
+    requestSessionId?: string | undefined;
 }
+/** Who is acting: the tab that asked, falling back to the runtime session. */
+export declare function actingSessionId(ctx: KanbanRouteHelperContext): string | undefined;
 export declare function syncSessionSource(ctx: KanbanRouteHelperContext, task: KanbanTask, remove?: boolean): Promise<void>;
 export declare function ok(ws: WebSocket, type: string, data?: unknown): void;
 export declare function fail(ws: WebSocket, type: string, message: string): void;
 export declare function has(payload: Record<string, unknown> | undefined, key: string): boolean;
+/**
+ * Event context for a board mutation requested over the WebUI socket.
+ *
+ * Throws when no acting session can be resolved. Every WebUI board mutation
+ * arrives on a tab's socket, so a missing session is a wiring bug in the route
+ * (a handler that dropped `requestSessionId`), not a state to write an
+ * unattributed event from.
+ */
 export declare function activityContext(ctx: KanbanRouteHelperContext, actor?: string, note?: string): KanbanEventContext;
 export declare function touchTaskPresence(ctx: KanbanRouteHelperContext, boardId: string, taskId: string): Promise<KanbanBoard | null>;
 export declare function findTask(tasks: KanbanTask[], taskId: string): KanbanTask | undefined;

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

@@ -8,6 +8,16 @@ export { KANBAN_CLIENT_MESSAGE_TYPES } from './kanban-route-protocol.js';
 export interface KanbanRouteContext {
     projectRoot: string;
     context?: Context | undefined;
+    /**
+     * Every session a tab is currently displaying.
+     *
+     * `context.session` is only the one the runtime last switched to. With four
+     * tabs open, guarding `kanban.delete` on that alone protected ONE live board
+     * and left the other three deletable out from under the tabs showing them.
+     * Hosts that track displayed tabs pass this; single-session hosts omit it
+     * and the runtime session remains the whole set.
+     */
+    getDisplayedSessionIds?: (() => string[]) | undefined;
     broadcast?: ((msg: WSServerMessage) => void) | undefined;
     dispatchTask?: KanbanTaskDispatcher | undefined;
     /**
@@ -17,6 +27,8 @@ export interface KanbanRouteContext {
      * double-audit that happens when both paths refresh the same board concurrently.
      */
     supervisor?: KanbanSupervisor | undefined;
+    /** Set per message by `handleKanbanRoute` — see `KanbanRouteHelperContext`. */
+    requestSessionId?: string | undefined;
 }
-export declare function handleKanbanRoute(ws: WebSocket, msg: WSClientMessage, ctx: KanbanRouteContext): Promise<boolean>;
+export declare function handleKanbanRoute(ws: WebSocket, msg: WSClientMessage, rawCtx: KanbanRouteContext): Promise<boolean>;
 //# sourceMappingURL=kanban-routes.d.ts.map

package/dist/server/kanban-supervisor.d.ts

@@ -4,6 +4,8 @@ export interface KanbanSupervisorDispatchOptions {
     model?: string | undefined;
     fallbackProfile?: string | undefined;
     fallbackModels?: string[] | undefined;
+    /** Named cost level; resolved against `modelTiers` at dispatch time. */
+    tier?: string | undefined;
     skills?: string[] | undefined;
     name?: string | undefined;
     /**

package/dist/server/kanban-task-routes.d.ts

@@ -1,10 +1,13 @@
 import type { Context } from '@wrongstack/core/agent';
 import type { WebSocket } from 'ws';
 import type { WSServerMessage } from './types.js';
-export interface KanbanTaskRouteContext {
+interface KanbanTaskRouteContext {
     projectRoot: string;
     context?: Context | undefined;
+    /** Tab that sent the request — the session every emitted event belongs to. */
+    requestSessionId?: string | undefined;
     broadcast?: ((msg: WSServerMessage) => void) | undefined;
 }
 export declare function handleKanbanTaskRoute(ws: WebSocket, type: string, payload: Record<string, unknown> | undefined, ctx: KanbanTaskRouteContext): Promise<boolean>;
+export {};
 //# sourceMappingURL=kanban-task-routes.d.ts.map

package/dist/server/lifecycle.d.ts

@@ -11,7 +11,7 @@
  * sequence can be unit tested without a real process signal, server, or
  * `process.exit` — `log` and `exit` are injectable seams.
  */
-export interface LifecycleResources {
+interface LifecycleResources {
     /** Persist + close the active session (best-effort; errors are logged). */
     flushSession: () => Promise<void>;
     /**
@@ -61,4 +61,5 @@ export declare function createShutdown(res: LifecycleResources): () => Promise<v
  * function that detaches both listeners (useful for tests and clean restarts).
  */
 export declare function registerShutdownHandlers(res: LifecycleResources): () => void;
+export {};
 //# sourceMappingURL=lifecycle.d.ts.map

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

@@ -13,7 +13,7 @@ import type { TrustBoundary } from '@wrongstack/core/security';
 import type { WebSocket } from 'ws';
 import type { WSClientMessage } from './types.js';
 /** Wire view of a server as the browser MCP panel consumes it. */
-export interface MCPServerView {
+interface MCPServerView {
     name: string;
     transport: string;
     status: 'stopped' | 'connecting' | 'connected' | 'sleeping' | 'discovering' | 'error';
@@ -59,4 +59,5 @@ export declare function handleMcpPrompts(ws: WebSocket, msg: WSClientMessage, _g
 export declare function handleMcpResourceRead(ws: WebSocket, msg: WSClientMessage, _globalConfigPath: string, mcpRegistry?: MCPRegistry): Promise<void>;
 /** mcp.prompt.get — explicit user selection; prompt argument values stay out of provenance. */
 export declare function handleMcpPromptGet(ws: WebSocket, msg: WSClientMessage, _globalConfigPath: string, mcpRegistry?: MCPRegistry): Promise<void>;
+export {};
 //# sourceMappingURL=mcp-handlers.d.ts.map

package/dist/server/message-dispatcher.d.ts

@@ -26,12 +26,26 @@ import type { ConnectedClient, WSClientMessage } from './types.js';
  * so a second user_message while running is rejected and a project swap can
  * tear down the in-flight run.
  */
+/**
+ * Run locks, one per conversation.
+ *
+ * There is no "the run" and no current session: this server can be driving
+ * four tabs at once, and every one of them owns its own controller. Both
+ * accessors REQUIRE the session id for that reason — the optional forms
+ * (and the "most recent run" pointer that answered them) were the shape
+ * that let a zero-argument caller abort, or fail to register, somebody
+ * else's run.
+ */
 interface RunLockControl {
-    get(): AbortController | null;
-    set(ctrl: AbortController | null): void;
-    /** Session ID that owns the active run, or null when idle. */
-    getSession(): string | null;
-    setSession(id: string | null): void;
+    /** Controller for this conversation's run, if one is in flight. */
+    get(sessionId: string): AbortController | null;
+    /** Register (or release, with `null`) this conversation's controller. */
+    set(ctrl: AbortController | null, sessionId: string): void;
+    has(sessionId: string): boolean;
+    hasAny(): boolean;
+    delete(sessionId: string): void;
+    /** Snapshot of every session id that currently holds a run lock. */
+    sessionIds(): string[];
 }
 interface MessageDispatcherOptions {
     state: WebuiMutableState;

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

@@ -1,4 +1,4 @@
-import { type Context, DefaultSystemPromptBuilder } from '@wrongstack/core/agent';
+import type { Context, DefaultSystemPromptBuilder } from '@wrongstack/core/agent';
 import type { DefaultModeStore } from '@wrongstack/core/models';
 import type { ToolRegistry } from '@wrongstack/core/registry';
 import type { Config, MemoryPort, SkillLoader } from '@wrongstack/core/types';
@@ -19,7 +19,7 @@ type SessionStartPayload = {
     contextMode: string;
 };
 type ModelCapabilities = NonNullable<ConstructorParameters<typeof DefaultSystemPromptBuilder>[0]>['modelCapabilities'];
-export interface ModeHandlersContext {
+interface ModeHandlersContext {
     modeStore: DefaultModeStore;
     memoryStore: MemoryPort;
     skillLoader: SkillLoader | undefined;
@@ -31,8 +31,10 @@ export interface ModeHandlersContext {
     projectRoot: string;
     globalRoot: string;
     clients: Map<WebSocket, ConnectedClient>;
-    setModeId: (id: string) => void;
-    sessionStartPayload: () => Promise<SessionStartPayload>;
+    setModeId: (id: string, sessionId?: string) => void;
+    sessionStartPayload: (overrides?: Record<string, unknown>) => Promise<SessionStartPayload>;
+    /** Resolve a session's own Context so the rebuild targets the right tab. */
+    getSessionContext?: ((sessionId?: string) => Context | undefined) | undefined;
 }
 export declare function createModeHandlers(context: ModeHandlersContext): import("./mode-routes.js").ModeRouteHandlers;
 export {};

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

@@ -11,14 +11,25 @@ interface ModeSession {
 }
 export interface ModeOperationsContext {
     modeStore?: ModeStore | undefined;
-    getSession?: (() => ModeSession | null | undefined) | undefined;
-    applyModeId: (id: string) => void;
-    afterSwitch?: ((id: string) => void | Promise<void>) | undefined;
+    /**
+     * The journal that should record the switch. `sessionId` names the tab that
+     * switched: the `mode_changed` entry belongs in ITS transcript, not in
+     * whichever session the runtime happens to be pointing at. Hosts with one
+     * session ignore the argument.
+     */
+    getSession?: ((sessionId?: string) => ModeSession | null | undefined) | undefined;
+    /**
+     * Record the active mode. `sessionId` names the tab that switched — each
+     * WebUI tab carries its own mode, so the process-wide value is only the
+     * default a newly opened tab inherits.
+     */
+    applyModeId: (id: string, sessionId?: string) => void;
+    afterSwitch?: ((id: string, sessionId?: string) => void | Promise<void>) | undefined;
     send: (ws: WebSocket, message: WSServerMessage) => void;
 }
 export declare function createModeOperations(context: ModeOperationsContext): {
     listModes(ws: WebSocket): Promise<void>;
-    switchMode(ws: WebSocket, id: string): Promise<void>;
+    switchMode(ws: WebSocket, id: string, sessionId?: string): Promise<void>;
 };
 export {};
 //# sourceMappingURL=mode-operations.d.ts.map

package/dist/server/model-catalog-search.d.ts

@@ -1,5 +1,5 @@
 import type { ModelsRegistry } from '@wrongstack/core/types';
-export interface CatalogModelMatch {
+interface CatalogModelMatch {
     providerId: string;
     providerName: string;
     modelId: string;
@@ -14,4 +14,5 @@ export interface CatalogModelMatch {
 }
 /** Search the loaded models.dev registry without sending the full catalog to the browser. */
 export declare function searchCatalogModels(registry: Pick<ModelsRegistry, 'listProviders'>, rawQuery: string, limit?: number): Promise<CatalogModelMatch[]>;
+export {};
 //# sourceMappingURL=model-catalog-search.d.ts.map

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

@@ -3,6 +3,8 @@ import type { Config, MemoryPort, ModelsRegistry, Provider, ProviderConfig } fro
 import type { WebSocket } from 'ws';
 import type { WSServerMessage } from './types.js';
 export interface ModelRefinePayload {
+    /** The asking tab's session, stamped by `withSession` on the client. */
+    sessionId?: string | undefined;
     text: string;
     timeoutMs?: number | undefined;
     provider?: string | undefined;
@@ -18,8 +20,10 @@ export interface ModelOperationsContext {
     getConfig: () => Config | undefined;
     getLiveProviderId: () => string;
     buildProvider: (providerId: string, config: ProviderConfig) => Provider | Promise<Provider>;
-    applyModelSwitch: (providerId: string, modelId: string) => Promise<void>;
-    isRunActive?: (() => boolean) | undefined;
+    applyModelSwitch: (providerId: string, modelId: string, sessionId?: string) => Promise<void>;
+    isRunActive?: ((sessionId?: string) => boolean) | undefined;
+    /** Resolve a session's own Context; falls back to the root when unknown. */
+    getSessionContext?: ((sessionId?: string) => Context | undefined) | undefined;
     send: (ws: WebSocket, message: WSServerMessage) => void;
     broadcast?: ((message: WSServerMessage) => void) | undefined;
     log?: ((message: string) => void) | undefined;