@grackle-ai/server 0.14.10 → 0.15.1

package/dist/ws-bridge.js

@@ -4,12 +4,13 @@ import { grackle, powerline } from "@grackle-ai/common";
 import * as envRegistry from "./env-registry.js";
 import * as sessionStore from "./session-store.js";
 import * as adapterManager from "./adapter-manager.js";
-import { reconnectOrProvision } from "./adapters/adapter.js";
+import { reconnectOrProvision, } from "./adapters/adapter.js";
 import * as streamHub from "./stream-hub.js";
 import * as tokenBroker from "./token-broker.js";
 import * as projectStore from "./project-store.js";
 import * as taskStore from "./task-store.js";
 import * as findingStore from "./finding-store.js";
+import * as personaStore from "./persona-store.js";
 import { v4 as uuid } from "uuid";
 import { join } from "node:path";
 import { LOGS_DIR, DEFAULT_RUNTIME, DEFAULT_MODEL, eventTypeToString, } from "@grackle-ai/common";
@@ -21,6 +22,7 @@ import { buildTaskSystemContext } from "./utils/system-context.js";
 import { slugify } from "./utils/slugify.js";
 import { processEventStream } from "./event-processor.js";
 import { broadcast, setWssInstance } from "./ws-broadcast.js";
+import { buildMcpServersJson } from "./grpc-service.js";
 import { exec } from "./utils/exec.js";
 const GH_CODESPACE_LIST_TIMEOUT_MS = 30_000;
 const GH_CODESPACE_CREATE_TIMEOUT_MS = 300_000;
@@ -108,7 +110,10 @@ async function autoProvisionEnvironment(ws, environmentId, env, logContext) {
     }
     const adapter = adapterManager.getAdapter(env.adapterType);
     if (!adapter) {
-        sendWs(ws, { type: "error", payload: { message: `No adapter for type: ${env.adapterType}` } });
+        sendWs(ws, {
+            type: "error",
+            payload: { message: `No adapter for type: ${env.adapterType}` },
+        });
         return undefined;
     }
     logger.info({ environmentId, ...logContext }, "Auto-provisioning environment");
@@ -121,7 +126,12 @@ async function autoProvisionEnvironment(ws, environmentId, env, logContext) {
             logger.info({ environmentId, stage: provEvent.stage, ...logContext }, "Auto-provision progress");
             broadcast({
                 type: "provision_progress",
-                payload: { environmentId, stage: provEvent.stage, message: provEvent.message, progress: provEvent.progress },
+                payload: {
+                    environmentId,
+                    stage: provEvent.stage,
+                    message: provEvent.message,
+                    progress: provEvent.progress,
+                },
             });
         }
         conn = await adapter.connect(environmentId, config, powerlineToken);
@@ -134,7 +144,12 @@ async function autoProvisionEnvironment(ws, environmentId, env, logContext) {
         logger.info({ environmentId, ...logContext }, "Auto-provision complete");
         broadcast({
             type: "provision_progress",
-            payload: { environmentId, stage: "ready", message: "Environment connected", progress: 1 },
+            payload: {
+                environmentId,
+                stage: "ready",
+                message: "Environment connected",
+                progress: 1,
+            },
         });
         return conn;
     }
@@ -145,9 +160,19 @@ async function autoProvisionEnvironment(ws, environmentId, env, logContext) {
         const errorMessage = err instanceof Error ? err.message : String(err);
         broadcast({
             type: "provision_progress",
-            payload: { environmentId, stage: "error", message: `Auto-provision failed: ${errorMessage}`, progress: 0 },
+            payload: {
+                environmentId,
+                stage: "error",
+                message: `Auto-provision failed: ${errorMessage}`,
+                progress: 0,
+            },
+        });
+        sendWs(ws, {
+            type: "error",
+            payload: {
+                message: `Failed to auto-connect environment ${environmentId}: ${errorMessage}`,
+            },
         });
-        sendWs(ws, { type: "error", payload: { message: `Failed to auto-connect environment ${environmentId}: ${errorMessage}` } });
         return undefined;
     }
 }
