@wrongstack/webui-server 0.284.0 → 0.285.0

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

@@ -0,0 +1,10 @@
+import type { WebSocket } from 'ws';
+import type { WSClientMessage } from './types.js';
+export interface AutoPhaseRouteHandlers {
+    handleMessage: (msg: {
+        type: string;
+        payload?: Record<string, unknown>;
+    }) => Promise<void>;
+}
+export declare function handleAutoPhaseRoute(_ws: WebSocket, msg: WSClientMessage, handlers: AutoPhaseRouteHandlers): Promise<boolean>;
+//# sourceMappingURL=autophase-routes.d.ts.map

package/dist/server/autophase-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autophase-routes.d.ts","sourceRoot":"","sources":["../../src/server/autophase-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5F;AAED,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,SAAS,EACd,GAAG,EAAE,eAAe,EACpB,QAAQ,EAAE,sBAAsB,GAC/B,OAAO,CAAC,OAAO,CAAC,CAIlB"}

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

@@ -0,0 +1,87 @@
+import type { WebSocket } from 'ws';
+import type { Agent, Context, EventBus, Logger } from '@wrongstack/core';
+interface AutoPhaseWSMessage {
+    type: string;
+    payload?: Record<string, unknown>;
+}
+/**
+ * AutoPhaseWebSocketHandler — WebSocket-based AutoPhase control.
+ *
+ * Message types:
+ *   autophase.start   → { title, phases?, autonomous? }
+ *   autophase.pause   → {}
+ *   autophase.resume  → {}
+ *   autophase.stop    → {}
+ *   autophase.status  → {}
+ *   autophase.selectPhase → { phaseId }
+ *   autophase.taskStatus  → { taskId, status }
+ */
+export declare class AutoPhaseWebSocketHandler {
+    private agent;
+    private context;
+    private logger;
+    private events?;
+    private projectRoot?;
+    private orchestrator;
+    private graph;
+    private store;
+    private clients;
+    private broadcastInterval;
+    /** Aborts in-flight task agents AND the planning turn when the run is stopped. */
+    private abort;
+    /** Set the instant a stop/clear/revert is requested, so a planning turn that
+     *  resolves afterwards never launches the orchestrator (the abort alone can't
+     *  cover the window between the LLM call resolving and the orchestrator start). */
+    private stopping;
+    /** Optional per-phase git-worktree isolation (lazily created at start). */
+    private worktrees;
+    /** Base branch + tip SHA captured at run start so a revert can git-revert the
+     *  run's squash commits (history-preserving) instead of a destructive reset. */
+    private runBase;
+    /** Per-run worker identities so the board can show "who is on what". */
+    private usedNicknames;
+    constructor(agent: Agent, context: Context, logger: Logger, storeDir: string, events?: EventBus | undefined, projectRoot?: string | undefined);
+    addClient(ws: WebSocket): void;
+    handleMessage(msg: AutoPhaseWSMessage): Promise<void>;
+    private handleStart;
+    /**
+     * Halt the run NOW — at any phase. Sets `stopping` (so a planning turn that
+     * resolves afterwards bails), aborts in-flight agents, stops the orchestrator
+     * tick, and ends the live broadcast. The board is kept for review; use
+     * `autophase.clear` to reset or `autophase.revert` to undo the changes.
+     */
+    private handleStop;
+    /**
+     * Stop + wipe: tear down phase worktrees and reset to an empty board so the UI
+     * returns to the start screen ("new one"). Does NOT touch already-merged commits
+     * on the base branch — that is `autophase.revert`.
+     */
+    private handleClear;
+    /**
+     * Stop + undo: remove phase worktrees, then history-preservingly `git revert`
+     * every commit this run landed on the base branch (captured `runBase`..HEAD),
+     * then reset to an empty board. Refuses (reports a reason) on a dirty tree or a
+     * conflicting revert rather than leaving the tree half-reverted.
+     */
+    private handleRevert;
+    /** Generic fallback phases when the LLM planner produces nothing usable. */
+    private defaultPhases;
+    /** Plan phases+todos for the goal via the LLM; fall back to defaults on failure.
+     *  The caller passes the run's abort signal so a stop during planning cancels
+     *  the LLM turn (the previous fresh, never-aborted controller made planning
+     *  uninterruptible). */
+    private planPhases;
+    private executeTaskWithAgent;
+    /** Persist + broadcast after an interactive board mutation. */
+    private afterBoardMutation;
+    private handleTaskStatusChange;
+    private startBroadcast;
+    private stopBroadcast;
+    private broadcastState;
+    private buildState;
+    private sendState;
+    private broadcast;
+    private send;
+}
+export {};
+//# sourceMappingURL=autophase-ws-handler.d.ts.map

