@grackle-ai/server 0.39.1 → 0.41.0

package/dist/ws-bridge.js

@@ -14,7 +14,10 @@ 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, SESSION_STATUS, TASK_STATUS, eventTypeToString, } from "@grackle-ai/common";
+import { LOGS_DIR, SESSION_STATUS, TASK_STATUS, eventTypeToString, } from "@grackle-ai/common";
+import { resolvePersona } from "./resolve-persona.js";
+import * as settingsStore from "./settings-store.js";
+import { isAllowedSettingKey } from "./settings-store.js";
 import { grackleHome } from "./paths.js";
 import * as logWriter from "./log-writer.js";
 import { safeParseJsonArray } from "./json-helpers.js";
@@ -23,8 +26,11 @@ import { buildTaskSystemContext } from "./utils/system-context.js";
 import { slugify } from "./utils/slugify.js";
 import { processEventStream } from "./event-processor.js";
 import * as processorRegistry from "./processor-registry.js";
-import { broadcast, setWssInstance, broadcastEnvironments, envRowToWs } from "./ws-broadcast.js";
+import { setWssInstance, envRowToWs } from "./ws-broadcast.js";
+import { emit } from "./event-bus.js";
 import { buildMcpServersJson } from "./grpc-service.js";
+import { reanimateAgent } from "./reanimate-agent.js";
+import { ConnectError } from "@connectrpc/connect";
 import { computeTaskStatus } from "./compute-task-status.js";
 import { exec } from "./utils/exec.js";
 import { formatGhError } from "./utils/format-gh-error.js";
@@ -108,20 +114,17 @@ async function autoProvisionEnvironment(ws, environmentId, env, logContext) {
     }
     logger.info({ environmentId, ...logContext }, "Auto-provisioning environment");
     envRegistry.updateEnvironmentStatus(environmentId, "connecting");
-    broadcastEnvironments();
+    emit("environment.changed", {});
     try {
         const config = safeParseAdapterConfig(env.adapterConfig, environmentId);
         const powerlineToken = env.powerlineToken || "";
         for await (const provEvent of reconnectOrProvision(environmentId, adapter, config, powerlineToken, !!env.bootstrapped)) {
             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,
-                },
+            emit("environment.provision_progress", {
+                environmentId,
+                stage: provEvent.stage,
+                message: provEvent.message,
+                progress: provEvent.progress,
             });
         }
         conn = await adapter.connect(environmentId, config, powerlineToken);
