@grackle-ai/server 0.25.0 → 0.27.0

package/dist/ws-bridge.js

@@ -13,7 +13,7 @@ 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";
+import { LOGS_DIR, DEFAULT_RUNTIME, DEFAULT_MODEL, SESSION_STATUS, TASK_STATUS, eventTypeToString, } from "@grackle-ai/common";
 import { grackleHome } from "./paths.js";
 import * as logWriter from "./log-writer.js";
 import { safeParseJsonArray } from "./json-helpers.js";
@@ -22,9 +22,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 } from "./ws-broadcast.js";
-import { buildMcpServersJson, makeTaskCompletionCallback } from "./grpc-service.js";
+import { broadcast, setWssInstance, broadcastEnvironments, envRowToWs } from "./ws-broadcast.js";
+import { buildMcpServersJson } from "./grpc-service.js";
+import { computeTaskStatus } from "./compute-task-status.js";
 import { exec } from "./utils/exec.js";
+import { formatGhError } from "./utils/format-gh-error.js";
 const GH_CODESPACE_LIST_TIMEOUT_MS = 30_000;
 const GH_CODESPACE_CREATE_TIMEOUT_MS = 300_000;
 const GH_CODESPACE_LIST_LIMIT = 50;
@@ -42,6 +44,7 @@ export function createWsBridge(httpServer, verifyApiKey) {
             return;
         }
         const subscriptions = new Map();
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
         ws.on("message", async (data) => {
             try {
                 const msg = JSON.parse(data.toString());
@@ -65,25 +68,6 @@ export function createWsBridge(httpServer, verifyApiKey) {
     });
     return wss;
 }
-/** Map a database environment row to the WebSocket payload shape. */
-function envRowToWs(r) {
-    return {
-        id: r.id,
-        displayName: r.displayName,
-        adapterType: r.adapterType,
-        adapterConfig: r.adapterConfig,
-        defaultRuntime: r.defaultRuntime,
-        status: r.status,
-        bootstrapped: r.bootstrapped,
-    };
-}
-/** Broadcast the current environment list to all connected WebSocket clients. */
-function broadcastEnvironments() {
-    broadcast({
-        type: "environments",
-        payload: { environments: envRegistry.listEnvironments().map(envRowToWs) },
-    });
-}
 /** Safely parse an adapter config string, returning an empty object on failure. */
 function safeParseAdapterConfig(raw, environmentId) {
     try {
@@ -191,7 +175,7 @@ async function startTaskSession(ws, task, options) {
         logger.warn({ taskId: task.id }, "startTaskSession failed: project not found");
         return `Project not found: ${task.projectId}`;
     }
-    const environmentId = task.environmentId || project.defaultEnvironmentId;
+    const environmentId = options?.environmentId || project.defaultEnvironmentId;
     const env = envRegistry.getEnvironment(environmentId);
     if (!env) {
         logger.warn({ taskId: task.id, environmentId }, "startTaskSession failed: environment not found");
@@ -204,7 +188,7 @@ async function startTaskSession(ws, task, options) {
         return undefined;
     }
     // Resolve persona
-    const resolvedPersonaId = options?.personaId || task.personaId;
+    const resolvedPersonaId = options?.personaId || "";
     const persona = resolvedPersonaId
         ? personaStore.getPersona(resolvedPersonaId)
         : undefined;
@@ -212,24 +196,17 @@ async function startTaskSession(ws, task, options) {
         return `Persona not found: ${resolvedPersonaId}`;
     }
     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 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);
     const freshTask = taskStore.getTask(task.id) || task;
-    let systemContext = buildTaskSystemContext(freshTask.title, freshTask.description, freshTask.reviewNotes, freshTask.canDecompose);
+    let systemContext = buildTaskSystemContext(freshTask.title, freshTask.description, options?.notes || "", freshTask.canDecompose);
     if (persona) {
         systemContext = persona.systemPrompt + "\n\n" + systemContext;
     }
-    sessionStore.createSession(sessionId, environmentId, runtime, freshTask.title, model, logPath, freshTask.id);
-    taskStore.setTaskSession(freshTask.id, sessionId);
-    taskStore.markTaskStarted(freshTask.id);
+    sessionStore.createSession(sessionId, environmentId, runtime, freshTask.title, model, logPath, freshTask.id, resolvedPersonaId);
     broadcast({
         type: "task_started",
         payload: {
@@ -263,7 +240,7 @@ async function startTaskSession(ws, task, options) {
         maxTurns,
         branch: freshTask.branch,
         worktreeBasePath: freshTask.branch
-            ? process.env.GRACKLE_WORKTREE_BASE || "/workspace"
+            ? (project.worktreeBasePath || process.env.GRACKLE_WORKTREE_BASE || "/workspace")
             : "",
         systemContext,
         projectId: freshTask.projectId,
@@ -275,7 +252,6 @@ async function startTaskSession(ws, task, options) {
         logPath,
         projectId: freshTask.projectId,
         taskId: freshTask.id,
-        onComplete: makeTaskCompletionCallback(freshTask.id, sessionId, freshTask.projectId),
     });
     return undefined;
 }
@@ -314,7 +290,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             }
             const session = sessionStore.getSession(sessionId);
-            if (!session || !session.logPath) {
+            if (!session?.logPath) {
                 return;
             }
             const entries = logWriter.readLog(session.logPath);
@@ -388,8 +364,8 @@ async function handleMessage(ws, msg, subscriptions) {
         case "spawn": {
             const environmentId = msg.payload?.environmentId;
             const prompt = msg.payload?.prompt;
-            const model = msg.payload?.model || "";
-            const runtime = msg.payload?.runtime || "";
+            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 || "";
@@ -420,7 +396,9 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             }
             const sessionId = uuid();
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime/model may be undefined from WS payload
             const sessionRuntime = runtime || spawnPersona?.runtime || env.defaultRuntime || DEFAULT_RUNTIME;
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             const sessionModel = model || spawnPersona?.model || process.env.GRACKLE_DEFAULT_MODEL || DEFAULT_MODEL;
             const maxTurns = spawnPersona?.maxTurns || 0;
             const logPath = join(grackleHome, LOGS_DIR, sessionId);
@@ -437,7 +415,9 @@ async function handleMessage(ws, msg, subscriptions) {
                 model: sessionModel,
                 maxTurns,
                 branch,
-                worktreeBasePath: branch ? "/workspace" : "",
+                worktreeBasePath: branch
+                    ? ((typeof msg.payload?.worktreeBasePath === "string" ? msg.payload.worktreeBasePath.trim() : "") || process.env.GRACKLE_WORKTREE_BASE || "/workspace")
+                    : "",
                 systemContext: finalSystemContext,
             });
             processEventStream(conn.client.spawn(powerlineReq), {
@@ -450,7 +430,7 @@ async function handleMessage(ws, msg, subscriptions) {
                             sessionId,
                             eventType: "error",
                             timestamp: new Date().toISOString(),
-                            content: `Spawn failed: ${err}`,
+                            content: `Spawn failed: ${err instanceof Error ? err.message : String(err)}`,
                         },
                     });
                 },
@@ -475,11 +455,11 @@ async function handleMessage(ws, msg, subscriptions) {
                 });
                 return;
             }
-            if (session.status !== "waiting_input") {
+            if (session.status !== SESSION_STATUS.IDLE) {
                 sendWs(ws, {
                     type: "error",
                     payload: {
-                        message: `Session ${sessionId} is not currently waiting for input (status: ${session.status})`,
+                        message: `Session ${sessionId} is not currently idle (status: ${session.status})`,
                     },
                 });
                 return;
@@ -532,21 +512,24 @@ 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}` },
-                    });
-                    return;
+                    logger.warn({ sessionId, err }, "PowerLine kill failed — marking session interrupted anyway");
                 }
             }
-            sessionStore.updateSession(sessionId, "killed");
+            sessionStore.updateSession(sessionId, SESSION_STATUS.INTERRUPTED);
             streamHub.publish(create(grackle.SessionEventSchema, {
                 sessionId,
                 type: grackle.EventType.STATUS,
                 timestamp: new Date().toISOString(),
-                content: "killed",
+                content: SESSION_STATUS.INTERRUPTED,
                 raw: "",
             }));
+            // Broadcast task_updated so frontend re-fetches computed status
+            if (session.taskId) {
+                const task = taskStore.getTask(session.taskId);
+                if (task) {
+                    broadcast({ type: "task_updated", payload: { taskId: task.id, projectId: task.projectId } });
+                }
+            }
             break;
         }
         // ─── Projects ──────────────────────────────────────────
@@ -563,6 +546,7 @@ async function handleMessage(ws, msg, subscriptions) {
                         defaultEnvironmentId: r.defaultEnvironmentId,
                         status: r.status,
                         useWorktrees: r.useWorktrees,
+                        worktreeBasePath: r.worktreeBasePath,
                         createdAt: r.createdAt,
                         updatedAt: r.updatedAt,
                     })),
@@ -586,7 +570,7 @@ 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);
+            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 } });
             break;
@@ -610,7 +594,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             }
             const nameVal = typeof msg.payload?.name === "string" ? msg.payload.name : undefined;
-            if (nameVal !== undefined && nameVal.trim() === "") {
+            if (nameVal?.trim() === "") {
                 sendWs(ws, { type: "error", payload: { message: "Project name cannot be empty" } });
                 return;
             }
@@ -622,12 +606,14 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             }
             const worktreesVal = typeof msg.payload?.useWorktrees === "boolean" ? msg.payload.useWorktrees : undefined;
+            const worktreeBasePathVal = typeof msg.payload?.worktreeBasePath === "string" ? msg.payload.worktreeBasePath : undefined;
             projectStore.updateProject(projectId, {
                 name: nameVal !== undefined ? nameVal.trim() : undefined,
                 description: descVal,
                 repoUrl: repoVal,
                 defaultEnvironmentId: envVal,
                 useWorktrees: worktreesVal,
+                worktreeBasePath: worktreeBasePathVal,
             });
             broadcast({ type: "project_updated", payload: { projectId } });
             break;
@@ -735,29 +721,39 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             const rows = taskStore.listTasks(projectId);
             const childIdsMap = taskStore.buildChildIdsMap(rows);
+            // Batch-fetch sessions for all tasks and group by taskId
+            const taskIds = rows.map((r) => r.id);
+            const allSessions = sessionStore.listSessionsByTaskIds(taskIds);
+            const sessionsByTask = new Map();
+            for (const s of allSessions) {
+                const arr = sessionsByTask.get(s.taskId) ?? [];
+                arr.push(s);
+                sessionsByTask.set(s.taskId, arr);
+            }
             sendWs(ws, {
                 type: "tasks",
                 payload: {
                     projectId,
-                    tasks: rows.map((r) => ({
-                        id: r.id,
-                        projectId: r.projectId,
-                        title: r.title,
-                        description: r.description,
-                        status: r.status,
-                        branch: r.branch,
-                        environmentId: r.environmentId,
-                        sessionId: r.sessionId,
-                        dependsOn: safeParseJsonArray(r.dependsOn),
-                        reviewNotes: r.reviewNotes,
-                        sortOrder: r.sortOrder,
-                        createdAt: r.createdAt,
-                        parentTaskId: r.parentTaskId,
-                        depth: r.depth,
-                        childTaskIds: childIdsMap.get(r.id) ?? [],
-                        canDecompose: r.canDecompose,
-                        personaId: r.personaId,
-                    })),
+                    tasks: rows.map((r) => {
+                        const taskSessions = sessionsByTask.get(r.id) ?? [];
+                        const computed = computeTaskStatus(r.status, taskSessions);
+                        return {
+                            id: r.id,
+                            projectId: r.projectId,
+                            title: r.title,
+                            description: r.description,
+                            status: computed.status,
+                            branch: r.branch,
+                            latestSessionId: computed.latestSessionId,
+                            dependsOn: safeParseJsonArray(r.dependsOn),
+                            sortOrder: r.sortOrder,
+                            createdAt: r.createdAt,
+                            parentTaskId: r.parentTaskId,
+                            depth: r.depth,
+                            childTaskIds: childIdsMap.get(r.id) ?? [],
+                            canDecompose: r.canDecompose,
+                        };
+                    }),
                 },
             });
             break;
@@ -783,19 +779,8 @@ async function handleMessage(ws, msg, subscriptions) {
             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 || "", resolvedEnvId, msg.payload?.dependsOn || [], slugify(project.name), parentTaskId, canDecompose, msg.payload?.personaId || "");
+            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",
@@ -826,7 +811,7 @@ async function handleMessage(ws, msg, subscriptions) {
                     sendWs(ws, { type: "error", payload: { message: `Session not found: ${lateBindSessionId}` } });
                     return;
                 }
-                const terminalStatuses = ["completed", "failed", "killed"];
+                const terminalStatuses = [SESSION_STATUS.COMPLETED, SESSION_STATUS.FAILED, SESSION_STATUS.INTERRUPTED];
                 if (terminalStatuses.includes(session.status)) {
                     sendWs(ws, {
                         type: "error",
@@ -843,11 +828,8 @@ async function handleMessage(ws, msg, subscriptions) {
                     return;
                 }
                 sessionStore.setSessionTask(lateBindSessionId, updateTaskId);
-                taskStore.setTaskSession(updateTaskId, lateBindSessionId);
-                taskStore.markTaskStarted(updateTaskId);
-                const onComplete = makeTaskCompletionCallback(updateTaskId, lateBindSessionId, existingTask.projectId);
                 try {
-                    processorRegistry.lateBind(lateBindSessionId, updateTaskId, existingTask.projectId, onComplete);
+                    processorRegistry.lateBind(lateBindSessionId, updateTaskId, existingTask.projectId);
                 }
                 catch (err) {
                     sendWs(ws, { type: "error", payload: { message: String(err) } });
@@ -859,8 +841,8 @@ async function handleMessage(ws, msg, subscriptions) {
                 });
                 break;
             }
-            // Only allow editing pending/assigned tasks (non-late-bind path)
-            if (!["pending", "assigned"].includes(existingTask.status)) {
+            // Only allow editing not_started tasks (non-late-bind path)
+            if (existingTask.status !== TASK_STATUS.NOT_STARTED) {
                 sendWs(ws, {
                     type: "error",
                     payload: { message: `Task ${updateTaskId} cannot be edited (status: ${existingTask.status})` },
@@ -881,13 +863,7 @@ async function handleMessage(ws, msg, subscriptions) {
                         .filter((d) => d !== updateTaskId)),
                 ]
                 : safeParseJsonArray(existingTask.dependsOn);
-            const updatedEnvironmentId = typeof msg.payload?.environmentId === "string"
-                ? msg.payload.environmentId
-                : existingTask.environmentId;
-            const updatedPersonaId = typeof msg.payload?.personaId === "string"
-                ? msg.payload.personaId
-                : existingTask.personaId;
-            taskStore.updateTask(updateTaskId, updatedTitle, updatedDescription, existingTask.status, updatedEnvironmentId, updatedDependsOn, existingTask.reviewNotes, updatedPersonaId);
+            taskStore.updateTask(updateTaskId, updatedTitle, updatedDescription, existingTask.status, updatedDependsOn);
             const updatedRow = taskStore.getTask(updateTaskId);
             broadcast({
                 type: "task_updated",
@@ -913,14 +889,18 @@ async function handleMessage(ws, msg, subscriptions) {
                 });
                 return;
             }
-            if (!["pending", "assigned", "failed"].includes(task.status)) {
-                sendWs(ws, {
-                    type: "error",
-                    payload: {
-                        message: `Task cannot be started (status: ${task.status})`,
-                    },
-                });
-                return;
+            {
+                const taskSessions = sessionStore.listSessionsForTask(taskId);
+                const { status: effectiveStatus } = computeTaskStatus(task.status, taskSessions);
+                if (![TASK_STATUS.NOT_STARTED, TASK_STATUS.FAILED].includes(effectiveStatus)) {
+                    sendWs(ws, {
+                        type: "error",
+                        payload: {
+                            message: `Task cannot be started (status: ${effectiveStatus})`,
+                        },
+                    });
+                    return;
+                }
             }
             if (!taskStore.areDependenciesMet(taskId)) {
                 sendWs(ws, {
@@ -932,68 +912,90 @@ async function handleMessage(ws, msg, subscriptions) {
             const startError = await startTaskSession(ws, task, {
                 runtime: msg.payload?.runtime,
                 model: msg.payload?.model,
-                personaId: msg.payload?.personaId || task.personaId || undefined,
+                personaId: msg.payload?.personaId || undefined,
+                environmentId: msg.payload?.environmentId || undefined,
+                notes: msg.payload?.notes || undefined,
             });
             if (startError) {
                 sendWs(ws, { type: "error", payload: { message: startError } });
             }
             break;
         }
-        case "approve_task": {
+        case "complete_task": {
             const taskId = msg.payload?.taskId;
             if (!taskId)
                 return;
-            taskStore.markTaskCompleted(taskId, "done");
+            taskStore.markTaskComplete(taskId, TASK_STATUS.COMPLETE);
             const task = taskStore.getTask(taskId);
             const unblocked = task ? taskStore.checkAndUnblock(task.projectId) : [];
             sendWs(ws, {
-                type: "task_approved",
+                type: "task_completed",
                 payload: {
                     taskId,
                     unblockedTaskIds: unblocked.map((t) => t.id),
                 },
             });
+            if (task) {
+                broadcast({
+                    type: "task_completed",
+                    payload: { taskId, projectId: task.projectId },
+                });
+            }
             break;
         }
-        case "reject_task": {
+        case "resume_task": {
             const taskId = msg.payload?.taskId;
-            const reviewNotes = msg.payload?.reviewNotes || "";
             if (!taskId)
                 return;
             const task = taskStore.getTask(taskId);
-            if (!task)
+            if (!task) {
+                sendWs(ws, { type: "error", payload: { message: `Task not found: ${taskId}` } });
                 return;
-            if (task.status !== "review") {
+            }
+            const latestSession = sessionStore.getLatestSessionForTask(taskId);
+            if (!latestSession) {
+                sendWs(ws, { type: "error", payload: { message: `Task ${taskId} has no sessions to resume` } });
+                return;
+            }
+            if (![SESSION_STATUS.INTERRUPTED, SESSION_STATUS.COMPLETED].includes(latestSession.status)) {
                 sendWs(ws, {
                     type: "error",
-                    payload: {
-                        message: `Task cannot be rejected (status: ${task.status})`,
-                    },
+                    payload: { message: `Latest session ${latestSession.id} is not resumable (status: ${latestSession.status})` },
                 });
                 return;
             }
-            // Preserve runtime/model from the previous session so the retry
-            // doesn't unexpectedly switch runtimes/models.
-            const previousSession = task.sessionId
-                ? sessionStore.getSession(task.sessionId)
-                : undefined;
-            // Store review notes and set status to assigned
-            taskStore.updateTask(task.id, task.title, task.description, "assigned", task.environmentId, safeParseJsonArray(task.dependsOn), reviewNotes, task.personaId);
-            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) {
-                const retryError = await startTaskSession(ws, freshTask, {
-                    runtime: previousSession?.runtime,
-                    model: previousSession?.model,
+            if (!latestSession.runtimeSessionId) {
+                sendWs(ws, {
+                    type: "error",
+                    payload: { message: `Latest session ${latestSession.id} has no runtime session ID — cannot resume` },
                 });
-                if (retryError) {
-                    logger.warn({ taskId, error: retryError }, "Auto-retry after rejection failed — task remains assigned");
-                }
+                return;
+            }
+            const env = envRegistry.getEnvironment(latestSession.environmentId);
+            if (!env) {
+                sendWs(ws, { type: "error", payload: { message: `Environment not found: ${latestSession.environmentId}` } });
+                return;
             }
+            const conn = await autoProvisionEnvironment(ws, latestSession.environmentId, env, { taskId });
+            if (!conn) {
+                return;
+            }
+            const powerlineReq = create(powerline.ResumeRequestSchema, {
+                sessionId: latestSession.id,
+                runtimeSessionId: latestSession.runtimeSessionId,
+                runtime: latestSession.runtime,
+            });
+            const logPath = latestSession.logPath || join(grackleHome, LOGS_DIR, latestSession.id);
+            processEventStream(conn.client.resume(powerlineReq), {
+                sessionId: latestSession.id,
+                logPath,
+                projectId: task.projectId,
+                taskId: task.id,
+            });
+            broadcast({
+                type: "task_started",
+                payload: { taskId: task.id, sessionId: latestSession.id, projectId: task.projectId },
+            });
             break;
         }
         case "delete_task": {
@@ -1015,28 +1017,26 @@ async function handleMessage(ws, msg, subscriptions) {
                 });
                 return;
             }
-            // 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");
-                        }
+            // Kill all active sessions before deleting the task
+            const activeSessions = sessionStore.getActiveSessionsForTask(taskId);
+            for (const activeSession of activeSessions) {
+                const conn = adapterManager.getConnection(activeSession.environmentId);
+                if (conn) {
+                    try {
+                        await conn.client.kill(create(powerline.SessionIdSchema, { id: activeSession.id }));
+                    }
+                    catch (err) {
+                        logger.warn({ taskId, sessionId: activeSession.id, 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: "",
-                    }));
                 }
+                sessionStore.updateSession(activeSession.id, SESSION_STATUS.INTERRUPTED);
+                streamHub.publish(create(grackle.SessionEventSchema, {
+                    sessionId: activeSession.id,
+                    type: grackle.EventType.STATUS,
+                    timestamp: new Date().toISOString(),
+                    content: SESSION_STATUS.INTERRUPTED,
+                    raw: "",
+                }));
             }
             const changes = taskStore.deleteTask(taskId);
             if (changes === 0) {
@@ -1118,15 +1118,14 @@ async function handleMessage(ws, msg, subscriptions) {
             if (!taskId)
                 return;
             const task = taskStore.getTask(taskId);
-            if (!task || !task.branch) {
+            if (!task?.branch) {
                 sendWs(ws, {
                     type: "task_diff",
                     payload: { taskId, error: "No branch" },
                 });
                 return;
             }
-            const environmentId = task.environmentId ||
-                projectStore.getProject(task.projectId)?.defaultEnvironmentId;
+            const environmentId = projectStore.getProject(task.projectId)?.defaultEnvironmentId;
             if (!environmentId) {
                 sendWs(ws, {
                     type: "task_diff",
@@ -1395,7 +1394,10 @@ async function handleMessage(ws, msg, subscriptions) {
                 logger.warn({ err }, "Failed to list codespaces");
                 sendWs(ws, {
                     type: "codespaces_list",
-                    payload: { codespaces: [], error: String(err) },
+                    payload: {
+                        codespaces: [],
+                        error: formatGhError(err, "list codespaces"),
+                    },
                 });
             }
             break;
@@ -1410,15 +1412,17 @@ async function handleMessage(ws, msg, subscriptions) {
                 return;
             }
             const trimmedRepo = repo.trim();
+            const machine = typeof msg.payload?.machine === "string"
+                ? msg.payload.machine.trim()
+                : "";
+            const createArgs = ["codespace", "create", "--repo", trimmedRepo];
+            if (machine) {
+                createArgs.push("--machine", machine);
+            }
             try {
-                const result = await exec("gh", [
-                    "codespace",
-                    "create",
-                    "--repo",
-                    trimmedRepo,
-                    "--machine",
-                    "basicLinux32gb",
-                ], { timeout: GH_CODESPACE_CREATE_TIMEOUT_MS });
+                const result = await exec("gh", createArgs, {
+                    timeout: GH_CODESPACE_CREATE_TIMEOUT_MS,
+                });
                 const codespaceName = result.stdout.trim();
                 sendWs(ws, {
                     type: "codespace_created",
@@ -1429,7 +1433,7 @@ async function handleMessage(ws, msg, subscriptions) {
                 logger.error({ err, repo }, "Failed to create codespace");
                 sendWs(ws, {
                     type: "codespace_create_error",
-                    payload: { message: String(err) },
+                    payload: { message: formatGhError(err, "create codespace") },
                 });
             }
             break;