@wrongstack/webui-server 0.309.1 → 0.310.0

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

@@ -0,0 +1,26 @@
+import type { WebSocket } from 'ws';
+import type { CollabContext } from './collab-context.js';
+import type { CollabFeature } from './dispatcher.js';
+/**
+ * Annotation flow, Phase 2 (6A-2). Moved verbatim from
+ * CollaborationWebSocketHandler: store-availability guard, annotator role
+ * gate, payload validation, session pinning, and the broadcast payloads.
+ *
+ * Deliberate invariant: neither flow calls scheduler.record(). The periodic
+ * 2s collab.state tick only re-sends when the participant-set fingerprint
+ * changes (join/leave), and annotations do not alter that set — so a record()
+ * here would write back the identical fingerprint and change nothing.
+ * Annotation payloads are event-stream messages delivered by the direct
+ * broadcast plus the replay ring buffer, not collab.state. Do not "fix" this
+ * asymmetry without first widening what stateFingerprint covers.
+ */
+export declare class AnnotateFeature implements CollabFeature {
+    readonly type = "collab.annotate";
+    handle(ctx: CollabContext, ws: WebSocket, raw: unknown): Promise<void>;
+}
+/** `collab.resolve` — resolves an annotation and broadcasts the update. */
+export declare class ResolveFeature implements CollabFeature {
+    readonly type = "collab.resolve";
+    handle(ctx: CollabContext, ws: WebSocket, raw: unknown): Promise<void>;
+}
+//# sourceMappingURL=annotations.d.ts.map

package/dist/server/collab/broadcast-scheduler.d.ts

@@ -0,0 +1,30 @@
+import type { CollabSessionRegistry } from './session-registry.js';
+/**
+ * CollabBroadcastScheduler — owns the 2s periodic `collab.state` broadcast
+ * (6A-4). The interval only re-sends state when a session's participant-set
+ * fingerprint changed (join/leave), so an idle session costs one tiny string
+ * build per tick instead of a serialize + fan-out. The eager fingerprint
+ * record on join/leave is `record()`; the interval compares against it.
+ *
+ * Extracted behavior-preserving from CollaborationWebSocketHandler:
+ * ensure/stop semantics (including `.unref?.()` and fingerprint clearing
+ * on stop) are the originals.
+ */
+export declare class CollabBroadcastScheduler {
+    private readonly registry;
+    /** Invoked when a session's state went stale since the last broadcast. */
+    private readonly onStaleState;
+    private interval;
+    private readonly fingerprints;
+    constructor(registry: CollabSessionRegistry, 
+    /** Invoked when a session's state went stale since the last broadcast. */
+    onStaleState: (sessionId: string) => void);
+    /** Start the periodic loop if not already running (idempotent). */
+    ensure(): void;
+    /** Record the just-broadcast fingerprint so the tick skips unchanged state. */
+    record(sessionId: string): void;
+    /** Drop a session's fingerprint when its bucket emptied (leave path). */
+    forget(sessionId: string): void;
+    stop(): void;
+}
+//# sourceMappingURL=broadcast-scheduler.d.ts.map

package/dist/server/collab/collab-context.d.ts

