@wrongstack/webui 0.313.1 → 0.316.2

package/dist/lib/agent-office.d.ts

@@ -1,6 +1,6 @@
 import type { VizEvent } from '@/stores/viz-store';
 export type OfficeToolKind = 'read' | 'write' | 'edit' | 'terminal' | 'web' | 'search' | 'memory' | 'other';
-export interface OfficeFileTarget {
+interface OfficeFileTarget {
     filePath: string;
     operation?: string | undefined;
     line?: number | undefined;
@@ -28,7 +28,7 @@ export interface OfficeToolCall {
     fileTargets: OfficeFileTarget[];
     raw?: unknown;
 }
-export interface OfficeMailboxMessage {
+interface OfficeMailboxMessage {
     id: string;
     from: string;
     to: string;
@@ -79,7 +79,7 @@ interface SnapshotMailReceipt {
 export declare function buildSnapshotToolCalls(receipts: SnapshotToolReceipt[] | undefined, agentId: string, sessionId?: string): OfficeToolCall[];
 /** Convert bounded registry receipts to mail parcels when the mailbox cache is behind. */
 export declare function buildSnapshotMailActivities(receipts: SnapshotMailReceipt[] | undefined): OfficeMailActivity[];
-export interface OfficeMailRoute {
+interface OfficeMailRoute {
     /** Mail id — also used to suppress the duplicate per-lane flyby. */
     id: string;
     mail: OfficeMailActivity;

package/dist/lib/agent-session.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Which tab does a fleet agent belong to?
+ *
+ * Fail-CLOSED, deliberately: an agent must NAME a session to be listed under
+ * it. Every roster in the app used to spell this as
+ *
+ *   !a.sessionId || !currentSessionId || a.sessionId === currentSessionId
+ *
+ * which lists an untagged agent in all four tabs at once — the roster half of
+ * the cross-tab bleed. The server stamps every `subagent.event` through
+ * `sessionPayload()`, so an untagged agent is a bug upstream, not a normal
+ * case to be generous about; showing it four times hides that bug instead of
+ * surfacing it.
+ *
+ * Before a session exists, only the equally session-less agents match, which
+ * keeps the pre-session roster non-empty without ever crossing a tab.
+ */
+export declare function agentBelongsToSession(agentSessionId: string | null | undefined, sessionId: string | null | undefined): boolean;
+//# sourceMappingURL=agent-session.d.ts.map

package/dist/lib/agent-status.d.ts

@@ -12,7 +12,7 @@
  * and only owns canonical short labels plus activity sorting/counting.
  */
 import type { SubagentView } from '@/stores';
-export type AgentStatus = SubagentView['status'];
+type AgentStatus = SubagentView['status'];
 /** Canonical short label per status (shared by the Fleet surfaces). */
 export declare const AGENT_STATUS_LABEL: Record<AgentStatus, string>;
 /** A subagent is "active" only while running. */
@@ -27,7 +27,7 @@ export declare function compareAgentsByActivity<T extends {
     status: string;
     startedAt: number;
 }>(a: T, b: T): number;
-export interface AgentTally {
+interface AgentTally {
     running: number;
     completed: number;
     /** failed + timeout — the two terminal-error states the Fleet UIs group. */
@@ -39,7 +39,7 @@ export declare function tallyAgents<T extends {
     status: string;
 }>(list: readonly T[]): AgentTally;
 /** Context-fill severity band. */
-export type CtxSeverity = 'low' | 'medium' | 'high';
+type CtxSeverity = 'low' | 'medium' | 'high';
 /** Clamp a context percentage [0, 100] and return its severity band. */
 export declare function classifyCtxPct(pct: number): {
     clamped: number;
@@ -74,7 +74,7 @@ export declare function fmtDuration(ms: number | undefined | null): string;
  * Pre-computed display values for an agent card or row.
  * All fields are derived from the SubagentView and ready to render.
  */
-export interface AgentDisplayStats {
+interface AgentDisplayStats {
     /** Context percentage [0..100], clamped. */
     ctxClamped: number;
     /** Severity band for the context bar colour. */
@@ -99,4 +99,5 @@ export interface AgentDisplayStats {
  *               Defaults to `Date.now()`. Pass a frozen timestamp in tests.
  */
 export declare function computeAgentStats(agent: SubagentView, now?: number): AgentDisplayStats;
+export {};
 //# sourceMappingURL=agent-status.d.ts.map

package/dist/lib/completion.d.ts

@@ -5,11 +5,11 @@ export declare const COMPLETION_SUFFIX_CHARS = 4000;
 export declare const COMPLETION_TIMEOUT_MS = 5000;
 export declare const COMPLETION_CACHE_TTL_MS = 10000;
 export declare const COMPLETION_DOCUMENT_CHARS = 500000;
-export interface CompletionTriggerInfo {
+interface CompletionTriggerInfo {
     triggerCharacter?: string;
     triggerKind?: number;
 }
-export interface CompletionCacheKeyInput {
+interface CompletionCacheKeyInput {
     filePath: string;
     language: string;
     lineNumber: number;
@@ -24,4 +24,5 @@ export declare function currentToken(linePrefix: string): string;
 export declare function shouldAskCompletionServer(trigger: CompletionTriggerInfo, tokenText: string): boolean;
 export declare function shouldAllowCompletionLlm(trigger: CompletionTriggerInfo, tokenText: string): boolean;
 export declare function buildCompletionCacheKey(input: CompletionCacheKeyInput): string;
+export {};
 //# sourceMappingURL=completion.d.ts.map

package/dist/lib/delegate-format.d.ts

@@ -0,0 +1,33 @@
+import type { SessionMarkerDetail } from '@wrongstack/core/types';
+/**
+ * The chat text of a delegation, for the live handler AND for replay.
+ *
+ * Two callers build these lines: `session-execution-handlers` when the
+ * `delegate.started` / `delegate.completed` frames arrive, and
+ * `session-replay-handlers` when the same delegation comes back from the
+ * journal as a marker. They must produce the same bubble, or a resumed session
+ * shows a delegation that reads differently from the one that was on screen —
+ * so the wording lives here rather than in either caller.
+ */
+/** Trim a single-line preview, matching the live handler's 180-char budget. */
+export declare function truncateDelegateTask(text: string, max?: number): string;
+export declare function delegateStartedText(target: string, task: string): string;
+export declare function delegateCompletedText(input: {
+    target: string;
+    ok: boolean;
+    status?: string | undefined;
+    summary: string;
+    durationMs: number;
+    iterations: number;
+    toolCalls: number;
+    costUsd?: number | undefined;
+}): string;
+/**
+ * Render a replayed delegate marker as the chat bubble it was live, or `null`
+ * when the marker is not a delegation.
+ */
+export declare function delegateMarkerText(detail: SessionMarkerDetail | undefined): {
+    content: string;
+    isError?: boolean | undefined;
+} | null;
+//# sourceMappingURL=delegate-format.d.ts.map

package/dist/lib/favicon.d.ts

@@ -12,10 +12,11 @@
  * The status auto-resets to 'idle' on the next visibilitychange where the
  * tab becomes visible — so the badge only persists while the user is away.
  */
-export type FaviconStatus = 'idle' | 'running' | 'ready' | 'error' | 'attention';
+type FaviconStatus = 'idle' | 'running' | 'ready' | 'error' | 'attention';
 export declare function setFaviconStatus(status: FaviconStatus): void;
 /** Install the visibilitychange listener once. When the user comes back to
  *  the tab we clear any "ready/error" badge so they don't see a stale
  *  notification dot after they've already returned. */
 export declare function installFaviconVisibilityReset(): void;
+export {};
 //# sourceMappingURL=favicon.d.ts.map

package/dist/lib/kanban-verification.d.ts

@@ -11,7 +11,7 @@ export type TaskVerificationState = 'unverified' | 'running' | 'passed' | 'faile
 export declare function verificationStateOf(task: KanbanTask, activity?: {
     startedAt: number;
 } | undefined): TaskVerificationState;
-export interface VerificationSummary {
+interface VerificationSummary {
     totalTasks: number;
     /** Only tasks in a terminal-ish state are graded (completed/review/failed). */
     gradedTasks: number;
@@ -36,7 +36,7 @@ export interface VerificationSummary {
     pendingProposals: KanbanTask[];
 }
 export declare function selectVerificationSummary(board: KanbanBoard): VerificationSummary;
-export interface TaskTreeNode {
+interface TaskTreeNode {
     task: KanbanTask;
     children: TaskTreeNode[];
     depth: number;
@@ -49,4 +49,5 @@ export interface TaskTreeNode {
 export declare function buildTaskTree(board: KanbanBoard): TaskTreeNode[];
 /** Flatten a tree into rows for simple list rendering. */
 export declare function flattenTaskTree(nodes: TaskTreeNode[]): TaskTreeNode[];
+export {};
 //# sourceMappingURL=kanban-verification.d.ts.map

package/dist/lib/model-matrix-routes.d.ts

@@ -1,8 +1,8 @@
-export interface ModelMatrixRouteRole {
+interface ModelMatrixRouteRole {
     role: string;
     name: string;
 }
-export interface ModelMatrixRouteGroup {
+interface ModelMatrixRouteGroup {
     phase: string;
     label: string;
     roles: readonly ModelMatrixRouteRole[];
@@ -10,8 +10,8 @@ export interface ModelMatrixRouteGroup {
 export declare const MODEL_MATRIX_DEFAULT_ROUTE = "*";
 export declare const MODEL_MATRIX_ROUTE_GROUPS: readonly ModelMatrixRouteGroup[];
 export declare const MODEL_MATRIX_PHASE_ROUTES: string[];
-export declare const MODEL_MATRIX_ROUTE_ROLES: readonly ModelMatrixRouteRole[];
 export declare const MODEL_MATRIX_ROLE_ROUTES: string[];
 export declare const MODEL_MATRIX_KNOWN_ROUTES: string[];
 export declare function formatModelMatrixRouteLabel(route: string): string;
+export {};
 //# sourceMappingURL=model-matrix-routes.d.ts.map

package/dist/lib/plugin-enablement.d.ts

@@ -1,6 +1,6 @@
 import type { PluginConfig } from '@wrongstack/core/types';
 type PluginEntry = string | PluginConfig;
-export interface ResolvedPluginState {
+interface ResolvedPluginState {
     /** Plugin name as it appears in `Config.plugins`. */
     readonly name: string;
     /** True iff the canonical config says this plugin is enabled. */

package/dist/lib/reasoning-effort.d.ts

@@ -0,0 +1,76 @@
+import type { ReasoningEffort } from '@wrongstack/core/types';
+/**
+ * Canonical effort levels. `satisfies` pins this copy to core's
+ * `ReasoningEffort` union — adding a level in core without updating this list
+ * (or vice versa) becomes a compile error instead of silently dropping the
+ * model's newest level from every dropdown.
+ */
+export declare const ALL_EFFORTS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type Effort = (typeof ALL_EFFORTS)[number];
+/**
+ * Sentinel for "follow the general (project-wide) setting". Never a wire
+ * value: the runtime resolver treats a conversation meta of `auto` as "no
+ * conversation-level override", so the global
+ * `Config.modelRuntime.reasoning.effort` applies (core's
+ * `withConversationReasoning` skips it, and the server never persists it as
+ * a concrete effort).
+ */
+export declare const AUTO_EFFORT = "auto";
+/** Every value an effort dropdown may offer. */
+export type EffortOption = typeof AUTO_EFFORT | Effort;
+/** Guard for server-supplied lists — anything outside the canonical enum
+ *  would render a raw key as its label; filter it instead. */
+export declare function isEffort(value: string): value is Effort;
+/**
+ * i18n keys for every canonical level. Typed against core's full union (not
+ * the local `Effort` alias) so the drift guard works in BOTH directions:
+ * `satisfies` on ALL_EFFORTS rejects a value core doesn't know, and this
+ * Record requires a label key for every value core DOES know — adding a level
+ * in core without a label here is a compile error, never a silently-missing
+ * dropdown entry.
+ */
+export declare const EFFORT_LABEL_KEYS: Record<ReasoningEffort, string>;
+/**
+ * Kept OUT of EFFORT_LABEL_KEYS so that Record stays pinned to core's union
+ * — `auto` is a WebUI-only sentinel, not a provider vocabulary level.
+ */
+export declare const AUTO_EFFORT_LABEL_KEY = "settings:agent.reasoningEffortAuto";
+/** Label key for any option value an effort select renders (auto included). */
+export declare function effortLabelKey(value: EffortOption): string;
+/**
+ * The effort options to offer for the ACTIVE model.
+ *
+ * `auto` always leads: it means "this tab follows the general setting"
+ * (`Config.modelRuntime.reasoning.effort`), whatever that currently is.
+ *
+ * `levels` is `session.reasoningEffortLevels` — the vocabulary the active
+ * model documents (models.dev reasoningConfig, sent only when the catalog
+ * lists explicit levels). Undefined/empty means the vocabulary is
+ * undocumented, and the full canonical set applies — matching the runtime
+ * resolver's conservative gate, which forwards the value whenever
+ * `effortSupported !== false` and drops it with a warning otherwise.
+ *
+ * A persisted effort the model no longer advertises (set on another model)
+ * is appended so the user sees what is actually configured and can change it
+ * deliberately; the runtime resolver independently omits unsupported values.
+ */
+export declare function resolveEffortOptions(levels: readonly string[] | undefined, current: string): EffortOption[];
+/**
+ * True when the persisted effort is KNOWN to be unsupported by the active
+ * model — i.e. the model documents an explicit level list and the current
+ * value is not in it. Absent levels mean "vocabulary undocumented", which is
+ * not evidence of support or its absence; the resolver forwards the value and
+ * the UI must not claim it is wrong. `auto` is never "not advertised" — it is
+ * not a level at all, it defers to the general setting.
+ */
+export declare function effortNotAdvertised(levels: readonly string[] | undefined, current: string): boolean;
+/**
+ * Tri-state visibility gate, mirroring the resolver's: hide the control only
+ * when the model DOCUMENTS that it has no effort control
+ * (`reasoningConfig.effortSupported === false`). `undefined` means the
+ * vocabulary is undocumented — the resolver forwards the value, so the UI
+ * shows the full canonical set rather than claiming support is absent.
+ * Boolean-coercing this tri-state is a bug: `undefined` is not `false`.
+ */
+export declare function effortControlHidden(effortSupported: boolean | undefined): boolean;
+//# sourceMappingURL=reasoning-effort.d.ts.map

package/dist/lib/sdd-theme.d.ts

@@ -6,8 +6,8 @@
  * apart as the views evolve.
  */
 import { type LucideIcon } from 'lucide-react';
-export type SddStatus = 'pending' | 'queued' | 'in_progress' | 'blocked' | 'review' | 'failed' | 'completed' | 'cancelled';
-export interface SddStatusStyle {
+type SddStatus = 'pending' | 'queued' | 'in_progress' | 'blocked' | 'review' | 'failed' | 'completed' | 'cancelled';
+interface SddStatusStyle {
     /** Short label, e.g. "Running". */
     label: string;
     /** Lucide icon for the status. */
@@ -25,7 +25,7 @@ export interface SddStatusStyle {
 }
 export declare const SDD_STATUS: Record<SddStatus, SddStatusStyle>;
 export declare function statusStyle(s: string): SddStatusStyle;
-export type SddPriority = 'critical' | 'high' | 'medium' | 'low';
+type SddPriority = 'critical' | 'high' | 'medium' | 'low';
 export declare const SDD_PRIORITY: Record<SddPriority, {
     text: string;
     chip: string;
@@ -49,4 +49,5 @@ export declare function agentInitials(name: string): string;
 export declare function fmtDuration(ms: number): string;
 /** Compact relative age, e.g. "5s" / "3m" / "2h". */
 export declare function fmtAgo(ts: number, now: number): string;
+export {};
 //# sourceMappingURL=sdd-theme.d.ts.map

package/dist/lib/task-brief-preview.d.ts

@@ -0,0 +1,5 @@
+/** One-line preview length — chimera briefs are multi-KB and must not enter chrome. */
+export declare const TASK_PREVIEW_CHARS = 140;
+/** Collapse whitespace and clip so pinned chrome never lays out the full brief. */
+export declare function taskBriefPreview(description: string, maxChars?: number): string;
+//# sourceMappingURL=task-brief-preview.d.ts.map

package/dist/lib/terminal-dock.d.ts

@@ -1,6 +1,5 @@
 export declare const TERMINAL_HEIGHT_STORAGE_KEY = "wrongstack.terminalDockHeight";
 export declare const MIN_TERMINAL_HEIGHT = 140;
 export declare const MAX_TERMINAL_HEIGHT = 640;
-export declare const MIN_MAIN_AREA_WHEN_TERMINAL_OPEN = 260;
 export declare function clampTerminalHeight(height: number): number;
 //# sourceMappingURL=terminal-dock.d.ts.map

package/dist/lib/view-navigation.d.ts

@@ -1,6 +1,6 @@
 import { type Activity } from '@/stores/ui-store';
-export type PanelMainView = 'chat' | 'files' | 'skill' | 'officemap' | 'changes' | 'mailbox' | 'design-gallery';
-export type MainView = 'goal' | 'kanban' | 'sddhub' | 'settings' | 'memory' | 'roster' | 'codemap' | 'techstack' | 'chronicle' | 'intake' | 'prompts';
+export type PanelMainView = 'chat' | 'files' | 'skill' | 'changes' | 'mailbox' | 'design-gallery';
+export type MainView = 'goal' | 'kanban' | 'sddhub' | 'settings' | 'memory' | 'roster' | 'codemap' | 'techstack' | 'chronicle' | 'intake' | 'prompts' | 'chimera';
 export type AppView = PanelMainView | MainView | 'sessions' | 'session-inspect' | 'setup' | 'debug' | 'refresh-debug' | 'analytics';
 export declare const PANEL_VIEW_BY_ACTIVITY: Record<Activity, PanelMainView>;
 export declare const VIEW_ACTIVITY: Partial<Record<AppView, Activity>>;

package/dist/lib/ws-client-actions.d.ts

@@ -102,6 +102,7 @@ export interface WsClientActionMethods {
     getStats(options?: WSSendOptions): void;
     saveSession(): void;
     resumeSessionById(id: string): void;
+    focusSessionById(id: string): void;
     listModes(): void;
     switchMode(id: string): void;
     listFiles(query?: string, limit?: number, path?: string): void;

package/dist/lib/ws-client-domain-methods.d.ts

@@ -2,20 +2,52 @@ import type { WSClientMessage } from '../types';
 import type { ProviderCustomModelWire } from '../types/client-message';
 import type { ContextEditorMessage, ContextEditorRemoval } from '../types/runtime';
 import type { WSSendOptions } from './ws-client-contracts';
-export interface WsClientDomainHost {
+interface WsClientDomainHost {
     send(message: WSClientMessage, options?: WSSendOptions): boolean;
-    withSession<T extends Record<string, unknown>>(payload: T): T & {
+    withSession<T extends Record<string, unknown>>(payload: T, sessionId?: string | undefined): T & {
         sessionId?: string;
     };
 }
-export declare const domainMethods: {
+declare const domainMethods: {
     getGitInfo(this: WsClientDomainHost): void;
     getGitChanges(this: WsClientDomainHost): void;
     getGitDiff(this: WsClientDomainHost, path: string): void;
+    stageGit(this: WsClientDomainHost, paths: string | string[]): void;
+    unstageGit(this: WsClientDomainHost, paths: string | string[]): void;
+    discardGit(this: WsClientDomainHost, paths: string | string[]): void;
+    commitGit(this: WsClientDomainHost, message: string): void;
     getProviderStatus(this: WsClientDomainHost): void;
+    getProviderAuditHistory(this: WsClientDomainHost, count?: number | undefined): void;
     retryProviderModel(this: WsClientDomainHost, providerId: string, model: string): void;
     clearProviderStatus(this: WsClientDomainHost, providerId: string, model: string): void;
-    newSession(this: WsClientDomainHost): void;
+    /**
+     * Open an ADDITIONAL session (a new WebUI tab).
+     *
+     * Deliberately does NOT go through `withSession()`: stamping the live
+     * session id made the server read it as "the session being replaced", so
+     * it aborted that session's in-flight run and closed its journal writer.
+     * Retiring a session alongside the new one is opt-in via `replaceSessionId`.
+     *
+     * session-stamping: deliberately-unstamped
+     */
+    newSession(this: WsClientDomainHost, payload?: {
+        systemPromptVariant?: string;
+        replaceSessionId?: string;
+    }): void;
+    /**
+     * Ask for the identity-prompt catalogue (variants, token estimates, current).
+     *
+     * Stamped with the asking tab: the catalogue is shared but `current` is that
+     * session's own variant, and the reply comes back stamped so it lands on the
+     * right tab instead of overwriting whichever one asked last.
+     */
+    getSystemPrompt(this: WsClientDomainHost): void;
+    /**
+     * Switch the identity-prompt size. Rides `prefs.update` because the variant is
+     * an ordinary persisted preference on the server; the server answers with a
+     * fresh `system_prompt.info` broadcast once the live prompt is rebuilt.
+     */
+    setSystemPromptVariant(this: WsClientDomainHost, variant: 'lite' | 'default' | 'pro'): void;
     listProviders(this: WsClientDomainHost): void;
     listProviderModels(this: WsClientDomainHost, providerId: string): void;
     listSavedProviders(this: WsClientDomainHost): void;
@@ -77,10 +109,18 @@ export declare const domainMethods: {
     deleteContextMode(this: WsClientDomainHost, id: string): void;
     switchAutonomy(this: WsClientDomainHost, mode: string): void;
     updatePrefs(this: WsClientDomainHost, prefs: Record<string, unknown>): void;
-    getPrefs(this: WsClientDomainHost): void;
+    /**
+     * Re-read preferences for ONE tab. Called on connect and on every tab
+     * switch: the session-scoped half of the snapshot belongs to whichever
+     * session asked, so an untagged `prefs.get` answers about whatever session
+     * the runtime happens to be on — a different tab from the asking one as
+     * often as not once four are open.
+     */
+    getPrefs(this: WsClientDomainHost, sessionId?: string): void;
 };
 export declare function installWsClientDomainMethods(ctor: {
     prototype: any;
 }): void;
 export type WsClientDomainMethods = typeof domainMethods;
+export {};
 //# sourceMappingURL=ws-client-domain-methods.d.ts.map

package/dist/lib/ws-client-utils.d.ts

@@ -1,3 +1,5 @@
+import { type ChatLaneActions } from '../stores/chat-lanes';
+import { type SessionLaneActions } from '../stores/session-lanes';
 import type { WSServerMessage } from '../types';
 /**
  * Generic event handler. When the consumer knows the literal message type K,
@@ -9,6 +11,23 @@ import type { WSServerMessage } from '../types';
 export type EventHandler<K extends WSServerMessage['type'] = WSServerMessage['type']> = (msg: Extract<WSServerMessage, {
     type: K;
 }>) => void;
+/**
+ * The session the user is looking at, or `null` when none is bound yet.
+ *
+ * There is exactly ONE answer to "which tab is in front": the lane pointer.
+ * Every other candidate drifts from it —
+ *
+ *  - `useSessionStore().session?.id` is the lane's SessionInfo record, which
+ *    is null from the moment a tab is opened until its `session.start` lands,
+ *    and again after `endSession`;
+ *  - the WS client's own `sessionId` is whichever session announced last on
+ *    the socket, which in a four-tab window is routinely a BACKGROUND tab.
+ *
+ * Both were used as stand-ins for the pointer on the send path, which is how
+ * a message typed in tab 2 started a run in tab 1's session. Read the pointer
+ * here and let the callers share it.
+ */
+export declare function foregroundSessionId(): string | null;
 /**
  * Returns true when a server message is intended for the currently-active
  * session. The server tags session-scoped messages with `payload.sessionId`.
@@ -21,6 +40,20 @@ export type EventHandler<K extends WSServerMessage['type'] = WSServerMessage['ty
  * boot-time and project-wide broadcasts are not dropped.
  */
 export declare function isActiveSessionMessage(msg: WSServerMessage): boolean;
+/**
+ * Read the session a message belongs to, or `null` when it names none.
+ * Empty-string counts as "none": the server stamps `sessionId: ''` when its
+ * context has no session, and that must never widen into "every session".
+ */
+export declare function messageSessionId(msg: WSServerMessage): string | null;
+export declare function chatFor(msg: WSServerMessage): ChatLaneActions | null;
+/**
+ * Resolve the SESSION-ACCOUNTING lane a message belongs to — tokens, cost,
+ * iteration, todos, context ceiling. Same positive-routing contract as
+ * `chatFor`: a background run's numbers land on the background tab's counters,
+ * never on the tab in front.
+ */
+export declare function sessionFor(msg: WSServerMessage): SessionLaneActions | null;
 /**
  * Convert a server message into a VizEvent and push it to the viz store,
  * activating the viz surface. No-op when the message isn't a viz source.