package/dist/server/autophase-ws-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autophase-ws-handler.d.ts","sourceRoot":"","sources":["../../src/server/autophase-ws-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAYpC,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAoDzE,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,yBAAyB;IAqBlC,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,WAAW,CAAC;IAzBtB,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,iBAAiB,CAA+C;IACxE,kFAAkF;IAClF,OAAO,CAAC,KAAK,CAAgC;IAC7C;;uFAEmF;IACnF,OAAO,CAAC,QAAQ,CAAS;IACzB,2EAA2E;IAC3E,OAAO,CAAC,SAAS,CAAgC;IACjD;oFACgF;IAChF,OAAO,CAAC,OAAO,CAAgD;IAC/D,wEAAwE;IACxE,OAAO,CAAC,aAAa,CAAqB;IAE1C,YACU,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,EACR,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,EAC7B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,EAGzC;IAED,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI,CAS7B;IAEK,aAAa,CAAC,GAAG,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyG1D;YAEa,WAAW;IAwIzB;;;;;OAKG;YACW,UAAU;IASxB;;;;OAIG;YACW,WAAW;IAYzB;;;;;OAKG;YACW,YAAY;IAsB1B,4EAA4E;IAC5E,OAAO,CAAC,aAAa;IAUrB;;;4BAGwB;YACV,UAAU;YA2BV,oBAAoB;IA+BlC,+DAA+D;IAC/D,OAAO,CAAC,kBAAkB;YAKZ,sBAAsB;IAcpC,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,UAAU;IAqGlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,IAAI;CAKb"}

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