@@ -0,0 +1,60 @@
+import type { CollaborationBus, ConsumedInjectionInfo } from '@wrongstack/core/coordination';
+import type { AnnotationsStore, SessionReader } from '@wrongstack/core/storage';
+import type { Logger } from '@wrongstack/core/types';
+import type { WebSocket } from 'ws';
+import type { WSCollabState, WSServerMessage } from '../types.js';
+import type { CollabBroadcastScheduler } from './broadcast-scheduler.js';
+import type { CollabSessionRegistry, Participant } from './session-registry.js';
+export interface CollaborationHandlerOptions {
+    /**
+     * Resolve the session currently owned by this WebUI runtime. When supplied,
+     * joins and live EventBus mirrors are constrained to that session.
+     */
+    getActiveSessionId?: (() => string) | undefined;
+    /**
+     * Host-owned authorization for roles that can mutate collaboration state.
+     * Omission is intentionally fail-closed: clients may only join as observers.
+     */
+    authorizeRole?: ((input: {
+        ws: WebSocket;
+        sessionId: string;
+        requestedRole: Exclude<Participant['role'], 'observer'>;
+    }) => boolean) | undefined;
+}
+/**
+ * Shared wiring every collab feature module operates on. Extracted from
+ * CollaborationWebSocketHandler (6A-2): features never reach back into the
+ * transport class — they speak to this context, which the handler owns.
+ */
+export interface CollabContext {
+    readonly registry: CollabSessionRegistry;
+    readonly scheduler: CollabBroadcastScheduler;
+    readonly logger: Logger;
+    readonly reader?: SessionReader | undefined;
+    readonly annotations?: AnnotationsStore | undefined;
+    readonly bus?: CollaborationBus | undefined;
+    readonly options: CollaborationHandlerOptions;
+    send(ws: WebSocket, msg: WSServerMessage): void;
+    broadcast(sessionId: string, msg: WSServerMessage): void;
+    /** Eager state broadcast + fingerprint record (join/leave path). */
+    broadcastState(sessionId: string): void;
+    stateMessage(sessionId: string): WSCollabState;
+    errorMessage(detail: string): WSServerMessage;
+    /** Detach close/error listeners tracked by the transport (leave path). */
+    detachSocket(ws: WebSocket): void;
+    /**
+     * Full socket teardown shared by `collab.leave` and WS close/error:
+     * client removal, listener detach, leave choreography, and the
+     * stop-broadcast-when-empty check. (Original handleDisconnect.)
+     */
+    removeSocket(ws: WebSocket): void;
+}
+export type { CollaborationBus, ConsumedInjectionInfo };
+/**
+ * The 5-step guard boilerplate every privileged handler repeats, collapsed
+ * into one call (6A-2): store/bus availability stays in each feature (its
+ * error text names the feature), this helper owns join + role checks.
+ * Returns the participant on success; null after sending the error itself.
+ */
+export declare function requireJoinedRole(ctx: CollabContext, ws: WebSocket, action: string, role: 'annotator' | 'controller'): Participant | null;
+//# sourceMappingURL=collab-context.d.ts.map

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

@@ -0,0 +1,25 @@
+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
+ * broadcast payloads, including the "already paused" state surface.
+ */
+export declare class RequestPauseFeature implements CollabFeature {
+    readonly type = "collab.request_pause";
+    handle(ctx: CollabContext, ws: WebSocket, raw: unknown): Promise<void>;
+}
+export declare class ResumeFeature implements CollabFeature {
+    readonly type = "collab.resume";
+    handle(ctx: CollabContext, ws: WebSocket, raw: unknown): Promise<void>;
+}
+export declare class GrantControlFeature implements CollabFeature {
+    readonly type = "collab.grant_control";
+    handle(ctx: CollabContext, ws: WebSocket, raw: unknown): Promise<void>;
+}
+export type { WSServerMessage };
+//# sourceMappingURL=controller.d.ts.map

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

@@ -0,0 +1,27 @@
+import type { WebSocket } from 'ws';
+import type { CollabContext } from './collab-context.js';
+/** A parsed inbound client message off the collaboration wire. */
+export interface CollabInboundMessage {
+    type: string;
+    payload?: unknown | undefined;
+}
+/**
+ * One collaboration protocol feature: owns a single message type and its
+ * full handling. Async flows fire-and-forget inside `handle` (the original
+ * dispatcher ignored the returned promise with `void`).
+ */
+export interface CollabFeature {
+    readonly type: string;
+    handle(ctx: CollabContext, ws: WebSocket, payload: unknown): void;
+}
+/**
+ * CollabDispatcher (6A-3) — maps message types to features. Returns true
+ * when the message was recognized and handled; false when the caller should
+ * ignore / log, so the upstream router can dispatch non-collab messages.
+ */
+export declare class CollabDispatcher {
+    private readonly byType;
+    constructor(features: readonly CollabFeature[]);
+    dispatch(ctx: CollabContext, ws: WebSocket, msg: CollabInboundMessage): boolean;
+}
+//# sourceMappingURL=dispatcher.d.ts.map

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