@@ -171,34 +196,76 @@ async function startTaskSession(ws, task, options) {
         logger.warn({ taskId: task.id, environmentId }, "startTaskSession failed: environment not found");
         return `Environment not found: ${environmentId}`;
     }
-    // autoProvisionEnvironment already sends a detailed WS error on failure,
-    // so we return undefined to avoid duplicate error messages to the client.
-    const conn = await autoProvisionEnvironment(ws, environmentId, env, { taskId: task.id });
+    const conn = await autoProvisionEnvironment(ws, environmentId, env, {
+        taskId: task.id,
+    });
     if (!conn) {
         return undefined;
     }
+    // Resolve persona
+    const resolvedPersonaId = options?.personaId || task.personaId;
+    const persona = resolvedPersonaId
+        ? personaStore.getPersona(resolvedPersonaId)
+        : undefined;
+    if (resolvedPersonaId && !persona) {
+        return `Persona not found: ${resolvedPersonaId}`;
+    }
     const sessionId = uuid();
-    const runtime = options?.runtime || env.defaultRuntime || DEFAULT_RUNTIME;
-    const model = options?.model || process.env.GRACKLE_DEFAULT_MODEL || DEFAULT_MODEL;
+    const runtime = options?.runtime ||
+        persona?.runtime ||
+        env.defaultRuntime ||
+        DEFAULT_RUNTIME;
+    const model = options?.model ||
+        persona?.model ||
+        process.env.GRACKLE_DEFAULT_MODEL ||
+        DEFAULT_MODEL;
+    const maxTurns = persona?.maxTurns || 0;
     const logPath = join(grackleHome, LOGS_DIR, sessionId);
-    // Re-read task to get latest reviewNotes (important for reject→retry flow)
     const freshTask = taskStore.getTask(task.id) || task;
-    const systemContext = buildTaskSystemContext(freshTask.title, freshTask.description, freshTask.reviewNotes, freshTask.canDecompose);
+    let systemContext = buildTaskSystemContext(freshTask.title, freshTask.description, freshTask.reviewNotes, freshTask.canDecompose);
+    if (persona) {
+        systemContext = persona.systemPrompt + "\n\n" + systemContext;
+    }
     sessionStore.createSession(sessionId, environmentId, runtime, freshTask.title, model, logPath);
     taskStore.setTaskSession(freshTask.id, sessionId);
     taskStore.markTaskStarted(freshTask.id);
-    broadcast({ type: "task_started", payload: { taskId: freshTask.id, sessionId, projectId: freshTask.projectId } });
+    broadcast({
+        type: "task_started",
+        payload: {
+            taskId: freshTask.id,
+            sessionId,
+            projectId: freshTask.projectId,
+        },
+    });
+    let mcpServersJson = "";
+    if (persona) {
+        try {
+            const parsed = JSON.parse(persona.mcpServers || "[]");
+            if (Array.isArray(parsed)) {
+                const mcpServers = parsed;
+                if (mcpServers.length > 0) {
+                    mcpServersJson = buildMcpServersJson(mcpServers);
+                }
+            }
+        }
+        catch {
+            logger.warn("Failed to parse persona.mcpServers JSON; ignoring");
+        }
+    }
     const powerlineReq = create(powerline.SpawnRequestSchema, {
         sessionId,
         runtime,
         prompt: freshTask.title,
         model,
-        maxTurns: 0,
+        maxTurns,
         branch: freshTask.branch,
-        worktreeBasePath: freshTask.branch ? (process.env.GRACKLE_WORKTREE_BASE || "/workspace") : "",
+        worktreeBasePath: freshTask.branch
+            ? process.env.GRACKLE_WORKTREE_BASE || "/workspace"
+            : "",
         systemContext,
         projectId: freshTask.projectId,
         taskId: freshTask.id,
+        mcpServersJson,
     });
     processEventStream(conn.client.spawn(powerlineReq), {
         sessionId,
@@ -215,7 +282,10 @@ async function startTaskSession(ws, task, options) {
                 else if (sess?.status === "failed") {
                     taskStore.markTaskCompleted(freshTask.id, "failed");
                 }
-                broadcast({ type: "task_updated", payload: { taskId: freshTask.id, projectId: freshTask.projectId } });
+                broadcast({
+                    type: "task_updated",
+                    payload: { taskId: freshTask.id, projectId: freshTask.projectId },
+                });
             }
         },
     });
