@grackle-ai/server 0.14.10 → 0.15.1

package/dist/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AAMtC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAatC,+EAA+E;AAC/E,wBAAgB,YAAY,IAAI,IAAI,CAmJnC;AAKD,yDAAyD;AACzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,QAAA,MAAM,EAAE,EAAE,qBAAqB,CAAC,OAAO,MAAM,CAAC,GAAG;IAAE,OAAO,EAAE,YAAY,CAAC,OAAO,QAAQ,CAAC,CAAA;CAAgC,CAAC;AAE1H,eAAe,EAAE,CAAC"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AAMtC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAatC,+EAA+E;AAC/E,wBAAgB,YAAY,IAAI,IAAI,CAgMnC;AAKD,yDAAyD;AACzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,QAAA,MAAM,EAAE,EAAE,qBAAqB,CAAC,OAAO,MAAM,CAAC,GAAG;IAC/C,OAAO,EAAE,YAAY,CAAC,OAAO,QAAQ,CAAC,CAAC;CACV,CAAC;AAEhC,eAAe,EAAE,CAAC"}

package/dist/db.js

@@ -81,7 +81,9 @@ export function initDatabase() {
       updated_at    TEXT NOT NULL DEFAULT (datetime('now')),
       sort_order    INTEGER NOT NULL DEFAULT 0,
       parent_task_id TEXT NOT NULL DEFAULT '',
-      depth         INTEGER NOT NULL DEFAULT 0
+      depth         INTEGER NOT NULL DEFAULT 0,
+      can_decompose INTEGER NOT NULL DEFAULT 0,
+      persona_id    TEXT NOT NULL DEFAULT ''
     );
 
     CREATE TABLE IF NOT EXISTS findings (
@@ -96,18 +98,36 @@ export function initDatabase() {
       created_at    TEXT NOT NULL DEFAULT (datetime('now'))
     );
 
+    CREATE TABLE IF NOT EXISTS personas (
+      id            TEXT PRIMARY KEY,
+      name          TEXT NOT NULL UNIQUE,
+      description   TEXT NOT NULL DEFAULT '',
+      system_prompt TEXT NOT NULL,
+      tool_config   TEXT NOT NULL DEFAULT '{}',
+      runtime       TEXT NOT NULL DEFAULT '',
+      model         TEXT NOT NULL DEFAULT '',
+      max_turns     INTEGER NOT NULL DEFAULT 0,
+      mcp_servers   TEXT NOT NULL DEFAULT '[]',
+      created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
     CREATE INDEX IF NOT EXISTS idx_findings_project ON findings(project_id);
   `);
     // Migration: add powerline_token column if missing (older databases)
     try {
         sqlite.exec("ALTER TABLE environments ADD COLUMN powerline_token TEXT NOT NULL DEFAULT ''");
     }
-    catch { /* column already exists */ }
+    catch {
+        /* column already exists */
+    }
     // Migration: rename sidecar_token → powerline_token (from older databases)
     try {
         sqlite.exec("ALTER TABLE environments RENAME COLUMN sidecar_token TO powerline_token");
     }
-    catch { /* column already renamed or doesn't exist */ }
+    catch {
+        /* column already renamed or doesn't exist */
+    }
     // Migration: backfill NULLs in stage-2 tables from older schemas that lacked NOT NULL
     sqlite.exec(`
     UPDATE projects SET description = '' WHERE description IS NULL;
@@ -138,11 +158,15 @@ export function initDatabase() {
     try {
         sqlite.exec("ALTER TABLE tasks ADD COLUMN parent_task_id TEXT NOT NULL DEFAULT ''");
     }
-    catch { /* column already exists */ }
+    catch {
+        /* column already exists */
+    }
     try {
         sqlite.exec("ALTER TABLE tasks ADD COLUMN depth INTEGER NOT NULL DEFAULT 0");
     }
-    catch { /* column already exists */ }
+    catch {
+        /* column already exists */
+    }
     // Migration: add can_decompose column if missing (older databases)
     try {
         sqlite.exec("ALTER TABLE tasks ADD COLUMN can_decompose INTEGER NOT NULL DEFAULT 0");
@@ -158,7 +182,16 @@ export function initDatabase() {
         )
     `);
     }
-    catch { /* column already exists */ }
+    catch {
+        /* column already exists */
+    }
+    // Migration: add persona_id column to tasks if missing
+    try {
+        sqlite.exec("ALTER TABLE tasks ADD COLUMN persona_id TEXT NOT NULL DEFAULT ''");
+    }
+    catch {
+        /* column already exists */
+    }
 }
 // Run init immediately for backwards compatibility — stores import db at module load
 initDatabase();

package/dist/db.js.map

@@ -1 +1 @@
-{"version":3,"file":"db.js","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC,SAAS,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAE5C,MAAM,MAAM,GAAW,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;AACtD,MAAM,MAAM,GAAkC,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;AAEnE,yDAAyD;AACzD,MAAM,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAEpC,4DAA4D;AAC5D,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAEnC,+EAA+E;AAC/E,MAAM,UAAU,YAAY;IAC1B,wDAAwD;IACxD,MAAM,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFX,CAAC,CAAC;IAEH,qEAAqE;IACrE,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,8EAA8E,CAAC,CAAC;IAC9F,CAAC;IAAC,MAAM,CAAC,CAAC,2BAA2B,CAAC,CAAC;IAEvC,2EAA2E;IAC3E,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,yEAAyE,CAAC,CAAC;IACzF,CAAC;IAAC,MAAM,CAAC,CAAC,6CAA6C,CAAC,CAAC;IAEzD,sFAAsF;IACtF,MAAM,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;GAwBX,CAAC,CAAC;IAEH,+EAA+E;IAC/E,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,sEAAsE,CAAC,CAAC;IACtF,CAAC;IAAC,MAAM,CAAC,CAAC,2BAA2B,CAAC,CAAC;IACvC,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,+DAA+D,CAAC,CAAC;IAC/E,CAAC;IAAC,MAAM,CAAC,CAAC,2BAA2B,CAAC,CAAC;IAEvC,mEAAmE;IACnE,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;QAErF,6EAA6E;QAC7E,MAAM,CAAC,IAAI,CAAC;;;;;;;;;KASX,CAAC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC,CAAC,2BAA2B,CAAC,CAAC;AACzC,CAAC;AAED,qFAAqF;AACrF,YAAY,EAAE,CAAC;AAIf,MAAM,EAAE,GAAsF,OAAO,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;AAE1H,eAAe,EAAE,CAAC"}
+{"version":3,"file":"db.js","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAEtC,SAAS,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AAE5C,MAAM,MAAM,GAAW,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;AACtD,MAAM,MAAM,GAAkC,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;AAEnE,yDAAyD;AACzD,MAAM,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAEpC,4DAA4D;AAC5D,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAEnC,+EAA+E;AAC/E,MAAM,UAAU,YAAY;IAC1B,wDAAwD;IACxD,MAAM,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGX,CAAC,CAAC;IAEH,qEAAqE;IACrE,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CACT,8EAA8E,CAC/E,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,2BAA2B;IAC7B,CAAC;IAED,2EAA2E;IAC3E,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CACT,yEAAyE,CAC1E,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,6CAA6C;IAC/C,CAAC;IAED,sFAAsF;IACtF,MAAM,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;GAwBX,CAAC,CAAC;IAEH,+EAA+E;IAC/E,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CACT,sEAAsE,CACvE,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,2BAA2B;IAC7B,CAAC;IACD,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CACT,+DAA+D,CAChE,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,2BAA2B;IAC7B,CAAC;IAED,mEAAmE;IACnE,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CACT,uEAAuE,CACxE,CAAC;QAEF,6EAA6E;QAC7E,MAAM,CAAC,IAAI,CAAC;;;;;;;;;KASX,CAAC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACP,2BAA2B;IAC7B,CAAC;IAED,uDAAuD;IACvD,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,CACT,kEAAkE,CACnE,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,2BAA2B;IAC7B,CAAC;AACH,CAAC;AAED,qFAAqF;AACrF,YAAY,EAAE,CAAC;AAIf,MAAM,EAAE,GAEJ,OAAO,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;AAEhC,eAAe,EAAE,CAAC"}

package/dist/grpc-service.d.ts

@@ -1,4 +1,11 @@
-import type { ConnectRouter } from "@connectrpc/connect";
+import { type ConnectRouter } from "@connectrpc/connect";
+/** Build a JSON string of MCP server configs for the PowerLine SpawnRequest. */
+export declare function buildMcpServersJson(mcpServers: {
+    name: string;
+    command: string;
+    args?: string[];
+    tools?: string[];
+}[]): string;
 /** Register all Grackle gRPC service handlers on the given ConnectRPC router. */
 export declare function registerGrackleRoutes(router: ConnectRouter): void;
 //# sourceMappingURL=grpc-service.d.ts.map

package/dist/grpc-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grpc-service.d.ts","sourceRoot":"","sources":["../src/grpc-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAuGzD,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAukBjE"}
+{"version":3,"file":"grpc-service.d.ts","sourceRoot":"","sources":["../src/grpc-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AA4M7E,gFAAgF;AAChF,wBAAgB,mBAAmB,CACjC,UAAU,EAAE;IACV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,EAAE,GACF,MAAM,CAUR;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAm5BjE"}

package/dist/grpc-service.js

@@ -1,3 +1,4 @@
+import { ConnectError, Code } from "@connectrpc/connect";
 import { create } from "@bufbuild/protobuf";
 import { grackle, powerline } from "@grackle-ai/common";
 import { v4 as uuid } from "uuid";
@@ -10,12 +11,14 @@ import * as tokenBroker from "./token-broker.js";
 import * as projectStore from "./project-store.js";
 import * as taskStore from "./task-store.js";
 import * as findingStore from "./finding-store.js";
+import * as personaStore from "./persona-store.js";
 import { broadcast } from "./ws-broadcast.js";
 import { processEventStream } from "./event-processor.js";
 import { join } from "node:path";
 import { LOGS_DIR, DEFAULT_RUNTIME, DEFAULT_MODEL, MAX_TASK_DEPTH, taskStatusToEnum, taskStatusToString, projectStatusToEnum, } from "@grackle-ai/common";
 import { grackleHome } from "./paths.js";
 import { safeParseJsonArray } from "./json-helpers.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";
@@ -82,12 +85,87 @@ function taskRowToProto(row, childIds) {
         sortOrder: row.sortOrder,
         parentTaskId: row.parentTaskId,
         depth: row.depth,
-        childTaskIds: childIds ?? taskStore.getChildren(row.id).map(c => c.id),
+        childTaskIds: childIds ?? taskStore.getChildren(row.id).map((c) => c.id),
         canDecompose: row.canDecompose,
+        personaId: row.personaId,
     });
 }
 function findingRowToProto(row) {
-    return create(grackle.FindingSchema, { ...row, tags: safeParseJsonArray(row.tags) });
+    return create(grackle.FindingSchema, {
+        ...row,
+        tags: safeParseJsonArray(row.tags),
+    });
+}
+/** Safely parse a JSON string, returning the fallback value on failure. */
+function safeParseJson(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Convert a persona database row to a Persona proto message. */
+function personaRowToProto(row) {
+    const toolConfig = safeParseJson(row.toolConfig, {});
+    const mcpServers = safeParseJson(row.mcpServers, []);
+    return create(grackle.PersonaSchema, {
+        id: row.id,
+        name: row.name,
+        description: row.description,
+        systemPrompt: row.systemPrompt,
+        toolConfig: create(grackle.ToolConfigSchema, {
+            allowedTools: Array.isArray(toolConfig.allowedTools)
+                ? toolConfig.allowedTools.filter((t) => typeof t === "string")
+                : [],
+            disallowedTools: Array.isArray(toolConfig.disallowedTools)
+                ? toolConfig.disallowedTools.filter((t) => typeof t === "string")
+                : [],
+        }),
+        runtime: row.runtime,
+        model: row.model,
+        maxTurns: row.maxTurns,
+        mcpServers: mcpServers
+            .filter((s) => typeof s === "object" &&
+            s !== null &&
+            typeof s.name === "string" &&
+            typeof s.command === "string")
+            .map((s) => create(grackle.McpServerConfigSchema, {
+            name: s.name,
+            command: s.command,
+            args: Array.isArray(s.args)
+                ? s.args.filter((a) => typeof a === "string")
+                : [],
+            tools: Array.isArray(s.tools)
+                ? s.tools.filter((t) => typeof t === "string")
+                : [],
+        })),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    });
+}
+/** Convert persona MCP server configs to a JSON string for the PowerLine SpawnRequest. */
+function personaMcpServersToJson(row) {
+    const mcpServers = JSON.parse(row.mcpServers || "[]");
+    if (mcpServers.length === 0) {
+        return "";
+    }
+    return buildMcpServersJson(mcpServers);
+}
+/** Build a JSON string of MCP server configs for the PowerLine SpawnRequest. */
+export function buildMcpServersJson(mcpServers) {
+    const obj = {};
+    for (const s of mcpServers) {
+        obj[s.name] = {
+            command: s.command,
+            args: s.args || [],
+            ...(s.tools && s.tools.length > 0 ? { tools: s.tools } : {}),
+        };
+    }
+    return JSON.stringify(obj);
 }
 /** Register all Grackle gRPC service handlers on the given ConnectRPC router. */
 export function registerGrackleRoutes(router) {
@@ -114,14 +192,19 @@ export function registerGrackleRoutes(router) {
                     try {
                         await adapter.disconnect(req.id);
                     }
-                    catch { /* best-effort */ }
+                    catch {
+                        /* best-effort */
+                    }
                 }
             }
             adapterManager.removeConnection(req.id);
             // Delete sessions referencing this environment (FK constraint)
             sessionStore.deleteByEnvironment(req.id);
             envRegistry.removeEnvironment(req.id);
-            broadcast({ type: "environment_removed", payload: { environmentId: req.id } });
+            broadcast({
+                type: "environment_removed",
+                payload: { environmentId: req.id },
+            });
             return create(grackle.EmptySchema, {});
         },
         async *provisionEnvironment(req) {
@@ -210,22 +293,42 @@ export function registerGrackleRoutes(router) {
             if (!conn) {
                 throw new Error(`Environment ${req.environmentId} not connected`);
             }
+            // Resolve persona if specified
+            const persona = req.personaId
+                ? personaStore.getPersona(req.personaId)
+                : undefined;
+            if (req.personaId && !persona) {
+                throw new Error(`Persona not found: ${req.personaId}`);
+            }
             const sessionId = uuid();
-            const runtime = req.runtime || env.defaultRuntime;
-            const model = req.model || process.env.GRACKLE_DEFAULT_MODEL || DEFAULT_MODEL;
+            const runtime = req.runtime || persona?.runtime || env.defaultRuntime;
+            const model = req.model ||
+                persona?.model ||
+                process.env.GRACKLE_DEFAULT_MODEL ||
+                DEFAULT_MODEL;
             const logPath = join(grackleHome, LOGS_DIR, sessionId);
+            let systemContext = req.systemContext || "";
+            if (persona) {
+                systemContext =
+                    persona.systemPrompt + (systemContext ? "\n\n" + systemContext : "");
+            }
             sessionStore.createSession(sessionId, req.environmentId, runtime, req.prompt, model, logPath);
+            const mcpServersJson = persona ? personaMcpServersToJson(persona) : "";
             const powerlineReq = create(powerline.SpawnRequestSchema, {
                 sessionId,
                 runtime,
                 prompt: req.prompt,
                 model,
-                maxTurns: 0,
+                maxTurns: persona?.maxTurns || 0,
                 branch: req.branch || "",
                 worktreeBasePath: req.branch ? "/workspace" : "",
-                systemContext: req.systemContext || "",
+                systemContext,
+                mcpServersJson,
+            });
+            processEventStream(conn.client.spawn(powerlineReq), {
+                sessionId,
+                logPath,
             });
-            processEventStream(conn.client.spawn(powerlineReq), { sessionId, logPath });
             const row = sessionStore.getSession(sessionId);
             return sessionRowToProto(row);
         },
@@ -244,7 +347,10 @@ export function registerGrackleRoutes(router) {
                 runtime: session.runtime,
             });
             const logPath = session.logPath || join(grackleHome, LOGS_DIR, session.id);
-            processEventStream(conn.client.resume(powerlineReq), { sessionId: session.id, logPath });
+            processEventStream(conn.client.resume(powerlineReq), {
+                sessionId: session.id,
+                logPath,
+            });
             const row = sessionStore.getSession(session.id);
             return sessionRowToProto(row);
         },
@@ -374,7 +480,7 @@ export function registerGrackleRoutes(router) {
             const rows = taskStore.listTasks(req.id);
             const childIdsMap = taskStore.buildChildIdsMap(rows);
             return create(grackle.TaskListSchema, {
-                tasks: rows.map(r => taskRowToProto(r, childIdsMap.get(r.id) ?? [])),
+                tasks: rows.map((r) => taskRowToProto(r, childIdsMap.get(r.id) ?? [])),
             });
         },
         async createTask(req) {
@@ -394,10 +500,23 @@ export function registerGrackleRoutes(router) {
                 }
             }
             const id = uuid().slice(0, 8);
-            const environmentId = req.environmentId || project.defaultEnvironmentId;
-            taskStore.createTask(id, req.projectId, req.title, req.description, environmentId, [...req.dependsOn], slugify(project.name), req.parentTaskId, req.canDecompose);
+            // 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);
             const row = taskStore.getTask(id);
-            broadcast({ type: "task_created", payload: { task: row ? { ...row } : null } });
+            broadcast({
+                type: "task_created",
+                payload: { task: row ? { ...row } : null },
+            });
             return taskRowToProto(row);
         },
         async getTask(req) {
@@ -418,7 +537,9 @@ 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 ? [...req.dependsOn] : safeParseJsonArray(existing.dependsOn), req.reviewNotes !== "" ? req.reviewNotes : existing.reviewNotes);
+            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
+                ? [...req.dependsOn]
+                : safeParseJsonArray(existing.dependsOn), req.reviewNotes !== "" ? req.reviewNotes : existing.reviewNotes);
             const row = taskStore.getTask(req.id);
             return taskRowToProto(row);
         },
@@ -441,27 +562,50 @@ export function registerGrackleRoutes(router) {
             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;
+            const persona = personaId
+                ? personaStore.getPersona(personaId)
+                : undefined;
+            if (personaId && !persona) {
+                throw new Error(`Persona not found: ${personaId}`);
+            }
             const env = envRegistry.getEnvironment(environmentId);
             const sessionId = uuid();
-            const runtime = req.runtime || env?.defaultRuntime || DEFAULT_RUNTIME;
-            const model = req.model || process.env.GRACKLE_DEFAULT_MODEL || DEFAULT_MODEL;
+            const runtime = req.runtime ||
+                persona?.runtime ||
+                env?.defaultRuntime ||
+                DEFAULT_RUNTIME;
+            const model = req.model ||
+                persona?.model ||
+                process.env.GRACKLE_DEFAULT_MODEL ||
+                DEFAULT_MODEL;
+            const maxTurns = persona?.maxTurns || 0;
             const logPath = join(grackleHome, LOGS_DIR, sessionId);
-            const systemContext = buildTaskSystemContext(task.title, task.description, task.reviewNotes, task.canDecompose);
+            let systemContext = buildTaskSystemContext(task.title, task.description, task.reviewNotes, task.canDecompose);
+            if (persona) {
+                systemContext = persona.systemPrompt + "\n\n" + systemContext;
+            }
             sessionStore.createSession(sessionId, environmentId, runtime, task.title, model, logPath);
             taskStore.setTaskSession(task.id, sessionId);
             taskStore.markTaskStarted(task.id);
-            broadcast({ type: "task_started", payload: { taskId: task.id, sessionId, projectId: task.projectId } });
+            broadcast({
+                type: "task_started",
+                payload: { taskId: task.id, sessionId, projectId: task.projectId },
+            });
+            const mcpServersJson = persona ? personaMcpServersToJson(persona) : "";
             const powerlineReq = create(powerline.SpawnRequestSchema, {
                 sessionId,
                 runtime,
                 prompt: task.title,
                 model,
-                maxTurns: 0,
+                maxTurns,
                 branch: task.branch,
                 worktreeBasePath: task.branch ? "/workspace" : "",
                 systemContext,
                 projectId: task.projectId,
                 taskId: task.id,
+                mcpServersJson,
             });
             processEventStream(conn.client.spawn(powerlineReq), {
                 sessionId,
@@ -479,7 +623,10 @@ export function registerGrackleRoutes(router) {
                         else if (sess?.status === "failed") {
                             taskStore.markTaskCompleted(task.id, "failed");
                         }
-                        broadcast({ type: "task_updated", payload: { taskId: task.id, projectId: task.projectId } });
+                        broadcast({
+                            type: "task_updated",
+                            payload: { taskId: task.id, projectId: task.projectId },
+                        });
                     }
                 },
             });
@@ -498,11 +645,18 @@ export function registerGrackleRoutes(router) {
                     sessionId: "",
                     type: grackle.EventType.SYSTEM,
                     timestamp: new Date().toISOString(),
-                    content: JSON.stringify({ type: "task_unblocked", taskId: t.id, title: t.title }),
+                    content: JSON.stringify({
+                        type: "task_unblocked",
+                        taskId: t.id,
+                        title: t.title,
+                    }),
                     raw: "",
                 }));
             }
-            broadcast({ type: "task_approved", payload: { taskId: task.id, projectId: task.projectId } });
+            broadcast({
+                type: "task_approved",
+                payload: { taskId: task.id, projectId: task.projectId },
+            });
             const row = taskStore.getTask(task.id);
             return taskRowToProto(row);
         },
@@ -511,25 +665,151 @@ export function registerGrackleRoutes(router) {
             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 || "");
-            broadcast({ type: "task_rejected", payload: { taskId: task.id, projectId: task.projectId } });
+            broadcast({
+                type: "task_rejected",
+                payload: { taskId: task.id, projectId: task.projectId },
+            });
             const row = taskStore.getTask(task.id);
             return taskRowToProto(row);
         },
         async deleteTask(req) {
             const task = taskStore.getTask(req.id);
+            if (!task) {
+                throw new ConnectError(`Task not found: ${req.id}`, Code.NotFound);
+            }
             const children = taskStore.getChildren(req.id);
             if (children.length > 0) {
-                throw new Error("Cannot delete task with children. Delete children first.");
+                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");
+                        }
+                    }
+                    sessionStore.updateSession(task.sessionId, "killed");
+                    streamHub.publish(create(grackle.SessionEventSchema, {
+                        sessionId: task.sessionId,
+                        type: grackle.EventType.STATUS,
+                        timestamp: new Date().toISOString(),
+                        content: "killed",
+                        raw: "",
+                    }));
+                }
+            }
+            const changes = taskStore.deleteTask(req.id);
+            if (changes === 0) {
+                logger.error({ taskId: req.id }, "deleteTask returned 0 changes despite task existing");
+                throw new ConnectError(`Failed to delete task ${req.id}: no rows affected`, Code.Internal);
+            }
+            broadcast({
+                type: "task_deleted",
+                payload: { taskId: req.id, projectId: task.projectId },
+            });
+            return create(grackle.EmptySchema, {});
+        },
+        // ─── Personas ───────────────────────────────────────────────
+        async listPersonas() {
+            const rows = personaStore.listPersonas();
+            return create(grackle.PersonaListSchema, {
+                personas: rows.map(personaRowToProto),
+            });
+        },
+        async createPersona(req) {
+            if (!req.name)
+                throw new Error("Persona name is required");
+            if (!req.systemPrompt)
+                throw new Error("Persona system_prompt is required");
+            // Enforce unique ID and unique name
+            let id = slugify(req.name) || uuid().slice(0, 8);
+            if (personaStore.getPersona(id)) {
+                id = `${id}-${uuid().slice(0, 4)}`;
             }
-            taskStore.deleteTask(req.id);
-            broadcast({ type: "task_deleted", payload: { taskId: req.id, projectId: task?.projectId } });
+            if (personaStore.getPersonaByName(req.name)) {
+                throw new Error(`Persona with name "${req.name}" already exists`);
+            }
+            const toolConfigJson = JSON.stringify({
+                allowedTools: [...(req.toolConfig?.allowedTools || [])],
+                disallowedTools: [...(req.toolConfig?.disallowedTools || [])],
+            });
+            const mcpServersJson = JSON.stringify(req.mcpServers.map((s) => ({
+                name: s.name,
+                command: s.command,
+                args: [...s.args],
+                tools: [...s.tools],
+            })));
+            personaStore.createPersona(id, req.name, req.description, req.systemPrompt, toolConfigJson, req.runtime, req.model, req.maxTurns, mcpServersJson);
+            broadcast({ type: "persona_created", payload: { personaId: id } });
+            const row = personaStore.getPersona(id);
+            return personaRowToProto(row);
+        },
+        async getPersona(req) {
+            const row = personaStore.getPersona(req.id);
+            if (!row)
+                throw new Error(`Persona not found: ${req.id}`);
+            return personaRowToProto(row);
+        },
+        async updatePersona(req) {
+            const existing = personaStore.getPersona(req.id);
+            if (!existing)
+                throw new Error(`Persona not found: ${req.id}`);
+            // 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));
+            const toolConfigJson = hasNewToolConfig
+                ? JSON.stringify({
+                    allowedTools: [...(req.toolConfig?.allowedTools || [])],
+                    disallowedTools: [...(req.toolConfig?.disallowedTools || [])],
+                })
+                : existing.toolConfig;
+            const hasNewMcpServers = Array.isArray(req.mcpServers) && req.mcpServers.length > 0;
+            const mcpServersJson = hasNewMcpServers
+                ? JSON.stringify(req.mcpServers.map((s) => ({
+                    name: s.name,
+                    command: s.command,
+                    args: [...s.args],
+                    tools: [...s.tools],
+                })))
+                : existing.mcpServers;
+            // Treat empty string / 0 as "not set" and keep existing value
+            const name = req.name || existing.name;
+            if (name !== existing.name && personaStore.getPersonaByName(name)) {
+                throw new Error(`Persona with name "${name}" already exists`);
+            }
+            const description = req.description || existing.description;
+            const systemPrompt = req.systemPrompt || existing.systemPrompt;
+            const runtime = req.runtime || existing.runtime;
+            const model = req.model || existing.model;
+            const maxTurns = req.maxTurns === 0 ? existing.maxTurns : req.maxTurns;
+            personaStore.updatePersona(req.id, name, description, systemPrompt, toolConfigJson, runtime, model, maxTurns, mcpServersJson);
+            broadcast({ type: "persona_updated", payload: { personaId: req.id } });
+            const row = personaStore.getPersona(req.id);
+            return personaRowToProto(row);
+        },
+        async deletePersona(req) {
+            personaStore.deletePersona(req.id);
+            broadcast({ type: "persona_deleted", payload: { personaId: req.id } });
             return create(grackle.EmptySchema, {});
         },
         // ─── Findings ────────────────────────────────────────────
         async postFinding(req) {
             const id = uuid().slice(0, 8);
             findingStore.postFinding(id, req.projectId, req.taskId, req.sessionId, req.category, req.title, req.content, [...req.tags]);
-            broadcast({ type: "finding_posted", payload: { projectId: req.projectId, findingId: id } });
+            broadcast({
+                type: "finding_posted",
+                payload: { projectId: req.projectId, findingId: id },
+            });
             const rows = findingStore.queryFindings(req.projectId);
             const row = rows.find((r) => r.id === id);
             return findingRowToProto(row);
@@ -556,7 +836,8 @@ export function registerGrackleRoutes(router) {
                 throw new Error(`Task not found: ${req.taskId}`);
             if (!task.branch)
                 throw new Error("Task has no branch");
-            const environmentId = task.environmentId || projectStore.getProject(task.projectId)?.defaultEnvironmentId;
+            const environmentId = task.environmentId ||
+                projectStore.getProject(task.projectId)?.defaultEnvironmentId;
             if (!environmentId)
                 throw new Error("No environment for task");
             const conn = adapterManager.getConnection(environmentId);