@@ -0,0 +1,26 @@
+import type { ConsumedInjectionInfo } from '@wrongstack/core/coordination';
+import type { WebSocket } from 'ws';
+import type { CollabContext } from './collab-context.js';
+import type { CollabFeature } from './dispatcher.js';
+/**
+ * Phase 4 — controller's manual tool-call injection (6A-2). Moved verbatim
+ * from CollaborationWebSocketHandler: the 5-field payload gate, the
+ * queued-duplicate rejection, and the `'(pending match)'` placeholder the
+ * middleware later replaces on the `consumed` event.
+ */
+export declare class InjectToolFeature implements CollabFeature {
+    readonly type = "collab.inject_tool";
+    handle(ctx: CollabContext, ws: WebSocket, raw: unknown): Promise<void>;
+}
+/**
+ * Bus callback: a queued injection was spliced into a real tool call. Re-emit
+ * `collab.injection.granted` with phase `'consumed'` and the now-known tool
+ * name. The injection carries no sessionId, so resolve it from the author's
+ * current participant. If the author has left, fail closed rather than leak
+ * the payload to unrelated sessions.
+ *
+ * Memory-pinned regression: the injection-listener cleanup coverage relies on
+ * this callback being registered via the handler-owned `offs` disposer.
+ */
+export declare function broadcastInjectionConsumed(ctx: CollabContext, info: ConsumedInjectionInfo): void;
+//# sourceMappingURL=injection.d.ts.map

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

@@ -0,0 +1,20 @@
+import type { WebSocket } from 'ws';
+import type { CollabContext } from './collab-context.js';
+import type { CollabFeature } from './dispatcher.js';
+/**
+ * Join/leave flow (6A-2). Moved verbatim from CollaborationWebSocketHandler:
+ * the join validation chain (active-session pin → no-double-join →
+ * role-store/bus availability → fail-closed authorizeRole) and the ordered
+ * leave choreography are behavior-critical; the 34-test suite pins them.
+ */
+export declare class MembershipFeature implements CollabFeature {
+    readonly type = "collab.join";
+    handle(ctx: CollabContext, ws: WebSocket, raw: unknown): void;
+    private join;
+}
+/** `collab.leave` — identical semantics to a WS close (memory-pinned by tests). */
+export declare class LeaveFeature implements CollabFeature {
+    readonly type = "collab.leave";
+    handle(ctx: CollabContext, ws: WebSocket): void;
+}
+//# sourceMappingURL=membership.d.ts.map

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

@@ -0,0 +1,14 @@
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { CollabContext } from './collab-context.js';
+/**
+ * Live kernel-event mirror (6A-2). Subscribes to the events an observer
+ * cares about and forwards each to all joined participants as a generic
+ * `collab.event` envelope so the client can render a flowing activity
+ * strip. Filtering / denormalization happens on the client.
+ *
+ * Moved verbatim from CollaborationWebSocketHandler.subscribe(); the
+ * disposers are pushed into the caller-owned `offs` array so dispose()
+ * removes every subscription.
+ */
+export declare function subscribeCollabMirror(ctx: CollabContext, events: EventBus, offs: Array<() => void>): void;
+//# sourceMappingURL=mirror.d.ts.map

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

@@ -0,0 +1,20 @@
+import type { WebSocket } from 'ws';
+import type { CollabContext } from './collab-context.js';
+/** How many historical events to replay to a late-joining observer. */
+export declare const REPLAY_LIMIT = 50;
+/**
+ * Replay the last `REPLAY_LIMIT` events from the on-disk session log
+ * to a single observer (the late joiner). Each event is forwarded as
+ * a `collab.event` with `replay: true` so the client can distinguish
+ * history from the live stream.
+ *
+ * The session log stores typed `SessionEvent`s (`user_input`,
+ * `llm_response`, `tool_result`, etc.) — different from the kernel's
+ * bus events. We translate the most useful subset (`tool.*` and
+ * `iteration.*`-shaped ones) into the same `kind` namespace the live
+ * mirror uses, so the client can render a single activity strip.
+ *
+ * Moved verbatim from CollaborationWebSocketHandler (6A-2).
+ */
+export declare function replayHistory(ctx: CollabContext, ws: WebSocket, sessionId: string): Promise<void>;
+//# sourceMappingURL=replay.d.ts.map

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

