@desplega.ai/agent-swarm 1.69.0 → 1.69.1

package/src/linear/sync.ts

@@ -1,4 +1,4 @@
-import { cancelTask, createTaskExtended, getAllAgents, getTaskById, resolveUser } from "../be/db";
+import { cancelTask, getAllAgents, getTaskById, resolveUser } from "../be/db";
 import { getOAuthTokens } from "../be/db-queries/oauth";
 import {
   createTrackerSync,
@@ -8,6 +8,8 @@ import {
 } from "../be/db-queries/tracker";
 import { ensureToken } from "../oauth/ensure-token";
 import { resolveTemplate } from "../prompts/resolver";
+import { linearContextKey } from "../tasks/context-key";
+import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 // Side-effect import: registers all Linear event templates in the in-memory registry
 import "./templates";
 
@@ -287,18 +289,26 @@ export async function handleAgentSessionEvent(event: Record<string, unknown>): P
   if (existing) {
     const existingTask = getTaskById(existing.swarmId);
 
-    // If the task is still active, acknowledge the new session but don't create a duplicate
+    // If the task is still active, post a user-visible response on the new
+    // session explaining that a sibling is already in flight and the new
+    // session can be closed. Do NOT create a duplicate swarm task. If the user
+    // wants to force a fresh run, they can re-assign the issue after the
+    // current task finishes.
     if (existingTask && !["completed", "failed", "cancelled"].includes(existingTask.status)) {
       console.log(
-        `[Linear Sync] Issue ${issueIdentifier} already tracked as active task ${existing.swarmId}, skipping`,
+        `[Linear Sync] Issue ${issueIdentifier} already tracked as active task ${existing.swarmId} (status: ${existingTask.status}), skipping duplicate`,
       );
       if (sessionId) {
         taskSessionMap.set(existingTask.id, sessionId);
-        acknowledgeAgentSession(
-          sessionId,
-          `This issue is already being worked on (task ${existing.swarmId}).`,
-        ).catch((err) => {
-          console.error("[Linear Sync] Failed to acknowledge duplicate AgentSession:", err);
+        const refuseMsg = [
+          `This issue is already being worked on — task \`${existing.swarmId}\` is currently \`${existingTask.status}\`.`,
+          "",
+          "To avoid duplicating work, I'm not starting a new session for this re-assignment. Progress on the active task will continue to be posted here.",
+          "",
+          "If you want to force a fresh run, wait for the current task to finish (or cancel it) and re-assign the issue.",
+        ].join("\n");
+        postAgentSessionResponse(sessionId, refuseMsg).catch((err) => {
+          console.error("[Linear Sync] Failed to post hard-refuse response:", err);
         });
       }
       return;
@@ -327,11 +337,12 @@ export async function handleAgentSessionEvent(event: Record<string, unknown>): P
     return;
   }
 
-  const task = createTaskExtended(templateResult.text, {
+  const task = createTaskWithSiblingAwareness(templateResult.text, {
     agentId: lead?.id ?? "",
     source: "linear",
     taskType: "linear-issue",
     requestedByUserId,
+    contextKey: linearContextKey({ issueIdentifier }),
   });
 
   // Delete old tracker_sync before creating new one (UNIQUE constraint)
@@ -570,11 +581,12 @@ export async function handleAgentSessionPrompted(event: Record<string, unknown>)
     return;
   }
 
-  const task = createTaskExtended(followupResult.text, {
+  const task = createTaskWithSiblingAwareness(followupResult.text, {
     agentId: lead?.id ?? "",
     source: "linear",
     taskType: "linear-issue",
     requestedByUserId: promptedRequestedByUserId,
+    contextKey: linearContextKey({ issueIdentifier }),
   });
 
   // Repoint the existing tracker_sync to the new follow-up task (can't create a

package/src/providers/claude-adapter.ts

@@ -212,6 +212,7 @@ class ClaudeSession implements ProviderSession {
     this.proc = Bun.spawn(cmd, {
       cwd: this.config.cwd,
       env: {
+        ENABLE_PROMPT_CACHING_1H: "1",
         ...(config.env || process.env),
         TASK_FILE: taskFilePath,
       } as Record<string, string>,

package/src/scheduler/scheduler.ts

@@ -1,12 +1,8 @@
 import { ensure } from "@desplega.ai/business-use";
 import { CronExpressionParser } from "cron-parser";
-import {
-  createTaskExtended,
-  getDb,
-  getDueScheduledTasks,
-  getScheduledTaskById,
-  updateScheduledTask,
-} from "@/be/db";
+import { getDb, getDueScheduledTasks, getScheduledTaskById, updateScheduledTask } from "@/be/db";
+import { scheduleContextKey } from "@/tasks/context-key";
+import { createTaskWithSiblingAwareness } from "@/tasks/sibling-awareness";
 import type { ScheduledTask } from "@/types";
 import type { ExecutorRegistry } from "@/workflows/executors/registry";
 import { handleScheduleTrigger } from "@/workflows/triggers";
@@ -49,7 +45,7 @@ async function recoverMissedSchedules(): Promise<void> {
 
       if (!triggeredWorkflows) {
         const tx = getDb().transaction(() => {
-          createTaskExtended(schedule.taskTemplate, {
+          createTaskWithSiblingAwareness(schedule.taskTemplate, {
             creatorAgentId: schedule.createdByAgentId,
             taskType: schedule.taskType,
             tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "recovered"],
@@ -58,6 +54,7 @@ async function recoverMissedSchedules(): Promise<void> {
             model: schedule.model,
             scheduleId: schedule.id,
             source: "schedule",
+            contextKey: scheduleContextKey({ scheduleId: schedule.id }),
           });
         });
         tx();
@@ -153,7 +150,7 @@ async function executeSchedule(schedule: ScheduledTask): Promise<void> {
     if (!triggeredWorkflows) {
       // No workflows linked — create standalone task (existing behavior)
       getDb().transaction(() => {
-        createTaskExtended(schedule.taskTemplate, {
+        createTaskWithSiblingAwareness(schedule.taskTemplate, {
           creatorAgentId: schedule.createdByAgentId,
           taskType: schedule.taskType,
           tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`],
@@ -162,6 +159,7 @@ async function executeSchedule(schedule: ScheduledTask): Promise<void> {
           model: schedule.model,
           scheduleId: schedule.id,
           source: "schedule",
+          contextKey: scheduleContextKey({ scheduleId: schedule.id }),
         });
       })();
     }
@@ -343,7 +341,7 @@ export async function runScheduleNow(scheduleId: string): Promise<void> {
   if (!triggeredWorkflows) {
     // No workflows linked — create standalone task (existing behavior)
     getDb().transaction(() => {
-      createTaskExtended(schedule.taskTemplate, {
+      createTaskWithSiblingAwareness(schedule.taskTemplate, {
         creatorAgentId: schedule.createdByAgentId,
         taskType: schedule.taskType,
         tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "manual-run"],
@@ -352,6 +350,7 @@ export async function runScheduleNow(scheduleId: string): Promise<void> {
         model: schedule.model,
         scheduleId: schedule.id,
         source: "schedule",
+        contextKey: scheduleContextKey({ scheduleId: schedule.id }),
       });
     })();
   }

package/src/slack/actions.ts

@@ -1,12 +1,7 @@
 import type { App } from "@slack/bolt";
-import {
-  cancelTask,
-  createTaskExtended,
-  getAgentById,
-  getLeadAgent,
-  getTaskById,
-  resolveUser,
-} from "../be/db";
+import { cancelTask, getAgentById, getLeadAgent, getTaskById, resolveUser } from "../be/db";
+import { slackContextKey } from "../tasks/context-key";
+import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { buildCancelledBlocks, getTaskLink } from "./blocks";
 
 export function registerActionHandlers(app: App): void {
@@ -73,7 +68,7 @@ export function registerActionHandlers(app: App): void {
 
     const lead = getLeadAgent();
     const requestedByUserId = resolveUser({ slackUserId: body.user.id })?.id;
-    const followUpTask = createTaskExtended(followUpText, {
+    const followUpTask = createTaskWithSiblingAwareness(followUpText, {
       agentId: lead?.id,
       source: "slack",
       parentTaskId: taskId,
@@ -81,6 +76,12 @@ export function registerActionHandlers(app: App): void {
       slackThreadTs: originalTask.slackThreadTs,
       slackUserId: body.user.id,
       requestedByUserId,
+      contextKey: originalTask.slackThreadTs
+        ? slackContextKey({
+            channelId: originalTask.slackChannelId,
+            threadTs: originalTask.slackThreadTs,
+          })
+        : undefined,
     });
 
     const taskLink = getTaskLink(followUpTask.id);

package/src/slack/assistant.ts

@@ -1,12 +1,13 @@
 import { Assistant } from "@slack/bolt";
 import {
-  createTaskExtended,
   getAgentWorkingOnThread,
   getLeadAgent,
   getMostRecentTaskInThread,
   resolveUser,
 } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
+import { slackContextKey } from "../tasks/context-key";
+import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { bufferThreadMessage } from "./thread-buffer";
 // Side-effect import: registers all Slack event templates in the in-memory registry
 import "./templates";
@@ -82,7 +83,7 @@ export function createAssistant(): Assistant {
 
           // Otherwise, create a follow-up task for the working agent
           const latestTask = getMostRecentTaskInThread(channelId, threadTs);
-          createTaskExtended(messageText, {
+          createTaskWithSiblingAwareness(messageText, {
             agentId: workingAgent.id,
             source: "slack",
             slackChannelId: channelId,
@@ -90,6 +91,7 @@ export function createAssistant(): Assistant {
             slackUserId: userId,
             parentTaskId: latestTask?.id,
             requestedByUserId,
+            contextKey: slackContextKey({ channelId, threadTs }),
           });
 
           await safeSetStatus("Processing follow-up...");
@@ -114,25 +116,27 @@ export function createAssistant(): Assistant {
         const lead = getLeadAgent();
         if (!lead) {
           // No lead — still queue the task
-          createTaskExtended(messageText + channelContext, {
+          createTaskWithSiblingAwareness(messageText + channelContext, {
             source: "slack",
             slackChannelId: channelId,
             slackThreadTs: threadTs,
             slackUserId: userId,
             requestedByUserId,
+            contextKey: slackContextKey({ channelId, threadTs }),
           });
           const offlineResult = resolveTemplate("slack.assistant.offline", {});
           await say(offlineResult.text);
           return;
         }
 
-        createTaskExtended(messageText + channelContext, {
+        createTaskWithSiblingAwareness(messageText + channelContext, {
           agentId: lead.id,
           source: "slack",
           slackChannelId: channelId,
           slackThreadTs: threadTs,
           slackUserId: userId,
           requestedByUserId,
+          contextKey: slackContextKey({ channelId, threadTs }),
         });
         // setStatus shows typing indicator — watcher will post final result when done
       } catch (error) {

package/src/slack/handlers.ts

@@ -10,6 +10,8 @@ import {
   resolveUser,
 } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
+import { slackContextKey } from "../tasks/context-key";
+import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { workflowEventBus } from "../workflows/event-bus";
 import { buildTreeBlocks, type TreeNode } from "./blocks";
 import type { SlackFile } from "./files";
@@ -538,13 +540,14 @@ export function registerMessageHandler(app: App): void {
       }
 
       const lead = getLeadAgent();
-      createTaskExtended(fullTaskDescription, {
+      createTaskWithSiblingAwareness(fullTaskDescription, {
         agentId: lead?.id,
         source: "slack",
         slackChannelId: msg.channel,
         slackThreadTs: threadTs,
         slackUserId: msg.user,
         requestedByUserId,
+        contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
       });
 
       await say({
@@ -610,7 +613,7 @@ export function registerMessageHandler(app: App): void {
       try {
         const latestTask = getMostRecentTaskInThread(msg.channel, threadTs);
         if (agent.isLead) {
-          const task = createTaskExtended(fullTaskDescription, {
+          const task = createTaskWithSiblingAwareness(fullTaskDescription, {
             agentId: agent.id,
             source: "slack",
             slackChannelId: msg.channel,
@@ -618,19 +621,21 @@ export function registerMessageHandler(app: App): void {
             slackUserId: msg.user,
             parentTaskId: latestTask?.id,
             requestedByUserId,
+            contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
           });
           results.assigned.push({ agentName: agent.name, taskId: task.id });
           continue;
         }
 
         // Workers receive tasks as before
-        const task = createTaskExtended(fullTaskDescription, {
+        const task = createTaskWithSiblingAwareness(fullTaskDescription, {
           agentId: agent.id,
           source: "slack",
           slackChannelId: msg.channel,
           slackThreadTs: threadTs,
           slackUserId: msg.user,
           requestedByUserId,
+          contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
         });
 
         // Check if agent has an in-progress task in this thread (queued follow-up)

package/src/slack/thread-buffer.ts

@@ -1,9 +1,7 @@
-import {
-  createTaskExtended,
-  getLatestActiveTaskInThread,
-  getLeadAgent,
-  getMostRecentTaskInThread,
-} from "../be/db";
+import { getLatestActiveTaskInThread, getLeadAgent, getMostRecentTaskInThread } from "../be/db";
+import { createAdditiveBuffer } from "../tasks/additive-buffer";
+import { slackContextKey } from "../tasks/context-key";
+import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { getSlackApp } from "./app";
 import { buildBufferFlushBlocks } from "./blocks";
 import { registerTreeMessage } from "./watcher";
@@ -12,24 +10,30 @@ interface BufferedMessage {
   text: string;
   userId: string;
   ts: string;
-}
-
-interface BufferedThread {
   channelId: string;
   threadTs: string;
-  messages: BufferedMessage[];
-  timer: Timer;
-  slackUserId: string; // original requester (first message sender)
 }
 
-const threadBuffers = new Map<string, BufferedThread>();
-
 const BUFFER_TIMEOUT_MS = Number(process.env.ADDITIVE_SLACK_BUFFER_MS) || 10_000;
 
 function makeKey(channelId: string, threadTs: string): string {
   return `${channelId}:${threadTs}`;
 }
 
+function splitKey(key: string): { channelId: string; threadTs: string } | null {
+  const idx = key.indexOf(":");
+  if (idx === -1) return null;
+  return { channelId: key.slice(0, idx), threadTs: key.slice(idx + 1) };
+}
+
+const slackBuffer = createAdditiveBuffer<BufferedMessage>({
+  timeoutMs: BUFFER_TIMEOUT_MS,
+  label: "slack-thread",
+  onFlush: async (items, key, reason) => {
+    await slackFlush(items, key, reason === "manual");
+  },
+});
+
 /**
  * Add a message to the thread buffer. Resets the debounce timer.
  */
@@ -40,43 +44,27 @@ export function bufferThreadMessage(
   userId: string,
   ts: string,
 ): void {
-  const key = makeKey(channelId, threadTs);
-  const existing = threadBuffers.get(key);
-
-  if (existing) {
-    // Append to existing buffer, reset timer
-    existing.messages.push({ text, userId, ts });
-    clearTimeout(existing.timer);
-    existing.timer = setTimeout(() => flushBuffer(key, false), BUFFER_TIMEOUT_MS);
-    console.log(
-      `[Slack] Buffer append: ${key} (${existing.messages.length} messages, timer reset to ${BUFFER_TIMEOUT_MS}ms)`,
-    );
-  } else {
-    // Create new buffer entry
-    const timer = setTimeout(() => flushBuffer(key, false), BUFFER_TIMEOUT_MS);
-    threadBuffers.set(key, {
-      channelId,
-      threadTs,
-      messages: [{ text, userId, ts }],
-      timer,
-      slackUserId: userId,
-    });
-    console.log(`[Slack] Buffer created: ${key} (timer set to ${BUFFER_TIMEOUT_MS}ms)`);
-  }
+  slackBuffer.enqueue(makeKey(channelId, threadTs), {
+    text,
+    userId,
+    ts,
+    channelId,
+    threadTs,
+  });
 }
 
 /**
  * Check if a thread currently has a pending buffer.
  */
 export function isThreadBuffered(channelId: string, threadTs: string): boolean {
-  return threadBuffers.has(makeKey(channelId, threadTs));
+  return slackBuffer.isBuffered(makeKey(channelId, threadTs));
 }
 
 /**
  * Get the number of messages currently in the buffer for a thread key.
  */
 export function getBufferMessageCount(key: string): number {
-  return threadBuffers.get(key)?.messages.length ?? 0;
+  return slackBuffer.count(key);
 }
 
 /**
@@ -84,12 +72,7 @@ export function getBufferMessageCount(key: string): number {
  * and flushes with immediate=true (no dependsOn).
  */
 export async function instantFlush(key: string): Promise<void> {
-  const buffer = threadBuffers.get(key);
-  if (buffer) {
-    clearTimeout(buffer.timer);
-    console.log(`[Slack] Instant flush triggered: ${key}`);
-  }
-  await flushBuffer(key, true);
+  await slackBuffer.instantFlush(key);
 }
 
 /**
@@ -130,27 +113,34 @@ async function getThreadContextForBuffer(channelId: string, threadTs: string): P
 }
 
 /**
- * Flush the buffer: concatenate messages, create task with optional dependency chaining.
- * @param key - The buffer key (channelId:threadTs)
- * @param immediate - If true, skip dependency chaining (used by !now)
+ * Flush the Slack thread buffer: concatenate messages, create task with optional
+ * dependency chaining.
  */
-async function flushBuffer(key: string, immediate = false): Promise<void> {
-  const buffer = threadBuffers.get(key);
-  if (!buffer || buffer.messages.length === 0) {
-    threadBuffers.delete(key);
+async function slackFlush(
+  items: BufferedMessage[],
+  key: string,
+  immediate: boolean,
+): Promise<void> {
+  if (items.length === 0) return;
+
+  const split = splitKey(key);
+  if (!split) {
+    console.warn(`[Slack] Buffer flush: malformed key ${key}`);
     return;
   }
+  const { channelId, threadTs } = split;
+  // Buffer is guaranteed to have at least one item — the first carries the
+  // original requester's userId (same semantics as the pre-refactor version).
+  const originalRequesterId = items[0]!.userId;
 
-  console.log(
-    `[Slack] Flushing buffer: ${key} (${buffer.messages.length} messages, immediate=${immediate})`,
-  );
+  console.log(`[Slack] Flushing buffer: ${key} (${items.length} messages, immediate=${immediate})`);
 
   // Build combined task description
-  const combinedText = buffer.messages.map((m) => m.text).join("\n---\n");
-  const description = `[Thread follow-up — ${buffer.messages.length} message(s) buffered]\n\n${combinedText}`;
+  const combinedText = items.map((m) => m.text).join("\n---\n");
+  const description = `[Thread follow-up — ${items.length} message(s) buffered]\n\n${combinedText}`;
 
   // Find the latest active task in this thread for dependency chaining
-  const latestActiveTask = getLatestActiveTaskInThread(buffer.channelId, buffer.threadTs);
+  const latestActiveTask = getLatestActiveTaskInThread(channelId, threadTs);
   if (latestActiveTask) {
     console.log(
       `[Slack] Dependency chaining: latest active task ${latestActiveTask.id} (status: ${latestActiveTask.status})`,
@@ -160,7 +150,7 @@ async function flushBuffer(key: string, immediate = false): Promise<void> {
   const lead = getLeadAgent();
 
   // Thread context for the task
-  const threadContext = await getThreadContextForBuffer(buffer.channelId, buffer.threadTs);
+  const threadContext = await getThreadContextForBuffer(channelId, threadTs);
   const fullDescription = threadContext
     ? `<thread_context>\n${threadContext}\n</thread_context>\n\n${description}`
     : description;
@@ -169,15 +159,16 @@ async function flushBuffer(key: string, immediate = false): Promise<void> {
   // Otherwise, depend on the latest active task so it queues naturally.
   const dependsOn = !immediate && latestActiveTask ? [latestActiveTask.id] : undefined;
 
-  const mostRecentTask = getMostRecentTaskInThread(buffer.channelId, buffer.threadTs);
-  const task = createTaskExtended(fullDescription, {
+  const mostRecentTask = getMostRecentTaskInThread(channelId, threadTs);
+  const task = createTaskWithSiblingAwareness(fullDescription, {
     agentId: lead?.id,
     source: "slack",
-    slackChannelId: buffer.channelId,
-    slackThreadTs: buffer.threadTs,
-    slackUserId: buffer.slackUserId,
+    slackChannelId: channelId,
+    slackThreadTs: threadTs,
+    slackUserId: originalRequesterId,
     dependsOn,
     parentTaskId: mostRecentTask?.id,
+    contextKey: slackContextKey({ channelId, threadTs }),
   });
 
   console.log(
@@ -189,18 +180,18 @@ async function flushBuffer(key: string, immediate = false): Promise<void> {
   if (app) {
     const hasDependency = !immediate && !!latestActiveTask;
     const blocks = buildBufferFlushBlocks({
-      messageCount: buffer.messages.length,
+      messageCount: items.length,
       taskId: task.id,
       hasDependency,
     });
     const fallbackText = hasDependency
-      ? `${buffer.messages.length} follow-up message(s) queued pending completion of current task`
-      : `${buffer.messages.length} follow-up message(s) batched into task`;
+      ? `${items.length} follow-up message(s) queued pending completion of current task`
+      : `${items.length} follow-up message(s) batched into task`;
 
     try {
       const result = await app.client.chat.postMessage({
-        channel: buffer.channelId,
-        thread_ts: buffer.threadTs,
+        channel: channelId,
+        thread_ts: threadTs,
         text: fallbackText,
         // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
         blocks: blocks as any,
@@ -208,7 +199,7 @@ async function flushBuffer(key: string, immediate = false): Promise<void> {
 
       // Register the batching message as the tree message for this task
       if (result.ts && task) {
-        registerTreeMessage(task.id, buffer.channelId, buffer.threadTs, result.ts);
+        registerTreeMessage(task.id, channelId, threadTs, result.ts);
         console.log(
           `[Slack] Registered batched task ${task.id.slice(0, 8)} tree message from buffer flush`,
         );
@@ -217,6 +208,4 @@ async function flushBuffer(key: string, immediate = false): Promise<void> {
       console.error("[Slack] Failed to post buffer flush feedback:", error);
     }
   }
-
-  threadBuffers.delete(key);
 }