@@ -0,0 +1,114 @@
+/**
+ * Post-context backend service construction for the standalone WebUI server.
+ *
+ * Phase 1c of the god-module split (issue: God-modules >1500 lines).
+ * `startWebUI` previously inlined ~400 lines of construction that runs
+ * AFTER `context` exists: the agent pipelines + collab middleware, the
+ * strategy compactor + auto-compaction middleware, the tool executor +
+ * agent, the tiered Brain + monitor, and the per-feature WebSocket
+ * handlers (AutoPhase, specs, SDD board/wizard, worktree, terminal, collab).
+ *
+ * All of that moves into `createAgentServices()`. The pre-context
+ * registries/stores (modelsRegistry, container, toolRegistry, session,
+ * tokenCounter, …) stay in `startWebUI` because they are interleaved with
+ * the `opts.services?` injection contract the CLI's embedded server
+ * relies on; lifting them would restructure that contract, which is a
+ * separate, higher-risk task.
+ *
+ * The factory is pure construction — no behaviour change. It returns a
+ * typed `AgentServices` object plus the `updateAutoCompactionMaxContext`
+ * closure (which needs the live `context`, `autoCompactor`, and
+ * `modelCapabilitiesRef` it just built).
+ */
+import type { AutoCompactionMiddleware, BrainAutoRisk, CollaborationBus, Compactor, Context, MemoryStore, DefaultModeStore, EventBus, Logger, ModelsRegistry, ObservableBrainArbiter, PermissionPolicy, Provider, ProviderRegistry, SessionStore, SkillInstaller, SkillLoader, ToolRegistry, AgentPipelines, Container, SessionReader } from '@wrongstack/core';
+import type { DefaultTokenCounter } from '@wrongstack/core/infrastructure';
+/** Session shape returned by `SessionStore.create()`. */
+type Session = Awaited<ReturnType<SessionStore['create']>>;
+import { Agent, BrainMonitor, ToolExecutor, type AnnotationsStore } from '@wrongstack/core';
+import type { MCPRegistry } from '@wrongstack/mcp';
+import { AutoPhaseWebSocketHandler } from './autophase-ws-handler.js';
+import { CollaborationWebSocketHandler } from './collaboration-ws-handler.js';
+import { SddBoardWebSocketHandler } from './sdd-board-ws-handler.js';
+import { SddWizardWebSocketHandler } from './sdd-wizard-ws-handler.js';
+import { SpecsWebSocketHandler } from './specs-ws-handler.js';
+import { TerminalWebSocketHandler } from './terminal-ws-handler.js';
+import { WorktreeWebSocketHandler } from './worktree-ws-handler.js';
+import type { Config, ProviderConfig } from '@wrongstack/core/types';
+import type { WstackPaths } from '@wrongstack/core/utils';
+export interface AgentServicesInput {
+    config: Config;
+    wpaths: WstackPaths;
+    logger: Logger;
+    projectRoot: string;
+    workingDir: string;
+    /** Pre-context services (built in startWebUI with opts.services injection). */
+    context: Context;
+    provider: Provider;
+    container: Container;
+    toolRegistry: ToolRegistry;
+    providerRegistry: ProviderRegistry;
+    modelsRegistry: ModelsRegistry;
+    events: EventBus;
+    mcpRegistry: MCPRegistry;
+    memoryStore: MemoryStore;
+    modeStore: DefaultModeStore;
+    customModeStore: import('./custom-context-modes.js').CustomModeStore;
+    skillLoader: SkillLoader | undefined;
+    skillInstaller: SkillInstaller | undefined;
+    tokenCounter: DefaultTokenCounter;
+    pipelines: AgentPipelines;
+    /** Mutable capabilities ref — the factory populates `.current`. */
+    modelCapabilitiesRef: {
+        current: unknown;
+    };
+    /** Returns the LIVE session (swapped on /new + resume) — read at send time. */
+    sessionGetter: () => Session;
+    /** Read-only session reader (collab replay-on-join). */
+    sessionReader: SessionReader;
+    /** Annotations store (collab notes). */
+    annotationsStore: AnnotationsStore;
+}
+export interface AgentServices {
+    collabBus: CollaborationBus;
+    compactor: Compactor;
+    autoCompactor: AutoCompactionMiddleware | undefined;
+    toolExecutor: ToolExecutor;
+    agent: Agent;
+    permissionPolicy: PermissionPolicy;
+    pipelines: AgentPipelines;
+    brain: ObservableBrainArbiter;
+    brainSettings: {
+        maxAutoRisk: BrainAutoRisk;
+    };
+    brainLog: Array<{
+        at: number;
+        kind: string;
+        question: string;
+        outcome: string;
+    }>;
+    brainMonitor: BrainMonitor;
+    codebaseIndexing: {
+        onFileWritten(filePath: string): void;
+        dispose(): void;
+    };
+    autoPhaseHandler: AutoPhaseWebSocketHandler;
+    specsHandler: SpecsWebSocketHandler;
+    sddBoardHandler: SddBoardWebSocketHandler;
+    sddWizardHandler: SddWizardWebSocketHandler;
+    worktreeHandler: WorktreeWebSocketHandler;
+    terminalHandler: TerminalWebSocketHandler;
+    collabHandler: CollaborationWebSocketHandler;
+    /** Refresh auto-compaction denominator on model switch. */
+    updateAutoCompactionMaxContext: (newProvider: Provider, providerId?: string, providerCfg?: ProviderConfig | undefined) => Promise<void>;
+}
+/**
+ * Build the post-context agent services: pipelines + middleware, compaction,
+ * tool executor + agent, Brain, and the per-feature WebSocket handlers.
+ *
+ * Returns everything `startWebUI` needs to wire routes + the dispatcher.
+ * The `updateAutoCompactionMaxContext` closure captures the live
+ * `autoCompactor` / `modelCapabilitiesRef` it built.
+ */
+export declare function createAgentServices(input: AgentServicesInput): Promise<AgentServices>;
+export {};
+//# sourceMappingURL=backend-services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"backend-services.d.ts","sourceRoot":"","sources":["../../src/server/backend-services.ts"],"names":[],"mappings":"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"}

package/dist/server/boot.d.ts