@@ -0,0 +1,74 @@
+import type { WebSocket } from 'ws';
+import type { CollabRole, WSCollabState } from '../types.js';
+/**
+ * Session-scoped membership record for one collaboration participant.
+ * Moved verbatim from collaboration-ws-handler.ts (6A-1); the shape is
+ * wire-visible via `collab.state` payloads, so field names are frozen.
+ */
+export interface Participant {
+    participantId: string;
+    ws: WebSocket;
+    sessionId: string;
+    role: CollabRole;
+    joinedAt: string;
+}
+/** One removal produced by `removeBySocket`, with leave-choreography facts. */
+export interface SocketRemoval {
+    sessionId: string;
+    participant: Participant;
+    /** True when this removal emptied the session bucket (no broadcast due). */
+    sessionEmptied: boolean;
+}
+/**
+ * CollabSessionRegistry — the in-memory membership/state store for the
+ * collaboration transport. Pure state: no sockets are written to, no
+ * timers run, no messages are sent from here. Send/broadcast orchestration
+ * stays in the handler + feature modules so ordering semantics
+ * (left-event → remove → broadcast) remain in one visible place.
+ *
+ * Extracted behavior-preserving from CollaborationWebSocketHandler (6A-1):
+ * the maps, lookups, and state projections below are line-for-line the
+ * originals; only the surrounding class changed.
+ */
+export declare class CollabSessionRegistry {
+    /** Sockets attached to the collab endpoint (joined or not). */
+    readonly clients: Set<WebSocket>;
+    /** sessionId → participants currently watching it. */
+    private readonly bySession;
+    /** True while at least one collaboration participant is attached to a session. */
+    hasParticipants(sessionId: string): boolean;
+    /** True while ANY session still has a participant (hot-path guard for the mirror). */
+    hasAnyParticipants(): boolean;
+    /** Register a participant in its session bucket, creating the bucket on demand. */
+    addParticipant(participant: Participant): void;
+    /**
+     * Remove every participant riding the given socket (a socket joins at
+     * most one session today, but the loop stays future-proof like the
+     * original handleDisconnect). Returns the removals in map order with
+     * the owning sessionId so the caller can run the ordered leave
+     * choreography (confirm → broadcast → state) exactly as before.
+     */
+    removeBySocket(ws: WebSocket): SocketRemoval[];
+    /**
+     * Look up the participant record for a given WS across all sessions.
+     * Returns null when the WS hasn't joined (e.g. the client sent a
+     * `collab.annotate` before `collab.join`).
+     */
+    findParticipant(ws: WebSocket): Participant | null;
+    findParticipantById(sessionId: string, participantId: string): Participant | null;
+    /** Session ids with at least one participant (snapshot for iteration). */
+    sessionIds(): string[];
+    /** Live iterator over one session's participants (no copy). */
+    participantIterator(sessionId: string): IterableIterator<Participant> | undefined;
+    stateMessage(sessionId: string): WSCollabState;
+    /**
+     * Cheap participant-set identity: participant ids are unique per join and
+     * `joinedAt` distinguishes a rejoin, so the fingerprint changes exactly on
+     * join/leave — the only events that alter `collab.state`.
+     */
+    stateFingerprint(sessionId: string): string;
+    /** Resolve the session a participant id currently lives in, if any. */
+    sessionIdOfParticipant(participantId: string): string | null;
+    clear(): void;
+}
+//# sourceMappingURL=session-registry.d.ts.map

package/dist/server/collaboration-ws-handler.d.ts

@@ -3,38 +3,20 @@ import type { EventBus } from '@wrongstack/core/kernel';
 import type { AnnotationsStore, SessionReader } from '@wrongstack/core/storage';
 import type { Logger } from '@wrongstack/core/types';
 import type { WebSocket } from 'ws';
