@desplega.ai/agent-swarm 1.49.0 → 1.52.0

package/src/commands/runner.ts

@@ -8,6 +8,7 @@ import {
   generateDefaultSoulMd,
   generateDefaultToolsMd,
 } from "../prompts/defaults.ts";
+import { configureHttpResolver, resolveTemplateAsync } from "../prompts/resolver.ts";
 import {
   type CostData,
   createProviderAdapter,
@@ -19,6 +20,8 @@ import { resolveCredentialPools } from "../utils/credentials.ts";
 import { prettyPrintLine, prettyPrintStderr } from "../utils/pretty-print.ts";
 import { detectVcsProvider } from "../vcs/index.ts";
 import { interpolate } from "../workflows/template.ts";
+// Side-effect import: registers runner trigger/resumption templates
+import "./templates.ts";
 
 /** Save PM2 process list for persistence across container restarts */
 async function savePm2State(role: string): Promise<void> {
@@ -89,6 +92,10 @@ async function ensureRepoForTask(
       } else {
         await Bun.$`git clone --branch ${defaultBranch} --single-branch ${url} ${clonePath}`.quiet();
       }
+      // Validate the clone actually created the directory
+      if (!existsSync(clonePath)) {
+        throw new Error(`Clone command succeeded but directory ${clonePath} does not exist`);
+      }
       console.log(`[${role}] Cloned ${name}`);
     } else {
       console.log(`[${role}] Repo ${name} already cloned at ${clonePath}`);
@@ -111,7 +118,9 @@ async function ensureRepoForTask(
     const errorMsg = (err as Error).message;
     console.warn(`[${role}] Error setting up repo ${name}: ${errorMsg}`);
     const warning = `Failed to clone/setup repo "${name}" at ${clonePath}: ${errorMsg}. The repo may not be available. You may need to clone it manually.`;
-    return { clonePath, claudeMd: null, warning };
+    // Only return clonePath if the directory actually exists (clone may have failed)
+    const cloneExists = existsSync(clonePath);
+    return { clonePath: cloneExists ? clonePath : "", claudeMd: null, warning };
   }
 }
 
@@ -549,34 +558,26 @@ async function resumeTaskViaAPI(config: ApiConfig, taskId: string): Promise<bool
 }
 
 /** Build prompt for a resumed task */
-function buildResumePrompt(
+async function buildResumePrompt(
   task: { id: string; task: string; progress?: string },
   fmt: (cmd: string) => string = (cmd) => `/${cmd}`,
-): string {
-  let prompt = `${fmt("work-on-task")} ${task.id}
-
-**RESUMED TASK** - This task was interrupted during a deployment and is being resumed.
-
-Task: "${task.task}"`;
-
+): Promise<string> {
   if (task.progress) {
-    prompt += `
-
-Previous Progress:
-${task.progress}
-
-Continue from where you left off. Review the progress above and complete the remaining work.`;
-  } else {
-    prompt += `
-
-No progress was saved before the interruption. Start the task fresh but be aware files may have been partially modified.`;
+    const result = await resolveTemplateAsync("task.resumption.with_progress", {
+      work_on_task_cmd: fmt("work-on-task"),
+      task_id: task.id,
+      task_description: task.task,
+      progress: task.progress,
+    });
+    return result.text;
   }
 
-  prompt += `
-
-When done, use \`store-progress\` with status: "completed" and include your output.`;
-
-  return prompt;
+  const result = await resolveTemplateAsync("task.resumption.no_progress", {
+    work_on_task_cmd: fmt("work-on-task"),
+    task_id: task.id,
+    task_description: task.task,
+  });
+  return result.text;
 }
 
 /** Setup signal handlers for graceful shutdown */
@@ -671,6 +672,8 @@ interface RunningTask {
   triggerType?: string;
   /** Set when the promise resolves, enabling non-blocking completion checks */
   result: ProviderResult | null;
+  /** Deferred cursor updates for channel_activity triggers — committed after success */
+  cursorUpdates?: Array<{ channelId: string; ts: string }>;
 }
 
 /** Runner state for tracking concurrent tasks */
@@ -781,6 +784,22 @@ async function saveProviderSessionId(
   });
 }
 