@@ -130,32 +133,26 @@ async function autoProvisionEnvironment(ws, environmentId, env, logContext) {
         await tokenBroker.pushToEnv(environmentId);
         envRegistry.updateEnvironmentStatus(environmentId, "connected");
         envRegistry.markBootstrapped(environmentId);
-        broadcastEnvironments();
+        emit("environment.changed", {});
         logger.info({ environmentId, ...logContext }, "Auto-provision complete");
-        broadcast({
-            type: "provision_progress",
-            payload: {
-                environmentId,
-                stage: "ready",
-                message: "Environment connected",
-                progress: 1,
-            },
+        emit("environment.provision_progress", {
+            environmentId,
+            stage: "ready",
+            message: "Environment connected",
+            progress: 1,
         });
         return conn;
     }
     catch (err) {
         logger.error({ environmentId, ...logContext, err }, "Auto-provision failed");
         envRegistry.updateEnvironmentStatus(environmentId, "error");
-        broadcastEnvironments();
+        emit("environment.changed", {});
         const errorMessage = err instanceof Error ? err.message : String(err);
-        broadcast({
-            type: "provision_progress",
-            payload: {
-                environmentId,
-                stage: "error",
-                message: `Auto-provision failed: ${errorMessage}`,
-                progress: 0,
-            },
+        emit("environment.provision_progress", {
+            environmentId,
+            stage: "error",
+            message: `Auto-provision failed: ${errorMessage}`,
+            progress: 0,
         });
         sendWs(ws, {
             type: "error",
@@ -192,51 +189,43 @@ async function startTaskSession(ws, task, options) {
     if (!conn) {
         return undefined;
     }
-    // Resolve persona
-    const resolvedPersonaId = options?.personaId || "";
-    const persona = resolvedPersonaId
-        ? personaStore.getPersona(resolvedPersonaId)
-        : undefined;
-    if (resolvedPersonaId && !persona) {
-        return `Persona not found: ${resolvedPersonaId}`;
+    // Resolve persona via cascade (request → task → project → app default)
+    let resolved;
+    try {
+        resolved = resolvePersona(options?.personaId || "", task.defaultPersonaId, project.defaultPersonaId);
+    }
+    catch (err) {
+        return err.message;
     }
     const sessionId = uuid();
-    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 { runtime, model, maxTurns, systemPrompt, persona: resolvedPersonaRow } = resolved;
     const logPath = join(grackleHome, LOGS_DIR, sessionId);
     const freshTask = taskStore.getTask(task.id) || task;
     let systemContext = buildTaskSystemContext(freshTask.title, freshTask.description, options?.notes || "", freshTask.canDecompose);
-    if (persona) {
-        systemContext = persona.systemPrompt + "\n\n" + systemContext;
+    if (systemPrompt) {
+        systemContext = systemPrompt + "\n\n" + systemContext;
     }
-    sessionStore.createSession(sessionId, environmentId, runtime, freshTask.title, model, logPath, freshTask.id, resolvedPersonaId);
-    broadcast({
-        type: "task_started",
-        payload: {
-            taskId: freshTask.id,
-            sessionId,
-            projectId: freshTask.projectId,
-        },
+    sessionStore.createSession(sessionId, environmentId, runtime, freshTask.title, model, logPath, freshTask.id, resolved.personaId);
+    emit("task.started", {
+        taskId: freshTask.id,
+        sessionId,
+        projectId: freshTask.projectId,
     });
     // Re-push stored tokens + provider credentials (scoped to runtime) so they're fresh for this session.
     // For local envs, skip file tokens — the PowerLine is on the same machine.
     await tokenBroker.refreshTokensForTask(environmentId, runtime, env.adapterType === "local" ? { excludeFileTokens: true } : undefined);
     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);
-                }
+    try {
+        const parsed = JSON.parse(resolvedPersonaRow.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");
-        }
+    }
+    catch {
+        logger.warn("Failed to parse persona.mcpServers JSON; ignoring");
     }
     const powerlineReq = create(powerline.SpawnRequestSchema, {
         sessionId,
@@ -371,8 +360,6 @@ async function handleMessage(ws, msg, subscriptions) {
         case "spawn": {
             const environmentId = msg.payload?.environmentId;
             const prompt = msg.payload?.prompt;
-            const model = msg.payload?.model || undefined;
-            const runtime = msg.payload?.runtime || undefined;
             const branch = msg.payload?.branch || "";
             const systemContext = msg.payload?.systemContext || "";
             const spawnPersonaId = msg.payload?.personaId || "";
@@ -383,10 +370,13 @@ async function handleMessage(ws, msg, subscriptions) {
                 });
                 return;
             }
-            // Resolve persona if specified
-            const spawnPersona = spawnPersonaId ? personaStore.getPersona(spawnPersonaId) : undefined;
-            if (spawnPersonaId && !spawnPersona) {
-                sendWs(ws, { type: "error", payload: { message: `Persona not found: ${spawnPersonaId}` } });
+            // Resolve persona via cascade (request → app default)
+            let resolved;
+            try {
+                resolved = resolvePersona(spawnPersonaId);
+            }
+            catch (err) {
+                sendWs(ws, { type: "error", payload: { message: err.message } });
                 return;
             }
             const env = envRegistry.getEnvironment(environmentId);
@@ -403,13 +393,11 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             }
             const sessionId = uuid();
-            const sessionRuntime = runtime || spawnPersona?.runtime || env.defaultRuntime || DEFAULT_RUNTIME;
-            const sessionModel = model || spawnPersona?.model || process.env.GRACKLE_DEFAULT_MODEL || DEFAULT_MODEL;
-            const maxTurns = spawnPersona?.maxTurns || 0;
+            const { runtime: sessionRuntime, model: sessionModel, maxTurns, systemPrompt: spawnSystemPrompt } = resolved;
             const logPath = join(grackleHome, LOGS_DIR, sessionId);
             let finalSystemContext = systemContext;
-            if (spawnPersona) {
-                finalSystemContext = spawnPersona.systemPrompt + (systemContext ? "\n\n" + systemContext : "");
+            if (spawnSystemPrompt) {
+                finalSystemContext = spawnSystemPrompt + (systemContext ? "\n\n" + systemContext : "");
             }
             sessionStore.createSession(sessionId, environmentId, sessionRuntime, prompt, sessionModel, logPath);
             sendWs(ws, { type: "spawned", payload: { sessionId } });
@@ -532,11 +520,27 @@ async function handleMessage(ws, msg, subscriptions) {
             if (session.taskId) {
                 const task = taskStore.getTask(session.taskId);
                 if (task) {
-                    broadcast({ type: "task_updated", payload: { taskId: task.id, projectId: task.projectId } });
+                    emit("task.updated", { taskId: task.id, projectId: task.projectId });
                 }
             }
             break;
         }
+        case "resume_agent": {
+            const resumeSessionId = msg.payload?.sessionId;
+            if (!resumeSessionId) {
+                sendWs(ws, { type: "error", payload: { message: "sessionId required" } });
+                return;
+            }
+            try {
+                reanimateAgent(resumeSessionId);
+                sendWs(ws, { type: "agent_resumed", payload: { sessionId: resumeSessionId } });
+            }
+            catch (err) {
+                const message = err instanceof ConnectError ? err.message : String(err);
+                sendWs(ws, { type: "error", payload: { message } });
+            }
+            break;
+        }
         // ─── Projects ──────────────────────────────────────────
         case "list_projects": {
             const rows = projectStore.listProjects();
@@ -549,6 +553,7 @@ async function handleMessage(ws, msg, subscriptions) {
                         description: r.description,
                         repoUrl: r.repoUrl,
                         defaultEnvironmentId: r.defaultEnvironmentId,
+                        defaultPersonaId: r.defaultPersonaId,
                         status: r.status,
                         useWorktrees: r.useWorktrees,
                         worktreeBasePath: r.worktreeBasePath,
@@ -575,16 +580,15 @@ async function handleMessage(ws, msg, subscriptions) {
             }
             // useWorktrees defaults to true when not specified
             const createUseWorktrees = msg.payload?.useWorktrees ?? true;
-            projectStore.createProject(id, name, msg.payload?.description || "", msg.payload?.repoUrl || "", msg.payload?.defaultEnvironmentId || "", createUseWorktrees, typeof msg.payload?.worktreeBasePath === "string" ? msg.payload.worktreeBasePath.trim() : "");
-            const row = projectStore.getProject(id);
-            broadcast({ type: "project_created", payload: { project: row } });
+            projectStore.createProject(id, name, msg.payload?.description || "", msg.payload?.repoUrl || "", msg.payload?.defaultEnvironmentId || "", createUseWorktrees, typeof msg.payload?.worktreeBasePath === "string" ? msg.payload.worktreeBasePath.trim() : "", msg.payload?.defaultPersonaId || "");
+            emit("project.created", { projectId: id });
             break;
         }
         case "archive_project": {
             const projectId = msg.payload?.projectId;
             if (projectId)
                 projectStore.archiveProject(projectId);
-            broadcast({ type: "project_archived", payload: { projectId } });
+            emit("project.archived", { projectId });
             break;
         }
         case "update_project": {
@@ -612,6 +616,7 @@ async function handleMessage(ws, msg, subscriptions) {
             }
             const worktreesVal = typeof msg.payload?.useWorktrees === "boolean" ? msg.payload.useWorktrees : undefined;
             const worktreeBasePathVal = typeof msg.payload?.worktreeBasePath === "string" ? msg.payload.worktreeBasePath : undefined;
+            const defaultPersonaIdVal = typeof msg.payload?.defaultPersonaId === "string" ? msg.payload.defaultPersonaId : undefined;
             projectStore.updateProject(projectId, {
                 name: nameVal !== undefined ? nameVal.trim() : undefined,
                 description: descVal,
@@ -619,8 +624,9 @@ async function handleMessage(ws, msg, subscriptions) {
                 defaultEnvironmentId: envVal,
                 useWorktrees: worktreesVal,
                 worktreeBasePath: worktreeBasePathVal,
+                defaultPersonaId: defaultPersonaIdVal,
             });
-            broadcast({ type: "project_updated", payload: { projectId } });
+            emit("project.updated", { projectId });
             break;
         }
         // ─── Personas ──────────────────────────────────────────
@@ -666,7 +672,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 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 } });
+            emit("persona.created", { personaId });
             break;
         }
         case "get_persona": {
@@ -702,10 +708,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 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 },
-            });
+            emit("persona.updated", { personaId: updatePersonaId });
             break;
         }
         case "delete_persona": {
@@ -713,10 +716,45 @@ async function handleMessage(ws, msg, subscriptions) {
             if (!deletePersonaId)
                 return;
             personaStore.deletePersona(deletePersonaId);
-            broadcast({
-                type: "persona_deleted",
-                payload: { personaId: deletePersonaId },
-            });
+            emit("persona.deleted", { personaId: deletePersonaId });
+            break;
+        }
+        // ─── Settings ────────────────────────────────────────────
+        case "get_setting": {
+            const key = msg.payload?.key;
+            if (typeof key !== "string" || !key)
+                return;
+            if (!isAllowedSettingKey(key)) {
+                sendWs(ws, { type: "error", payload: { message: `Setting key not allowed: ${key}` } });
+                return;
+            }
+            const value = settingsStore.getSetting(key) ?? "";
+            sendWs(ws, { type: "setting", payload: { key, value } });
+            break;
+        }
+        case "set_setting": {
+            const key = msg.payload?.key;
+            const value = msg.payload?.value || "";
+            if (typeof key !== "string" || !key)
+                return;
+            if (!isAllowedSettingKey(key)) {
+                sendWs(ws, { type: "error", payload: { message: `Setting key not allowed: ${key}` } });
+                return;
+            }
+            // Validate persona exists and has required fields when setting default_persona_id
+            if (key === "default_persona_id" && value) {
+                const persona = personaStore.getPersona(value);
+                if (!persona) {
+                    sendWs(ws, { type: "error", payload: { message: `Persona not found: ${value}` } });
+                    return;
+                }
+                if (!persona.runtime || !persona.model) {
+                    sendWs(ws, { type: "error", payload: { message: `Persona "${persona.name}" must have runtime and model configured` } });
+                    return;
+                }
+            }
+            settingsStore.setSetting(key, value);
+            emit("setting.changed", { key, value });
             break;
         }
         // ─── Tasks ─────────────────────────────────────────────
@@ -760,6 +798,7 @@ async function handleMessage(ws, msg, subscriptions) {
                             depth: r.depth,
                             childTaskIds: childIdsMap.get(r.id) ?? [],
                             canDecompose: r.canDecompose,
+                            defaultPersonaId: r.defaultPersonaId,
                         };
                     }),
                 },
@@ -794,17 +833,8 @@ async function handleMessage(ws, msg, subscriptions) {
             const canDecompose = typeof rawCanDecompose === "boolean" ? rawCanDecompose : false;
             try {
                 const id = uuid().slice(0, 8);
-                taskStore.createTask(id, projectId, title, msg.payload?.description || "", msg.payload?.dependsOn || [], slugify(project.name), parentTaskId, canDecompose);
-                const row = taskStore.getTask(id);
-                broadcast({
-                    type: "task_created",
-                    payload: {
-                        task: row
-                            ? { ...row, dependsOn: safeParseJsonArray(row.dependsOn) }
-                            : null,
-                        requestId,
-                    },
-                });
+                taskStore.createTask(id, projectId, title, msg.payload?.description || "", msg.payload?.dependsOn || [], slugify(project.name), parentTaskId, canDecompose, msg.payload?.defaultPersonaId || "");
+                emit("task.created", { taskId: id, projectId, requestId });
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : "Failed to create task";
@@ -858,10 +888,7 @@ async function handleMessage(ws, msg, subscriptions) {
                     sendWs(ws, { type: "error", payload: { message: String(err) } });
                     return;
                 }
-                broadcast({
-                    type: "task_started",
-                    payload: { taskId: updateTaskId, sessionId: lateBindSessionId, projectId: existingTask.projectId },
-                });
+                emit("task.started", { taskId: updateTaskId, sessionId: lateBindSessionId, projectId: existingTask.projectId });
                 break;
             }
             // Only allow editing not_started tasks (non-late-bind path)
@@ -886,18 +913,11 @@ async function handleMessage(ws, msg, subscriptions) {
                         .filter((d) => d !== updateTaskId)),
                 ]
                 : safeParseJsonArray(existingTask.dependsOn);
-            taskStore.updateTask(updateTaskId, updatedTitle, updatedDescription, existingTask.status, updatedDependsOn);
-            const updatedRow = taskStore.getTask(updateTaskId);
-            broadcast({
-                type: "task_updated",
-                payload: {
-                    taskId: updateTaskId,
-                    projectId: existingTask.projectId,
-                    task: updatedRow
-                        ? { ...updatedRow, dependsOn: safeParseJsonArray(updatedRow.dependsOn) }
-                        : null,
-                },
-            });
+            const updatedDefaultPersonaId = typeof msg.payload?.defaultPersonaId === "string"
+                ? msg.payload.defaultPersonaId
+                : undefined;
+            taskStore.updateTask(updateTaskId, updatedTitle, updatedDescription, existingTask.status, updatedDependsOn, updatedDefaultPersonaId);
+            emit("task.updated", { taskId: updateTaskId, projectId: existingTask.projectId });
             break;
         }
         case "start_task": {
@@ -933,8 +953,6 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             }
             const startError = await startTaskSession(ws, task, {
-                runtime: msg.payload?.runtime,
-                model: msg.payload?.model,
                 personaId: msg.payload?.personaId || undefined,
                 environmentId: msg.payload?.environmentId || undefined,
                 notes: msg.payload?.notes || undefined,
@@ -959,10 +977,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 },
             });
             if (task) {
-                broadcast({
-                    type: "task_completed",
-                    payload: { taskId, projectId: task.projectId },
-                });
+                emit("task.completed", { taskId, projectId: task.projectId });
             }
             break;
         }
@@ -1015,10 +1030,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 projectId: task.projectId,
                 taskId: task.id,
             });
-            broadcast({
-                type: "task_started",
-                payload: { taskId: task.id, sessionId: latestSession.id, projectId: task.projectId },
-            });
+            emit("task.started", { taskId: task.id, sessionId: latestSession.id, projectId: task.projectId });
             break;
         }
         case "delete_task": {
@@ -1067,7 +1079,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 sendWs(ws, { type: "error", payload: { message: `Failed to delete task ${taskId}: no rows affected` } });
                 return;
             }