-import type { CollabRole } from './types.js';
-export interface CollaborationHandlerOptions {
-    /**
-     * Resolve the session currently owned by this WebUI runtime. When supplied,
-     * joins and live EventBus mirrors are constrained to that session.
-     */
-    getActiveSessionId?: (() => string) | undefined;
-    /**
-     * Host-owned authorization for roles that can mutate collaboration state.
-     * Omission is intentionally fail-closed: clients may only join as observers.
-     */
-    authorizeRole?: ((input: {
-        ws: WebSocket;
-        sessionId: string;
-        requestedRole: Exclude<CollabRole, 'observer'>;
-    }) => boolean) | undefined;
-}
+import type { CollaborationHandlerOptions } from './collab/collab-context.js';
+import { type CollabInboundMessage } from './collab/dispatcher.js';
+export type { CollaborationHandlerOptions };
 /**
  * CollaborationWebSocketHandler — session-scoped collaboration transport.
  * Mirrors `WorktreeWebSocketHandler` and `GoalWebSocketHandler`.
  *
- * Capabilities in this phase:
- *   - A second human (or any client) joins an active agent run as an
- *     `observer` and receives a live mirror of the kernel's iteration /
- *     tool / subagent events.
- *   - The observer declares a `sessionId` on join. Hosts provide the live
- *     runtime session id so replay and EventBus routing stay session-scoped.
- *   - The observer can leave at any time; cleanup runs on WS close/error.
- *   - Privileged roles are never accepted from the wire by themselves.
- *     The host must explicitly authorize annotator/controller grants.
+ * Split (6A): this file is now the thin transport + wiring shell; the
+ * protocol lives in collab/ feature modules dispatched by CollabDispatcher.
+ * Behavior is preserved verbatim — the 34-test suite in
+ * tests/collaboration-ws-handler.test.ts pins the wire protocol, replay
+ * semantics, and the dispose/leave ordering.
  *
- * Protocol additions (see `packages/webui/src/types.ts`):
+ * Protocol (see `packages/webui/src/types.ts`):
  *   client → server:  collab.join { sessionId, role: 'observer' }
  *                     collab.leave { sessionId }
  *   server → client:  collab.state          (initial + 2s periodic)
@@ -45,145 +27,42 @@ export interface CollaborationHandlerOptions {
 export declare class CollaborationWebSocketHandler {
     private readonly events;
     private readonly logger;
-    /**
-     * Optional reader over the on-disk session log. When provided, late
-     * joiners receive the last `REPLAY_LIMIT` events of the joined
-     * session before live mirroring begins. Without a reader, joining
-     * is still allowed — the observer simply starts from "now" with no
-     * historical context.
-     */
     private readonly reader?;
-    /**
-     * Optional sidecar store for collaboration annotations. Required
-     * for the `annotator` role — without it, `collab.annotate` messages
-     * are rejected with an error.
-     */
     private readonly annotations?;
-    /**
-     * Optional kernel-level pause/resume bus. Required for the
-     * `controller` role — without it, `collab.request_pause` is rejected
-     * with an error. Wired to the agent's `toolCall` pipeline via
-     * `collabPauseMiddleware` in the webui server boot.
-     */
     private readonly bus?;
     private readonly options;
-    private readonly clients;
-    /** sessionId → participants currently watching it. */
-    private readonly bySession;
-    private broadcastInterval;
-    /**
-     * Last-broadcast participant-set fingerprint per session. The 2s interval
-     * only re-sends `collab.state` when the fingerprint changed (join/leave),
-     * so an idle session costs one tiny string build per tick instead of a
-     * serialize + fan-out.
-     */
-    private readonly lastStateFingerprints;
+    private readonly registry;
+    private readonly scheduler;
+    private readonly dispatcher;
     private readonly offs;
