@wrongstack/webui-server 0.302.2 → 0.305.0

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

@@ -12,22 +12,41 @@ export interface WorklistContext {
     send: (ws: WebSocket, msg: WSServerMessage) => void;
     broadcast: (msg: WSServerMessage) => void;
     replaceTodos?: ((todos: TodoItem[]) => void) | undefined;
+    mutateTodos?: ((todos: TodoItem[]) => Promise<{
+        todos: TodoItem[];
+        warnings?: string[] | undefined;
+    }>) | undefined;
+    mutateTaskStatus?: ((id: string, status: 'pending' | 'in_progress' | 'blocked' | 'failed' | 'review' | 'completed') => Promise<{
+        ok: boolean;
+        message: string;
+    }>) | undefined;
+    mutatePlan?: ((operation: {
+        action: 'template_use';
+        template: string;
+    } | {
+        action: 'status';
+        target: string;
+        status: 'open' | 'in_progress' | 'done';
+    }) => Promise<{
+        ok: boolean;
+        message: string;
+    }>) | undefined;
 }
 export interface WorklistMessage {
     type: string;
     payload?: unknown;
 }
 export declare function handleTodosGet(ctx: WorklistContext, ws: WebSocket): void;
-export declare function handleTodosClear(ctx: WorklistContext, ws: WebSocket): void;
+export declare function handleTodosClear(ctx: WorklistContext, ws: WebSocket): Promise<void>;
 export declare function handleTodosRemove(ctx: WorklistContext, ws: WebSocket, payload: {
     id?: string | undefined;
     index?: number | undefined;
-} | undefined): void;
+} | undefined): Promise<void>;
 export declare function handleTodoUpdate(ctx: WorklistContext, ws: WebSocket, payload: {
-    id: string;
+    id?: string | undefined;
     status?: TodoItem['status'] | undefined;
     activeForm?: string | undefined;
-}): void;
+} | undefined): Promise<void>;
 export declare function handleTasksGet(ctx: WorklistContext, ws: WebSocket): Promise<void>;
 export declare function handleTaskUpdate(ctx: WorklistContext, ws: WebSocket, payload: {
     id: string;

package/dist/server/handlers.js

@@ -55,12 +55,34 @@ function handleTodosGet(ctx, ws) {
     payload: sessionPayload(ctx, { todos: [...ctx.context.todos] })
   });
 }