@@ -332,12 +402,18 @@ async function handleMessage(ws, msg, subscriptions) {
             const branch = msg.payload?.branch || "";
             const systemContext = msg.payload?.systemContext || "";
             if (!environmentId || !prompt) {
-                sendWs(ws, { type: "error", payload: { message: "environmentId and prompt required" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "environmentId and prompt required" },
+                });
                 return;
             }
             const env = envRegistry.getEnvironment(environmentId);
             if (!env) {
-                sendWs(ws, { type: "error", payload: { message: `Environment not found: ${environmentId}` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Environment not found: ${environmentId}` },
+                });
                 return;
             }
             // Auto-provision the environment if not already connected
@@ -382,29 +458,59 @@ async function handleMessage(ws, msg, subscriptions) {
             const sessionId = msg.payload?.sessionId;
             const text = msg.payload?.text;
             if (!sessionId || !text) {
-                sendWs(ws, { type: "error", payload: { message: "sessionId and text required" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "sessionId and text required" },
+                });
                 return;
             }
             const session = sessionStore.getSession(sessionId);
             if (!session) {
-                sendWs(ws, { type: "error", payload: { message: `Session not found: ${sessionId}` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Session not found: ${sessionId}` },
+                });
                 return;
             }
             if (session.status !== "waiting_input") {
-                sendWs(ws, { type: "error", payload: { message: `Session ${sessionId} is not currently waiting for input (status: ${session.status})` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: {
+                        message: `Session ${sessionId} is not currently waiting for input (status: ${session.status})`,
+                    },
+                });
                 return;
             }
             const conn = adapterManager.getConnection(session.environmentId);
             if (!conn) {
-                sendWs(ws, { type: "error", payload: { message: `Environment ${session.environmentId} is not connected` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: {
+                        message: `Environment ${session.environmentId} is not connected`,
+                    },
+                });
                 return;
             }
+            // Record the user's input as a session event before forwarding to the agent
+            const userInputEvent = create(grackle.SessionEventSchema, {
+                sessionId,
+                type: grackle.EventType.USER_INPUT,
+                timestamp: new Date().toISOString(),
+                content: text,
+            });
+            if (session.logPath) {
+                logWriter.writeEvent(session.logPath, userInputEvent);
+            }
+            streamHub.publish(userInputEvent);
             try {
                 await conn.client.sendInput(create(powerline.InputMessageSchema, { sessionId, text }));
             }
             catch (err) {
                 const errMessage = err instanceof Error ? err.message : String(err);
-                sendWs(ws, { type: "error", payload: { message: `Failed to send input: ${errMessage}` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Failed to send input: ${errMessage}` },
+                });
             }
             break;
         }
@@ -423,7 +529,10 @@ async function handleMessage(ws, msg, subscriptions) {
                     await conn.client.kill(create(powerline.SessionIdSchema, { id: sessionId }));
                 }
                 catch (err) {
-                    sendWs(ws, { type: "error", payload: { message: `Kill failed: ${err}` } });
+                    sendWs(ws, {
+                        type: "error",
+                        payload: { message: `Kill failed: ${err}` },
+                    });
                     return;
                 }
             }
@@ -482,6 +591,102 @@ async function handleMessage(ws, msg, subscriptions) {
             broadcast({ type: "project_archived", payload: { projectId } });
             break;
         }
+        // ─── Personas ──────────────────────────────────────────
+        case "list_personas": {
+            const rows = personaStore.listPersonas();
+            sendWs(ws, {
+                type: "personas",
+                payload: {
+                    personas: rows.map((r) => ({
+                        id: r.id,
+                        name: r.name,
+                        description: r.description,
+                        systemPrompt: r.systemPrompt,
+                        toolConfig: r.toolConfig,
+                        runtime: r.runtime,
+                        model: r.model,
+                        maxTurns: r.maxTurns,
+                        mcpServers: r.mcpServers,
+                        createdAt: r.createdAt,
+                        updatedAt: r.updatedAt,
+                    })),
+                },
+            });
+            break;
+        }
+        case "create_persona": {
+            const personaName = msg.payload?.name;
+            if (!personaName) {
+                sendWs(ws, { type: "error", payload: { message: "name required" } });
+                return;
+            }
+            const personaSystemPrompt = msg.payload?.systemPrompt;
+            if (!personaSystemPrompt) {
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "systemPrompt required" },
+                });
+                return;
+            }
+            let personaId = slugify(personaName) || uuid().slice(0, 8);
+            const MAX_ID_RETRIES = 10;
+            for (let i = 0; i < MAX_ID_RETRIES && personaStore.getPersona(personaId); i++) {
+                personaId = `${slugify(personaName) || "persona"}-${uuid().slice(0, 4)}`;
+            }
+            personaStore.createPersona(personaId, personaName, msg.payload?.description || "", personaSystemPrompt, msg.payload?.toolConfig || "{}", msg.payload?.runtime || "", msg.payload?.model || "", msg.payload?.maxTurns || 0, msg.payload?.mcpServers || "[]");
+            broadcast({ type: "persona_created", payload: { personaId } });
+            break;
+        }
+        case "get_persona": {
+            const getPersonaId = msg.payload?.personaId;
+            if (!getPersonaId)
+                return;
+            const personaRow = personaStore.getPersona(getPersonaId);
+            if (!personaRow) {
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Persona not found: ${getPersonaId}` },
+                });
+                return;
+            }
+            sendWs(ws, { type: "persona", payload: { persona: personaRow } });
+            break;
+        }
+        case "update_persona": {
+            const updatePersonaId = msg.payload?.personaId;
+            if (!updatePersonaId) {
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "personaId required" },
+                });
+                return;
+            }
+            const existingPersona = personaStore.getPersona(updatePersonaId);
+            if (!existingPersona) {
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Persona not found: ${updatePersonaId}` },
+                });
+                return;
+            }
+            personaStore.updatePersona(updatePersonaId, msg.payload?.name || existingPersona.name, msg.payload?.description || existingPersona.description, msg.payload?.systemPrompt || existingPersona.systemPrompt, msg.payload?.toolConfig || existingPersona.toolConfig, msg.payload?.runtime || existingPersona.runtime, msg.payload?.model || existingPersona.model, msg.payload?.maxTurns || existingPersona.maxTurns, msg.payload?.mcpServers || existingPersona.mcpServers);
+            broadcast({
+                type: "persona_updated",
+                payload: { personaId: updatePersonaId },
+            });
+            break;
+        }
+        case "delete_persona": {
+            const deletePersonaId = msg.payload?.personaId;
+            if (!deletePersonaId)
+                return;
+            personaStore.deletePersona(deletePersonaId);
+            broadcast({
+                type: "persona_deleted",
+                payload: { personaId: deletePersonaId },
+            });
+            break;
+        }
         // ─── Tasks ─────────────────────────────────────────────
         case "list_tasks": {
             const projectId = msg.payload?.projectId;
@@ -510,6 +715,7 @@ async function handleMessage(ws, msg, subscriptions) {
                         depth: r.depth,
                         childTaskIds: childIdsMap.get(r.id) ?? [],
                         canDecompose: r.canDecompose,
+                        personaId: r.personaId,
                     })),
                 },
             });
@@ -519,21 +725,45 @@ async function handleMessage(ws, msg, subscriptions) {
             const projectId = msg.payload?.projectId;
             const title = msg.payload?.title;
             if (!projectId || !title) {
-                sendWs(ws, { type: "error", payload: { message: "projectId and title required" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "projectId and title required" },
+                });
                 return;
             }
             const project = projectStore.getProject(projectId);
             if (!project) {
-                sendWs(ws, { type: "error", payload: { message: `Project not found: ${projectId}` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Project not found: ${projectId}` },
+                });
                 return;
             }
             const parentTaskId = msg.payload?.parentTaskId || "";
             const rawCanDecompose = msg.payload?.canDecompose;
             const canDecompose = typeof rawCanDecompose === "boolean" ? rawCanDecompose : undefined;
