@wrongstack/webui-server 0.313.0 → 0.316.1

package/dist/server/embedded-host-adapters.d.ts

@@ -1,4 +1,4 @@
-import type { Agent } from '@wrongstack/core/agent';
+import type { Agent, Context } from '@wrongstack/core/agent';
 import { type EventBus } from '@wrongstack/core/kernel';
 import type { Config, MemoryPort, ModelsRegistry, ModeStore, ProviderConfig, SessionStore, SessionWriter } from '@wrongstack/core/types';
 import type { WebSocket } from 'ws';
@@ -6,6 +6,7 @@ import type { ConversationRouteHandlers } from './conversation-routes.js';
 import type { CustomModeStore } from './custom-context-modes.js';
 import type { PendingConfirm } from './pending-confirms.js';
 import type { ProjectRouteHandlers } from './project-routes.js';
+import type { LoadAgentSessions } from './session-agent-sessions.js';
 import type { SessionRouteHandlers } from './session-routes.js';
 import type { SessionIdentityTarget } from './standalone-session-identity.js';
 import type { WSServerMessage } from './types.js';
@@ -33,7 +34,16 @@ export interface EmbeddedAgentConfigContext extends EmbeddedHostTransport {
     onMaxContextResolved?: ((providerId: string, modelId: string, maxContext: number) => void) | undefined;
     persistPrefs?: ((payload: Record<string, unknown>) => Promise<void>) | undefined;
 }