@@ -0,0 +1,19 @@
+import { type Config, type DefaultLogger, type DefaultSecretVault, type WstackPaths } from '@wrongstack/core';
+export interface BootResult {
+    config: Config;
+    vault: DefaultSecretVault;
+    globalConfigPath: string;
+    projectRoot: string;
+    wpaths: WstackPaths;
+    logger: InstanceType<typeof DefaultLogger>;
+}
+/**
+ * Thin WebUI wrapper over the canonical `bootConfig` in `@wrongstack/core`
+ * (mirrors packages/cli/src/boot-config.ts). All real boot behavior — wstack
+ * path resolution, the AES-GCM `DefaultSecretVault`, plaintext-secret
+ * migration, and config load/merge — lives in core so the WebUI server and the
+ * CLI can't drift. Only the secret-migration notice label (`WebUI`) differs.
+ */
+export declare function bootConfig(): Promise<BootResult>;
+export declare function patchConfig(config: Config, updates: Partial<Config>): Config;
+//# sourceMappingURL=boot.d.ts.map

package/dist/server/boot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot.d.ts","sourceRoot":"","sources":["../../src/server/boot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAEjB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,kBAAkB,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,YAAY,CAAC,OAAO,aAAa,CAAC,CAAC;CAC5C;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC,CAKtD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAE5E"}

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

@@ -0,0 +1,9 @@
+import type { WebSocket } from 'ws';
+import type { WSClientMessage } from './types.js';
+export interface BrainRouteHandlers {
+    status: (ws: WebSocket, msg: WSClientMessage) => Promise<void> | void;
+    risk: (ws: WebSocket, msg: WSClientMessage) => Promise<void> | void;
+    ask: (ws: WebSocket, msg: WSClientMessage) => Promise<void> | void;
+}
+export declare function handleBrainRoute(ws: WebSocket, msg: WSClientMessage, handlers: BrainRouteHandlers): Promise<boolean>;
+//# sourceMappingURL=brain-routes.d.ts.map

package/dist/server/brain-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain-routes.d.ts","sourceRoot":"","sources":["../../src/server/brain-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACtE,IAAI,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACpE,GAAG,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACpE;AAED,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,eAAe,EACpB,QAAQ,EAAE,kBAAkB,GAC3B,OAAO,CAAC,OAAO,CAAC,CAclB"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"codebase-indexing.d.ts","sourceRoot":"","sources":["../../src/server/codebase-indexing.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAqBxE,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,SAAS,CAAA;KAAE,CAAC;IAClD,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,yBAAyB,GAC9B,qBAAqB,CAmFvB"}

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