-function handleTodosClear(ctx, ws) {
-  ctx.replaceTodos?.([]);
-  sendResult(ctx, ws, true, "Todos cleared");
-  ctx.broadcast({ type: "todos.updated", payload: sessionPayload(ctx, { todos: [] }) });
+async function commitTodos(ctx, todos) {
+  if (ctx.mutateTodos) {
+    const result = await ctx.mutateTodos(todos);
+    return { todos: result.todos, warnings: result.warnings ?? [] };
+  }
+  ctx.replaceTodos?.(todos);
+  return { todos: [...todos], warnings: [] };
+}
+function managedProjectionMessage() {
+  return "Kanban-bound todos are task projections. Change or remove the task from Kanban.";
 }
-function handleTodosRemove(ctx, ws, payload) {
+async function handleTodosClear(ctx, ws) {
+  if (ctx.context.todos.some((todo) => todo.kanbanBoardId && todo.kanbanTaskId)) {
+    sendResult(ctx, ws, false, managedProjectionMessage());
+    return;
+  }
+  try {
+    const result = await commitTodos(ctx, []);
+    sendResult(ctx, ws, true, "Todos cleared");
+    ctx.broadcast({
+      type: "todos.updated",
+      payload: sessionPayload(ctx, { todos: result.todos })
+    });
+  } catch (error) {
+    sendResult(ctx, ws, false, error instanceof Error ? error.message : String(error));
+  }
+}
+async function handleTodosRemove(ctx, ws, payload) {
   if (!payload) {
     sendResult(ctx, ws, false, "Missing id or index");
     return;
@@ -77,12 +99,27 @@ function handleTodosRemove(ctx, ws, payload) {
     sendResult(ctx, ws, false, "Todo not found");
     return;
   }
+  if (removed.kanbanBoardId && removed.kanbanTaskId) {
+    sendResult(ctx, ws, false, managedProjectionMessage());
+    return;
+  }
   const next = [...todos.slice(0, targetIndex), ...todos.slice(targetIndex + 1)];
-  ctx.replaceTodos?.(next);
-  sendResult(ctx, ws, true, `Removed: ${removed.content}`);
-  ctx.broadcast({ type: "todos.updated", payload: sessionPayload(ctx, { todos: next }) });
+  try {
+    const result = await commitTodos(ctx, next);
+    sendResult(ctx, ws, true, `Removed: ${removed.content}`);
+    ctx.broadcast({
+      type: "todos.updated",
+      payload: sessionPayload(ctx, { todos: result.todos })
+    });
+  } catch (error) {
+    sendResult(ctx, ws, false, error instanceof Error ? error.message : String(error));
+  }
 }
-function handleTodoUpdate(ctx, ws, payload) {
+async function handleTodoUpdate(ctx, ws, payload) {
+  if (!payload || typeof payload.id !== "string" || payload.status !== void 0 && payload.status !== "pending" && payload.status !== "in_progress" && payload.status !== "completed" || payload.activeForm !== void 0 && typeof payload.activeForm !== "string") {
+    sendResult(ctx, ws, false, "Invalid todo update payload");
+    return;
+  }
   const index = ctx.context.todos.findIndex((todo) => todo.id === payload.id);
   const existing = ctx.context.todos[index];
   if (index === -1 || !existing) {
@@ -95,9 +132,25 @@ function handleTodoUpdate(ctx, ws, payload) {
     status: payload.status ?? existing.status,
     activeForm: payload.activeForm !== void 0 ? payload.activeForm : existing.activeForm
   };
-  ctx.replaceTodos?.(next);
-  sendResult(ctx, ws, true, `Todo "${existing.content}" updated`);
-  ctx.broadcast({ type: "todos.updated", payload: sessionPayload(ctx, { todos: next }) });
+  try {
+    const result = await commitTodos(ctx, next);
+    const projected = result.todos.find((todo) => todo.id === existing.id);
+    const requestedStatus = payload.status ?? existing.status;
+    const projectionRejected = Boolean(existing.kanbanBoardId && existing.kanbanTaskId) && projected?.status !== requestedStatus;
+    const warning = result.warnings[0];
+    sendResult(
+      ctx,
+      ws,
+      !projectionRejected,
+      projectionRejected ? warning ?? `Kanban kept "${existing.content}" at ${projected?.status ?? "its current state"}.` : warning ? `Todo "${existing.content}" updated. ${warning}` : `Todo "${existing.content}" updated`
+    );
+    ctx.broadcast({
+      type: "todos.updated",
+      payload: sessionPayload(ctx, { todos: result.todos })
+    });
+  } catch (error) {
+    sendResult(ctx, ws, false, error instanceof Error ? error.message : String(error));
+  }
 }
 async function handleTasksGet(ctx, ws) {
   const taskPath = taskPathOf(ctx);
@@ -125,14 +178,32 @@ async function handleTaskUpdate(ctx, ws, payload) {
     return;
   }
   try {
-    const file = await mutateTasks(taskPath, currentSessionId(ctx), async (tasks) => {
-      const task = tasks.tasks.find((candidate) => candidate.id === payload.id);
-      if (!task) return tasks;
-      task.status = payload.status;
-      task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      return tasks;
-    });
-    sendResult(ctx, ws, true, `Task status updated to "${payload.status}".`);
+    let file;
+    if (ctx.mutateTaskStatus) {
+      const result = await ctx.mutateTaskStatus(payload.id, payload.status);
+      if (!result.ok) {
+        sendResult(ctx, ws, false, result.message);
+        return;
+      }
+      file = await loadTasks(taskPath);
+      if (!file) throw new Error("Task mutation succeeded but its persisted snapshot is missing.");
+      sendResult(ctx, ws, true, result.message);
+    } else {
+      let matched = false;
+      file = await mutateTasks(taskPath, currentSessionId(ctx), async (tasks) => {
+        const task = tasks.tasks.find((candidate) => candidate.id === payload.id);
+        if (!task) return tasks;
+        matched = true;
+        task.status = payload.status;
+        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return tasks;
+      });
+      if (!matched) {
+        sendResult(ctx, ws, false, `Task "${payload.id}" not found.`);
+        return;
+      }
+      sendResult(ctx, ws, true, `Task status updated to "${payload.status}".`);
+    }
     ctx.broadcast({
       type: "tasks.updated",
       payload: sessionPayload(ctx, { tasks: file.tasks })
@@ -179,6 +250,18 @@ async function handlePlanTemplateUse(ctx, ws, template) {
     return;
   }
   try {
+    if (ctx.mutatePlan) {
+      const result = await ctx.mutatePlan({ action: "template_use", template });
+      if (!result.ok) {
+        sendResult(ctx, ws, false, result.message);
+        return;
+      }
+      const plan2 = await loadPlan(planPath);
+      if (!plan2) throw new Error("Plan mutation succeeded but its persisted snapshot is missing.");
+      sendResult(ctx, ws, true, result.message);
+      ctx.broadcast({ type: "plan.updated", payload: sessionPayload(ctx, { plan: plan2 }) });
+      return;
+    }
     const templateDefinition = getPlanTemplate(template);
     if (!templateDefinition) {
       sendResult(ctx, ws, false, `Unknown template "${template}".`);
@@ -207,6 +290,22 @@ async function handlePlanItemUpdate(ctx, ws, payload) {
     return;
   }
   try {
+    if (ctx.mutatePlan) {
+      const result = await ctx.mutatePlan({
+        action: "status",
+        target: payload.target,
+        status: payload.status
+      });
+      if (!result.ok) {
+        sendResult(ctx, ws, false, result.message);
+        return;
+      }
+      const plan2 = await loadPlan(planPath);
+      if (!plan2) throw new Error("Plan mutation succeeded but its persisted snapshot is missing.");
+      sendResult(ctx, ws, true, result.message);
+      ctx.broadcast({ type: "plan.updated", payload: sessionPayload(ctx, { plan: plan2 }) });
+      return;
+    }
     let changed = false;
     const plan = await mutatePlan(planPath, currentSessionId(ctx), async (currentPlan) => {
       const before = currentPlan.updatedAt;
@@ -230,13 +329,17 @@ async function handleWorklistMessage(ctx, ws, message) {
       handleTodosGet(ctx, ws);
       return;
     case "todos.clear":
-      handleTodosClear(ctx, ws);
+      await handleTodosClear(ctx, ws);
       return;
     case "todos.remove":
-      handleTodosRemove(ctx, ws, message.payload);
+      await handleTodosRemove(
+        ctx,
+        ws,
+        message.payload
+      );
       return;
     case "todo.update":
-      handleTodoUpdate(
+      await handleTodoUpdate(
         ctx,
         ws,
         message.payload

package/dist/server/kanban-contract-routes.d.ts

@@ -0,0 +1,8 @@
+import type { WebSocket } from 'ws';
+import type { WSServerMessage } from './types.js';
+export interface KanbanContractRouteContext {
+    projectRoot: string;
+    broadcast?: ((msg: WSServerMessage) => void) | undefined;
+}
+export declare function handleKanbanContractRoute(ws: WebSocket, type: string, payload: Record<string, unknown> | undefined, ctx: KanbanContractRouteContext): Promise<boolean>;
+//# sourceMappingURL=kanban-contract-routes.d.ts.map

package/dist/server/kanban-route-protocol.d.ts

@@ -1,2 +1,2 @@
-export declare const KANBAN_CLIENT_MESSAGE_TYPES: readonly ['kanban.capabilities', 'kanban.column.add', 'kanban.column.remove', 'kanban.create', 'kanban.decomposition.approve', 'kanban.decomposition.reject', 'kanban.delete', 'kanban.duplicate', 'kanban.generate', 'kanban.get', 'kanban.health', 'kanban.list', 'kanban.snapshot', 'kanban.supervisor.audit', 'kanban.supervisor.status', 'kanban.task.activity', 'kanban.task.activity.add', 'kanban.task.add', 'kanban.task.assign', 'kanban.task.chain', 'kanban.task.chain.get', 'kanban.task.check.add', 'kanban.task.check.update', 'kanban.task.claim', 'kanban.task.copy', 'kanban.task.dispatch', 'kanban.task.get', 'kanban.task.merge', 'kanban.task.metric.add', 'kanban.task.metric.update', 'kanban.task.move', 'kanban.task.note.add', 'kanban.task.ready', 'kanban.task.release', 'kanban.task.remove', 'kanban.task.split', 'kanban.task.transfer', 'kanban.task.transition', 'kanban.task.update', 'kanban.task.verify', 'kanban.taskgraph.export', 'kanban.taskgraph.sync', 'kanban.update'];
+export declare const KANBAN_CLIENT_MESSAGE_TYPES: readonly ['kanban.capabilities', 'kanban.contract.configure', 'kanban.contract.edge.add', 'kanban.contract.edge.remove', 'kanban.contract.get', 'kanban.contract.node.remove', 'kanban.contract.node.upsert', 'kanban.create', 'kanban.decomposition.approve', 'kanban.decomposition.reject', 'kanban.delete', 'kanban.duplicate', 'kanban.generate', 'kanban.get', 'kanban.health', 'kanban.list', 'kanban.snapshot', 'kanban.supervisor.audit', 'kanban.supervisor.status', 'kanban.task.activity', 'kanban.task.activity.add', 'kanban.task.add', 'kanban.task.assign', 'kanban.task.chain', 'kanban.task.chain.get', 'kanban.task.check.add', 'kanban.task.check.update', 'kanban.task.claim', 'kanban.task.copy', 'kanban.task.dispatch', 'kanban.task.get', 'kanban.task.merge', 'kanban.task.metric.add', 'kanban.task.metric.update', 'kanban.task.move', 'kanban.task.note.add', 'kanban.task.ready', 'kanban.task.release', 'kanban.task.remove', 'kanban.task.split', 'kanban.task.transfer', 'kanban.task.transition', 'kanban.task.update', 'kanban.task.verify', 'kanban.taskgraph.export', 'kanban.taskgraph.sync', 'kanban.update', 'kanban.workbench'];
 //# sourceMappingURL=kanban-route-protocol.d.ts.map

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

@@ -1,10 +1,10 @@
 import type { Context } from '@wrongstack/core/agent';
 import type { WebSocket } from 'ws';
-import type { WSClientMessage, WSServerMessage } from './types.js';
 import { type KanbanTaskDispatcher } from './kanban-dispatch.js';
 import type { KanbanSupervisor } from './kanban-supervisor.js';
+import type { WSClientMessage, WSServerMessage } from './types.js';
+export { type KanbanBoardPage, paginateKanbanBoards } from './kanban-route-pagination.js';
 export { KANBAN_CLIENT_MESSAGE_TYPES } from './kanban-route-protocol.js';
-export { paginateKanbanBoards, type KanbanBoardPage } from './kanban-route-pagination.js';
 export interface KanbanRouteContext {
     projectRoot: string;
     context?: Context | undefined;

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

@@ -90,6 +90,12 @@ export declare function handleSageDelete(ws: WebSocket, msg: unknown, memoryStor
  * - otherwise returns the freshly-restored memory
  */
 export declare function handleSageRecover(ws: WebSocket, msg: unknown, memoryStore: MemoryPort): Promise<void>;
+/**
+ * List review-queue candidates (hygiene / triage proposals).
+ * Request:  { type: 'memory.sage.listCandidates', payload?: { includeResolved?: boolean } }
+ * Response: { type: 'memory.sage.listCandidates', payload: { candidates } }
+ */
+export declare function handleSageListCandidates(ws: WebSocket, msg: unknown, memoryStore: MemoryPort): Promise<void>;
 /**
  * Resolve a pending hygiene review candidate (PR #1).
  * Request:  { type: 'memory.sage.candidateResolve', payload: { candidateId, action: 'accept'|'reject', reason? } }

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

@@ -26,8 +26,8 @@ export interface ModeHandlersContext {
     modelCapabilities: ModelCapabilities;
     context: Context;
     toolRegistry: ToolRegistry;
-    config: Pick<Config, 'provider' | 'model' | 'systemPrompt'>;
-    getConfig?: () => Pick<Config, 'provider' | 'model' | 'systemPrompt'>;
+    config: Pick<Config, 'provider' | 'model' | 'systemPrompt' | 'features'>;
+    getConfig?: () => Pick<Config, 'provider' | 'model' | 'systemPrompt' | 'features'>;
     projectRoot: string;
     globalRoot: string;
     clients: Map<WebSocket, ConnectedClient>;

package/dist/server/pre-context-services.d.ts

@@ -21,8 +21,8 @@
  */
 import { Context } from '@wrongstack/core/agent';
 import { DefaultPromptLoader, DefaultSkillLoader } from '@wrongstack/core/execution';
-import { type Container, EventBus } from '@wrongstack/core/kernel';
 import { DefaultTokenCounter } from '@wrongstack/core/infrastructure';
+import { type Container, EventBus } from '@wrongstack/core/kernel';
 import { DefaultModeStore } from '@wrongstack/core/models';
 import { ProviderRegistry, ToolRegistry } from '@wrongstack/core/registry';
 import { SkillInstaller } from '@wrongstack/core/skills';

package/dist/server/server-runtime.d.ts

@@ -1,6 +1,18 @@
+/**
+ * Server lifecycle helpers for the standalone WebUI server.
+ *
+ * Phase 1e of the god-module split: the port resolution, WS auth/server
+ * creation, event arming, session-start payload builder, HTTP server
+ * startup, and graceful shutdown registration all moved here from
+ * `start-webui.ts` so the orchestrator reads as connect-the-dots.
+ *
+ * Each function is a pure construction step — no behaviour change. The
+ * WS/HTTP/shutdown wiring that used to be inline (~370 lines) now lives
+ * behind four focused entry points.
+ */
 import type { Config, ModelsRegistry } from '@wrongstack/core/types';
-import { WebSocketServer, type WebSocket } from 'ws';
-import { setupEvents, type FileWatcherMetrics } from './setup-events.js';
+import { type WebSocket, WebSocketServer } from 'ws';
+import { type FileWatcherMetrics, setupEvents } from './setup-events.js';
 import type { ConnectedClient } from './types.js';
 interface ResolvedPorts {
     wsHost: string;

package/dist/server/setup-events-status-watcher.d.ts

@@ -1,8 +1,8 @@
 import type { EventName, Listener } from '@wrongstack/core/kernel';
 import type { WstackPaths } from '@wrongstack/core/utils';
 import type { WebSocket } from 'ws';
-import type { ConnectedClient, WSServerMessage } from './types.js';
 import { type FileWatcherMetrics } from './setup-events-watcher.js';
+import type { ConnectedClient, WSServerMessage } from './types.js';
 export interface SetupEventsStatusWatcherDeps {
     wpaths?: WstackPaths | undefined;
     watcherMetrics?: FileWatcherMetrics | undefined;

package/dist/server/ws-utils.d.ts

@@ -7,7 +7,7 @@ export declare const WEBUI_WS_MAX_BUFFERED_BYTES: number;
  * A socket above the cap cannot be trusted to catch up: keeping it alive would
  * let `ws` retain every subsequent broadcast in memory.
  */
-export declare function sendSerialized(ws: WebSocket, data: string): boolean;
+export declare function sendSerialized(ws: WebSocket, data: string, frameBytes?: number): boolean;
 /**
  * Send a JSON message to a single WebSocket client.
  * No-op when the socket is not in OPEN state (disconnected / closing).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/webui-server",
-  "version": "0.302.2",
+  "version": "0.305.0",
   "license": "MIT",
   "description": "WrongStack WebUI HTTP/WebSocket server module — extracted from @wrongstack/webui in PR #243/244 to remove the CLI -> @wrongstack/webui/server cross-package edge (audit §3.1.1). Pure backend: HTTP routes, WebSocket handlers, MCP tool wrappers, HTML serving. The web frontend lives in @wrongstack/webui; this package is the standalone server it can run on.",
   "keywords": [
@@ -40,16 +40,16 @@
   ],
   "dependencies": {
     "ws": "^8.21.1",
-    "@wrongstack/core": "0.302.2",
-    "@wrongstack/sdd": "0.302.2",
-    "@wrongstack/mcp": "0.302.2",
-    "@wrongstack/providers": "0.302.2",
-    "@wrongstack/kanban": "0.302.2",
-    "@wrongstack/sage": "0.302.2",
-    "@wrongstack/requirement-intake": "0.302.2",
-    "@wrongstack/runtime": "0.302.2",
-    "@wrongstack/techstack": "0.302.2",
-    "@wrongstack/tools": "0.302.2"
+    "@wrongstack/runtime": "0.305.0",
+    "@wrongstack/mcp": "0.305.0",
+    "@wrongstack/providers": "0.305.0",
+    "@wrongstack/kanban": "0.305.0",
+    "@wrongstack/core": "0.305.0",
+    "@wrongstack/requirement-intake": "0.305.0",
+    "@wrongstack/techstack": "0.305.0",
+    "@wrongstack/sage": "0.305.0",
+    "@wrongstack/tools": "0.305.0",
+    "@wrongstack/sdd": "0.305.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",