-            broadcast({ type: "task_deleted", payload: { taskId, projectId: deletedTask.projectId } });
+            emit("task.deleted", { taskId, projectId: deletedTask.projectId });
             break;
         }
         // ─── Task Sessions ─────────────────────────────────────
@@ -1218,7 +1230,7 @@ async function handleMessage(ws, msg, subscriptions) {
             }
             logger.info({ environmentId, adapterType: env.adapterType }, "Provisioning environment");
             envRegistry.updateEnvironmentStatus(environmentId, "connecting");
-            broadcastEnvironments();
+            emit("environment.changed", {});
             // Run provision in background, broadcasting progress to all connected clients
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
             (async () => {
@@ -1227,14 +1239,11 @@ async function handleMessage(ws, msg, subscriptions) {
                     const powerlineToken = env.powerlineToken || "";
                     for await (const event of reconnectOrProvision(environmentId, adapter, config, powerlineToken, !!env.bootstrapped)) {
                         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,
-                            },
+                        emit("environment.provision_progress", {
+                            environmentId,
+                            stage: event.stage,
+                            message: event.message,
+                            progress: event.progress,
                         });
                     }
                     logger.info({ environmentId }, "Provision complete, calling adapter.connect");
@@ -1245,31 +1254,25 @@ async function handleMessage(ws, msg, subscriptions) {
                     envRegistry.updateEnvironmentStatus(environmentId, "connected");
                     envRegistry.markBootstrapped(environmentId);
                     logger.info({ environmentId }, "Environment connected");
-                    broadcast({
-                        type: "provision_progress",
-                        payload: {
-                            environmentId,
-                            stage: "ready",
-                            message: "Environment connected",
-                            progress: 1,
-                        },
+                    emit("environment.provision_progress", {
+                        environmentId,
+                        stage: "ready",
+                        message: "Environment connected",
+                        progress: 1,
                     });
                 }
                 catch (err) {
                     logger.error({ environmentId, err }, "Provision failed");
                     envRegistry.updateEnvironmentStatus(environmentId, "error");
                     const errorMessage = err instanceof Error ? err.message : String(err);
-                    broadcast({
-                        type: "provision_progress",
-                        payload: {
-                            environmentId,
-                            stage: "error",
-                            message: `Connection failed: ${errorMessage}`,
-                            progress: 0,
-                        },
+                    emit("environment.provision_progress", {
+                        environmentId,
+                        stage: "error",
+                        message: `Connection failed: ${errorMessage}`,
+                        progress: 0,
                     });
                 }
-                broadcastEnvironments();
+                emit("environment.changed", {});
             })();
             break;
         }
@@ -1298,7 +1301,7 @@ async function handleMessage(ws, msg, subscriptions) {
             adapterManager.removeConnection(environmentId);
             envRegistry.updateEnvironmentStatus(environmentId, "disconnected");
             logger.info({ environmentId }, "Environment stopped");
-            broadcastEnvironments();
+            emit("environment.changed", {});
             break;
         }
         case "add_environment": {
@@ -1357,11 +1360,10 @@ async function handleMessage(ws, msg, subscriptions) {
                 });
                 return;
             }
-            const defaultRuntime = msg.payload?.defaultRuntime || DEFAULT_RUNTIME;
-            envRegistry.addEnvironment(id, displayName, adapterType, adapterConfig, defaultRuntime);
+            envRegistry.addEnvironment(id, displayName, adapterType, adapterConfig);
             logger.info({ id, displayName, adapterType }, "Environment added via WebSocket");
-            broadcast({ type: "environment_added", payload: { environmentId: id } });
-            broadcastEnvironments();
+            emit("environment.added", { environmentId: id });
+            emit("environment.changed", {});
             break;
         }
         case "remove_environment": {
@@ -1396,8 +1398,8 @@ async function handleMessage(ws, msg, subscriptions) {
             sessionStore.deleteByEnvironment(environmentId);
             envRegistry.removeEnvironment(environmentId);
             logger.info({ environmentId }, "Environment removed");
-            broadcast({ type: "environment_removed", payload: { environmentId } });
-            broadcastEnvironments();
+            emit("environment.removed", { environmentId });
+            emit("environment.changed", {});
             break;
         }
         // ─── Codespaces ─────────────────────────────────────
@@ -1497,7 +1499,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 value,
                 expiresAt: msg.payload?.expiresAt || "",
             });
-            broadcast({ type: "token_changed" });
+            emit("token.changed", {});
             break;
         }
         case "delete_token": {
@@ -1507,7 +1509,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             }
             await tokenBroker.deleteToken(tokenName);
-            broadcast({ type: "token_changed" });
+            emit("token.changed", {});
             break;
         }
         case "get_credential_providers": {
@@ -1524,10 +1526,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             }
             credentialProviders.setCredentialProviders(msg.payload);
-            broadcast({
-                type: "credential_providers",
-                payload: credentialProviders.getCredentialProviders(),
-            });
+            emit("credential.providers_changed", credentialProviders.getCredentialProviders());
             break;
         }
     }