-export declare function applyEmbeddedModelSwitch(ctx: EmbeddedAgentConfigContext, providerId: string, modelId: string): Promise<void>;
+export declare function applyEmbeddedModelSwitch(ctx: EmbeddedAgentConfigContext, providerId: string, modelId: string, 
+/**
+ * The tab that asked. A model switch rebuilds the provider, the model, the
+ * context ceiling and the price table OF ONE CONVERSATION; applying it to
+ * `ctx.agent.ctx` — the leader, i.e. the boot tab's runtime — meant that
+ * choosing a model in ANY tab re-pointed the boot tab instead, and left the
+ * asking tab still running the model it had. Resolved through the caller so
+ * hosts without a registry keep the single-context behaviour.
+ */
+targetContext?: Context | undefined): Promise<void>;
 export declare function createEmbeddedProviderOperations(ctx: EmbeddedProviderContext): {
     handleProvidersList: (ws: WebSocket) => Promise<void>;
     handleProvidersSaved: (ws: WebSocket) => Promise<void>;
@@ -73,9 +83,47 @@ export declare function createEmbeddedProviderOperations(ctx: EmbeddedProviderCo
 };
 export interface EmbeddedConversationContext extends EmbeddedHostTransport {
     agent: Agent;
+    /**
+     * The Agent that owns ONE session's runs.
+     *
+     * Without this every tab was handed `ctx.agent`, the single leader instance,
+     * and the second tab to start a run walked straight into `Agent.run()`'s
+     * concurrency guard — "already in progress on this instance". The guard is
+     * correct; one Agent for four tabs was not. Hosts supply a per-session
+     * registry (see `session-agent-registry.ts`); omitting it keeps the old
+     * single-agent behaviour for hosts that genuinely have one session.
+     */
+    getAgent?: ((sessionId?: string | undefined) => Agent) | undefined;
+    /**
+     * Non-creating registry lookup for session-ownership checks. `getAgent`
+     * CREATES on read, so using it to ask "does this host serve session X?"
+     * materialised an agent for every id a client ever typed; `peekAgent`
+     * answers the same question without side effects. Optional: hosts without
+     * a registry omit it and keep the single-session behaviour.
+     */
+    peekAgent?: ((sessionId?: string | undefined) => Agent | undefined) | undefined;
     /** Session-keyed abort controllers — one active run per session. */
     abortControllers: Map<string, AbortController>;
     pendingConfirms: Map<string, PendingConfirm>;
+    /**
+     * Stop the subagents a session spawned. Called when that session's run is
+     * aborted: killing the leader's controller only unwinds workers it is
+     * blocked on, so async ones keep running unless someone asks them to stop.
+     */
+    stopSessionFleet?: ((sessionId: string) => void | Promise<void>) | undefined;
+    /**
+     * The host's session-transition serialiser, SHARED with the session routes.
+     *
+     * `user_message` setup reads and mutates the target agent's context, so it
+     * must not interleave with a `session.new` / `session.resume` that is
+     * halfway through re-pointing writers and contexts. The standalone host has
+     * always passed its gate here; this one passed nothing, so
+     * `createConversationOperations` fell back to a pass-through and the CLI
+     * host — the one people actually run — serialised transitions against each
+     * other but never against turn setup. Only the SETUP is gated; runs proceed
+     * outside it so four tabs still stream concurrently.
+     */
+    withSessionTransition?: (<T>(operation: () => Promise<T>) => Promise<T>) | undefined;
 }
 export declare function createEmbeddedConversationRoutes(ctx: EmbeddedConversationContext): ConversationRouteHandlers;
 export interface EmbeddedSessionOptions {
@@ -93,10 +141,66 @@ export interface EmbeddedSessionContext extends EmbeddedHostTransport {
     opts: EmbeddedSessionOptions;
     buildSessionStart: (overrides?: Record<string, unknown>) => Promise<unknown>;
     getCustomModeStore: () => Promise<CustomModeStore>;
+    /**
+     * The Agent that owns one session — the same registry the conversation
+     * routes use. Session transitions re-point a CONTEXT (writer, messages,
+     * todos, plan/task paths); without this they re-point the leader's, so
+     * resuming tab 2 rewrote the context tab 1 was running in.
+     */
+    getAgent?: ((sessionId?: string | undefined) => Agent) | undefined;
+    /**
+     * Non-creating registry lookup for session-ownership checks — same reason
+     * as `EmbeddedConversationContext.peekAgent`: asking "can this host serve
+     * session X?" through the creating `getAgent` materialised agents for ids
+     * no client ever opened.
+     */
+    peekAgent?: ((sessionId?: string | undefined) => Agent | undefined) | undefined;
+    /**
+     * The host's own "which tab is in front" pointer, and its setter.
+     *
+     * Multi-session hosts MUST supply both. Without them the pointer is the
+     * leader agent's `ctx.session` — but the leader agent is simultaneously the
+     * RUNTIME of the boot tab, so re-pointing it to another tab's writer made
+     * the boot tab write into that tab's journal, and did so mid-run if the boot
+     * tab was busy. With them, the pointer moves and no agent's context is
+     * touched except the one that owns the session.
+     */
+    getForegroundSession?: (() => SessionWriter) | undefined;
+    setForegroundSession?: ((next: SessionWriter) => void) | undefined;
+    /** Does this host already hold an open writer for that session? */
+    isSessionLive?: ((sessionId: string) => boolean) | undefined;
+    /**
+     * Read back NAMED subagents' transcripts, so a replayed session brings its
+     * fleet panel back with it. See `session-agent-sessions.ts`.
+     */
+    loadAgentSessions?: LoadAgentSessions | undefined;
+    /**
+     * Per-connection display registry, so `session.subscribe` is honoured and
+     * "which sessions are on screen right now" has an answer.
+     *
+     * Only the two session fields are read through this path (the embedded host
+     * supplies its own send/broadcast), so a host may keep a leaner client
+     * record than the standalone server's `ConnectedClient`. Without it a
+     * background tab's session is invisible to the delete guard and to agent
+     * eviction — both then treat an open tab as abandoned.
+     */
+    clients?: Map<WebSocket, {
+        sessionId: string | null;
+        sessionIds?: Set<string> | undefined;
+    }> | undefined;
+    /** Sessions no connection is displaying any more — retire their agents. */
+    onSessionsUndisplayed?: ((sessionIds: string[]) => void) | undefined;
     /** When sessionId is provided, abort only that session's run; otherwise abort all. */
     abortActiveRun?: ((sessionId?: string) => void) | undefined;
     /** True while an embedded agent run is active. */
     isRunActive?: ((sessionId?: string) => boolean) | undefined;
+    /**
+     * The host's session-transition serialiser, SHARED with the conversation
+     * routes. Omitting it leaves the session handlers to create a PRIVATE gate,
+     * which orders transitions against each other but not against turn setup —
+     * see the note on `EmbeddedConversationContext.withSessionTransition`.
+     */
+    withSessionTransition?: (<T>(operation: () => Promise<T>) => Promise<T>) | undefined;
 }
 export declare function createEmbeddedSessionRoutes(ctx: EmbeddedSessionContext): SessionRouteHandlers;
 export declare function broadcastEmbeddedGoalSnapshot(ctx: EmbeddedSessionContext): Promise<void>;
@@ -108,6 +212,20 @@ export interface EmbeddedProjectContext extends EmbeddedHostTransport {
     abortControllers: Map<string, AbortController>;
     abortLegacyRun: () => void;
     buildSessionStart: (overrides?: Record<string, unknown>) => Promise<unknown>;
+    /**
+     * The host's foreground-session pointer — the same one the session routes
+     * move. A project switch retires every session in the process, so the
+     * pointer has to follow it here too or the host keeps naming a session that
+     * belongs to the previous project.
+     */
+    getForegroundSession?: (() => SessionWriter) | undefined;
+    setForegroundSession?: ((next: SessionWriter) => void) | undefined;
+    /**
+     * Deliver to every connection regardless of what it displays. The project
+     * switch needs it: `broadcast` routes on the payload's session, and the
+     * switch announces one no client has had a chance to subscribe to.
+     */
+    broadcastEveryone?: ((message: WSServerMessage) => void) | undefined;
 }
 export declare function createEmbeddedProjectRoutes(ctx: EmbeddedProjectContext): ProjectRouteHandlers;
 //# sourceMappingURL=embedded-host-adapters.d.ts.map

package/dist/server/embedded-message-router.d.ts

@@ -5,6 +5,7 @@ import type { Logger, MemoryPort } from '@wrongstack/core/types';
 import type { MCPRegistry } from '@wrongstack/mcp';
 import type { WebSocket } from 'ws';
 import { type BrainHandlerContext } from './brain-handlers.js';
+import type { ChimeraRouteHandlers } from './chimera-routes.js';
 import type { DesignContext } from './design-handlers.js';
 import { type EmbeddedAgentConfigContext, type EmbeddedConversationContext, type EmbeddedProjectContext, type EmbeddedProviderContext, type EmbeddedSessionContext } from './embedded-host-adapters.js';
 import type { GoalWebSocketHandler } from './goal-ws-handler.js';
@@ -53,13 +54,23 @@ export interface EmbeddedMessageRouterDeps {
     introspectionCtx: IntrospectionRouteContext;
     skillsCtx: SkillsContext;
     promptsCtx: PromptsContext;
-    designCtx: DesignContext;
+    /**
+     * Built per tab: the active design kit is pinned on the picking session's
+     * own meta, so the CLI host resolves that session's context here.
+     */
+    designCtx: DesignContext | ((sessionId?: string | undefined) => DesignContext);
     agentConfigCtx: EmbeddedAgentConfigContext;
     prefsCtx: PrefsHandlerContext;
     projectCtx: EmbeddedProjectContext;
     sessionCtx: EmbeddedSessionContext;
     conversationCtx: EmbeddedConversationContext;
     mailboxRoutes: MailboxRouteHandlers;
+    /**
+     * Chimera review-report routes. Optional so an older CLI host (built before
+     * this family existed) can still construct the router — the tab then just
+     * never receives report-list answers instead of failing to boot.
+     */
+    chimeraRoutes?: ChimeraRouteHandlers | undefined;
     goalHandler: GoalWebSocketHandler;
     specsHandler: SpecsWebSocketHandler;
     sddBoardHandler: SddBoardWebSocketHandler;
@@ -70,6 +81,9 @@ export interface EmbeddedMessageRouterDeps {
     /** Shared provider/model health tracker for the WebUI waiting-room panel.
      * Undefined when the host has not wired one (e.g. test harnesses). */
     statusTracker?: ProviderModelStatusTracker | undefined;
+    /** Durable block/open audit trail (JSONL) next to the profile config.
+     * Undefined when the host did not provide a profile path (test harnesses). */
+    providerAuditFile?: string | undefined;
 }
 export type EmbeddedMessageRouter = (ws: WebSocket, client: unknown, message: WSClientMessage) => Promise<void>;
 export declare function createEmbeddedMessageRouter(deps: EmbeddedMessageRouterDeps): EmbeddedMessageRouter;