@@ -0,0 +1,159 @@
+import type { WebSocket } from 'ws';
+import type { CollaborationBus, EventBus, Logger } from '@wrongstack/core';
+import type { AnnotationsStore, SessionReader } from '@wrongstack/core/storage';
+/**
+ * CollaborationWebSocketHandler — passive read-only session observer (Phase 1
+ * of idea #13 from IDEAS.md). Mirrors `WorktreeWebSocketHandler` and
+ * `AutoPhaseWebSocketHandler`.
+ *
+ * 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 (used for state scoping
+ *     and future replay-on-join). Live event routing is session-agnostic
+ *     for now — see the limitation note below.
+ *   - The observer can leave at any time; cleanup runs on WS close/error.
+ *   - The observer CANNOT modify the agent's state, pause it, or inject
+ *     tool calls. Those capabilities land in Phase 2/3.
+ *
+ * Limitation (documented, acceptable for Phase 1):
+ *   The webui server multiplexes every active session onto a single
+ *   EventBus, and most event payloads (`tool.started`, `iteration.*`,
+ *   `subagent.*`) do NOT carry a `sessionId` field. The webui's primary
+ *   WS path works because it is the only consumer and assumes one
+ *   active session at a time. We mirror that assumption here. When a
+ *   future multi-session "session router" lands, this handler will be
+ *   upgraded to filter by sessionId.
+ *
+ * Protocol additions (see `packages/webui/src/types.ts`):
+ *   client → server:  collab.join { sessionId, role: 'observer' }
+ *                     collab.leave { sessionId }
+ *   server → client:  collab.state          (initial + 2s periodic)
+ *                     collab.participant.joined
+ *                     collab.participant.left
+ *                     collab.event          (live kernel event mirror)
+ */
+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 clients;
+    /** sessionId → participants currently watching it. */
+    private readonly bySession;
+    private broadcastInterval;
+    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);
+    addClient(ws: WebSocket): void;
+    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.
+     */
+    private replayHistory;
+    /**
+     * 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;
+    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 session; if they've already left, fall back to every live session.
+     */
+    private broadcastInjectionConsumed;
+}
+//# sourceMappingURL=collaboration-ws-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collaboration-ws-handler.d.ts","sourceRoot":"","sources":["../../src/server/collaboration-ws-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,gBAAgB,EAAyB,QAAQ,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAClG,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAchF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBAAa,6BAA6B;IAQtC,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IACxB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAC7B;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC;IA7BvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,sDAAsD;IACtD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuC;IACjE,OAAO,CAAC,iBAAiB,CAA+C;IACxE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyB;IAE9C,YACmB,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,MAAM;IAC/B;;;;;;OAMG;IACc,MAAM,CAAC,EAAE,aAAa,GAAG,SAAS;IACnD;;;;OAIG;IACc,WAAW,CAAC,EAAE,gBAAgB,GAAG,SAAS;IAC3D;;;;;OAKG;IACc,GAAG,CAAC,EAAE,gBAAgB,GAAG,SAAS,EAMpD;IAID,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI,CAK7B;IAED,OAAO,IAAI,IAAI,CAId;IAID;;;;;OAKG;IACH,aAAa,CACX,EAAE,EAAE,SAAS,EACb,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KAAE,GACnD,OAAO,CAyCT;IAID,OAAO,CAAC,IAAI;IAmEZ,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,gBAAgB;IAwCxB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,mBAAmB;YASb,cAAc;YA4Ed,aAAa;IA0E3B,OAAO,CAAC,SAAS;IA6CjB,OAAO,CAAC,cAAc;IAsBtB;;;;;;;;;;;OAWG;YACW,aAAa;IAiC3B;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,YAAY;IAiBpB,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,SAAS;IAiBjB,OAAO,CAAC,IAAI;IAQZ,OAAO,CAAC,YAAY;YAMN,kBAAkB;YAiDlB,YAAY;YA0CZ,kBAAkB;IAgDhC;;;;;;OAMG;YACW,gBAAgB;IAuF9B;;;;;OAKG;IACH,OAAO,CAAC,0BAA0B;CA8BnC"}

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

@@ -0,0 +1,39 @@
+/**
+ * Context-aware editor completion for the WebUI Monaco surface.
+ *
+ * The handler combines fast symbol-index hits with a short, JSON-only LLM call.
+ * It is intentionally side-effect free: it never writes files and only reads the
+ * existing codebase index when available.
+ */
+import type { WebSocket } from 'ws';
+import type { Context, Provider, Tool } from '@wrongstack/core';
+export type CompletionItemKind = 'text' | 'method' | 'function' | 'constructor' | 'field' | 'variable' | 'class' | 'interface' | 'module' | 'property' | 'unit' | 'value' | 'enum' | 'keyword' | 'snippet' | 'file' | 'reference';
+export interface CompletionSuggestion {
+    label: string;
+    insertText: string;
+    kind?: CompletionItemKind | undefined;
+    detail?: string | undefined;
+    documentation?: string | undefined;
+    sortText?: string | undefined;
+    source?: 'llm' | 'index' | 'lsp' | undefined;
+}
+export interface CompletionHandlerOptions {
+    projectRoot: string;
+    provider?: Provider | undefined;
+    model?: string | undefined;
+    indexDir?: string | undefined;
+    lspCompletion?: LspCompletionSource | undefined;
+    timeoutMs?: number | undefined;
+}
+export interface LspCompletionSourceRequest {
+    filePath: string;
+    lineNumber: number;
+    column: number;
+    content?: string | undefined;
+    triggerCharacter?: string | undefined;
+    signal: AbortSignal;
+}
+export type LspCompletionSource = (request: LspCompletionSourceRequest) => Promise<CompletionSuggestion[]>;
+export declare function handleCompletionRequest(ws: WebSocket, msg: unknown, opts: CompletionHandlerOptions): Promise<void>;
+export declare function createToolLspCompletionSource(tool: Tool | undefined, ctx: Context): LspCompletionSource | undefined;
+//# sourceMappingURL=completion-handlers.d.ts.map

