@desplega.ai/agent-swarm 1.145.0 → 1.147.0

package/dist/handlers-yfp1qn81.js

@@ -1,592 +0,0 @@
-import {
-  bufferThreadMessage,
-  formatSlackSteeringAck,
-  getBufferMessageCount,
-  instantFlush,
-  requestSlackThreadSteering,
-  wasEventSeen
-} from "./cli-m1xa8be7.js";
-import {
-  extractSlackMessageText,
-  extractTaskFromMessage,
-  hasOtherUserMention,
-  routeMessage
-} from "./cli-jnf5zghe.js";
-import {
-  enrichSlackUserEmail,
-  resolveSlackUserId,
-  rewriteSlackMentions
-} from "./cli-xytwff7f.js";
-import"./cli-z96t0thj.js";
-import {
-  createTaskWithSiblingAwareness
-} from "./cli-axs8e6d4.js";
-import {
-  ackSlackMessage,
-  buildTreeBlocks,
-  ensureSlackThreadTree,
-  isSlackRenderV2Enabled,
-  registerTreeMessage
-} from "./cli-jmb7g47h.js";
-import"./cli-q51yprfq.js";
-import"./cli-yatxqynm.js";
-import {
-  getAgentById,
-  getAgentWorkingOnThread,
-  getLeadAgent,
-  getMostRecentTaskInThread,
-  getTasksByAgentId,
-  init_context_key,
-  init_db,
-  reactionName,
-  slackContextKey
-} from "./cli-f567d5c1.js";
-import"./cli-kpev657q.js";
-import {
-  init_resolver,
-  resolveTemplate
-} from "./cli-7fnkj1hj.js";
-import"./cli-e29gmdmw.js";
-import"./cli-c2mk1kgf.js";
-import {
-  init_env_flag,
-  isEnvFlagEnabled
-} from "./cli-ej6gbxfb.js";
-import"./cli-sd0mxa3c.js";
-import"./cli-w5e1d1vv.js";
-import"./cli-dc9k2ba9.js";
-import"./cli-xqcq9y5e.js";
-import"./cli-pzxba7gw.js";
-import {
-  init_event_bus,
-  workflowEventBus
-} from "./cli-f7kvq46p.js";
-import"./cli-zf8jjwex.js";
-import"./cli-bd957dgb.js";
-import"./cli-bc05qbss.js";
-
-// src/slack/handlers.ts
-init_db();
-init_resolver();
-init_context_key();
-init_event_bus();
-init_env_flag();
-var allowedEmailDomains = (process.env.SLACK_ALLOWED_EMAIL_DOMAINS || "").split(",").map((d) => d.trim().toLowerCase()).filter(Boolean);
-var allowedUserIds = (process.env.SLACK_ALLOWED_USER_IDS || "").split(",").map((id) => id.trim()).filter(Boolean);
-var filteringEnabled = allowedEmailDomains.length > 0 || allowedUserIds.length > 0;
-function checkUserAccess(userId, email, config) {
-  const { allowedEmailDomains: domains, allowedUserIds: userIds } = config;
-  if (domains.length === 0 && userIds.length === 0) {
-    return true;
-  }
-  if (userIds.includes(userId)) {
-    return true;
-  }
-  if (domains.length === 0) {
-    return false;
-  }
-  if (!email) {
-    return false;
-  }
-  const domain = email.split("@")[1]?.toLowerCase();
-  if (!domain) {
-    return false;
-  }
-  return domains.includes(domain);
-}
-async function isUserAllowed(client, userId) {
-  if (!filteringEnabled) {
-    return true;
-  }
-  if (allowedUserIds.includes(userId)) {
-    return true;
-  }
-  if (allowedEmailDomains.length === 0) {
-    return false;
-  }
-  const email = await enrichSlackUserEmail(client, userId);
-  if (!email) {
-    console.log(`[Slack] User ${userId} has no email, denying access`);
-    return false;
-  }
-  const domain = email.split("@")[1]?.toLowerCase();
-  if (!domain) {
-    console.log(`[Slack] User ${userId} has invalid email format, denying access`);
-    return false;
-  }
-  const allowed = allowedEmailDomains.includes(domain);
-  if (!allowed) {
-    console.log(`[Slack] User ${userId} email domain "${domain}" not in allowed list`);
-  }
-  return allowed;
-}
-function isBotMessage(event, botUserId) {
-  if (event.subtype === "bot_message")
-    return true;
-  if (event.bot_id)
-    return true;
-  if (botUserId && event.user === botUserId)
-    return true;
-  return false;
-}
-var cachedBotUserId = null;
-var cachedBotId = null;
-var swarmThreadRootCache = new Map;
-var SWARM_THREAD_ROOT_CACHE_MAX = 1000;
-function resetSlackHandlerCachesForTesting() {
-  cachedBotUserId = null;
-  cachedBotId = null;
-  swarmThreadRootCache.clear();
-}
-function isSwarmThreadRoot(root, botUserId, botId) {
-  if (!root)
-    return false;
-  if (botUserId && root.user === botUserId)
-    return true;
-  if (botId && root.bot_id === botId)
-    return true;
-  return false;
-}
-async function wasThreadStartedBySwarm(client, channelId, threadTs) {
-  const key = `${channelId}:${threadTs}`;
-  const cached = swarmThreadRootCache.get(key);
-  if (cached !== undefined)
-    return cached;
-  let startedBySwarm = false;
-  try {
-    const resp = await client.conversations.replies({
-      channel: channelId,
-      ts: threadTs,
-      limit: 1,
-      inclusive: true
-    });
-    const root = resp.messages?.[0];
-    startedBySwarm = isSwarmThreadRoot(root, cachedBotUserId, cachedBotId);
-  } catch (error) {
-    console.error("[Slack] Failed to check whether thread was started by swarm:", error);
-  }
-  if (swarmThreadRootCache.size >= SWARM_THREAD_ROOT_CACHE_MAX) {
-    const oldest = swarmThreadRootCache.keys().next().value;
-    if (oldest !== undefined)
-      swarmThreadRootCache.delete(oldest);
-  }
-  swarmThreadRootCache.set(key, startedBySwarm);
-  return startedBySwarm;
-}
-async function hasSwarmThreadActivity(client, channelId, threadTs) {
-  return await getAgentWorkingOnThread(channelId, threadTs) !== null || await wasThreadStartedBySwarm(client, channelId, threadTs);
-}
-async function getThreadContext(client, channel, threadTs, currentTs, botUserId) {
-  if (!threadTs)
-    return "";
-  try {
-    const result = await client.conversations.replies({
-      channel,
-      ts: threadTs,
-      limit: 20
-    });
-    const messages = result.messages || [];
-    const previousMessages = messages.filter((m) => {
-      if (m.ts === currentTs)
-        return false;
-      return extractSlackMessageText(m) !== "";
-    });
-    if (previousMessages.length === 0)
-      return "";
-    const formattedMessages = [];
-    for (const m of previousMessages) {
-      const isBotMessage2 = m.user === botUserId || m.bot_id !== undefined || m.subtype === "bot_message";
-      const text = extractSlackMessageText(m);
-      if (isBotMessage2) {
-        const truncatedText = text.length > 500 ? `${text.slice(0, 500)}...` : text;
-        formattedMessages.push(`[Agent]: ${truncatedText}`);
-      } else {
-        const authorTag = m.user ? `<@${m.user}>` : "Unknown";
-        formattedMessages.push(`${authorTag}: ${text}`);
-      }
-    }
-    return await rewriteSlackMentions(formattedMessages.join(`
-`), botUserId);
-  } catch (error) {
-    console.error("[Slack] Failed to fetch thread context:", error);
-    return "";
-  }
-}
-function formatFileSize(bytes) {
-  if (bytes < 1024)
-    return `${bytes} B`;
-  if (bytes < 1024 * 1024)
-    return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024)
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-function buildAttachmentText(files) {
-  return files.map((f) => `[File: ${f.name} (${f.mimetype}, ${formatFileSize(f.size)}) id=${f.id}]`).join(`
-`);
-}
-function buildEffectiveText(text, files) {
-  const hasText = !!text?.trim();
-  const hasFiles = files && files.length > 0;
-  if (hasText && hasFiles) {
-    return `${text}
-
-${buildAttachmentText(files)}`;
-  }
-  if (hasFiles) {
-    return buildAttachmentText(files);
-  }
-  return text || "";
-}
-var processedMessages = new Set;
-var MESSAGE_DEDUP_TTL = 60000;
-function isMessageProcessed(messageKey) {
-  if (processedMessages.has(messageKey)) {
-    console.log(`[Slack] Duplicate event detected: ${messageKey}`);
-    return true;
-  }
-  processedMessages.add(messageKey);
-  setTimeout(() => processedMessages.delete(messageKey), MESSAGE_DEDUP_TTL);
-  console.log(`[Slack] Processing new message: ${messageKey}`);
-  return false;
-}
-var rateLimitMap = new Map;
-var RATE_LIMIT_WINDOW = 60000;
-var MAX_REQUESTS_PER_WINDOW = 10;
-function checkRateLimit(userId) {
-  const userRequests = rateLimitMap.get(userId) || 0;
-  if (userRequests >= MAX_REQUESTS_PER_WINDOW) {
-    return false;
-  }
-  rateLimitMap.set(userId, userRequests + 1);
-  setTimeout(() => {
-    const current = rateLimitMap.get(userId) || 0;
-    if (current > 0) {
-      rateLimitMap.set(userId, current - 1);
-    }
-  }, RATE_LIMIT_WINDOW);
-  return true;
-}
-function registerMessageHandler(app) {
-  app.event("message", async ({ event, body, client, say }) => {
-    const eventId = body?.event_id;
-    if (wasEventSeen(eventId)) {
-      console.log(`[Slack] dropping Slack retry: event_id=${eventId}`);
-      return;
-    }
-    const msg = event;
-    if (msg.subtype === "message_changed")
-      return;
-    if (!cachedBotUserId) {
-      try {
-        const authResult = await client.auth.test();
-        cachedBotUserId = authResult.user_id;
-        cachedBotId = authResult.bot_id ?? null;
-      } catch (error) {
-        console.error("[Slack] Failed to cache bot user ID:", error);
-      }
-    }
-    if (isBotMessage(msg, cachedBotUserId)) {
-      return;
-    }
-    const hasText = !!msg.text?.trim();
-    const hasFiles = !!(msg.files && msg.files.length > 0);
-    if (!hasText && !hasFiles || !msg.user)
-      return;
-    const messageKey = `${msg.channel}:${msg.ts}`;
-    if (isMessageProcessed(messageKey)) {
-      return;
-    }
-    if (!await isUserAllowed(client, msg.user)) {
-      console.log(`[Slack] Ignoring message from unauthorized user ${msg.user}`);
-      return;
-    }
-    const requestedByUserId = await resolveSlackUserId(client, msg.user, {
-      sampleEventType: "message",
-      sampleContext: msg.text ?? ""
-    });
-    workflowEventBus.emit("slack.message", {
-      channel: msg.channel,
-      text: msg.text,
-      user: msg.user,
-      ts: msg.ts,
-      threadTs: msg.thread_ts
-    });
-    const effectiveText = buildEffectiveText(msg.text, msg.files);
-    if (!cachedBotUserId) {
-      console.error("[Slack] Bot user ID unavailable — skipping message to avoid silent misbehavior");
-      return;
-    }
-    const botUserId = cachedBotUserId;
-    const botMentioned = !!msg.text?.includes(`<@${botUserId}>`);
-    const isAssistantThread = !!msg.assistant_thread;
-    const isImplicitMention = isAssistantThread && !botMentioned && !hasOtherUserMention(effectiveText, botUserId);
-    const additiveSlack = isEnvFlagEnabled("ADDITIVE_SLACK", false);
-    const requireMentionForThreadFollowup = isEnvFlagEnabled("SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION", false);
-    if (additiveSlack && msg.thread_ts) {
-      const stripped = effectiveText.replace(/<@[A-Z0-9]+>/g, "").trim();
-      if (stripped.startsWith("!now") && await hasSwarmThreadActivity(client, msg.channel, msg.thread_ts)) {
-        const nowMessage = stripped.replace(/^!now\s*/, "").trim();
-        const threadKey = `${msg.channel}:${msg.thread_ts}`;
-        console.log(`[Slack] !now command detected in thread ${threadKey}${nowMessage ? ` with message: "${nowMessage}"` : ""}`);
-        if (nowMessage) {
-          bufferThreadMessage(msg.channel, msg.thread_ts, nowMessage, msg.user, msg.ts);
-        }
-        await instantFlush(threadKey);
-        await ackSlackMessage(client, msg.channel, msg.ts, reactionName("now"), "now");
-        return;
-      }
-    }
-    if (additiveSlack && !botMentioned && msg.thread_ts && !requireMentionForThreadFollowup) {
-      if (hasOtherUserMention(effectiveText, botUserId)) {
-        console.log(`[Slack] Skipping ADDITIVE buffer in ${msg.channel}/${msg.thread_ts}: message mentions another user`);
-        return;
-      }
-      const hasSwarmActivity = await hasSwarmThreadActivity(client, msg.channel, msg.thread_ts);
-      if (hasSwarmActivity) {
-        const threadKey = `${msg.channel}:${msg.thread_ts}`;
-        bufferThreadMessage(msg.channel, msg.thread_ts, effectiveText, msg.user, msg.ts);
-        const count = getBufferMessageCount(threadKey);
-        const event2 = count === 1 ? "accepted" : "buffered";
-        const name = reactionName(event2);
-        console.log(`[Slack] Additive buffer: ${threadKey} (message #${count}, reaction: ${name})`);
-        await ackSlackMessage(client, msg.channel, msg.ts, name, event2);
-        return;
-      }
-    }
-    const routingText = msg.text || effectiveText;
-    const routingThreadContext = msg.thread_ts ? { channelId: msg.channel, threadTs: msg.thread_ts } : undefined;
-    const matches = await routeMessage(routingText, botUserId, botMentioned || isImplicitMention, routingThreadContext);
-    if (matches.length === 0) {
-      if (!botMentioned && !isImplicitMention)
-        return;
-      if (!checkRateLimit(msg.user)) {
-        if (!isSlackRenderV2Enabled()) {
-          await say({
-            text: ":satellite: _You're sending too many requests. Please slow down._",
-            thread_ts: msg.thread_ts || msg.ts
-          });
-        }
-        return;
-      }
-      const taskDescription2 = isImplicitMention ? effectiveText : extractTaskFromMessage(effectiveText, botUserId);
-      if (!taskDescription2) {
-        if (!isImplicitMention && !isSlackRenderV2Enabled()) {
-          await say({
-            text: ":satellite: _Please provide a task description after mentioning an agent._",
-            thread_ts: msg.thread_ts || msg.ts
-          });
-        }
-        return;
-      }
-      const threadTs2 = msg.thread_ts || msg.ts;
-      const threadContext2 = await getThreadContext(client, msg.channel, msg.thread_ts, msg.ts, botUserId);
-      let fullTaskDescription2;
-      if (threadContext2) {
-        const ctxResult = resolveTemplate("slack.message.thread_context", {
-          thread_messages: threadContext2
-        });
-        fullTaskDescription2 = `${ctxResult.text}
-
-${taskDescription2}`;
-      } else {
-        fullTaskDescription2 = taskDescription2;
-      }
-      const lead = await getLeadAgent();
-      const task = await createTaskWithSiblingAwareness(fullTaskDescription2, {
-        agentId: lead?.id,
-        source: "slack",
-        slackChannelId: msg.channel,
-        slackThreadTs: threadTs2,
-        slackTriggerMessageTs: msg.ts,
-        slackUserId: msg.user,
-        requestedByUserId,
-        contextKey: slackContextKey({ channelId: msg.channel, threadTs: threadTs2 })
-      });
-      await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
-      if (isSlackRenderV2Enabled()) {
-        await ensureSlackThreadTree([task.id]);
-      } else {
-        await say({
-          text: ":satellite: _No agents are online right now. Your request has been queued and will be processed when agents come back up._",
-          thread_ts: threadTs2
-        });
-      }
-      return;
-    }
-    if (!checkRateLimit(msg.user)) {
-      if (!isSlackRenderV2Enabled()) {
-        await say({
-          text: ":satellite: _You're sending too many requests. Please slow down._",
-          thread_ts: msg.thread_ts || msg.ts
-        });
-      }
-      return;
-    }
-    const taskDescription = extractTaskFromMessage(effectiveText, botUserId);
-    if (!taskDescription) {
-      if (!isSlackRenderV2Enabled()) {
-        await say({
-          text: ":satellite: _Please provide a task description after mentioning an agent._",
-          thread_ts: msg.thread_ts || msg.ts
-        });
-      }
-      return;
-    }
-    const threadTs = msg.thread_ts || msg.ts;
-    const threadContext = await getThreadContext(client, msg.channel, msg.thread_ts, msg.ts, botUserId);
-    let fullTaskDescription;
-    if (threadContext) {
-      const ctxResult = resolveTemplate("slack.message.thread_context", {
-        thread_messages: threadContext
-      });
-      fullTaskDescription = `${ctxResult.text}
-
-${taskDescription}`;
-    } else {
-      fullTaskDescription = taskDescription;
-    }
-    const results = { assigned: [], queued: [], steered: [], failed: [] };
-    for (const match of matches) {
-      const agent = await getAgentById(match.agent.id);
-      if (!agent) {
-        results.failed.push({ agentName: match.agent.name, reason: "not found" });
-        continue;
-      }
-      try {
-        const latestTask = await getMostRecentTaskInThread(msg.channel, threadTs);
-        if (agent.isLead) {
-          const steering = msg.thread_ts ? await requestSlackThreadSteering({
-            channelId: msg.channel,
-            threadTs,
-            message: taskDescription,
-            messageTimestamps: [msg.ts],
-            requestedByUserId
-          }) : null;
-          if (steering) {
-            await ackSlackMessage(client, msg.channel, msg.ts, reactionName("steered"), "steered");
-            results.steered.push({
-              agentName: agent.name,
-              acknowledgement: formatSlackSteeringAck(steering.result)
-            });
-            continue;
-          }
-          const task2 = await createTaskWithSiblingAwareness(fullTaskDescription, {
-            agentId: agent.id,
-            source: "slack",
-            slackChannelId: msg.channel,
-            slackThreadTs: threadTs,
-            slackTriggerMessageTs: msg.ts,
-            slackUserId: msg.user,
-            parentTaskId: latestTask?.id,
-            requestedByUserId,
-            contextKey: slackContextKey({ channelId: msg.channel, threadTs })
-          });
-          await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
-          results.assigned.push({ agentName: agent.name, taskId: task2.id });
-          continue;
-        }
-        const task = await createTaskWithSiblingAwareness(fullTaskDescription, {
-          agentId: agent.id,
-          source: "slack",
-          slackChannelId: msg.channel,
-          slackThreadTs: threadTs,
-          slackTriggerMessageTs: msg.ts,
-          slackUserId: msg.user,
-          requestedByUserId,
-          contextKey: slackContextKey({ channelId: msg.channel, threadTs })
-        });
-        await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
-        const agentTasks = await getTasksByAgentId(agent.id);
-        const inProgressInThread = agentTasks.find((t) => t.id !== task.id && t.status === "in_progress" && t.slackThreadTs === threadTs);
-        if (inProgressInThread) {
-          results.queued.push({ agentName: agent.name, taskId: task.id });
-        } else {
-          results.assigned.push({ agentName: agent.name, taskId: task.id });
-        }
-      } catch {
-        results.failed.push({ agentName: agent.name, reason: "error" });
-      }
-    }
-    const totalResults = results.assigned.length + results.queued.length + results.failed.length;
-    if (totalResults > 0) {
-      const successfulTaskIds = [...results.assigned, ...results.queued].map(({ taskId }) => taskId);
-      if (isSlackRenderV2Enabled()) {
-        if (successfulTaskIds.length > 0)
-          await ensureSlackThreadTree(successfulTaskIds);
-      } else {
-        const initialNodes = results.assigned.map(({ agentName, taskId }) => ({
-          taskId,
-          agentName,
-          status: "in_progress",
-          children: []
-        }));
-        for (const q of results.queued) {
-          initialNodes.push({
-            taskId: q.taskId,
-            agentName: q.agentName,
-            status: "pending",
-            children: []
-          });
-        }
-        const blocks = buildTreeBlocks(initialNodes);
-        if (results.failed.length > 0) {
-          const failedLines = results.failed.map((f) => `⚠️ Could not assign to: *${f.agentName}* — ${f.reason}`).join(`
-`);
-          blocks.push({
-            type: "context",
-            elements: [{ type: "mrkdwn", text: failedLines }]
-          });
-        }
-        const parts = [];
-        if (results.assigned.length > 0) {
-          const names = results.assigned.map((a) => `${a.agentName}`).join(", ");
-          parts.push(`Task assigned to: ${names}`);
-        }
-        if (results.queued.length > 0) {
-          const names = results.queued.map((q) => `${q.agentName}`).join(", ");
-          parts.push(`Task queued for: ${names}`);
-        }
-        if (results.failed.length > 0) {
-          const names = results.failed.map((f) => `${f.agentName}`).join(", ");
-          parts.push(`Could not assign to: ${names}`);
-        }
-        console.log(`[Slack] Posting initial tree message with ${initialNodes.length} node(s)${results.failed.length > 0 ? ` and ${results.failed.length} failed assignment(s)` : ""}`);
-        const resp = await say({
-          text: parts.join(". "),
-          blocks,
-          thread_ts: msg.thread_ts || msg.ts
-        });
-        if (resp?.ts) {
-          for (const { taskId } of results.assigned) {
-            await registerTreeMessage(taskId, msg.channel, threadTs, resp.ts);
-          }
-          for (const { taskId } of results.queued) {
-            await registerTreeMessage(taskId, msg.channel, threadTs, resp.ts);
-          }
-        }
-      }
-    }
-    if (!isSlackRenderV2Enabled()) {
-      for (const steered of results.steered) {
-        await say({
-          text: `${steered.acknowledgement} *${steered.agentName}* will receive it.`,
-          thread_ts: threadTs
-        });
-      }
-    }
-  });
-  app.event("app_mention", async ({ event }) => {
-    console.log(`[Slack] App mentioned in channel ${event.channel}`);
-  });
-}
-export {
-  buildAttachmentText,
-  buildEffectiveText,
-  checkUserAccess,
-  formatFileSize,
-  isBotMessage,
-  isSwarmThreadRoot,
-  registerMessageHandler,
-  resetSlackHandlerCachesForTesting
-};

