@grackle-ai/server 0.25.0 → 0.27.0

package/dist/grpc-service.js

@@ -12,40 +12,18 @@ 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 { broadcast } from "./ws-broadcast.js";
+import { broadcast, broadcastEnvironments } from "./ws-broadcast.js";
 import { processEventStream } from "./event-processor.js";
 import * as processorRegistry from "./processor-registry.js";
 import { join } from "node:path";
-import { LOGS_DIR, DEFAULT_RUNTIME, DEFAULT_MODEL, MAX_TASK_DEPTH, taskStatusToEnum, taskStatusToString, projectStatusToEnum, } from "@grackle-ai/common";
+import { LOGS_DIR, DEFAULT_RUNTIME, DEFAULT_MODEL, MAX_TASK_DEPTH, SESSION_STATUS, TASK_STATUS, taskStatusToEnum, taskStatusToString, projectStatusToEnum, } from "@grackle-ai/common";
 import { grackleHome } from "./paths.js";
 import { safeParseJsonArray } from "./json-helpers.js";
+import { computeTaskStatus } from "./compute-task-status.js";
 import { logger } from "./logger.js";
 import { slugify } from "./utils/slugify.js";
 import { buildTaskSystemContext } from "./utils/system-context.js";
 import { importGitHubIssues as executeGitHubImport } from "./github-import.js";
-/**
- * Build a completion callback that transitions a task to review/failed
- * when its associated session ends. Shared across startTask, resumeAgent,
- * updateTask (late-bind), and WS bridge paths.
- */
-export function makeTaskCompletionCallback(taskId, sessionId, projectId) {
-    return () => {
-        const t = taskStore.getTask(taskId);
-        if (t && (t.status === "in_progress" || t.status === "waiting_input")) {
-            const sess = sessionStore.getSession(sessionId);
-            if (sess?.status === "completed") {
-                taskStore.markTaskCompleted(taskId, "review");
-            }
-            else if (sess?.status === "failed") {
-                taskStore.markTaskCompleted(taskId, "failed");
-            }
-            broadcast({
-                type: "task_updated",
-                payload: { taskId, projectId },
-            });
-        }
-    };
-}
 function envRowToProto(row) {
     return create(grackle.EnvironmentSchema, {
         id: row.id,
@@ -75,7 +53,8 @@ function sessionRowToProto(row) {
         suspendedAt: row.suspendedAt ?? "",
         endedAt: row.endedAt ?? "",
         error: row.error ?? "",
-        taskId: row.taskId ?? "",
+        taskId: row.taskId,
+        personaId: row.personaId,
     });
 }
 function projectRowToProto(row) {
@@ -89,23 +68,21 @@ function projectRowToProto(row) {
         createdAt: row.createdAt,
         updatedAt: row.updatedAt,
         useWorktrees: row.useWorktrees,
+        worktreeBasePath: row.worktreeBasePath,
     });
 }