-    constructor(events: EventBus, logger: Logger, 
-    /**
-     * Optional reader over the on-disk session log. When provided, late
-     * joiners receive the last `REPLAY_LIMIT` events of the joined
-     * session before live mirroring begins. Without a reader, joining
-     * is still allowed — the observer simply starts from "now" with no
-     * historical context.
-     */
-    reader?: SessionReader | undefined, 
-    /**
-     * Optional sidecar store for collaboration annotations. Required
-     * for the `annotator` role — without it, `collab.annotate` messages
-     * are rejected with an error.
-     */
-    annotations?: AnnotationsStore | undefined, 
-    /**
-     * Optional kernel-level pause/resume bus. Required for the
-     * `controller` role — without it, `collab.request_pause` is rejected
-     * with an error. Wired to the agent's `toolCall` pipeline via
-     * `collabPauseMiddleware` in the webui server boot.
-     */
-    bus?: CollaborationBus | undefined, options?: CollaborationHandlerOptions);
+    /** Per-socket disconnect removers so dispose() can detach still-live sockets. */
+    private readonly socketOffs;
+    private readonly ctx;
+    constructor(events: EventBus, logger: Logger, reader?: SessionReader | undefined, annotations?: AnnotationsStore | undefined, bus?: CollaborationBus | undefined, options?: CollaborationHandlerOptions);
     addClient(ws: WebSocket): void;
     /** True while at least one collaboration participant is attached to a session. */
     hasParticipants(sessionId: string): boolean;
     dispose(): void;
     /**
      * Dispatch a parsed client message. Returns true when the message was
-     * recognized and handled; false when the caller should ignore / log.
-     * Phase 1 only knows `collab.join` and `collab.leave`; unknown types
-     * return false so the upstream router can decide.
-     */
-    handleMessage(ws: WebSocket, msg: {
-        type: string;
-        payload?: unknown | undefined;
-    }): boolean;
-    private join;
-    private leave;
-    private handleDisconnect;
-    /**
-     * Look up the participant record for a given WS across all sessions.
-     * Returns null when the WS hasn't joined (e.g. the client sent a
-     * `collab.annotate` before `collab.join`).
-     */
-    private findParticipant;
-    private findParticipantById;
-    private handleAnnotate;
-    private handleResolve;
-    private subscribe;
-    private broadcastEvent;
-    /**
-     * Replay the last `REPLAY_LIMIT` events from the on-disk session log
-     * to a single observer (the late joiner). Each event is forwarded as
-     * a `collab.event` with `replay: true` so the client can distinguish
-     * history from the live stream.
-     *
-     * The session log stores typed `SessionEvent`s (`user_input`,
-     * `llm_response`, `tool_result`, etc.) — different from the kernel's
-     * bus events. We translate the most useful subset (`tool.*` and
-     * `iteration.*`-shaped ones) into the same `kind` namespace the live
-     * mirror uses, so the client can render a single activity strip.
+     * recognized and handled; false when the caller should ignore / log so
+     * the upstream router can dispatch non-collab messages.
      */
-    private replayHistory;
+    handleMessage(ws: WebSocket, msg: CollabInboundMessage): boolean;
+    private makeContext;
     /**
-     * Map a stored `SessionEvent` to a `collab.event.kind` so the live
-     * strip and the history strip can share a single rendering path.
-     * Returns null for events that don't have a meaningful live analog
-     * (e.g. `session_start`, file-snapshot bookkeeping, rewind markers).
-     */
-    private historyEventToKind;
-    private stateMessage;
-    /**
-     * Cheap participant-set identity: participant ids are unique per join and
-     * `joinedAt` distinguishes a rejoin, so the fingerprint changes exactly on
-     * join/leave — the only events that alter `collab.state`.
-     */
-    private stateFingerprint;
-    /**
-     * Broadcast the current state for a session and record the fingerprint.
-     * Used on join/leave (eager broadcast) and by the periodic interval.
+     * Shared `collab.leave` / WS close-error path. Order matters:
+     *   1. Remove from the client set and detach tracked listeners.
+     *   2. Send `participant.left` to the leaving ws, then delete from bucket.
+     *   3. Broadcast the fresh state to remaining observers.
+     *   4. Stop the interval once nobody can be broadcast to.
      */
+    private removeSocket;
+    private detachSocket;
+    /** Broadcast the current state for a session and record the fingerprint. */
     private broadcastState;
