@wrongstack/webui-server 0.302.0 → 0.303.0

package/dist/server/agent-roster-handlers.d.ts

@@ -44,18 +44,19 @@ export interface AgentRosterHandlerOptions {
      * clients refresh the affected roster card without a manual reload.
      */
     broadcast?: (msg: WSServerMessage) => void;
+    /**
+     * Live read of `fleet.learning.autoOptimize`. Optional: without it the
+     * status endpoint reports the built-in defaults, which is still the right
+     * answer for a host that never overrode them.
+     */
+    getAutoOptimizeSettings?: (() => Record<string, unknown> | undefined) | undefined;
 }
 export declare class AgentRosterWSHandler {
     private readonly getProjectRoot;
     private readonly getLlm;
     private readonly broadcast;
+    private readonly getAutoOptimizeSettings;
     constructor(opts: AgentRosterHandlerOptions);
-    /**
-     * Run the consolidation LLM synthesis headlessly and return the cleaned
-     * document text. Returns undefined when no LLM is available so the caller
-     * can fall back to the instruction-only path.
-     */
-    private synthesizeConsolidation;
     /** Handle an incoming client message. Returns a response payload. */
     handleMessage(_ws: WebSocket, type: string, payload: unknown): Promise<WSServerMessage>;
 }

package/dist/server/codemap-cache.d.ts

@@ -3,7 +3,19 @@ export interface CodemapCacheEntry {
     /** Pre-serialized JSON body — avoids re-stringify on cache hits. */
     body: string;
 }
-/** Filesystem fingerprint of the index DB used as the cache generation key. */
+/**
+ * Filesystem fingerprint of the index DB used as the cache generation key.
+ *
+ * The index uses WAL mode (`PRAGMA journal_mode = WAL`), so indexer writes land
+ * in `index.db-wal` and only move into `index.db` on a checkpoint. Fingerprinting
+ * `index.db` alone returns the same mtime/size across an entire indexing run,
+ * which makes a stale empty-graph response cached before the first successful
+ * index look like a permanent cache hit — the CodeMap canvas shows
+ * "No indexed nodes at this level" indefinitely.
+ *
+ * Including the WAL file's mtime/size (and falling back gracefully when no WAL
+ * exists yet) ensures the fingerprint changes as soon as the indexer writes.
+ */
 export declare function indexDbVersion(projectRoot: string, indexDir?: string): string;
 export declare function codemapCacheKey(projectRoot: string, indexDir: string | undefined, scope: string): string;
 export declare function getCachedCodemapBody(key: string, version: string): string | undefined;

package/dist/server/connections-health-route.d.ts

@@ -1,10 +1,10 @@
 import type { TrustBoundary } from '@wrongstack/core/security';
-import { authorizeWebUIAction } from './privileged-actions.js';
 import type { WebSocket } from 'ws';
+import { authorizeWebUIAction } from './privileged-actions.js';
 import type { WSClientMessage, WSServerMessage } from './types.js';
 export type ConnectionHealthStatus = 'healthy' | 'degraded' | 'offline' | 'unavailable' | 'error';
 export interface ConnectionHealthService {
-    id: 'webui' | 'chronicle' | 'codebase-index' | 'sage' | 'kanban' | 'mailbox' | 'governance';
+    id: 'webui' | 'session-catalog' | 'chronicle' | 'codebase-index' | 'sage' | 'kanban' | 'mailbox' | 'governance';
     label: string;
     status: ConnectionHealthStatus;
     required: boolean;

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

@@ -7,10 +7,15 @@ type OutboundMessage = {
     payload: unknown;
 };
 export interface ConversationRunControl {
-    /** Return a controller when acquired, or undefined when this host is busy. */
-    begin(ws: WebSocket): AbortController | undefined;
-    end(ws: WebSocket, controller: AbortController): void;
-    abort(ws: WebSocket): void;
+    /**
+     * Acquire a run controller for the given session.
+     * Return a controller when acquired, or undefined when this host is busy.
+     */
+    begin(ws: WebSocket, sessionId: string): AbortController | undefined;
+    /** Release the controller for the given session after the run completes. */
+    end(ws: WebSocket, sessionId: string, controller: AbortController): void;
+    /** Abort only the run belonging to `sessionId`, leaving other sessions intact. */
+    abort(ws: WebSocket, sessionId: string): void;
 }
 export interface ConversationOperationsContext {
     getAgent: () => Agent;

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

@@ -73,7 +73,8 @@ export declare function createEmbeddedProviderOperations(ctx: EmbeddedProviderCo
 };
 export interface EmbeddedConversationContext extends EmbeddedHostTransport {
     agent: Agent;
-    abortControllers: Map<WebSocket, AbortController>;
+    /** Session-keyed abort controllers — one active run per session. */
+    abortControllers: Map<string, AbortController>;
     pendingConfirms: Map<string, PendingConfirm>;
 }
 export declare function createEmbeddedConversationRoutes(ctx: EmbeddedConversationContext): ConversationRouteHandlers;
@@ -92,10 +93,10 @@ export interface EmbeddedSessionContext extends EmbeddedHostTransport {
     opts: EmbeddedSessionOptions;
     buildSessionStart: (overrides?: Record<string, unknown>) => Promise<unknown>;
     getCustomModeStore: () => Promise<CustomModeStore>;
-    /** Abort the in-flight agent run before session.new/resume swaps the session. */
-    abortActiveRun?: (() => 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?: (() => boolean) | undefined;
+    isRunActive?: ((sessionId?: string) => boolean) | undefined;
 }
 export declare function createEmbeddedSessionRoutes(ctx: EmbeddedSessionContext): SessionRouteHandlers;
 export declare function broadcastEmbeddedGoalSnapshot(ctx: EmbeddedSessionContext): Promise<void>;
@@ -103,7 +104,8 @@ export interface EmbeddedProjectContext extends EmbeddedHostTransport {
     opts: EmbeddedSessionOptions & {
         globalConfigPath?: string | undefined;
     };
-    abortControllers: Map<WebSocket, AbortController>;
+    /** Session-keyed — same instance as EmbeddedConversationContext. */
+    abortControllers: Map<string, AbortController>;
     abortLegacyRun: () => void;
     buildSessionStart: (overrides?: Record<string, unknown>) => Promise<unknown>;
 }