-function taskRowToProto(row, childIds) {
+function taskRowToProto(row, childIds, computedStatus, latestSessionId) {
     return create(grackle.TaskSchema, {
         id: row.id,
         projectId: row.projectId,
         title: row.title,
         description: row.description,
-        status: taskStatusToEnum(row.status),
+        status: taskStatusToEnum(computedStatus ?? row.status),
         branch: row.branch,
-        environmentId: row.environmentId,
-        sessionId: row.sessionId,
+        latestSessionId: latestSessionId ?? "",
         dependsOn: safeParseJsonArray(row.dependsOn),
-        assignedAt: row.assignedAt ?? "",
         startedAt: row.startedAt ?? "",
         completedAt: row.completedAt ?? "",
-        reviewNotes: row.reviewNotes,
         createdAt: row.createdAt,
         updatedAt: row.updatedAt,
         sortOrder: row.sortOrder,
@@ -113,7 +90,6 @@ function taskRowToProto(row, childIds) {
         depth: row.depth,
         childTaskIds: childIds ?? taskStore.getChildren(row.id).map((c) => c.id),
         canDecompose: row.canDecompose,
-        personaId: row.personaId,
     });
 }
 function findingRowToProto(row) {
@@ -155,8 +131,10 @@ function personaRowToProto(row) {
         model: row.model,
         maxTurns: row.maxTurns,
         mcpServers: mcpServers
-            .filter((s) => typeof s === "object" &&
-            s !== null &&
+            .filter((s) => 
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typeof null === "object", JSON.parse can return null
+        s !== null &&
+            typeof s === "object" &&
             typeof s.name === "string" &&
             typeof s.command === "string")
             .map((s) => create(grackle.McpServerConfigSchema, {
@@ -253,8 +231,9 @@ export function registerGrackleRoutes(router) {
                 return;
             }
             envRegistry.updateEnvironmentStatus(req.id, "connecting");
+            broadcastEnvironments();
             const config = JSON.parse(env.adapterConfig);
-            const powerlineToken = env.powerlineToken || "";
+            const powerlineToken = env.powerlineToken;
             for await (const event of reconnectOrProvision(req.id, adapter, config, powerlineToken, !!env.bootstrapped)) {
                 yield create(grackle.ProvisionEventSchema, {
                     stage: event.stage,
@@ -269,6 +248,7 @@ export function registerGrackleRoutes(router) {
                 await tokenBroker.pushToEnv(req.id);
                 envRegistry.updateEnvironmentStatus(req.id, "connected");
                 envRegistry.markBootstrapped(req.id);
+                broadcastEnvironments();
                 yield create(grackle.ProvisionEventSchema, {
                     stage: "ready",
                     message: "Environment connected",
@@ -277,9 +257,10 @@ export function registerGrackleRoutes(router) {
             }
             catch (err) {
                 envRegistry.updateEnvironmentStatus(req.id, "error");
+                broadcastEnvironments();
                 yield create(grackle.ProvisionEventSchema, {
                     stage: "error",
-                    message: `Connection failed: ${err}`,
+                    message: `Connection failed: ${err instanceof Error ? err.message : String(err)}`,
                     progress: 0,
                 });
             }
@@ -295,6 +276,7 @@ export function registerGrackleRoutes(router) {
             }
             adapterManager.removeConnection(req.id);
             envRegistry.updateEnvironmentStatus(req.id, "disconnected");
+            broadcastEnvironments();
             return create(grackle.EmptySchema, {});
         },
         async destroyEnvironment(req) {
@@ -308,6 +290,7 @@ export function registerGrackleRoutes(router) {
             }
             adapterManager.removeConnection(req.id);
             envRegistry.updateEnvironmentStatus(req.id, "disconnected");
+            broadcastEnvironments();
             return create(grackle.EmptySchema, {});
         },
         async spawnAgent(req) {
@@ -346,8 +329,10 @@ export function registerGrackleRoutes(router) {
                 prompt: req.prompt,
                 model,
                 maxTurns: persona?.maxTurns || 0,
-                branch: req.branch || "",
-                worktreeBasePath: req.branch ? "/workspace" : "",
+                branch: req.branch,
+                worktreeBasePath: req.branch
+                    ? (req.worktreeBasePath.trim() || process.env.GRACKLE_WORKTREE_BASE || "/workspace")
+                    : "",
                 systemContext,
                 mcpServersJson,
             });
@@ -376,13 +361,11 @@ export function registerGrackleRoutes(router) {
             // Auto-bind task context from DB if session was previously associated with a task
             let resumeProjectId;
             let resumeTaskId;
-            let resumeOnComplete;
             if (session.taskId) {
                 const task = taskStore.getTask(session.taskId);
                 if (task) {
                     resumeProjectId = task.projectId;
                     resumeTaskId = task.id;
-                    resumeOnComplete = makeTaskCompletionCallback(task.id, session.id, task.projectId);
                 }
             }
             processEventStream(conn.client.resume(powerlineReq), {
@@ -390,7 +373,6 @@ export function registerGrackleRoutes(router) {
                 logPath,
                 projectId: resumeProjectId,
                 taskId: resumeTaskId,
-                onComplete: resumeOnComplete,
             });
             const row = sessionStore.getSession(session.id);
             return sessionRowToProto(row);
@@ -400,8 +382,8 @@ export function registerGrackleRoutes(router) {
             if (!session) {
                 throw new Error(`Session not found: ${req.sessionId}`);
             }
-            if (session.status !== "waiting_input") {
-                throw new Error(`Session ${req.sessionId} is not waiting for input (status: ${session.status})`);
+            if (session.status !== SESSION_STATUS.IDLE) {
+                throw new Error(`Session ${req.sessionId} is not idle (status: ${session.status})`);
             }
             const conn = adapterManager.getConnection(session.environmentId);
             if (!conn) {
@@ -420,16 +402,28 @@ export function registerGrackleRoutes(router) {
             }
             const conn = adapterManager.getConnection(session.environmentId);
             if (conn) {
-                await conn.client.kill(create(powerline.SessionIdSchema, { id: req.id }));
+                try {
+                    await conn.client.kill(create(powerline.SessionIdSchema, { id: req.id }));
+                }
+                catch (err) {
+                    logger.warn({ sessionId: req.id, err }, "PowerLine kill failed — marking session interrupted anyway");
+                }
             }
-            sessionStore.updateSession(req.id, "killed");
+            sessionStore.updateSession(req.id, SESSION_STATUS.INTERRUPTED);
             streamHub.publish(create(grackle.SessionEventSchema, {
                 sessionId: req.id,
                 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 } });
+                }
+            }
             return create(grackle.EmptySchema, {});
         },
         async listSessions(req) {
@@ -502,7 +496,7 @@ export function registerGrackleRoutes(router) {
             }
             // useWorktrees defaults to true when not specified
             const useWorktrees = req.useWorktrees ?? true;
-            projectStore.createProject(id, req.name, req.description, req.repoUrl, req.defaultEnvironmentId, useWorktrees);
+            projectStore.createProject(id, req.name, req.description, req.repoUrl, req.defaultEnvironmentId, useWorktrees, req.worktreeBasePath ?? "");
             broadcast({ type: "project_created", payload: { projectId: id } });
             const row = projectStore.getProject(id);
             return projectRowToProto(row);
@@ -523,7 +517,7 @@ export function registerGrackleRoutes(router) {
             if (!existing) {
                 throw new Error(`Project not found: ${req.id}`);
             }
-            if (req.name !== undefined && req.name.trim() === "") {
+            if (req.name?.trim() === "") {
                 throw new Error("Project name cannot be empty");
             }
             if (req.repoUrl !== undefined && req.repoUrl !== "" && !/^https?:\/\//i.test(req.repoUrl)) {
@@ -535,6 +529,7 @@ export function registerGrackleRoutes(router) {
                 repoUrl: req.repoUrl,
                 defaultEnvironmentId: req.defaultEnvironmentId,
                 useWorktrees: req.useWorktrees ?? undefined,
+                worktreeBasePath: req.worktreeBasePath,
             });
             if (!row) {
                 throw new Error(`Project not found after update: ${req.id}`);
@@ -546,8 +541,21 @@ export function registerGrackleRoutes(router) {
         async listTasks(req) {
             const rows = taskStore.listTasks(req.id);
             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);
+            }
             return create(grackle.TaskListSchema, {
-                tasks: rows.map((r) => taskRowToProto(r, childIdsMap.get(r.id) ?? [])),
+                tasks: rows.map((r) => {
+                    const taskSessions = sessionsByTask.get(r.id) ?? [];
+                    const { status, latestSessionId } = computeTaskStatus(r.status, taskSessions);
+                    return taskRowToProto(r, childIdsMap.get(r.id) ?? [], status, latestSessionId);
+                }),
             });
         },
         async createTask(req) {
@@ -567,18 +575,7 @@ export function registerGrackleRoutes(router) {
                 }
             }
             const id = uuid().slice(0, 8);
-            // Resolve environment: explicit > parent task's env > project default
-            let environmentId = req.environmentId;
-            if (!environmentId && req.parentTaskId) {
-                const parent = taskStore.getTask(req.parentTaskId);
-                if (parent?.environmentId) {
-                    environmentId = parent.environmentId;
-                }
-            }
-            if (!environmentId) {
-                environmentId = project.defaultEnvironmentId;
-            }
-            taskStore.createTask(id, req.projectId, req.title, req.description, environmentId, [...req.dependsOn], slugify(project.name), req.parentTaskId, req.canDecompose, req.personaId);
+            taskStore.createTask(id, req.projectId, req.title, req.description, [...req.dependsOn], slugify(project.name), req.parentTaskId, req.canDecompose);
             const row = taskStore.getTask(id);
             broadcast({
                 type: "task_created",
@@ -590,7 +587,9 @@ export function registerGrackleRoutes(router) {
             const row = taskStore.getTask(req.id);
             if (!row)
                 throw new Error(`Task not found: ${req.id}`);
-            return taskRowToProto(row);
+            const taskSessions = sessionStore.listSessionsForTask(req.id);
+            const { status, latestSessionId } = computeTaskStatus(row.status, taskSessions);
+            return taskRowToProto(row, undefined, status, latestSessionId);
         },
         async updateTask(req) {
             const existing = taskStore.getTask(req.id);
@@ -604,16 +603,16 @@ export function registerGrackleRoutes(router) {
                 }
                 reqStatus = converted;
             }
-            taskStore.updateTask(req.id, req.title !== "" ? req.title : existing.title, req.description !== "" ? req.description : existing.description, reqStatus, req.environmentId !== "" ? req.environmentId : existing.environmentId, req.dependsOn.length > 0
+            taskStore.updateTask(req.id, req.title !== "" ? req.title : existing.title, req.description !== "" ? req.description : existing.description, reqStatus, req.dependsOn.length > 0
                 ? [...req.dependsOn]
-                : safeParseJsonArray(existing.dependsOn), req.reviewNotes !== "" ? req.reviewNotes : existing.reviewNotes, existing.personaId);
+                : safeParseJsonArray(existing.dependsOn));
             // Late-bind: associate an existing session with this task
             if (req.sessionId !== "") {
                 const session = sessionStore.getSession(req.sessionId);
                 if (!session) {
                     throw new ConnectError(`Session not found: ${req.sessionId}`, Code.NotFound);
                 }
-                const terminalStatuses = ["completed", "failed", "killed"];
+                const terminalStatuses = [SESSION_STATUS.COMPLETED, SESSION_STATUS.FAILED, SESSION_STATUS.INTERRUPTED];
                 if (terminalStatuses.includes(session.status)) {
                     throw new ConnectError(`Cannot bind terminal session ${req.sessionId} (status: ${session.status})`, Code.FailedPrecondition);
                 }
@@ -622,24 +621,27 @@ export function registerGrackleRoutes(router) {
                     throw new ConnectError(`No active event processor for session ${req.sessionId}`, Code.FailedPrecondition);
                 }
                 sessionStore.setSessionTask(req.sessionId, req.id);
-                taskStore.setTaskSession(req.id, req.sessionId);
-                taskStore.markTaskStarted(req.id);
-                const onComplete = makeTaskCompletionCallback(req.id, req.sessionId, existing.projectId);
-                processorRegistry.lateBind(req.sessionId, req.id, existing.projectId, onComplete);
+                processorRegistry.lateBind(req.sessionId, req.id, existing.projectId);
                 broadcast({
                     type: "task_started",
                     payload: { taskId: req.id, sessionId: req.sessionId, projectId: existing.projectId },
                 });
             }
             const row = taskStore.getTask(req.id);
-            return taskRowToProto(row);
+            const taskSessions = sessionStore.listSessionsForTask(req.id);
+            const { status, latestSessionId } = computeTaskStatus(row.status, taskSessions);
+            return taskRowToProto(row, undefined, status, latestSessionId);
         },
         async startTask(req) {
             const task = taskStore.getTask(req.taskId);
             if (!task)
                 throw new Error(`Task not found: ${req.taskId}`);
-            if (!["pending", "assigned", "failed"].includes(task.status)) {
-                throw new Error(`Task ${req.taskId} cannot be started (status: ${task.status})`);
+            {
+                const taskSessions = sessionStore.listSessionsForTask(req.taskId);
+                const { status: effectiveStatus } = computeTaskStatus(task.status, taskSessions);
+                if (![TASK_STATUS.NOT_STARTED, TASK_STATUS.FAILED].includes(effectiveStatus)) {
+                    throw new Error(`Task ${req.taskId} cannot be started (status: ${effectiveStatus})`);
+                }
             }
             if (!taskStore.areDependenciesMet(req.taskId)) {
                 throw new Error(`Task ${req.taskId} has unmet dependencies`);
@@ -647,14 +649,15 @@ export function registerGrackleRoutes(router) {
             const project = projectStore.getProject(task.projectId);
             if (!project)
                 throw new Error(`Project not found: ${task.projectId}`);
-            const environmentId = task.environmentId || project.defaultEnvironmentId;
-            if (!environmentId)
+            const environmentId = req.environmentId || project.defaultEnvironmentId;
+            if (!environmentId) {
                 throw new Error("No environment specified for task or project");
+            }
             const conn = adapterManager.getConnection(environmentId);
             if (!conn)
                 throw new Error(`Environment ${environmentId} not connected`);
-            // Resolve persona (StartTaskRequest override > task's stored persona)
-            const personaId = req.personaId || task.personaId;
+            // Resolve persona from StartTaskRequest
+            const personaId = req.personaId || "";
             const persona = personaId
                 ? personaStore.getPersona(personaId)
                 : undefined;
@@ -673,13 +676,11 @@ export function registerGrackleRoutes(router) {
                 DEFAULT_MODEL;
             const maxTurns = persona?.maxTurns || 0;
             const logPath = join(grackleHome, LOGS_DIR, sessionId);
-            let systemContext = buildTaskSystemContext(task.title, task.description, task.reviewNotes, task.canDecompose);
+            let systemContext = buildTaskSystemContext(task.title, task.description, req.notes || "", task.canDecompose);
             if (persona) {
                 systemContext = persona.systemPrompt + "\n\n" + systemContext;
             }
-            sessionStore.createSession(sessionId, environmentId, runtime, task.title, model, logPath, task.id);
-            taskStore.setTaskSession(task.id, sessionId);
-            taskStore.markTaskStarted(task.id);
+            sessionStore.createSession(sessionId, environmentId, runtime, task.title, model, logPath, task.id, personaId);
             broadcast({
                 type: "task_started",
                 payload: { taskId: task.id, sessionId, projectId: task.projectId },
@@ -701,7 +702,9 @@ export function registerGrackleRoutes(router) {
                 model,
                 maxTurns,
                 branch: task.branch,
-                worktreeBasePath: task.branch && useWorktrees ? "/workspace" : "",
+                worktreeBasePath: task.branch && useWorktrees
+                    ? (project.worktreeBasePath || process.env.GRACKLE_WORKTREE_BASE || "/workspace")
+                    : "",
                 systemContext,
                 projectId: task.projectId,
                 taskId: task.id,
@@ -712,16 +715,15 @@ export function registerGrackleRoutes(router) {
                 logPath,
                 projectId: task.projectId,
                 taskId: task.id,
-                onComplete: makeTaskCompletionCallback(task.id, sessionId, task.projectId),
             });
             const row = sessionStore.getSession(sessionId);
             return sessionRowToProto(row);
         },
-        async approveTask(req) {
+        async completeTask(req) {
             const task = taskStore.getTask(req.id);
             if (!task)
                 throw new Error(`Task not found: ${req.id}`);
-            taskStore.markTaskCompleted(task.id, "done");
+            taskStore.markTaskComplete(task.id, TASK_STATUS.COMPLETE);
             // Check for newly unblocked tasks
             const unblocked = taskStore.checkAndUnblock(task.projectId);
             for (const t of unblocked) {
@@ -738,23 +740,50 @@ export function registerGrackleRoutes(router) {
                 }));
             }
             broadcast({
-                type: "task_approved",
+                type: "task_completed",
                 payload: { taskId: task.id, projectId: task.projectId },
             });
             const row = taskStore.getTask(task.id);
-            return taskRowToProto(row);
+            const taskSessions = sessionStore.listSessionsForTask(task.id);
+            const { status, latestSessionId } = computeTaskStatus(row.status, taskSessions);
+            return taskRowToProto(row, undefined, status, latestSessionId);
         },
-        async rejectTask(req) {
+        async resumeTask(req) {
             const task = taskStore.getTask(req.id);
             if (!task)
                 throw new Error(`Task not found: ${req.id}`);
-            taskStore.updateTask(task.id, task.title, task.description, "assigned", task.environmentId, safeParseJsonArray(task.dependsOn), req.reviewNotes || "", task.personaId);
+            const latestSession = sessionStore.getLatestSessionForTask(req.id);
+            if (!latestSession) {
+                throw new Error(`Task ${req.id} has no sessions to resume`);
+            }
+            if (![SESSION_STATUS.INTERRUPTED, SESSION_STATUS.COMPLETED].includes(latestSession.status)) {
+                throw new Error(`Latest session ${latestSession.id} is not resumable (status: ${latestSession.status})`);
+            }
+            if (!latestSession.runtimeSessionId) {
+                throw new Error(`Latest session ${latestSession.id} has no runtime session ID — cannot resume`);
+            }
+            const conn = adapterManager.getConnection(latestSession.environmentId);
+            if (!conn) {
+                throw new Error(`Environment ${latestSession.environmentId} not connected`);
+            }
+            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_rejected",
-                payload: { taskId: task.id, projectId: task.projectId },
+                type: "task_started",
+                payload: { taskId: task.id, sessionId: latestSession.id, projectId: task.projectId },
             });
-            const row = taskStore.getTask(task.id);
-            return taskRowToProto(row);
+            const row = sessionStore.getSession(latestSession.id);
+            return sessionRowToProto(row);
         },
         async deleteTask(req) {
             const task = taskStore.getTask(req.id);
@@ -765,28 +794,26 @@ export function registerGrackleRoutes(router) {
             if (children.length > 0) {
                 throw new ConnectError("Cannot delete task with children. Delete children first.", Code.FailedPrecondition);
             }
-            // Kill active session before deleting the task
-            if (task.sessionId) {
-                const activeSession = sessionStore.getSession(task.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: task.sessionId }));
-                        }
-                        catch (err) {
-                            logger.warn({ taskId: req.id, sessionId: task.sessionId, err }, "Failed to kill session during task deletion");
-                        }
+            // Kill all active sessions before deleting the task
+            const activeSessions = sessionStore.getActiveSessionsForTask(req.id);
+            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: req.id, sessionId: activeSession.id, err }, "Failed to kill session during task deletion");
                     }
-                    sessionStore.updateSession(task.sessionId, "killed");
-                    streamHub.publish(create(grackle.SessionEventSchema, {
-                        sessionId: task.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(req.id);
             if (changes === 0) {
@@ -847,10 +874,8 @@ export function registerGrackleRoutes(router) {
             // Only update toolConfig/mcpServers if the request provides non-empty values;
             // otherwise keep the existing stored value.
             const hasNewToolConfig = !!req.toolConfig &&
-                ((req.toolConfig.allowedTools &&
-                    req.toolConfig.allowedTools.length > 0) ||
-                    (req.toolConfig.disallowedTools &&
-                        req.toolConfig.disallowedTools.length > 0));
+                (req.toolConfig.allowedTools.length > 0 ||
+                    req.toolConfig.disallowedTools.length > 0);
             const toolConfigJson = hasNewToolConfig
                 ? JSON.stringify({
                     allowedTools: [...(req.toolConfig?.allowedTools || [])],