+            // Resolve environment: explicit > parent task's env > project default
+            let resolvedEnvId = msg.payload?.environmentId || "";
+            if (!resolvedEnvId && parentTaskId) {
+                const parentTask = taskStore.getTask(parentTaskId);
+                if (parentTask?.environmentId) {
+                    resolvedEnvId = parentTask.environmentId;
+                }
+            }
+            if (!resolvedEnvId) {
+                resolvedEnvId = project.defaultEnvironmentId;
+            }
             const id = uuid().slice(0, 8);
-            taskStore.createTask(id, projectId, title, msg.payload?.description || "", msg.payload?.environmentId || project.defaultEnvironmentId, msg.payload?.dependsOn || [], slugify(project.name), parentTaskId, canDecompose);
+            taskStore.createTask(id, projectId, title, msg.payload?.description || "", resolvedEnvId, msg.payload?.dependsOn || [], slugify(project.name), parentTaskId, canDecompose, msg.payload?.personaId || "");
             const row = taskStore.getTask(id);
-            broadcast({ type: "task_created", payload: { task: row ? { ...row, dependsOn: safeParseJsonArray(row.dependsOn) } : null } });
+            broadcast({
+                type: "task_created",
+                payload: {
+                    task: row
+                        ? { ...row, dependsOn: safeParseJsonArray(row.dependsOn) }
+                        : null,
+                },
+            });
             break;
         }
         case "start_task": {
@@ -542,20 +772,32 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             const task = taskStore.getTask(taskId);
             if (!task) {
-                sendWs(ws, { type: "error", payload: { message: `Task not found: ${taskId}` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Task not found: ${taskId}` },
+                });
                 return;
             }
             if (!["pending", "assigned", "failed"].includes(task.status)) {
-                sendWs(ws, { type: "error", payload: { message: `Task cannot be started (status: ${task.status})` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: {
+                        message: `Task cannot be started (status: ${task.status})`,
+                    },
+                });
                 return;
             }
             if (!taskStore.areDependenciesMet(taskId)) {
-                sendWs(ws, { type: "error", payload: { message: "Task has unmet dependencies" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "Task has unmet dependencies" },
+                });
                 return;
             }
             const startError = await startTaskSession(ws, task, {
                 runtime: msg.payload?.runtime,
                 model: msg.payload?.model,
+                personaId: msg.payload?.personaId || task.personaId || undefined,
             });
             if (startError) {
                 sendWs(ws, { type: "error", payload: { message: startError } });
@@ -587,7 +829,12 @@ async function handleMessage(ws, msg, subscriptions) {
             if (!task)
                 return;
             if (task.status !== "review") {
-                sendWs(ws, { type: "error", payload: { message: `Task cannot be rejected (status: ${task.status})` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: {
+                        message: `Task cannot be rejected (status: ${task.status})`,
+                    },
+                });
                 return;
             }
             // Preserve runtime/model from the previous session so the retry
@@ -597,7 +844,10 @@ async function handleMessage(ws, msg, subscriptions) {
                 : undefined;
             // Store review notes and set status to assigned
             taskStore.updateTask(task.id, task.title, task.description, "assigned", task.environmentId, safeParseJsonArray(task.dependsOn), reviewNotes);
-            broadcast({ type: "task_rejected", payload: { taskId, projectId: task.projectId } });
+            broadcast({
+                type: "task_rejected",
+                payload: { taskId, projectId: task.projectId },
+            });
             // Auto-retry: start a new session with the review feedback
             const freshTask = taskStore.getTask(taskId);
             if (freshTask) {
@@ -615,14 +865,51 @@ async function handleMessage(ws, msg, subscriptions) {
             const taskId = msg.payload?.taskId;
             if (!taskId)
                 return;
+            const deletedTask = taskStore.getTask(taskId);
+            if (!deletedTask) {
+                sendWs(ws, { type: "error", payload: { message: `Task not found: ${taskId}` } });
+                return;
+            }
             const children = taskStore.getChildren(taskId);
             if (children.length > 0) {
-                sendWs(ws, { type: "error", payload: { message: "Cannot delete task with children. Delete children first." } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: {
+                        message: "Cannot delete task with children. Delete children first.",
+                    },
+                });
                 return;
             }
-            const deletedTask = taskStore.getTask(taskId);
-            taskStore.deleteTask(taskId);
-            broadcast({ type: "task_deleted", payload: { taskId, projectId: deletedTask?.projectId } });
+            // Kill active session before deleting the task
+            if (deletedTask.sessionId) {
+                const activeSession = sessionStore.getSession(deletedTask.sessionId);
+                if (activeSession && (activeSession.status === "running" || activeSession.status === "waiting_input")) {
+                    const conn = adapterManager.getConnection(activeSession.environmentId);
+                    if (conn) {
+                        try {
+                            await conn.client.kill(create(powerline.SessionIdSchema, { id: deletedTask.sessionId }));
+                        }
+                        catch (err) {
+                            logger.warn({ taskId, sessionId: deletedTask.sessionId, err }, "Failed to kill session during task deletion");
+                        }
+                    }
+                    sessionStore.updateSession(deletedTask.sessionId, "killed");
+                    streamHub.publish(create(grackle.SessionEventSchema, {
+                        sessionId: deletedTask.sessionId,
+                        type: grackle.EventType.STATUS,
+                        timestamp: new Date().toISOString(),
+                        content: "killed",
+                        raw: "",
+                    }));
+                }
+            }
+            const changes = taskStore.deleteTask(taskId);
+            if (changes === 0) {
+                logger.error({ taskId }, "deleteTask returned 0 changes despite task existing");
+                sendWs(ws, { type: "error", payload: { message: `Failed to delete task ${taskId}: no rows affected` } });
+                return;
+            }
+            broadcast({ type: "task_deleted", payload: { taskId, projectId: deletedTask.projectId } });
             break;
         }
         // ─── Findings ──────────────────────────────────────────
@@ -654,7 +941,10 @@ async function handleMessage(ws, msg, subscriptions) {
             const projectId = msg.payload?.projectId;
             const title = msg.payload?.title;
             if (!projectId || !title) {
-                sendWs(ws, { type: "error", payload: { message: "projectId and title required" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "projectId and title required" },
+                });
                 return;
             }
             const id = uuid().slice(0, 8);
@@ -669,17 +959,27 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             const task = taskStore.getTask(taskId);
             if (!task || !task.branch) {
-                sendWs(ws, { type: "task_diff", payload: { taskId, error: "No branch" } });
+                sendWs(ws, {
+                    type: "task_diff",
+                    payload: { taskId, error: "No branch" },
+                });
                 return;
             }
-            const environmentId = task.environmentId || projectStore.getProject(task.projectId)?.defaultEnvironmentId;
+            const environmentId = task.environmentId ||
+                projectStore.getProject(task.projectId)?.defaultEnvironmentId;
             if (!environmentId) {
-                sendWs(ws, { type: "task_diff", payload: { taskId, error: "No environment" } });
+                sendWs(ws, {
+                    type: "task_diff",
+                    payload: { taskId, error: "No environment" },
+                });
                 return;
             }
             const conn = adapterManager.getConnection(environmentId);
             if (!conn) {
-                sendWs(ws, { type: "task_diff", payload: { taskId, error: "Environment not connected" } });
+                sendWs(ws, {
+                    type: "task_diff",
+                    payload: { taskId, error: "Environment not connected" },
+                });
                 return;
             }
             try {
@@ -701,24 +1001,36 @@ async function handleMessage(ws, msg, subscriptions) {
                 });
             }
             catch (err) {
-                sendWs(ws, { type: "task_diff", payload: { taskId, error: String(err) } });
+                sendWs(ws, {
+                    type: "task_diff",
+                    payload: { taskId, error: String(err) },
+                });
             }
             break;
         }
         case "provision_environment": {
             const environmentId = msg.payload?.environmentId;
             if (!environmentId) {
-                sendWs(ws, { type: "error", payload: { message: "environmentId required" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "environmentId required" },
+                });
                 return;
             }
             const env = envRegistry.getEnvironment(environmentId);
             if (!env) {
-                sendWs(ws, { type: "error", payload: { message: `Environment not found: ${environmentId}` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Environment not found: ${environmentId}` },
+                });
                 return;
             }
             const adapter = adapterManager.getAdapter(env.adapterType);
             if (!adapter) {
-                sendWs(ws, { type: "error", payload: { message: `No adapter for type: ${env.adapterType}` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `No adapter for type: ${env.adapterType}` },
+                });
                 return;
             }
             logger.info({ environmentId, adapterType: env.adapterType }, "Provisioning environment");
@@ -734,7 +1046,12 @@ async function handleMessage(ws, msg, subscriptions) {
                         logger.info({ environmentId, stage: event.stage, message: event.message }, "Provision progress");
                         broadcast({
                             type: "provision_progress",
-                            payload: { environmentId, stage: event.stage, message: event.message, progress: event.progress },
+                            payload: {
+                                environmentId,
+                                stage: event.stage,
+                                message: event.message,
+                                progress: event.progress,
+                            },
                         });
                     }
                     logger.info({ environmentId }, "Provision complete, calling adapter.connect");
@@ -747,7 +1064,12 @@ async function handleMessage(ws, msg, subscriptions) {
                     logger.info({ environmentId }, "Environment connected");
                     broadcast({
                         type: "provision_progress",
-                        payload: { environmentId, stage: "ready", message: "Environment connected", progress: 1 },
+                        payload: {
+                            environmentId,
+                            stage: "ready",
+                            message: "Environment connected",
+                            progress: 1,
+                        },
                     });
                 }
                 catch (err) {
@@ -756,7 +1078,12 @@ async function handleMessage(ws, msg, subscriptions) {
                     const errorMessage = err instanceof Error ? err.message : String(err);
                     broadcast({
                         type: "provision_progress",
-                        payload: { environmentId, stage: "error", message: `Connection failed: ${errorMessage}`, progress: 0 },
+                        payload: {
+                            environmentId,
+                            stage: "error",
+                            message: `Connection failed: ${errorMessage}`,
+                            progress: 0,
+                        },
                     });
                 }
                 broadcastEnvironments();
@@ -766,12 +1093,18 @@ async function handleMessage(ws, msg, subscriptions) {
         case "stop_environment": {
             const environmentId = msg.payload?.environmentId;
             if (!environmentId) {
-                sendWs(ws, { type: "error", payload: { message: "environmentId required" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "environmentId required" },
+                });
                 return;
             }
             const env = envRegistry.getEnvironment(environmentId);
             if (!env) {
-                sendWs(ws, { type: "error", payload: { message: `Environment not found: ${environmentId}` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Environment not found: ${environmentId}` },
+                });
                 return;
             }
             const adapter = adapterManager.getAdapter(env.adapterType);
@@ -789,11 +1122,17 @@ async function handleMessage(ws, msg, subscriptions) {
             const displayName = msg.payload?.displayName || "";
             const adapterType = msg.payload?.adapterType || "";
             if (!displayName || !adapterType) {
-                sendWs(ws, { type: "error", payload: { message: "displayName and adapterType required" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "displayName and adapterType required" },
+                });
                 return;
             }
             if (!adapterManager.getAdapter(adapterType)) {
-                sendWs(ws, { type: "error", payload: { message: `Unknown adapter type: ${adapterType}` } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Unknown adapter type: ${adapterType}` },
+                });
                 return;
             }
             const baseEnvId = slugify(displayName) || uuid().slice(0, 8);
@@ -815,7 +1154,10 @@ async function handleMessage(ws, msg, subscriptions) {
                     JSON.parse(normalized);
                 }
                 catch {
-                    sendWs(ws, { type: "error", payload: { message: "adapterConfig string is not valid JSON" } });
+                    sendWs(ws, {
+                        type: "error",
+                        payload: { message: "adapterConfig string is not valid JSON" },
+                    });
                     return;
                 }
                 adapterConfig = normalized;
@@ -824,7 +1166,12 @@ async function handleMessage(ws, msg, subscriptions) {
                 adapterConfig = JSON.stringify(rawAdapterConfig);
             }
             else {
-                sendWs(ws, { type: "error", payload: { message: "adapterConfig must be an object or JSON string" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: {
+                        message: "adapterConfig must be an object or JSON string",
+                    },
+                });
                 return;
             }
             const defaultRuntime = msg.payload?.defaultRuntime || DEFAULT_RUNTIME;
@@ -837,7 +1184,10 @@ async function handleMessage(ws, msg, subscriptions) {
         case "remove_environment": {
             const environmentId = msg.payload?.environmentId;
             if (!environmentId) {
-                sendWs(ws, { type: "error", payload: { message: "environmentId required" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "environmentId required" },
+                });
                 return;
             }
             const env = envRegistry.getEnvironment(environmentId);
@@ -848,11 +1198,15 @@ async function handleMessage(ws, msg, subscriptions) {
                     try {
                         await adapter.destroy(environmentId, config);
                     }
-                    catch { /* best-effort */ }
+                    catch {
+                        /* best-effort */
+                    }
                     try {
                         await adapter.disconnect(environmentId);
                     }
-                    catch { /* best-effort */ }
+                    catch {
+                        /* best-effort */
+                    }
                 }
             }
             adapterManager.removeConnection(environmentId);
@@ -867,31 +1221,43 @@ async function handleMessage(ws, msg, subscriptions) {
         case "list_codespaces": {
             try {
                 const result = await exec("gh", [
-                    "codespace", "list",
-                    "--json", "name,repository,state,gitStatus",
-                    "--limit", String(GH_CODESPACE_LIST_LIMIT),
+                    "codespace",
+                    "list",
+                    "--json",
+                    "name,repository,state,gitStatus",
+                    "--limit",
+                    String(GH_CODESPACE_LIST_LIMIT),
                 ], { timeout: GH_CODESPACE_LIST_TIMEOUT_MS });
                 const codespaces = JSON.parse(result.stdout || "[]");
                 sendWs(ws, { type: "codespaces_list", payload: { codespaces } });
             }
             catch (err) {
                 logger.warn({ err }, "Failed to list codespaces");
-                sendWs(ws, { type: "codespaces_list", payload: { codespaces: [], error: String(err) } });
+                sendWs(ws, {
+                    type: "codespaces_list",
+                    payload: { codespaces: [], error: String(err) },
+                });
             }
             break;
         }
         case "create_codespace": {
             const repo = msg.payload?.repo;
             if (typeof repo !== "string" || repo.trim().length === 0) {
-                sendWs(ws, { type: "codespace_create_error", payload: { message: "repo required" } });
+                sendWs(ws, {
+                    type: "codespace_create_error",
+                    payload: { message: "repo required" },
+                });
                 return;
             }
             const trimmedRepo = repo.trim();
             try {
                 const result = await exec("gh", [
-                    "codespace", "create",
-                    "--repo", trimmedRepo,
-                    "--machine", "basicLinux32gb",
+                    "codespace",
+                    "create",
+                    "--repo",
+                    trimmedRepo,
+                    "--machine",
+                    "basicLinux32gb",
                 ], { timeout: GH_CODESPACE_CREATE_TIMEOUT_MS });
                 const codespaceName = result.stdout.trim();
                 sendWs(ws, {
@@ -901,7 +1267,10 @@ async function handleMessage(ws, msg, subscriptions) {
             }
             catch (err) {
                 logger.error({ err, repo }, "Failed to create codespace");
-                sendWs(ws, { type: "codespace_create_error", payload: { message: String(err) } });
+                sendWs(ws, {
+                    type: "codespace_create_error",
+                    payload: { message: String(err) },
+                });
             }
             break;
         }
@@ -926,7 +1295,10 @@ async function handleMessage(ws, msg, subscriptions) {
             const name = msg.payload?.name;
             const value = msg.payload?.value;
             if (!name || !value) {
-                sendWs(ws, { type: "error", payload: { message: "name and value required" } });
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: "name and value required" },
+                });
                 return;
             }
             await tokenBroker.setToken({