package/plugin/commands/work-on-task.md

@@ -1,39 +0,0 @@
----
-description: Work on a specific task assigned to you in the agent swarm
-argument-hint: [taskId]
----
-
-# Working on a Task
-
-If no `taskId` is provided, call `poll-task` to get a new task.
-
-## Workflow
-
-1. **Get task details**: Call `get-task-details` with the taskId.
-
-2. **Recall relevant memories**: Use `memory-search` with the task description before starting any work. Past learnings, solutions, and gotchas are indexed here.
-
-3. **Choose your approach** based on the task type:
-   - **Research task** → use `/researching`
-   - **Development task** → use `/planning` first, then `/implementing`
-   - **Simple/direct task** (no plan needed) → implement directly
-
-4. **Work on it**, calling `store-progress` at each meaningful milestone (not just start and end — the lead monitors this).
-
-5. **Complete the task** — see Completion below.
-
-## Completion
-
-Call `store-progress` with:
-- **Success**: `status: "completed"` + `output: "<what you did and the result>"`. Output should be specific enough for the lead to assess without re-reading your work.
-- **Failure**: `status: "failed"` + `failureReason: "<what went wrong and what you tried>"`.
-
-Then reply "DONE" to end the session.
-
-## Interruptions
-
-If interrupted by the user, adapt to their instructions. When resuming, call `/work-on-task <taskId>` again to pick up where you left off.
-
-## When to escalate
-
-If you're stuck after genuine effort (not just first failure), use `/swarm-chat` to ask the lead for help or clarification. Don't spin — escalate.

