agor-live 0.17.2 → 0.17.3

package/dist/daemon/register-routes.js

@@ -16293,11 +16293,47 @@ async function getOAuthStatus(ctx, mcpServer) {
   }
   return { authenticated: false };
 }
+async function summarizeMcpServer(ctx, mcpServer) {
+  const authType = mcpServer.auth?.type || "none";
+  const oauthMode = mcpServer.auth?.oauth_mode || "per_user";
+  const { authenticated } = await getOAuthStatus(ctx, mcpServer);
+  return {
+    mcp_server_id: mcpServer.mcp_server_id,
+    name: mcpServer.name,
+    display_name: mcpServer.display_name,
+    transport: mcpServer.transport,
+    auth_type: authType,
+    oauth_mode: oauthMode,
+    oauth_authenticated: authenticated,
+    enabled: mcpServer.enabled
+  };
+}
+async function listAttachedMcpServers(ctx, sessionId, opts = {}) {
+  const sessionMCPServers = await ctx.app.service("session-mcp-servers").find({
+    ...ctx.baseServiceParams,
+    query: {
+      session_id: sessionId,
+      ...opts.includeDisabled ? {} : { enabled: true },
+      $limit: 100
+    }
+  });
+  const data = Array.isArray(sessionMCPServers) ? sessionMCPServers : sessionMCPServers.data;
+  const summaries = [];
+  for (const sms of data) {
+    try {
+      const mcpServer = await ctx.app.service("mcp-servers").get(sms.mcp_server_id, ctx.baseServiceParams);
+      summaries.push(await summarizeMcpServer(ctx, mcpServer));
+    } catch (error48) {
+      console.warn(`Failed to fetch MCP server ${sms.mcp_server_id}:`, error48);
+    }
+  }
+  return summaries;
+}
 function registerMcpServerTools(server, ctx) {
   server.registerTool(
     "agor_mcp_servers_list",
     {
-      description: "List MCP servers available to the current session. Shows each server's name, transport type, authentication type, and OAuth connection status. Use this to see which external tools/services are configured and whether they need authentication.",
+      description: "List the MCP-server catalog the current user can access (i.e. servers eligible to attach to a session). Each entry includes name, transport, auth type, and OAuth status. Use this to discover IDs to pass to `agor_sessions_create({ mcpServerIds })`. To see which servers are currently ATTACHED to a session, read `attached_mcp_servers` from `agor_sessions_get_current` or `agor_sessions_get`.",
       annotations: { readOnlyHint: true },
       inputSchema: external_exports2.object({
         includeDisabled: external_exports2.boolean().optional().describe("Include disabled MCP servers (default: false)")
@@ -16305,62 +16341,20 @@ function registerMcpServerTools(server, ctx) {
     },
     async (args) => {
       const includeDisabled = args.includeDisabled === true;
-      const sessionMCPServers = await ctx.app.service("session-mcp-servers").find({
+      const result = await ctx.app.service("mcp-servers").find({
         ...ctx.baseServiceParams,
         query: {
-          session_id: ctx.sessionId,
+          scope: "global",
           ...includeDisabled ? {} : { enabled: true },
           $limit: 100
         }
       });
+      const data = Array.isArray(result) ? result : result.data;
       const servers = [];
-      const sessionMCPData = Array.isArray(sessionMCPServers) ? sessionMCPServers : sessionMCPServers.data;
-      const mcpServerIds = sessionMCPData.map(
-        (sms) => sms.mcp_server_id
-      );
-      for (const serverId of mcpServerIds) {
-        try {
-          const mcpServer = await ctx.app.service("mcp-servers").get(serverId, ctx.baseServiceParams);
-          const authType = mcpServer.auth?.type || "none";
-          const oauthMode = mcpServer.auth?.oauth_mode || "per_user";
-          const { authenticated } = await getOAuthStatus(ctx, mcpServer);
-          servers.push({
-            mcp_server_id: mcpServer.mcp_server_id,
-            name: mcpServer.name,
-            display_name: mcpServer.display_name,
-            transport: mcpServer.transport,
-            auth_type: authType,
-            oauth_mode: oauthMode,
-            oauth_authenticated: authenticated,
-            enabled: mcpServer.enabled
-          });
-        } catch (error48) {
-          console.warn(`Failed to fetch MCP server ${serverId}:`, error48);
-        }
-      }
-      const globalServers = await ctx.app.service("mcp-servers").find({
-        ...ctx.baseServiceParams,
-        query: { scope: "global", ...includeDisabled ? {} : { enabled: true }, $limit: 100 }
-      });
-      for (const mcpServer of Array.isArray(globalServers) ? globalServers : globalServers.data) {
-        if (!mcpServerIds.includes(mcpServer.mcp_server_id)) {
-          const authType = mcpServer.auth?.type || "none";
-          const oauthMode = mcpServer.auth?.oauth_mode || "per_user";
-          const { authenticated } = await getOAuthStatus(ctx, mcpServer);
-          servers.push({
-            mcp_server_id: mcpServer.mcp_server_id,
-            name: mcpServer.name,
-            display_name: mcpServer.display_name,
-            transport: mcpServer.transport,
-            auth_type: authType,
-            oauth_mode: oauthMode,
-            oauth_authenticated: authenticated,
-            enabled: mcpServer.enabled
-          });
-        }
+      for (const mcpServer of data) {
+        servers.push(await summarizeMcpServer(ctx, mcpServer));
       }
       return textResult({
-        session_id: ctx.sessionId,
         mcp_servers: servers,
         summary: {
           total: servers.length,
@@ -16797,11 +16791,24 @@ var init_search = __esm({
 
 // src/mcp/tools/sessions.ts
 import { WorktreeRepository as WorktreeRepository3 } from "@agor/core/db";
-import { resolveModelConfigPrecedence } from "@agor/core/models";
+import {
+  AVAILABLE_CLAUDE_MODEL_ALIASES,
+  CODEX_MODEL_METADATA,
+  DEFAULT_CLAUDE_MODEL,
+  DEFAULT_CODEX_MODEL,
+  DEFAULT_GEMINI_MODEL,
+  GEMINI_MODELS
+} from "@agor/core/models";
+import { resolveSessionDefaults } from "@agor/core/sessions";
 import {
   AGENTIC_TOOL_CAPABILITIES,
   getSessionType
 } from "@agor/core/types";
+function coerceModelConfig(input) {
+  if (input === void 0) return void 0;
+  if (typeof input === "string") return { model: input };
+  return input;
+}
 function registerSessionTools(server, ctx) {
   server.registerTool(
     "agor_sessions_list",
@@ -16854,7 +16861,7 @@ function registerSessionTools(server, ctx) {
   server.registerTool(
     "agor_sessions_get",
     {
-      description: "Get detailed information about a specific session, including genealogy and current state. The response includes a `url` field with a clickable link to view the session in the UI.",
+      description: "Get detailed information about a specific session, including genealogy, current state, and the MCP servers currently attached to it (with OAuth status \u2014 check `attached_mcp_servers[].oauth_authenticated` to spot servers needing auth). The response includes a `url` field with a clickable link to view the session in the UI.",
       annotations: { readOnlyHint: true },
       inputSchema: external_exports2.object({
         sessionId: external_exports2.string().describe("Session ID (UUIDv7 or short ID like 01a1b2c3)")
@@ -16867,13 +16874,14 @@ function registerSessionTools(server, ctx) {
         _last_message_truncation_length: 500
       };
       const session = await ctx.app.service("sessions").get(args.sessionId, sessionParams);
-      return textResult(session);
+      const attached_mcp_servers = await listAttachedMcpServers(ctx, session.session_id);
+      return textResult({ ...session, attached_mcp_servers });
     }
   );
   server.registerTool(
     "agor_sessions_get_current",
     {
-      description: "Get information about the current session (the one making this MCP call). Returns session details plus denormalized worktree, repo, and board context \u2014 useful for introspection and getting IDs needed by other tools.",
+      description: "Get information about the current session (the one making this MCP call). Returns session details, denormalized worktree/repo/board context, and the MCP servers attached to this session (each with `oauth_authenticated` so callers can spot servers needing auth). To browse the broader catalog of servers eligible to attach, use `agor_mcp_servers_list`.",
       annotations: { readOnlyHint: true },
       inputSchema: external_exports2.object({})
     },
@@ -16923,11 +16931,13 @@ function registerSessionTools(server, ctx) {
         } catch {
         }
       }
+      const attached_mcp_servers = await listAttachedMcpServers(ctx, ctx.sessionId);
       return textResult({
         session,
         worktree,
         repo,
-        board
+        board,
+        attached_mcp_servers
       });
     }
   );
@@ -17084,10 +17094,10 @@ function registerSessionTools(server, ctx) {
         extraInstructions: args.extraInstructions,
         task_id: args.taskId,
         mcpServerIds: args.mcpServerIds,
-        modelConfig: args.modelConfig
+        modelConfig: coerceModelConfig(args.modelConfig)
       };
       const childSession = await ctx.app.service("sessions").spawn(ctx.sessionId, spawnData, ctx.baseServiceParams);
-      const promptResponse = await ctx.app.service("/sessions/:id/prompt").create(
+      const task = await ctx.app.service("/sessions/:id/prompt").create(
         {
           prompt: args.prompt,
           permissionMode: childSession.permission_config?.mode || "acceptEdits",
@@ -17100,8 +17110,8 @@ function registerSessionTools(server, ctx) {
       );
       return textResult({
         session: childSession,
-        taskId: promptResponse.taskId,
-        status: promptResponse.status,
+        taskId: task.task_id,
+        status: task.status,
         note: "Subsession created and prompt execution started in background."
       });
     }
@@ -17131,22 +17141,23 @@ function registerSessionTools(server, ctx) {
       const mode = args.mode;
       const sessionId = await resolveSessionId(ctx, args.sessionId);
       if (mode === "continue") {
-        const promptResponse = await ctx.app.service("/sessions/:id/prompt").create(
+        const task = await ctx.app.service("/sessions/:id/prompt").create(
           { prompt: args.prompt, stream: true },
           { ...ctx.baseServiceParams, route: { id: sessionId } }
         );
-        if (promptResponse.queued) {
+        if (task.status === "queued") {
           return textResult({
             success: true,
             queued: true,
-            queue_position: promptResponse.queue_position,
+            taskId: task.task_id,
+            queue_position: task.queue_position,
             note: "Session is busy. Prompt has been queued and will execute automatically when the session becomes idle."
           });
         }
         return textResult({
           success: true,
-          taskId: promptResponse.taskId,
-          status: promptResponse.status,
+          taskId: task.task_id,
+          status: task.status,
           note: "Prompt added to existing session and execution started."
         });
       } else if (mode === "fork" || mode === "btw") {
@@ -17175,7 +17186,7 @@ function registerSessionTools(server, ctx) {
           await ctx.app.service("sessions").patch(forkedSession.session_id, forkPatch, ctx.baseServiceParams);
         }
         const updatedSession = await ctx.app.service("sessions").get(forkedSession.session_id, ctx.baseServiceParams);
-        const promptResponse = await ctx.app.service("/sessions/:id/prompt").create(
+        const task = await ctx.app.service("/sessions/:id/prompt").create(
           {
             prompt: args.prompt,
             permissionMode: updatedSession.permission_config?.mode,
@@ -17186,21 +17197,21 @@ function registerSessionTools(server, ctx) {
         const note = mode === "btw" ? 'Ephemeral "btw" fork created. Result will be sent back via callback when done, then the fork will auto-archive.' : "Forked session created and prompt execution started.";
         return textResult({
           session: updatedSession,
-          taskId: promptResponse.taskId,
-          status: promptResponse.status,
+          taskId: task.task_id,
+          status: task.status,
           note
         });
       } else if (mode === "subsession") {
         const spawnData = {
           prompt: args.prompt,
           mcpServerIds: args.mcpServerIds,
-          modelConfig: args.modelConfig
+          modelConfig: coerceModelConfig(args.modelConfig)
         };
         if (args.title) spawnData.title = args.title;
         if (args.agenticTool) spawnData.agent = args.agenticTool;
         if (args.taskId) spawnData.task_id = args.taskId;
         const childSession = await ctx.app.service("sessions").spawn(sessionId, spawnData, ctx.baseServiceParams);
-        const promptResponse = await ctx.app.service("/sessions/:id/prompt").create(
+        const task = await ctx.app.service("/sessions/:id/prompt").create(
           {
             prompt: args.prompt,
             permissionMode: childSession.permission_config?.mode,
@@ -17210,8 +17221,8 @@ function registerSessionTools(server, ctx) {
         );
         return textResult({
           session: childSession,
-          taskId: promptResponse.taskId,
-          status: promptResponse.status,
+          taskId: task.task_id,
+          status: task.status,
           note: "Subsession created and prompt execution started."
         });
       }
@@ -17221,7 +17232,7 @@ function registerSessionTools(server, ctx) {
   server.registerTool(
     "agor_sessions_create",
     {
-      description: "Create a new session in an existing worktree. Use for starting fresh work on a new task in the same codebase (e.g., new feature branch, separate investigation). Unlike spawn, this creates an independent session with no parent-child relationship. MCP servers are inherited from the worktree (if configured) or user defaults, or can be overridden via `mcpServerIds`. Model selection falls back to user defaults and can be overridden via `modelConfig`. Supports optional callbacks to notify the creating session when the new session completes.",
+      description: 'Create a new session in an existing worktree. Use for starting fresh work on a new task in the same codebase (e.g., new feature branch, separate investigation). Unlike spawn, this creates an independent session with no parent-child relationship. MCP servers are inherited from the worktree (if configured) or user defaults, or can be overridden via `mcpServerIds`. Model selection falls back to user defaults and can be overridden via `modelConfig` (accepts either a model ID string like "claude-opus-4-6" or a full {mode, model, effort, provider} object \u2014 call `agor_models_list` to discover valid model IDs per agenticTool). Supports optional callbacks to notify the creating session when the new session completes.',
       inputSchema: external_exports2.object({
         worktreeId: external_exports2.string().describe("Worktree ID where the session will run (required)"),
         agenticTool: external_exports2.enum(["claude-code", "codex", "gemini"]).describe("Which agent to use for this session (required)"),
@@ -17255,27 +17266,20 @@ function registerSessionTools(server, ctx) {
       const { getGitState, getCurrentBranch } = await import("@agor/core/git");
       const currentSha = await getGitState(worktree.path);
       const currentRef = await getCurrentBranch(worktree.path);
-      const { getDefaultPermissionMode } = await import("@agor/core/types");
-      const { mapPermissionMode } = await import("@agor/core/utils/permission-mode-mapper");
-      const userToolDefaults = user?.default_agentic_config?.[agenticTool];
-      const requestedMode = userToolDefaults?.permissionMode || getDefaultPermissionMode(agenticTool);
-      const permissionMode = mapPermissionMode(requestedMode, agenticTool);
-      const permissionConfig = {
-        mode: permissionMode,
-        allowedTools: []
-      };
-      if (agenticTool === "codex" && userToolDefaults?.codexSandboxMode && userToolDefaults?.codexApprovalPolicy) {
-        permissionConfig.codex = {
-          sandboxMode: userToolDefaults.codexSandboxMode,
-          approvalPolicy: userToolDefaults.codexApprovalPolicy,
-          networkAccess: userToolDefaults.codexNetworkAccess
-        };
-      }
-      const modelConfig = resolveModelConfigPrecedence([
-        args.modelConfig,
-        userToolDefaults?.modelConfig
-      ]);
-      const mcpServerIds = args.mcpServerIds !== void 0 ? await Promise.all(args.mcpServerIds.map((id) => resolveMcpServerId(ctx, id))) : worktree.mcp_server_ids && worktree.mcp_server_ids.length > 0 ? worktree.mcp_server_ids : userToolDefaults?.mcpServerIds || [];
+      const explicitMcpServerIds = args.mcpServerIds !== void 0 ? await Promise.all(args.mcpServerIds.map((id) => resolveMcpServerId(ctx, id))) : void 0;
+      const resolvedDefaults = resolveSessionDefaults({
+        agenticTool,
+        user,
+        worktree,
+        overrides: {
+          modelConfig: coerceModelConfig(args.modelConfig),
+          mcpServerIds: explicitMcpServerIds
+        }
+      });
+      const permissionConfig = resolvedDefaults.permission_config;
+      const modelConfig = resolvedDefaults.model_config;
+      const mcpServerIds = resolvedDefaults.mcp_server_ids;
+      const permissionMode = permissionConfig.mode;
       const mcpServerIdsFromArgs = args.mcpServerIds !== void 0;
       const callbackConfig = {};
       const effectiveCallbackSessionId = args.callbackSessionId || ctx.sessionId;
@@ -17331,9 +17335,9 @@ function registerSessionTools(server, ctx) {
       if (mcpServerIds && mcpServerIds.length > 0) {
         for (const mcpServerId of mcpServerIds) {
           try {
-            await ctx.app.service("session-mcp-servers").create(
-              { session_id: session.session_id, mcp_server_id: mcpServerId },
-              ctx.baseServiceParams
+            await ctx.app.service("/sessions/:id/mcp-servers").create(
+              { mcpServerId },
+              { ...ctx.baseServiceParams, route: { id: session.session_id } }
             );
           } catch (error48) {
             const reason = error48 instanceof Error ? error48.message : String(error48);
@@ -17347,9 +17351,9 @@ function registerSessionTools(server, ctx) {
           }
         }
       }
-      let promptResponse = null;
+      let initialTask = null;
       if (args.initialPrompt) {
-        promptResponse = await ctx.app.service("/sessions/:id/prompt").create(
+        initialTask = await ctx.app.service("/sessions/:id/prompt").create(
           { prompt: args.initialPrompt, permissionMode, stream: true },
           { ...ctx.baseServiceParams, route: { id: session.session_id } }
         );
@@ -17358,7 +17362,7 @@ function registerSessionTools(server, ctx) {
       const mcpFailureNote = mcpAttachFailures.length > 0 ? ` Warning: ${mcpAttachFailures.length} requested MCP server(s) failed to attach \u2014 see mcpAttachFailures.` : "";
       return textResult({
         session,
-        taskId: promptResponse?.taskId,
+        taskId: initialTask?.task_id,
         note: args.initialPrompt ? `Session created and initial prompt execution started.${callbackNote}${mcpFailureNote}` : `Session created successfully.${callbackNote}${mcpFailureNote}`,
         ...mcpAttachFailures.length > 0 && { mcpAttachFailures }
       });
@@ -17619,8 +17623,56 @@ function registerSessionTools(server, ctx) {
       });
     }
   );
+  server.registerTool(
+    "agor_models_list",
+    {
+      description: "List valid model IDs grouped by agenticTool. Use this to discover what to pass for `modelConfig` (or its string shorthand) in agor_sessions_create / spawn / prompt. Sourced live from the daemon model registry \u2014 when new models ship and the registry is updated, this tool returns them on the next call.",
+      annotations: { readOnlyHint: true },
+      inputSchema: external_exports2.object({
+        agenticTool: external_exports2.enum(["claude-code", "codex", "gemini"]).optional().describe("Filter to a single agentic tool. Omit to return all tools.")
+      })
+    },
+    async (args) => {
+      const claudeModels = AVAILABLE_CLAUDE_MODEL_ALIASES.map((m) => ({
+        id: m.id,
+        displayName: m.displayName,
+        description: m.description,
+        family: m.family
+      }));
+      const codexModels = Object.entries(CODEX_MODEL_METADATA).map(([id, meta3]) => ({
+        id,
+        displayName: meta3.name,
+        description: meta3.description
+      }));
+      const geminiModels = Object.entries(GEMINI_MODELS).map(([id, meta3]) => ({
+        id,
+        displayName: meta3.name,
+        description: meta3.description,
+        useCase: meta3.useCase
+      }));
+      const all = {
+        "claude-code": {
+          default: DEFAULT_CLAUDE_MODEL,
+          models: claudeModels
+        },
+        codex: {
+          default: DEFAULT_CODEX_MODEL,
+          models: codexModels
+        },
+        gemini: {
+          default: DEFAULT_GEMINI_MODEL,
+          models: geminiModels,
+          note: "Gemini models are normally fetched live from the Google API per-user. This is the static fallback list \u2014 newer models may exist."
+        }
+      };
+      if (args.agenticTool) {
+        return textResult({ [args.agenticTool]: all[args.agenticTool] });
+      }
+      return textResult(all);
+    }
+  );
 }
-var modelConfigInputSchema;
+var modelConfigObjectSchema, modelConfigInputSchema;
 var init_sessions = __esm({
   "src/mcp/tools/sessions.ts"() {
     "use strict";
@@ -17628,15 +17680,22 @@ var init_sessions = __esm({
     init_worktree_authorization();
     init_resolve_ids();
     init_server();
-    modelConfigInputSchema = external_exports2.object({
+    init_mcp_servers();
+    modelConfigObjectSchema = external_exports2.object({
       mode: external_exports2.enum(["alias", "exact"]).optional().describe("Model selection mode (default: 'alias')"),
       // .min(1): reject empty-string model explicitly so callers don't silently
       // fall through to user defaults when they meant to pin a specific model.
       model: external_exports2.string().min(1).describe("Model identifier (e.g. 'claude-opus-4-6', 'claude-sonnet-4-6')"),
       effort: external_exports2.enum(["low", "medium", "high", "max"]).optional().describe("Reasoning effort level (default: high)"),
       provider: external_exports2.string().optional().describe("Provider ID (OpenCode only, e.g. 'anthropic')")
-    }).optional().describe(
-      "Model override for this session. When set, overrides the user default model_config. Threaded through to the spawned agent process so it actually runs on the requested model."
+    });
+    modelConfigInputSchema = external_exports2.union([
+      external_exports2.string().min(1).describe(
+        "Shorthand: just the model ID string (e.g. 'claude-opus-4-6'). Equivalent to { model: <id> }."
+      ),
+      modelConfigObjectSchema
+    ]).optional().describe(
+      "Model override for this session. Pass either a model ID string (e.g. 'claude-opus-4-6') or a full { mode, model, effort, provider } object. Overrides the user default model_config and is threaded through to the spawned agent process. Call agor_models_list to discover valid model IDs per agenticTool."
     );
   }
 });
@@ -17838,7 +17897,7 @@ var init_users = __esm({
 // src/mcp/tools/worktrees.ts
 import { isWorktreeRbacEnabled as isWorktreeRbacEnabled2 } from "@agor/core/config";
 import { WorktreeRepository as WorktreeRepository4 } from "@agor/core/db";
-import { resolveModelConfig } from "@agor/core/models";
+import { resolveSessionDefaults as resolveSessionDefaults2 } from "@agor/core/sessions";
 import { getAssistantConfig, isAssistant, WORKTREE_PERMISSION_LEVELS as WORKTREE_PERMISSION_LEVELS2 } from "@agor/core/types";
 import { computeZoneRelativePosition } from "@agor/core/utils/board-placement";
 import { normalizeOptionalHttpUrl } from "@agor/core/utils/url";
@@ -18274,27 +18333,28 @@ function registerWorktreeTools(server, ctx) {
         };
         const renderedPrompt = renderTemplate(zone.trigger.template, templateContext);
         if (renderedPrompt) {
-          const promptResponse = await ctx.app.service("/sessions/:id/prompt").create(
+          const task = await ctx.app.service("/sessions/:id/prompt").create(
             { prompt: renderedPrompt, stream: true },
             { ...ctx.baseServiceParams, route: { id: targetSessionId } }
           );
-          if (promptResponse.queued) {
+          if (task.status === "queued") {
             promptResult = {
               queued: true,
-              queue_position: promptResponse.queue_position,
+              taskId: task.task_id,
+              queue_position: task.queue_position,
               sessionId: targetSessionId,
               note: "Session is busy. Zone trigger prompt has been queued."
             };
             console.log(
-              `\u{1F4EC} Zone trigger queued for session ${targetSessionId.substring(0, 8)} at position ${promptResponse.queue_position}`
+              `\u{1F4EC} Zone trigger queued for session ${targetSessionId.substring(0, 8)} at position ${task.queue_position}`
             );
           } else {
             promptResult = {
-              taskId: promptResponse.taskId,
+              taskId: task.task_id,
               sessionId: targetSessionId,
               note: "Zone trigger prompt sent to target session"
             };
-            console.log(`\u2705 Zone trigger executed: task ${promptResponse.taskId.substring(0, 8)}`);
+            console.log(`\u2705 Zone trigger executed: task ${task.task_id.substring(0, 8)}`);
           }
         } else {
           promptResult = {
@@ -18334,24 +18394,11 @@ function registerWorktreeTools(server, ctx) {
           const { getGitState, getCurrentBranch } = await import("@agor/core/git");
           const currentSha = await getGitState(worktree.path);
           const currentRef = await getCurrentBranch(worktree.path);
-          const { getDefaultPermissionMode } = await import("@agor/core/types");
-          const { mapPermissionMode } = await import("@agor/core/utils/permission-mode-mapper");
-          const userToolDefaults = user?.default_agentic_config?.[agenticTool];
-          const requestedMode = userToolDefaults?.permissionMode || getDefaultPermissionMode(agenticTool);
-          const permissionMode = mapPermissionMode(requestedMode, agenticTool);
-          const permissionConfig = {
-            mode: permissionMode,
-            allowedTools: []
-          };
-          if (agenticTool === "codex" && userToolDefaults?.codexSandboxMode && userToolDefaults?.codexApprovalPolicy) {
-            permissionConfig.codex = {
-              sandboxMode: userToolDefaults.codexSandboxMode,
-              approvalPolicy: userToolDefaults.codexApprovalPolicy,
-              networkAccess: userToolDefaults.codexNetworkAccess
-            };
-          }
-          const modelConfig = resolveModelConfig(userToolDefaults?.modelConfig);
-          const mcpServerIds = worktree.mcp_server_ids && worktree.mcp_server_ids.length > 0 ? worktree.mcp_server_ids : userToolDefaults?.mcpServerIds || [];
+          const {
+            permission_config: permissionConfig,
+            model_config: modelConfig,
+            mcp_server_ids: mcpServerIds
+          } = resolveSessionDefaults2({ agenticTool, user, worktree });
           const sessionData = {
             worktree_id: worktreeId,
             agentic_tool: agenticTool,
@@ -18376,12 +18423,9 @@ function registerWorktreeTools(server, ctx) {
           if (mcpServerIds.length > 0) {
             for (const mcpServerId of mcpServerIds) {
               try {
-                await ctx.app.service("session-mcp-servers").create(
-                  {
-                    session_id: newSession.session_id,
-                    mcp_server_id: mcpServerId
-                  },
-                  ctx.baseServiceParams
+                await ctx.app.service("/sessions/:id/mcp-servers").create(
+                  { mcpServerId },
+                  { ...ctx.baseServiceParams, route: { id: newSession.session_id } }
                 );
               } catch (error48) {
                 console.warn(
@@ -18391,16 +18435,16 @@ function registerWorktreeTools(server, ctx) {
             }
             console.log(`\u2705 Attached ${mcpServerIds.length} MCP servers`);
           }
-          const promptResponse = await ctx.app.service("/sessions/:id/prompt").create(
+          const task = await ctx.app.service("/sessions/:id/prompt").create(
             { prompt: renderedPrompt, stream: true },
             { ...ctx.baseServiceParams, route: { id: newSession.session_id } }
           );
           promptResult = {
-            taskId: promptResponse.taskId,
+            taskId: task.task_id,
             sessionId: newSession.session_id,
             note: `always_new trigger: created session ${newSession.session_id.substring(0, 8)} (${agenticTool}) and sent prompt`
           };
-          console.log(`\u2705 Zone trigger executed: task ${promptResponse.taskId.substring(0, 8)}`);
+          console.log(`\u2705 Zone trigger executed: task ${task.task_id.substring(0, 8)}`);
         } else {
           promptResult = {
             note: "Zone trigger template rendered to empty string (check template syntax)"
@@ -19545,16 +19589,10 @@ async function registerRoutes(ctx) {
         return {
           accessToken,
           refreshToken: newRefreshToken,
-          user: {
-            user_id: user.user_id,
-            email: user.email,
-            name: user.name,
-            emoji: user.emoji,
-            role: user.role
-          }
+          user
         };
       } catch (_error) {
-        throw new Error("Invalid or expired refresh token");
+        throw new NotAuthenticated6("Invalid or expired refresh token");
       }
     }
   });
@@ -19766,6 +19804,188 @@ async function registerRoutes(ctx) {
       throw error48;
     }
   }
+  async function spawnTaskExecutor(task, options, params) {
+    const session = await sessionsService.get(task.session_id, params);
+    const messageStartIndex = await sessionsRepository.countMessages(task.session_id);
+    const startTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const { captureGitStateViaShell: captureGitStateViaShell2 } = await Promise.resolve().then(() => (init_git_shell_capture(), git_shell_capture_exports));
+    let gitStateAtStart = "unknown";
+    let refAtStart = "unknown";
+    if (session.worktree_id) {
+      try {
+        const worktree = await app.service("worktrees").get(session.worktree_id, params);
+        const gitState = await captureGitStateViaShell2(worktree.path);
+        gitStateAtStart = gitState.sha;
+        refAtStart = gitState.ref;
+        if (gitStateAtStart === "unknown") {
+          console.warn(
+            `[Git State] captureGitStateViaShell returned 'unknown' for worktree ${worktree.path} (ref: ${refAtStart})`
+          );
+        }
+      } catch (error48) {
+        console.warn(
+          `[Git State] Failed to get git state for worktree ${session.worktree_id}:`,
+          error48
+        );
+      }
+    }
+    const updatedTask = await app.service("tasks").patch(
+      task.task_id,
+      {
+        status: TaskStatus.RUNNING,
+        started_at: startTimestamp,
+        queue_position: void 0,
+        message_range: {
+          start_index: messageStartIndex,
+          end_index: messageStartIndex + 1,
+          start_timestamp: startTimestamp,
+          end_timestamp: startTimestamp
+        },
+        git_state: {
+          ref_at_start: refAtStart,
+          sha_at_start: gitStateAtStart
+        }
+      },
+      params
+    );
+    if (config2.execution?.daemon_writes_user_message !== false) {
+      try {
+        const isCallback = task.metadata?.is_agor_callback === true;
+        const messageMetadata = {};
+        if (isCallback) {
+          messageMetadata.is_agor_callback = true;
+        }
+        const source = task.metadata?.source ?? options.messageSource;
+        if (source) {
+          messageMetadata.source = source;
+        }
+        const userMessage = {
+          message_id: generateId2(),
+          session_id: task.session_id,
+          // Callback messages are typed `system` so the UI shows the special
+          // Agor-callback styling. Normal prompts stay `user`.
+          type: isCallback ? "system" : "user",
+          role: "user",
+          index: messageStartIndex,
+          timestamp: startTimestamp,
+          content_preview: task.full_prompt.substring(0, 200),
+          content: task.full_prompt,
+          task_id: task.task_id,
+          metadata: Object.keys(messageMetadata).length > 0 ? messageMetadata : void 0
+        };
+        await app.service("messages").create(userMessage, params);
+      } catch (msgErr) {
+        console.warn(
+          `\u26A0\uFE0F  [Daemon] Failed to write initial user-message row for task ${task.task_id.substring(0, 8)} (executor will retry):`,
+          msgErr
+        );
+      }
+    }
+    await app.service("sessions").patch(
+      task.session_id,
+      {
+        status: SessionStatus2.RUNNING,
+        ready_for_prompt: false,
+        tasks: [...session.tasks, task.task_id]
+      },
+      params
+    );
+    let promptForExecutor = task.full_prompt;
+    const prompterUserId = params.user?.user_id;
+    if (prompterUserId && prompterUserId !== session.created_by) {
+      try {
+        const prompterUserRepo = new UsersRepository2(db);
+        const prompterUser = await prompterUserRepo.findById(prompterUserId);
+        if (prompterUser) {
+          const prompterName = sanitizeUserField(prompterUser.name || prompterUser.email);
+          const prompterEmail = sanitizeUserField(prompterUser.email);
+          promptForExecutor = `[Prompted by: ${prompterName} (${prompterEmail})]
+
+${task.full_prompt}`;
+        }
+      } catch (err) {
+        console.warn(
+          `[Prompt] Failed to look up prompter user ${prompterUserId.substring(0, 8)}:`,
+          err
+        );
+      }
+    }
+    const useStreaming = options.stream !== false;
+    const sessionId = task.session_id;
+    const taskId = task.task_id;
+    setImmediate(async () => {
+      try {
+        console.log(
+          `\u{1F680} [Daemon] Routing ${session.agentic_tool} to Feathers/WebSocket executor (task ${taskId.substring(0, 8)})`
+        );
+        await sessionsService.executeTask(
+          sessionId,
+          {
+            taskId,
+            prompt: promptForExecutor,
+            permissionMode: options.permissionMode,
+            stream: useStreaming,
+            messageSource: options.messageSource
+          },
+          params
+        );
+        console.log(
+          `\u2705 [Daemon] Executor spawned for session ${sessionId.substring(0, 8)}, waiting for task completion`
+        );
+      } catch (error48) {
+        const errorMessage = error48 instanceof Error ? error48.message : String(error48);
+        console.error(
+          `\u274C [Daemon] Executor spawn failed for session=${sessionId.substring(0, 8)} task=${taskId.substring(0, 8)} agent=${session.agentic_tool} unix_username=${session.unix_username ?? "null"}: ${errorMessage}`,
+          error48
+        );
+        await safePatch(
+          "tasks",
+          taskId,
+          {
+            status: TaskStatus.FAILED,
+            completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+            error_message: errorMessage
+          },
+          "Task",
+          params
+        );
+        try {
+          const sysIndex = await sessionsRepository.countMessages(sessionId);
+          const errorContent = `\u26A0\uFE0F The agent failed to start.
+
+${errorMessage}`;
+          const sysMessage = {
+            message_id: generateId2(),
+            session_id: sessionId,
+            type: "system",
+            role: "assistant",
+            index: sysIndex,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            content_preview: errorContent.substring(0, 200),
+            content: errorContent,
+            task_id: taskId,
+            metadata: { is_meta: true }
+          };
+          await app.service("messages").create(sysMessage, params);
+        } catch (sysErr) {
+          console.warn(
+            "[Daemon] Failed to write system error message after spawn failure:",
+            sysErr
+          );
+        }
+        try {
+          app.service("tasks").emit("failed", {
+            task_id: taskId,
+            session_id: sessionId,
+            error_message: errorMessage
+          });
+        } catch (emitErr) {
+          console.warn("[Daemon] Failed to emit tasks:failed event:", emitErr);
+        }
+      }
+    });
+    return updatedTask;
+  }
   registerAuthenticatedRoute(
     app,
     "/sessions/:id/prompt",
@@ -19810,232 +20030,61 @@ async function registerRoutes(ctx) {
         if (session.status === SessionStatus2.STOPPING) {
           throw new Error("Cannot send prompt: session is currently stopping");
         }
-        const isInternalCall = !params.provider;
-        if (!(data._fromQueue && isInternalCall)) {
-          const queueCheckRepo = new MessagesRepository(db);
-          const queuedItems = await queueCheckRepo.findQueued(id);
-          const hasQueuedItems = queuedItems.length > 0;
-          if (session.status !== SessionStatus2.IDLE || hasQueuedItems) {
-            const queuedMessage = await queueCheckRepo.createQueued(id, data.prompt, {
-              queued_by_user_id: params.user?.user_id
-            });
-            console.log(
-              `\u{1F4EC} [Prompt] Auto-queued message for session ${id.substring(0, 8)} at position ${queuedMessage.queue_position} (session status: ${session.status}, existing queue items: ${queuedItems.length})`
-            );
-            app.service("messages").emit("queued", queuedMessage);
-            if (session.status === SessionStatus2.IDLE) {
-              setImmediate(async () => {
-                try {
-                  await sessionsService.triggerQueueProcessing(id, params);
-                } catch (error48) {
-                  console.error(
-                    `\u274C [Prompt] Failed to trigger queue processing after auto-queue:`,
-                    error48
-                  );
-                }
-              });
+        const taskRepo = new TaskRepository(db);
+        const queuedTasks = await taskRepo.findQueued(id);
+        const shouldQueue = session.status !== SessionStatus2.IDLE || queuedTasks.length > 0;
+        const createdBy = params.user?.user_id ?? "anonymous";
+        if (shouldQueue) {
+          const queuedTask = await taskRepo.createPending({
+            session_id: id,
+            full_prompt: data.prompt,
+            created_by: createdBy,
+            status: TaskStatus.QUEUED,
+            metadata: {
+              ...params.user?.user_id ? { queued_by_user_id: params.user.user_id } : {},
+              ...messageSource ? { source: messageSource } : {}
             }
-            return {
-              success: true,
-              queued: true,
-              message: queuedMessage,
-              queue_position: queuedMessage.queue_position
-            };
+          });
+          console.log(
+            `\u{1F4EC} [Prompt] Auto-queued task for session ${id.substring(0, 8)} at position ${queuedTask.queue_position} (session status: ${session.status}, existing queue items: ${queuedTasks.length})`
+          );
+          app.service("tasks").emit("queued", queuedTask);
+          if (session.status === SessionStatus2.IDLE) {
+            setImmediate(async () => {
+              try {
+                await sessionsService.triggerQueueProcessing(id, params);
+              } catch (error48) {
+                console.error(
+                  `\u274C [Prompt] Failed to trigger queue processing after auto-queue:`,
+                  error48
+                );
+              }
+            });
           }
+          return queuedTask;
         }
         console.log(`   Session agent: ${session.agentic_tool}`);
         console.log(
           `   Session permission_config.mode: ${session.permission_config?.mode || "not set"}`
         );
-        const messageStartIndex = await sessionsRepository.countMessages(id);
-        const startTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-        const { captureGitStateViaShell: captureGitStateViaShell2 } = await Promise.resolve().then(() => (init_git_shell_capture(), git_shell_capture_exports));
-        let gitStateAtStart = "unknown";
-        let refAtStart = "unknown";
-        if (session.worktree_id) {
-          try {
-            const worktreesService2 = app.service("worktrees");
-            const worktree = await worktreesService2.get(session.worktree_id, params);
-            console.log(
-              `[Git State] Capturing git state at task start for worktree ${worktree.path}`
-            );
-            const gitState = await captureGitStateViaShell2(worktree.path);
-            gitStateAtStart = gitState.sha;
-            refAtStart = gitState.ref;
-            if (gitStateAtStart === "unknown") {
-              console.warn(
-                `[Git State] captureGitStateViaShell returned 'unknown' for worktree ${worktree.path} (ref: ${refAtStart})`
-              );
-            }
-          } catch (error48) {
-            console.warn(
-              `[Git State] Failed to get git state for worktree ${session.worktree_id}:`,
-              error48
-            );
-          }
-        }
-        const task = await tasksService.create(
-          {
-            session_id: id,
-            status: TaskStatus.RUNNING,
-            started_at: (/* @__PURE__ */ new Date()).toISOString(),
-            description: data.prompt.substring(0, 120),
-            full_prompt: data.prompt,
-            message_range: {
-              start_index: messageStartIndex,
-              end_index: messageStartIndex + 1,
-              start_timestamp: startTimestamp,
-              end_timestamp: startTimestamp
-            },
-            tool_use_count: 0,
-            git_state: {
-              ref_at_start: refAtStart,
-              sha_at_start: gitStateAtStart
-            }
-          },
-          params
-        );
-        await app.service("sessions").patch(
-          id,
+        const task = await taskRepo.createPending({
+          session_id: id,
+          full_prompt: data.prompt,
+          created_by: createdBy,
+          status: TaskStatus.CREATED,
+          metadata: messageSource ? { source: messageSource } : void 0
+        });
+        app.service("tasks").emit("created", task);
+        const runningTask = await spawnTaskExecutor(
+          task,
           {
-            tasks: [...session.tasks, task.task_id]
+            permissionMode: data.permissionMode,
+            stream: data.stream !== false,
+            messageSource
           },
           params
         );
-        const _streamingCallbacks = {
-          onStreamStart: (messageId, metadata) => {
-            console.debug(
-              `\u{1F4E1} [${(/* @__PURE__ */ new Date()).toISOString()}] Streaming start: ${messageId.substring(0, 8)}`
-            );
-            app.service("messages").emit("streaming:start", {
-              message_id: messageId,
-              ...metadata
-            });
-          },
-          onStreamChunk: (messageId, chunk) => {
-            app.service("messages").emit("streaming:chunk", {
-              message_id: messageId,
-              session_id: id,
-              chunk
-            });
-          },
-          onStreamEnd: (messageId) => {
-            console.debug(
-              `\u{1F4E1} [${(/* @__PURE__ */ new Date()).toISOString()}] Streaming end: ${messageId.substring(0, 8)}`
-            );
-            app.service("messages").emit("streaming:end", {
-              message_id: messageId,
-              session_id: id
-            });
-          },
-          onStreamError: (messageId, error48) => {
-            console.error(`\u274C Streaming error for message ${messageId.substring(0, 8)}:`, error48);
-            app.service("messages").emit("streaming:error", {
-              message_id: messageId,
-              session_id: id,
-              error: error48.message
-            });
-          },
-          onThinkingStart: (messageId, metadata) => {
-            console.debug(
-              `\u{1F4E1} [${(/* @__PURE__ */ new Date()).toISOString()}] Thinking start: ${messageId.substring(0, 8)}`
-            );
-            app.service("messages").emit("thinking:start", {
-              message_id: messageId,
-              ...metadata
-            });
-          },
-          onThinkingChunk: (messageId, chunk) => {
-            app.service("messages").emit("thinking:chunk", {
-              message_id: messageId,
-              session_id: id,
-              chunk
-            });
-          },
-          onThinkingEnd: (messageId) => {
-            console.debug(
-              `\u{1F4E1} [${(/* @__PURE__ */ new Date()).toISOString()}] Thinking end: ${messageId.substring(0, 8)}`
-            );
-            app.service("messages").emit("thinking:end", {
-              message_id: messageId,
-              session_id: id
-            });
-          }
-        };
-        const useStreaming = data.stream !== false;
-        let promptForExecutor = data.prompt;
-        const prompterUserId = params.user?.user_id;
-        if (prompterUserId && prompterUserId !== session.created_by) {
-          try {
-            const prompterUserRepo = new UsersRepository2(db);
-            const prompterUser = await prompterUserRepo.findById(prompterUserId);
-            if (prompterUser) {
-              const prompterName = sanitizeUserField(prompterUser.name || prompterUser.email);
-              const prompterEmail = sanitizeUserField(prompterUser.email);
-              promptForExecutor = `[Prompted by: ${prompterName} (${prompterEmail})]
-
-${data.prompt}`;
-            }
-          } catch (err) {
-            console.warn(
-              `[Prompt] Failed to look up prompter user ${prompterUserId.substring(0, 8)}:`,
-              err
-            );
-          }
-        }
-        setImmediate(async () => {
-          try {
-            console.log(
-              `\u{1F680} [Daemon] Routing ${session.agentic_tool} to Feathers/WebSocket executor`
-            );
-            await sessionsService.executeTask(
-              id,
-              {
-                taskId: task.task_id,
-                prompt: promptForExecutor,
-                permissionMode: data.permissionMode,
-                stream: useStreaming,
-                messageSource
-              },
-              params
-            );
-            console.log(
-              `\u2705 [Daemon] Executor spawned for session ${id.substring(0, 8)}, waiting for task completion`
-            );
-          } catch (error48) {
-            const errorMessage = error48 instanceof Error ? error48.message : String(error48);
-            console.error(
-              `\u274C [Daemon] Executor spawn failed for session=${id.substring(0, 8)} task=${task.task_id.substring(0, 8)} agent=${session.agentic_tool} unix_username=${session.unix_username ?? "null"}: ${errorMessage}`,
-              error48
-            );
-            await safePatch(
-              "tasks",
-              task.task_id,
-              {
-                status: TaskStatus.FAILED,
-                completed_at: (/* @__PURE__ */ new Date()).toISOString(),
-                error_message: errorMessage
-              },
-              "Task",
-              params
-            );
-            try {
-              app.service("tasks").emit("failed", {
-                task_id: task.task_id,
-                session_id: id,
-                error_message: errorMessage
-              });
-            } catch (emitErr) {
-              console.warn("[Daemon] Failed to emit tasks:failed event:", emitErr);
-            }
-          }
-        });
-        return {
-          success: true,
-          taskId: task.task_id,
-          status: TaskStatus.RUNNING,
-          streaming: useStreaming
-        };
+        return runningTask;
       }
     },
     {
@@ -20286,7 +20335,7 @@ ${data.prompt}`;
             id,
             {
               status: SessionStatus2.IDLE,
-              ready_for_prompt: false
+              ready_for_prompt: true
             },
             params
           );
@@ -20324,7 +20373,7 @@ ${data.prompt}`;
             id,
             {
               status: SessionStatus2.IDLE,
-              ready_for_prompt: false
+              ready_for_prompt: true
             },
             params
           );
@@ -20341,31 +20390,13 @@ ${data.prompt}`;
   );
   registerAuthenticatedRoute(
     app,
-    "/sessions/:id/messages/queue",
+    "/sessions/:id/tasks/queue",
     {
-      async create(data, params) {
-        const sessionId = params.route?.id;
-        if (!sessionId) throw new Error("Session ID required");
-        if (!data.prompt) throw new Error("Prompt required");
-        const _session = await sessionsService.get(sessionId, params);
-        const messageRepo = new MessagesRepository(db);
-        const queuedMessage = await messageRepo.createQueued(sessionId, data.prompt, {
-          queued_by_user_id: params.user?.user_id
-        });
-        console.log(
-          `\u{1F4EC} Queued message for session ${sessionId.substring(0, 8)} at position ${queuedMessage.queue_position}`
-        );
-        app.service("messages").emit("queued", queuedMessage);
-        return {
-          success: true,
-          message: queuedMessage
-        };
-      },
       async find(params) {
         const sessionId = params.route?.id;
         if (!sessionId) throw new Error("Session ID required");
-        const messageRepo = new MessagesRepository(db);
-        const queued = await messageRepo.findQueued(sessionId);
+        const taskQueueRepo = new TaskRepository(db);
+        const queued = await taskQueueRepo.findQueued(sessionId);
         return {
           total: queued.length,
           data: queued
@@ -20374,14 +20405,13 @@ ${data.prompt}`;
       // biome-ignore lint/suspicious/noExplicitAny: Service type not compatible with Express
     },
     {
-      create: { role: ROLES5.MEMBER, action: "queue messages" },
       find: { role: ROLES5.MEMBER, action: "view queue" }
     },
     requireAuth
   );
   const queueProcessingLocks = /* @__PURE__ */ new Map();
   const queueRetryScheduled = /* @__PURE__ */ new Set();
-  async function processNextQueuedMessage(sessionId, params) {
+  async function processNextQueuedTask(sessionId, params) {
     const existingLock = queueProcessingLocks.get(sessionId);
     if (existingLock) {
       console.log(
@@ -20393,7 +20423,7 @@ ${data.prompt}`;
         setImmediate(async () => {
           queueRetryScheduled.delete(sessionId);
           try {
-            await processNextQueuedMessage(sessionId, params);
+            await processNextQueuedTask(sessionId, params);
           } catch (error48) {
             console.error(
               `\u274C [Queue] Retry failed for session ${sessionId.substring(0, 8)}:`,
@@ -20404,7 +20434,7 @@ ${data.prompt}`;
       }
       return;
     }
-    const processingPromise = processNextQueuedMessageInternal(sessionId, params);
+    const processingPromise = processNextQueuedTaskInternal(sessionId, params);
     queueProcessingLocks.set(
       sessionId,
       processingPromise.catch(() => {
@@ -20416,69 +20446,51 @@ ${data.prompt}`;
       queueProcessingLocks.delete(sessionId);
     }
   }
-  async function processNextQueuedMessageInternal(sessionId, params) {
-    const messageRepo = new MessagesRepository(db);
-    const nextMessage = await messageRepo.getNextQueued(sessionId);
-    if (!nextMessage) {
-      console.log(`\u{1F4ED} No queued messages for session ${sessionId.substring(0, 8)}`);
+  async function processNextQueuedTaskInternal(sessionId, params) {
+    const taskRepo = new TaskRepository(db);
+    const nextTask = await taskRepo.getNextQueued(sessionId);
+    if (!nextTask) {
+      console.log(`\u{1F4ED} No queued tasks for session ${sessionId.substring(0, 8)}`);
       return;
     }
-    const userId = nextMessage.metadata?.queued_by_user_id;
+    const userId = nextTask.metadata?.queued_by_user_id;
     const userRepo = new UsersRepository2(db);
     const queuedByUser = userId ? await userRepo.findById(userId) : void 0;
-    const messageParams = queuedByUser ? {
+    const taskParams = queuedByUser ? {
       ...params,
       user: queuedByUser
     } : params;
     console.log(
-      `\u{1F4EC} Processing queued message ${nextMessage.message_id.substring(0, 8)} with user context: ${queuedByUser ? queuedByUser.user_id.substring(0, 8) : "none"}`
+      `\u{1F4EC} Processing queued task ${nextTask.task_id.substring(0, 8)} (position ${nextTask.queue_position}) with user context: ${queuedByUser ? queuedByUser.user_id.substring(0, 8) : "none"}`
     );
-    const session = await sessionsService.get(sessionId, messageParams);
+    const session = await sessionsService.get(sessionId, taskParams);
     if (session.status !== SessionStatus2.IDLE) {
       console.log(
-        `\u23F8\uFE0F  [Queue] Session ${sessionId.substring(0, 8)} is ${session.status}, message ${nextMessage.message_id.substring(0, 8)} waiting in queue (will be processed when session becomes IDLE via patch hook)`
+        `\u23F8\uFE0F  [Queue] Session ${sessionId.substring(0, 8)} is ${session.status}, task ${nextTask.task_id.substring(0, 8)} waiting in queue (will be processed when session becomes IDLE via patch hook)`
       );
       return;
     }
-    console.log(
-      `\u{1F4EC} Processing queued message ${nextMessage.message_id.substring(0, 8)} (position ${nextMessage.queue_position})`
-    );
-    const prompt = nextMessage.content;
-    const messagesServiceInst = app.service("messages");
-    try {
-      const stillExists = await messagesServiceInst.get(nextMessage.message_id, messageParams);
-      if (!stillExists || stillExists.status !== "queued") {
-        console.log(
-          `\u26A0\uFE0F  Queued message ${nextMessage.message_id.substring(0, 8)} was deleted or modified, skipping`
-        );
-        return;
-      }
-    } catch (_error) {
-      console.log(
-        `\u26A0\uFE0F  Queued message ${nextMessage.message_id.substring(0, 8)} no longer exists, skipping`
-      );
+    const stillQueued = await taskRepo.findById(nextTask.task_id);
+    if (!stillQueued || stillQueued.status !== TaskStatus.QUEUED) {
+      console.log(`\u26A0\uFE0F  Queued task ${nextTask.task_id.substring(0, 8)} no longer queued, skipping`);
       return;
     }
-    await messagesServiceInst.remove(nextMessage.message_id, messageParams);
-    const promptService = app.service("/sessions/:id/prompt");
-    await promptService.create(
+    const source = nextTask.metadata?.source;
+    await spawnTaskExecutor(
+      stillQueued,
       {
-        prompt,
         stream: true,
-        _fromQueue: true
+        messageSource: source
       },
-      {
-        ...messageParams,
-        route: { id: sessionId }
-      }
+      taskParams
     );
-    console.log(`\u2705 Queued message triggered for session ${sessionId.substring(0, 8)}`);
+    console.log(`\u2705 Queued task drained for session ${sessionId.substring(0, 8)}`);
   }
   sessionsService.setQueueProcessor(async (sessionId, params) => {
     try {
-      await processNextQueuedMessage(sessionId, params || {});
+      await processNextQueuedTask(sessionId, params || {});
     } catch (error48) {
-      console.error(`\u274C [Sessions] Failed to process queued message:`, error48);
+      console.error(`\u274C [Sessions] Failed to process queued task:`, error48);
     }
   });
   registerAuthenticatedRoute(