package/dist/server/completion-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion-handlers.d.ts","sourceRoot":"","sources":["../../src/server/completion-handlers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAW,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAIzE,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,QAAQ,GACR,UAAU,GACV,aAAa,GACb,OAAO,GACP,UAAU,GACV,OAAO,GACP,WAAW,GACX,QAAQ,GACR,UAAU,GACV,MAAM,GACN,OAAO,GACP,MAAM,GACN,SAAS,GACT,SAAS,GACT,MAAM,GACN,WAAW,CAAC;AAEhB,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACtC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,KAAK,GAAG,SAAS,CAAC;CAC9C;AAgBD,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,aAAa,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAChD,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,MAAM,mBAAmB,GAAG,CAChC,OAAO,EAAE,0BAA0B,KAChC,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAAC;AA+DrC,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,wBAAwB,GAC7B,OAAO,CAAC,IAAI,CAAC,CA4Ef;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,GAAG,EAAE,OAAO,GACX,mBAAmB,GAAG,SAAS,CAkBjC"}

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

@@ -0,0 +1,72 @@
+/**
+ * WebSocket connection lifecycle for the standalone WebUI server.
+ *
+ * Phase 1b of the god-module split (issue: God-modules >1500 lines).
+ * `startWebUI` in `./index.ts` previously inlined:
+ *   - per-connection message rate limiting (state + `checkRateLimit`)
+ *   - the `handleConnection` callback registered on both WS servers
+ *   - the F5-resilience replay (transcript + usage) shipped to every new
+ *     connection so a browser refresh rehydrates without an extra round-trip
+ *
+ * All of that moves here. The factory returns the `(ws) => void` handler
+ * that `startWebUI` registers on `wssPrimary` / `wssSecondary`. Behaviour is
+ * preserved verbatim — rate-limit windows, the 2 000-message replay cap, the
+ * pending-confirm cleanup on close, and the error swallow on socket errors.
+ */
+import type { Context, Message, Usage } from '@wrongstack/core';
+import type { DefaultTokenCounter } from '@wrongstack/core/infrastructure';
+import type { WebSocket } from 'ws';
+import type { AutoPhaseWebSocketHandler } from './autophase-ws-handler.js';
+import type { CollaborationWebSocketHandler } from './collaboration-ws-handler.js';
+import type { SddBoardWebSocketHandler } from './sdd-board-ws-handler.js';
+import type { SddWizardWebSocketHandler } from './sdd-wizard-ws-handler.js';
+import type { SpecsWebSocketHandler } from './specs-ws-handler.js';
+import type { TerminalWebSocketHandler } from './terminal-ws-handler.js';
+import type { WorktreeWebSocketHandler } from './worktree-ws-handler.js';
+import type { ConnectedClient, WSClientMessage } from './types.js';
+import { type PendingConfirm } from './pending-confirms.js';
+/** The session.start payload enriched with optional F5-replay fields. */
+type SessionStartEnriched = Record<string, unknown>;
+export interface ConnectionHandlerOptions {
+    /** Live session id — re-read every connect (mutable across /new + resume). */
+    getSessionId(): string;
+    /** Builds the rich session.start payload (model, costs, cwd, …). */
+    sessionStartPayload(): Promise<SessionStartEnriched>;
+    /** Token counter — `total()` feeds the replayUsage block. */
+    tokenCounter: DefaultTokenCounter;
+    /** Agent context — fallback source for replay when the session log is unavailable. */
+    context: Context;
+    /**
+     * Load the visible chat replay for a reconnecting client. Prefer the
+     * session log over `context.messages`: context is the model working set and
+     * may have been compacted, while the session log is the UI transcript.
+     */
+    loadReplay?: (() => Promise<{
+        messages: Message[];
+        usage?: Usage | undefined;
+    } | null>) | undefined;
+    /** Live WS clients map (shared with the dispatcher + broadcaster). */
+    clients: Map<WebSocket, ConnectedClient>;
+    /** Pending permission confirmations — drained to 'no' on disconnect. */
+    pendingConfirms: Map<string, PendingConfirm>;
+    /** Per-feature WS handlers that register each new client for their feeds. */
+    autoPhaseHandler: AutoPhaseWebSocketHandler;
+    specsHandler: SpecsWebSocketHandler;
+    sddBoardHandler: SddBoardWebSocketHandler;
+    sddWizardHandler: SddWizardWebSocketHandler;
+    worktreeHandler: WorktreeWebSocketHandler;
+    collabHandler: CollaborationWebSocketHandler;
+    terminalHandler: TerminalWebSocketHandler;
+    /** The inbound message dispatcher (handles parsed WSClientMessage). */
+    handleMessage: (ws: WebSocket, client: ConnectedClient, msg: WSClientMessage) => Promise<void>;
+}
+/**
+ * Build the `(ws) => void` connection handler.
+ *
+ * Owns the rate-limit state + the per-process connection-id sequence so two
+ * handlers built in the same process don't share buckets. Returns the handler
+ * plus a `dispose` for tests; production registers it directly on the servers.
+ */
+export declare function createConnectionHandler(opts: ConnectionHandlerOptions): (ws: WebSocket) => void;
+export {};
+//# sourceMappingURL=connection-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connection-handler.d.ts","sourceRoot":"","sources":["../../src/server/connection-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAEpC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,+BAA+B,CAAC;AACnF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACnE,OAAO,EAA6B,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGvF,yEAAyE;AACzE,KAAK,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEpD,MAAM,WAAW,wBAAwB;IACvC,8EAA8E;IAC9E,YAAY,IAAI,MAAM,CAAC;IACvB,oEAAoE;IACpE,mBAAmB,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACrD,6DAA6D;IAC7D,YAAY,EAAE,mBAAmB,CAAC;IAClC,sFAAsF;IACtF,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,OAAO,CAAC;QAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;IACpG,sEAAsE;IACtE,OAAO,EAAE,GAAG,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;IACzC,wEAAwE;IACxE,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC7C,6EAA6E;IAC7E,gBAAgB,EAAE,yBAAyB,CAAC;IAC5C,YAAY,EAAE,qBAAqB,CAAC;IACpC,eAAe,EAAE,wBAAwB,CAAC;IAC1C,gBAAgB,EAAE,yBAAyB,CAAC;IAC5C,eAAe,EAAE,wBAAwB,CAAC;IAC1C,aAAa,EAAE,6BAA6B,CAAC;IAC7C,eAAe,EAAE,wBAAwB,CAAC;IAC1C,uEAAuE;IACvE,aAAa,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAChG;AA2BD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,wBAAwB,GAC7B,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CA4LzB"}

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