package/plugin/pi-skills/work-on-task/SKILL.md

@@ -1,39 +0,0 @@
----
-name: work-on-task
-description: Work on a specific task assigned to you in the agent swarm
----
-
-# Working on a Task
-
-If no `taskId` is provided, call `poll-task` to get a new task.
-
-## Workflow
-
-1. **Get task details**: Call `get-task-details` with the taskId.
-
-2. **Recall relevant memories**: Use `memory-search` with the task description before starting any work. Past learnings, solutions, and gotchas are indexed here.
-
-3. **Choose your approach** based on the task type:
-   - **Research task** → use `/researching`
-   - **Development task** → use `/planning` first, then `/implementing`
-   - **Simple/direct task** (no plan needed) → implement directly
-
-4. **Work on it**, calling `store-progress` at each meaningful milestone (not just start and end — the lead monitors this).
-
-5. **Complete the task** — see Completion below.
-
-## Completion
-
-Call `store-progress` with:
-- **Success**: `status: "completed"` + `output: "<what you did and the result>"`. Output should be specific enough for the lead to assess without re-reading your work.
-- **Failure**: `status: "failed"` + `failureReason: "<what went wrong and what you tried>"`.
-
-Then reply "DONE" to end the session.
-
-## Interruptions
-
-If interrupted by the user, adapt to their instructions. When resuming, call `/skill:work-on-task <taskId>` again to pick up where you left off.
-
-## When to escalate
-
-If you're stuck after genuine effort (not just first failure), use `/skill:swarm-chat` to ask the lead for help or clarification. Don't spin — escalate.