+/** Save provider session ID on the active session (for pool tasks where realTaskId is unknown) */
+async function saveProviderSessionIdOnActiveSession(
+  apiUrl: string,
+  apiKey: string,
+  effectiveTaskId: string,
+  providerSessionId: string,
+): Promise<void> {
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  await fetch(`${apiUrl}/api/active-sessions/provider-session/${effectiveTaskId}`, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify({ providerSessionId }),
+  });
+}
+
 /** Fetch Claude session ID for a task (for --resume) */
 async function fetchProviderSessionId(
   apiUrl: string,
@@ -806,6 +825,7 @@ async function registerActiveSession(
     taskId: string;
     triggerType: string;
     taskDescription?: string;
+    runnerSessionId?: string;
   },
 ): Promise<void> {
   const headers: Record<string, string> = {
@@ -822,6 +842,7 @@ async function registerActiveSession(
         taskId: session.taskId,
         triggerType: session.triggerType,
         taskDescription: session.taskDescription,
+        runnerSessionId: session.runnerSessionId,
       }),
     });
   } catch {
@@ -868,7 +889,8 @@ interface Trigger {
     | "task_offered"
     | "unread_mentions"
     | "pool_tasks_available"
-    | "epic_progress_changed";
+    | "epic_progress_changed"
+    | "channel_activity";
   taskId?: string;
   task?: unknown;
   mentionsCount?: number;
@@ -885,8 +907,14 @@ interface Trigger {
   messages?: Array<{
     id: string;
     content: string;
+    channelId?: string;
+    channelName?: string;
+    ts?: string;
+    user?: string;
+    text?: string;
   }>;
   epics?: unknown; // Epic progress updates for lead
+  cursorUpdates?: Array<{ channelId: string; ts: string }>; // Deferred cursor commits for channel_activity
 }
 
 /** Options for polling */
@@ -980,11 +1008,11 @@ async function pollForTrigger(opts: PollOptions): Promise<Trigger | null> {
 }
 
 /** Build prompt based on trigger type */
-function buildPromptForTrigger(
+async function buildPromptForTrigger(
   trigger: Trigger,
   defaultPrompt: string,
   fmt: (cmd: string) => string = (cmd) => `/${cmd}`,
-): string {
+): Promise<string> {
   switch (trigger.type) {
     case "task_assigned": {
       // Use the work-on-task command with task ID and description
@@ -992,19 +1020,25 @@ function buildPromptForTrigger(
         trigger.task && typeof trigger.task === "object" && "task" in trigger.task
           ? (trigger.task as { task: string }).task
           : null;
-      let prompt = `${fmt("work-on-task")} ${trigger.taskId}`;
-      if (taskDesc) {
-        prompt += `\n\nTask: "${taskDesc}"`;
-      }
+      const taskDescSection = taskDesc ? `\n\nTask: "${taskDesc}"` : "";
 
-      // Inject outputSchema instructions if present
+      // Build output instructions — use outputSchema if present, otherwise generic
       const taskObj = trigger.task as Record<string, unknown> | undefined;
+      let outputInstructions: string;
       if (taskObj?.outputSchema && typeof taskObj.outputSchema === "object") {
-        prompt += `\n\n**Required Output Format**: When completing this task, you MUST call store-progress with output that is valid JSON conforming to this schema:\n\`\`\`json\n${JSON.stringify(taskObj.outputSchema, null, 2)}\n\`\`\`\nCall store-progress with status "completed" and your JSON output. If your output doesn't match the schema, the tool call will fail and you should fix and retry.`;
+        outputInstructions = `\n\n**Required Output Format**: When completing this task, you MUST call store-progress with output that is valid JSON conforming to this schema:\n\`\`\`json\n${JSON.stringify(taskObj.outputSchema, null, 2)}\n\`\`\`\nCall store-progress with status "completed" and your JSON output. If your output doesn't match the schema, the tool call will fail and you should fix and retry.`;
       } else {
-        prompt += `\n\nWhen done, use \`store-progress\` with status: "completed" and include your output.`;
+        outputInstructions =
+          '\n\nWhen done, use `store-progress` with status: "completed" and include your output.';
       }
-      return prompt;
+
+      const result = await resolveTemplateAsync("task.trigger.assigned", {
+        work_on_task_cmd: fmt("work-on-task"),
+        task_id: trigger.taskId,
+        task_desc_section: taskDescSection,
+        output_instructions: outputInstructions,
+      });
+      return result.text;
     }
 
     case "task_offered": {
@@ -1013,31 +1047,28 @@ function buildPromptForTrigger(
         trigger.task && typeof trigger.task === "object" && "task" in trigger.task
           ? (trigger.task as { task: string }).task
           : null;
-      let prompt = `${fmt("review-offered-task")} ${trigger.taskId}`;
-      if (taskDesc) {
-        prompt += `\n\nA task has been offered to you:\n"${taskDesc}"`;
-      }
-      prompt += `\n\nAccept if you have capacity and skills. Reject with a reason if you cannot handle it.`;
-      return prompt;
+      const taskDescSection = taskDesc ? `\n\nA task has been offered to you:\n"${taskDesc}"` : "";
+      const result = await resolveTemplateAsync("task.trigger.offered", {
+        review_offered_task_cmd: fmt("review-offered-task"),
+        task_id: trigger.taskId,
+        task_desc_section: taskDescSection,
+      });
+      return result.text;
     }
 
-    case "unread_mentions":
-      // Check messages - numbered steps for clarity
-      return `You have ${trigger.count || "unread"} mention(s) in chat channels.
-
-1. Use \`read-messages\` with unreadOnly: true to see them
-2. Respond to questions or requests directed at you
-3. If a message requires work, create a task using \`send-task\``;
-
-    case "pool_tasks_available":
-      // Worker: claim a task from the pool - numbered steps for clarity
-      return `${trigger.count} task(s) available in the pool.
-
-1. Run \`get-tasks\` with unassigned: true to browse
-2. Pick one matching your skills
-3. Run \`task-action\` with action: "claim" and taskId: "<id>"
+    case "unread_mentions": {
+      const result = await resolveTemplateAsync("task.trigger.unread_mentions", {
+        mention_count: trigger.count || "unread",
+      });
+      return result.text;
+    }
 
-Note: Claims are first-come-first-serve. If claim fails, pick another.`;
+    case "pool_tasks_available": {
+      const result = await resolveTemplateAsync("task.trigger.pool_available", {
+        task_count: trigger.count,
+      });
+      return result.text;
+    }
 
     case "epic_progress_changed": {
       // Lead: Epic progress updated - tasks completed or failed for an active epic
@@ -1074,19 +1105,19 @@ Note: Claims are first-come-first-serve. If claim fails, pick another.`;
         return "Epic progress was updated but no details available. Use `list-epics` to check status.";
       }
 
-      let prompt = `## Epic Progress Update\n\n${trigger.count} epic(s) have progress updates:\n\n`;
-
+      // Build epics detail section as a pre-computed variable
+      let epicsDetail = "";
       for (const { epic, finishedTasks } of epics) {
-        prompt += `### Epic: "${epic.name}" (${epic.id.slice(0, 8)})\n`;
-        prompt += `**Goal:** ${epic.goal}\n`;
-        prompt += `**Progress:** ${epic.progress}% complete (${epic.taskStats.completed}/${epic.taskStats.total} tasks)\n`;
-        prompt += `**Status:** ${epic.status}\n\n`;
+        epicsDetail += `### Epic: "${epic.name}" (${epic.id.slice(0, 8)})\n`;
+        epicsDetail += `**Goal:** ${epic.goal}\n`;
+        epicsDetail += `**Progress:** ${epic.progress}% complete (${epic.taskStats.completed}/${epic.taskStats.total} tasks)\n`;
+        epicsDetail += `**Status:** ${epic.status}\n\n`;
 
         if (epic.plan) {
-          prompt += `**Plan:**\n${epic.plan.slice(0, 2000)}\n\n`;
+          epicsDetail += `**Plan:**\n${epic.plan.slice(0, 2000)}\n\n`;
         }
         if (epic.prd) {
-          prompt += `**PRD:**\n${epic.prd.slice(0, 1000)}\n\n`;
+          epicsDetail += `**PRD:**\n${epic.prd.slice(0, 1000)}\n\n`;
         }
 
         // Show finished tasks
@@ -1094,48 +1125,63 @@ Note: Claims are first-come-first-serve. If claim fails, pick another.`;
         const failed = finishedTasks.filter((t) => t.status === "failed");
 
         if (completed.length > 0) {
-          prompt += "**Recently Completed:**\n";
+          epicsDetail += "**Recently Completed:**\n";
           for (const t of completed) {
             const agentName = t.agentId ? `Agent ${t.agentId.slice(0, 8)}` : "Unknown";
             const output = t.output ? t.output.slice(0, 150) : "(no output)";
-            prompt += `- Task ${t.id.slice(0, 8)} by ${agentName}: "${t.task.slice(0, 80)}"\n`;
-            prompt += `  Output: ${output}${t.output && t.output.length > 150 ? "..." : ""}\n`;
+            epicsDetail += `- Task ${t.id.slice(0, 8)} by ${agentName}: "${t.task.slice(0, 80)}"\n`;
+            epicsDetail += `  Output: ${output}${t.output && t.output.length > 150 ? "..." : ""}\n`;
           }
         }
 
         if (failed.length > 0) {
-          prompt += "\n**Recently Failed:**\n";
+          epicsDetail += "\n**Recently Failed:**\n";
           for (const t of failed) {
             const agentName = t.agentId ? `Agent ${t.agentId.slice(0, 8)}` : "Unknown";
-            prompt += `- Task ${t.id.slice(0, 8)} by ${agentName}: "${t.task.slice(0, 80)}"\n`;
-            prompt += `  Reason: ${t.failureReason || "(no reason)"}\n`;
+            epicsDetail += `- Task ${t.id.slice(0, 8)} by ${agentName}: "${t.task.slice(0, 80)}"\n`;
+            epicsDetail += `  Reason: ${t.failureReason || "(no reason)"}\n`;
           }
         }
 
         // Show remaining work
         const { inProgress, pending } = epic.taskStats;
         if (inProgress > 0 || pending > 0) {
-          prompt += `\n**Remaining:** ${inProgress} in progress, ${pending} pending\n`;
+          epicsDetail += `\n**Remaining:** ${inProgress} in progress, ${pending} pending\n`;
         }
 
-        prompt += "\n---\n\n";
+        epicsDetail += "\n---\n\n";
       }
 
-      prompt += `## Your Task: Plan Next Steps
+      const result = await resolveTemplateAsync("task.trigger.epic_progress", {
+        epic_count: trigger.count,
+        epics_detail: epicsDetail,
+      });
+      return result.text;
+    }
 
-For each epic:
-1. **Review** the completed work and any failures
-2. **Determine** if the epic goal is met (progress = 100% and all tasks succeeded)
-3. **If complete:** Use \`update-epic\` to mark status as "completed"
-4. **If not complete:**
-   - Retry failed tasks with \`send-task\` (reassign or modify)
-   - Create new tasks for remaining work with \`send-task\` (include epicId)
-   - Keep the epic progressing until the goal is achieved
+    case "channel_activity": {
+      const msgs = (trigger.messages || []) as Array<{
+        channelId?: string;
+        channelName?: string;
+        ts?: string;
+        user?: string;
+        text?: string;
+      }>;
+      if (msgs.length === 0) {
+        return "New Slack channel activity detected but no message details available. Use `slack-read` to check recent messages.";
+      }
 
-This is an iterative process - you'll be notified again when more tasks finish.
-The epic should keep progressing until 100% complete and the goal is achieved.`;
+      let messagesDetail = "";
+      for (const msg of msgs) {
+        const channel = msg.channelName ? `#${msg.channelName}` : msg.channelId || "unknown";
+        messagesDetail += `- **${channel}** (user: ${msg.user || "unknown"}): ${msg.text?.slice(0, 200) || "(no text)"}\n`;
+      }
 
-      return prompt;
+      const result = await resolveTemplateAsync("task.trigger.channel_activity", {
+        message_count: trigger.count || msgs.length,
+        messages_detail: messagesDetail,
+      });
+      return result.text;
     }
 
     default:
@@ -1306,6 +1352,17 @@ async function spawnProviderProcess(
           saveProviderSessionId(opts.apiUrl, opts.apiKey, realTaskId, event.sessionId).catch(
             (err) => console.warn(`[runner] Failed to save session ID: ${err}`),
           );
+        } else {
+          // Pool task: save provider session ID on active session so it can be
+          // propagated to the real task when the agent claims one
+          saveProviderSessionIdOnActiveSession(
+            opts.apiUrl,
+            opts.apiKey,
+            effectiveTaskId,
+            event.sessionId,
+          ).catch((err) =>
+            console.warn(`[runner] Failed to save provider session on active session: ${err}`),
+          );
         }
         break;
       case "tool_start": {
@@ -1486,6 +1543,7 @@ async function checkCompletedProcesses(
     taskId: string;
     result: ProviderResult;
     triggerType?: string;
+    cursorUpdates?: Array<{ channelId: string; ts: string }>;
   }> = [];
 
   for (const [taskId, task] of state.activeTasks) {
@@ -1498,12 +1556,13 @@ async function checkCompletedProcesses(
         taskId,
         result: task.result,
         triggerType: task.triggerType,
+        cursorUpdates: task.cursorUpdates,
       });
     }
   }
 
   // Remove completed tasks from the map and ensure they're marked as finished
-  for (const { taskId, result } of completedTasks) {
+  for (const { taskId, result, cursorUpdates } of completedTasks) {
     state.activeTasks.delete(taskId);
 
     if (apiConfig) {
@@ -1519,6 +1578,25 @@ async function checkCompletedProcesses(
         console.log(`[${role}] Detected error for task ${taskId.slice(0, 8)}: ${failureReason}`);
       }
       await ensureTaskFinished(apiConfig, role, taskId, result.exitCode, failureReason);
+
+      // Commit channel activity cursors after successful processing
+      // If the task failed, cursors stay uncommitted so messages are re-seen on next poll
+      if (cursorUpdates && cursorUpdates.length > 0 && result.exitCode === 0) {
+        try {
+          const headers: Record<string, string> = { "Content-Type": "application/json" };
+          if (apiConfig.apiKey) headers.Authorization = `Bearer ${apiConfig.apiKey}`;
+          await fetch(`${apiConfig.apiUrl}/api/channel-activity/commit-cursors`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ cursorUpdates }),
+          });
+          console.log(
+            `[${role}] Committed ${cursorUpdates.length} channel activity cursor(s) for task ${taskId.slice(0, 8)}`,
+          );
+        } catch (err) {
+          console.warn(`[${role}] Failed to commit channel activity cursors: ${err}`);
+        }
+      }
     }
   }
 }
@@ -1605,6 +1683,11 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   const apiUrl = process.env.MCP_BASE_URL || `http://localhost:${process.env.PORT || "3013"}`;
   const swarmUrl = process.env.SWARM_URL || "localhost";
 
+  // Configure HTTP-based template resolution (workers resolve via API, not local DB)
+  if (process.env.API_KEY) {
+    configureHttpResolver(apiUrl, process.env.API_KEY);
+  }
+
   let capabilities = config.capabilities;
 
   // Agent identity fields — populated after registration by fetching full profile
@@ -1615,12 +1698,13 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
   let agentClaudeMd: string | undefined;
   let agentProfileName: string | undefined;
   let agentDescription: string | undefined;
+  let agentSkillsSummary: { name: string; description: string }[] | undefined;
 
   // Per-task repo context — set when processing a task with githubRepo
   let currentRepoContext: BasePromptArgs["repoContext"] | undefined;
 
   // Generate base prompt (identity fields injected after profile fetch below)
-  const buildSystemPrompt = () => {
+  const buildSystemPrompt = async () => {
     return getBasePrompt({
       role,
       agentId,
@@ -1633,10 +1717,11 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       toolsMd: agentToolsMd,
       claudeMd: agentClaudeMd,
       repoContext: currentRepoContext,
+      skillsSummary: agentSkillsSummary,
     });
   };
 
-  let basePrompt = buildSystemPrompt();
+  let basePrompt = await buildSystemPrompt();
 
   // Resolve additional system prompt: CLI flag > env var
   let additionalSystemPrompt: string | undefined;
@@ -1860,8 +1945,36 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           }
         }
 
+        // Fetch installed skills for system prompt
+        try {
+          const skillsResp = await fetch(`${apiUrl}/api/agents/${agentId}/skills`, {
+            headers: {
+              Authorization: `Bearer ${apiKey}`,
+              "X-Agent-ID": agentId,
+            },
+          });
+          if (skillsResp.ok) {
+            const skillsData = (await skillsResp.json()) as {
+              skills: {
+                name: string;
+                description: string;
+                isActive: boolean;
+                isEnabled: boolean;
+              }[];
+            };
+            agentSkillsSummary = skillsData.skills
+              .filter((s) => s.isActive && s.isEnabled)
+              .map((s) => ({ name: s.name, description: s.description }));
+            if (agentSkillsSummary.length > 0) {
+              console.log(`[${role}] Loaded ${agentSkillsSummary.length} skills for system prompt`);
+            }
+          }
+        } catch {
+          // Non-fatal — skills are optional
+        }
+
         // Rebuild system prompt with identity
-        basePrompt = buildSystemPrompt();
+        basePrompt = await buildSystemPrompt();
         resolvedSystemPrompt = additionalSystemPrompt
           ? `${basePrompt}\n\n${additionalSystemPrompt}`
           : basePrompt;
@@ -1928,6 +2041,37 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
       }
     }
 