@@ -0,0 +1,28 @@
+/**
+ * Context-meta seeding for the standalone WebUI server.
+ *
+ * Phase 1c of the god-module split (issue: God-modules >1500 lines).
+ * `startWebUI` in `./index.ts` previously inlined a ~70-line block that
+ * mirrored the CLI's `getSettings()` mapping: it reads the persisted
+ * `config.json` shape and projects the relevant fields onto `context.meta`
+ * so the settings panel, autonomy engine, fallback chain, feature toggles,
+ * and Telegram extension state all reflect the persisted config on first
+ * connect — before any `prefs.update` arrives.
+ *
+ * Pure config → meta projection. No behaviour change.
+ */
+import type { Config } from '@wrongstack/core/types';
+/**
+ * Seed `context.meta` from the loaded config. Mirrors the CLI's
+ * `getSettings()` mapping so TUI and WebUI agree. Without this the snapshot
+ * is empty and every browser shows localStorage defaults (autonomy "off",
+ * etc.) regardless of what config.json says.
+ *
+ * The `context` is typed structurally so this module does not take a
+ * dependency on the higher `Context` class — anything with a writable
+ * `meta: Record<string, unknown>` works.
+ */
+export declare function seedContextMeta(config: Config, context: {
+    meta: Record<string, unknown>;
+}): void;
+//# sourceMappingURL=context-meta.d.ts.map

package/dist/server/context-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-meta.d.ts","sourceRoot":"","sources":["../../src/server/context-meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GACzC,IAAI,CAyEN"}