-    private ensureBroadcast;
-    private stopBroadcast;
     private broadcast;
     private send;
     private errorMessage;
-    private handleRequestPause;
-    private handleResume;
-    private handleGrantControl;
-    /**
-     * Phase 4 — handle a controller's manual tool-call injection.
-     * Validates the payload, queues it on the bus, and broadcasts
-     * the grant so observers see what just happened. The actual
-     * splice into the agent's pipeline is performed by the
-     * `collabInjectMiddleware` on the next tool call.
-     */
-    private handleInjectTool;
-    /**
-     * Bus callback: a queued injection was spliced into a real tool call. Re-emit
-     * `collab.injection.granted` with phase `'consumed'` and the now-known tool
-     * name. The injection carries no sessionId, so resolve it from the author's
-     * current participant. If the author has left, fail closed rather than leak
-     * the payload to unrelated sessions.
-     */
-    private broadcastInjectionConsumed;
 }
 //# sourceMappingURL=collaboration-ws-handler.d.ts.map

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

@@ -40,7 +40,8 @@ export declare function createEmbeddedProviderOperations(ctx: EmbeddedProviderCo
     handleProviderModels: (ws: WebSocket, providerId: string) => Promise<void>;
     handleProviderModelsSearch: (ws: WebSocket, query: string, limit?: number | undefined) => Promise<void>;
     adoptDefaultProviderIfUnset: (providerId: string) => Promise<void>;
-    broadcastSaved: (providers: Record<string, ProviderConfig>) => void;
+    handleCustomModelSet: (ws: WebSocket, providerId: string, modelId: string, definition: NonNullable<ProviderConfig['customModels']>[string]) => Promise<void>;
+    handleCustomModelRemove: (ws: WebSocket, providerId: string, modelId: string) => Promise<void>;
     handleKeyUpsert: (ws: WebSocket, providerId: string, label: string, apiKey: string) => Promise<void>;
     handleKeyDelete: (ws: WebSocket, providerId: string, label: string) => Promise<void>;
     handleKeySetActive: (ws: WebSocket, providerId: string, label: string) => Promise<void>;
@@ -54,8 +55,6 @@ export declare function createEmbeddedProviderOperations(ctx: EmbeddedProviderCo
     }) => Promise<boolean>;
     handleProviderRemove: (ws: WebSocket, providerId: string) => Promise<void>;
     handleProviderClearModels: (ws: WebSocket, providerId: string) => Promise<void>;
-    handleCustomModelSet: (ws: WebSocket, providerId: string, modelId: string, definition: NonNullable<ProviderConfig['customModels']>[string]) => Promise<void>;
-    handleCustomModelRemove: (ws: WebSocket, providerId: string, modelId: string) => Promise<void>;
     handleProviderUndoClear: (ws: WebSocket, providerId: string, previousModels: string[]) => Promise<void>;
     handleProviderUpdate: (ws: WebSocket, payload: {
         id: string;
@@ -65,10 +64,11 @@ export declare function createEmbeddedProviderOperations(ctx: EmbeddedProviderCo
         models?: string[] | undefined;
         customModels?: ProviderConfig['customModels'] | undefined;
     }) => Promise<void>;
-    handleProviderProbe: (ws: WebSocket, providerId: string, timeoutMs?: number) => Promise<void>;
     handleOAuthStart: (ws: WebSocket, kind: import("@wrongstack/providers/oauth").OAuthKind, customProviderId?: string) => Promise<void>;
     handleOAuthCode: (ws: WebSocket, kind: import("@wrongstack/providers/oauth").OAuthKind, input: string) => Promise<void>;
     handleOAuthCancel: (ws: WebSocket, kind: import("@wrongstack/providers/oauth").OAuthKind) => void;
+    handleProviderProbe: (ws: WebSocket, providerId: string, timeoutMs?: number) => Promise<void>;
+    broadcastSaved: (providers: Record<string, ProviderConfig>) => void;
     loadConfigProviders: () => Promise<Record<string, ProviderConfig>>;
 };
 export interface EmbeddedConversationContext extends EmbeddedHostTransport {