+    // ========== Sync skills to filesystem ==========
+    try {
+      console.log(`[${role}] Syncing skills to filesystem...`);
+      const syncHeaders: Record<string, string> = {
+        "Content-Type": "application/json",
+        "X-Agent-ID": agentId,
+      };
+      if (apiKey) syncHeaders.Authorization = `Bearer ${apiKey}`;
+      const syncRes = await fetch(`${swarmUrl}/api/skills/sync-filesystem`, {
+        method: "POST",
+        headers: syncHeaders,
+      });
+      if (syncRes.ok) {
+        const syncResult = (await syncRes.json()) as {
+          synced: number;
+          removed: number;
+          errors: string[];
+        };
+        console.log(
+          `[${role}] Skills synced: ${syncResult.synced} written, ${syncResult.removed} removed`,
+        );
+        if (syncResult.errors.length > 0) {
+          console.warn(`[${role}] Skill sync errors: ${syncResult.errors.join(", ")}`);
+        }
+      } else {
+        console.warn(`[${role}] Skill sync failed: HTTP ${syncRes.status}`);
+      }
+    } catch (err) {
+      console.warn(`[${role}] Skill sync failed: ${(err as Error).message}`);
+    }
+
     // ========== Resume paused tasks with PRIORITY ==========
     // Check for paused tasks from previous shutdown and resume them before normal polling
     try {
@@ -1966,7 +2110,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           }
 
           // Build prompt with resume context + memory injection
-          let resumePrompt = buildResumePrompt(task, adapter.formatCommand.bind(adapter));
+          let resumePrompt = await buildResumePrompt(task, adapter.formatCommand.bind(adapter));
 
           // Inject relevant memories for resumed tasks
           const resumeMemoryContext = await fetchRelevantMemories(
@@ -2048,32 +2192,46 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
             }
           }
 
-          const runningTask = await spawnProviderProcess(
-            adapter,
-            {
-              prompt: resumePrompt,
-              logFile,
-              systemPrompt: resolvedSystemPrompt,
-              additionalArgs: resumeAdditionalArgs,
-              role,
-              apiUrl,
-              apiKey,
-              agentId,
-              runnerSessionId: sessionId,
-              iteration,
-              taskId: task.id,
-              model: (task as { model?: string }).model,
-              cwd: resumeCwd,
-            },
-            logDir,
-            isYolo,
-          );
+          // Per-task runner session ID so session logs are scoped to this task
+          const resumeRunnerSessionId = crypto.randomUUID();
+
+          let runningTask: RunningTask;
+          try {
+            runningTask = await spawnProviderProcess(
+              adapter,
+              {
+                prompt: resumePrompt,
+                logFile,
+                systemPrompt: resolvedSystemPrompt,
+                additionalArgs: resumeAdditionalArgs,
+                role,
+                apiUrl,
+                apiKey,
+                agentId,
+                runnerSessionId: resumeRunnerSessionId,
+                iteration,
+                taskId: task.id,
+                model: (task as { model?: string }).model,
+                cwd: resumeCwd,
+              },
+              logDir,
+              isYolo,
+            );
+          } catch (spawnErr) {
+            const errMsg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
+            console.error(
+              `[${role}] Failed to spawn process for resumed task ${task.id.slice(0, 8)}: ${errMsg}`,
+            );
+            await ensureTaskFinished(apiConfig, role, task.id, 1, `Spawn failed: ${errMsg}`);
+            continue;
+          }
 
           state.activeTasks.set(task.id, runningTask);
           registerActiveSession(apiConfig, {
             taskId: task.id,
             triggerType: "task_resumed",
             taskDescription: task.task?.slice(0, 200),
+            runnerSessionId: resumeRunnerSessionId,
           });
           console.log(
             `[${role}] Resumed task ${task.id.slice(0, 8)} (${state.activeTasks.size}/${state.maxConcurrent} active)`,
@@ -2151,7 +2309,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           console.log(`[${role}] Trigger received: ${trigger.type}`);
 
           // Build prompt based on trigger
-          let triggerPrompt = buildPromptForTrigger(
+          let triggerPrompt = await buildPromptForTrigger(
             trigger,
             prompt,
             adapter.formatCommand.bind(adapter),
@@ -2294,7 +2452,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           }
 
           // Rebuild system prompt with per-task repo context
-          const taskBasePrompt = buildSystemPrompt();
+          const taskBasePrompt = await buildSystemPrompt();
           const taskSystemPrompt =
             (additionalSystemPrompt
               ? `${taskBasePrompt}\n\n${additionalSystemPrompt}`
@@ -2323,31 +2481,60 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           };
           await Bun.write(logFile, `${JSON.stringify(metadata)}\n`);
 
+          // Per-task runner session ID so session logs are scoped to this task
+          const taskRunnerSessionId = crypto.randomUUID();
+
           // Spawn without blocking (await to set up session, but process runs async)
-          const runningTask = await spawnProviderProcess(
-            adapter,
-            {
-              prompt: triggerPrompt,
-              logFile,
-              systemPrompt: taskSystemPrompt,
-              additionalArgs: effectiveAdditionalArgs,
-              role,
-              apiUrl,
-              apiKey,
-              agentId,
-              runnerSessionId: sessionId,
-              iteration,
-              taskId: trigger.taskId,
-              model: taskModel,
-              cwd: effectiveCwd,
-            },
-            logDir,
-            isYolo,
-          );
+          let runningTask: RunningTask;
+          try {
+            runningTask = await spawnProviderProcess(
+              adapter,
+              {
+                prompt: triggerPrompt,
+                logFile,
+                systemPrompt: taskSystemPrompt,
+                additionalArgs: effectiveAdditionalArgs,
+                role,
+                apiUrl,
+                apiKey,
+                agentId,
+                runnerSessionId: taskRunnerSessionId,
+                iteration,
+                taskId: trigger.taskId,
+                model: taskModel,
+                cwd: effectiveCwd,
+              },
+              logDir,
+              isYolo,
+            );
+          } catch (spawnErr) {
+            const errMsg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
+            console.error(
+              `[${role}] Failed to spawn process for task ${trigger.taskId?.slice(0, 8) || "unknown"}: ${errMsg}`,
+            );
+            if (trigger.taskId) {
+              await ensureTaskFinished(
+                apiConfig,
+                role,
+                trigger.taskId,
+                1,
+                `Spawn failed: ${errMsg}`,
+              );
+            }
+            continue;
+          }
 
           // Attach trigger metadata for logging
           runningTask.triggerType = trigger.type;
 
+          // Attach deferred cursor updates for channel_activity triggers
+          if (trigger.type === "channel_activity" && trigger.cursorUpdates) {
+            runningTask.cursorUpdates = trigger.cursorUpdates as Array<{
+              channelId: string;
+              ts: string;
+            }>;
+          }
+
           state.activeTasks.set(runningTask.taskId, runningTask);
 
           // Register active session for concurrency awareness
@@ -2359,6 +2546,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
             taskId: runningTask.taskId,
             triggerType: trigger.type,
             taskDescription: taskDesc,
+            runnerSessionId: taskRunnerSessionId,
           });
 
           console.log(