opencode-async-agent 1.0.0 → 1.0.1

package/dist/async-agent.js

@@ -0,0 +1,932 @@
+// src/plugin/utils.ts
+function createLogger(client) {
+  const log = (level, message) => client.app.log({ body: { service: "async-agent", level, message } }).catch(() => {
+  });
+  return {
+    debug: (msg) => log("debug", msg),
+    info: (msg) => log("info", msg),
+    warn: (msg) => log("warn", msg),
+    error: (msg) => log("error", msg)
+  };
+}
+function showToast(client, title, message, variant = "info", duration = 3e3) {
+  const tuiClient = client;
+  if (!tuiClient.tui?.showToast) return;
+  tuiClient.tui.showToast({
+    body: { title, message, variant, duration }
+  }).catch(() => {
+  });
+}
+function formatDuration(startedAt, completedAt) {
+  const end = completedAt || /* @__PURE__ */ new Date();
+  const diffMs = end.getTime() - startedAt.getTime();
+  const diffSec = Math.floor(diffMs / 1e3);
+  if (diffSec < 60) {
+    return `${diffSec}s`;
+  }
+  const diffMin = Math.floor(diffSec / 60);
+  if (diffMin < 60) {
+    const secs = diffSec % 60;
+    return secs > 0 ? `${diffMin}m ${secs}s` : `${diffMin}m`;
+  }
+  const diffHour = Math.floor(diffMin / 60);
+  const mins = diffMin % 60;
+  return mins > 0 ? `${diffHour}h ${mins}m` : `${diffHour}h`;
+}
+
+// src/plugin/types.ts
+var MAX_RUN_TIME_MS = 15 * 60 * 1e3;
+
+// src/plugin/manager.ts
+function parseModel(model) {
+  const [providerID, ...rest] = model.split("/");
+  return { providerID, modelID: rest.join("/") };
+}
+var DelegationManager = class {
+  delegations = /* @__PURE__ */ new Map();
+  client;
+  log;
+  pendingByParent = /* @__PURE__ */ new Map();
+  constructor(client, log) {
+    this.client = client;
+    this.log = log;
+  }
+  calculateDuration(delegation) {
+    return formatDuration(delegation.startedAt, delegation.completedAt);
+  }
+  // ---- Core operations ----
+  async delegate(input) {
+    await this.debugLog(`delegate() called`);
+    const agentsResult = await this.client.app.agents({});
+    const agents = agentsResult.data ?? [];
+    const validAgent = agents.find((a) => a.name === input.agent);
+    if (!validAgent) {
+      const available = agents.filter((a) => a.mode === "subagent" || a.mode === "all" || !a.mode).map((a) => `\u2022 ${a.name}${a.description ? ` - ${a.description}` : ""}`).join("\n");
+      throw new Error(
+        `Agent "${input.agent}" not found.
+
+Available agents:
+${available || "(none)"}`
+      );
+    }
+    const sessionResult = await this.client.session.create({
+      body: {
+        title: `Delegation: ${input.agent}`,
+        parentID: input.parentSessionID
+      }
+    });
+    await this.debugLog(`session.create result: ${JSON.stringify(sessionResult.data)}`);
+    if (!sessionResult.data?.id) {
+      throw new Error("Failed to create delegation session");
+    }
+    const sessionID = sessionResult.data.id;
+    const delegation = {
+      id: sessionID,
+      sessionID,
+      parentSessionID: input.parentSessionID,
+      parentMessageID: input.parentMessageID,
+      parentAgent: input.parentAgent,
+      prompt: input.prompt,
+      agent: input.agent,
+      model: input.model,
+      status: "running",
+      startedAt: /* @__PURE__ */ new Date(),
+      progress: {
+        toolCalls: 0,
+        lastUpdate: /* @__PURE__ */ new Date()
+      }
+    };
+    await this.debugLog(`Created delegation ${delegation.id}`);
+    this.delegations.set(delegation.id, delegation);
+    const parentId = input.parentSessionID;
+    if (!this.pendingByParent.has(parentId)) {
+      this.pendingByParent.set(parentId, /* @__PURE__ */ new Set());
+    }
+    this.pendingByParent.get(parentId)?.add(delegation.id);
+    await this.debugLog(
+      `Tracking delegation ${delegation.id} for parent ${parentId}. Pending count: ${this.pendingByParent.get(parentId)?.size}`
+    );
+    setTimeout(() => {
+      const current = this.delegations.get(delegation.id);
+      if (current && current.status === "running") {
+        this.handleTimeout(delegation.id);
+      }
+    }, MAX_RUN_TIME_MS + 5e3);
+    showToast(this.client, "New Background Task", `${delegation.id} (${input.agent})`, "info", 3e3);
+    const promptBody = {
+      agent: input.agent,
+      parts: [{ type: "text", text: input.prompt }],
+      tools: {
+        task: false,
+        delegate: false,
+        todowrite: false,
+        plan_save: false
+      }
+    };
+    if (input.model) {
+      promptBody.model = parseModel(input.model);
+    }
+    this.client.session.prompt({
+      path: { id: delegation.sessionID },
+      body: promptBody
+    }).catch((error) => {
+      delegation.status = "error";
+      delegation.error = error.message;
+      delegation.completedAt = /* @__PURE__ */ new Date();
+      delegation.duration = this.calculateDuration(delegation);
+      this.notifyParent(delegation);
+    });
+    return delegation;
+  }
+  async resume(delegationId, newPrompt) {
+    const delegation = this.delegations.get(delegationId);
+    if (!delegation) {
+      throw new Error(`Delegation "${delegationId}" not found`);
+    }
+    if (delegation.status === "running") {
+      throw new Error(`Delegation is already running. Wait for it to complete or cancel it first.`);
+    }
+    delegation.status = "running";
+    delegation.completedAt = void 0;
+    delegation.error = void 0;
+    delegation.startedAt = /* @__PURE__ */ new Date();
+    delegation.progress = {
+      toolCalls: 0,
+      lastUpdate: /* @__PURE__ */ new Date()
+    };
+    const parentId = delegation.parentSessionID;
+    if (!this.pendingByParent.has(parentId)) {
+      this.pendingByParent.set(parentId, /* @__PURE__ */ new Set());
+    }
+    this.pendingByParent.get(parentId)?.add(delegation.id);
+    const prompt = newPrompt || "Continue from where you left off.";
+    const resumeBody = {
+      agent: delegation.agent,
+      parts: [{ type: "text", text: prompt }],
+      tools: {
+        task: false,
+        delegate: false,
+        todowrite: false,
+        plan_save: false
+      }
+    };
+    if (delegation.model) {
+      resumeBody.model = parseModel(delegation.model);
+    }
+    this.client.session.prompt({
+      path: { id: delegation.sessionID },
+      body: resumeBody
+    }).catch((error) => {
+      delegation.status = "error";
+      delegation.error = error.message;
+      delegation.completedAt = /* @__PURE__ */ new Date();
+      delegation.duration = this.calculateDuration(delegation);
+      this.notifyParent(delegation);
+    });
+    await this.debugLog(`Resumed delegation ${delegation.id}`);
+    return delegation;
+  }
+  async cancel(delegationId) {
+    const delegation = this.delegations.get(delegationId);
+    if (!delegation) return false;
+    if (delegation.status !== "running") return false;
+    delegation.status = "cancelled";
+    delegation.completedAt = /* @__PURE__ */ new Date();
+    delegation.duration = this.calculateDuration(delegation);
+    try {
+      await this.client.session.abort({
+        path: { id: delegation.sessionID }
+      });
+    } catch {
+    }
+    const pendingSet = this.pendingByParent.get(delegation.parentSessionID);
+    if (pendingSet) {
+      pendingSet.delete(delegationId);
+    }
+    await this.notifyParent(delegation);
+    showToast(this.client, "Task Cancelled", `${delegation.id} cancelled (${delegation.duration})`, "info", 3e3);
+    await this.debugLog(`Cancelled delegation ${delegation.id}`);
+    return true;
+  }
+  async cancelAll(parentSessionID) {
+    const cancelled = [];
+    for (const delegation of this.delegations.values()) {
+      if (delegation.parentSessionID === parentSessionID && delegation.status === "running") {
+        const success = await this.cancel(delegation.id);
+        if (success) {
+          cancelled.push(delegation.id);
+        }
+      }
+    }
+    return cancelled;
+  }
+  // ---- Event handlers ----
+  async handleTimeout(delegationId) {
+    const delegation = this.delegations.get(delegationId);
+    if (!delegation || delegation.status !== "running") return;
+    await this.debugLog(`handleTimeout for delegation ${delegation.id}`);
+    delegation.status = "timeout";
+    delegation.completedAt = /* @__PURE__ */ new Date();
+    delegation.duration = this.calculateDuration(delegation);
+    delegation.error = `Delegation timed out after ${MAX_RUN_TIME_MS / 1e3}s`;
+    try {
+      await this.client.session.abort({
+        path: { id: delegation.sessionID }
+      });
+    } catch {
+    }
+    await this.notifyParent(delegation);
+  }
+  async handleSessionIdle(sessionID) {
+    const delegation = this.findBySession(sessionID);
+    if (!delegation || delegation.status !== "running") return;
+    await this.debugLog(`handleSessionIdle for delegation ${delegation.id}`);
+    delegation.status = "completed";
+    delegation.completedAt = /* @__PURE__ */ new Date();
+    delegation.duration = this.calculateDuration(delegation);
+    try {
+      const messages = await this.client.session.messages({
+        path: { id: delegation.sessionID }
+      });
+      const messageData = messages.data;
+      if (messageData && messageData.length > 0) {
+        const firstUser = messageData.find((m) => m.info.role === "user");
+        if (firstUser) {
+          const textPart = firstUser.parts.find((p) => p.type === "text");
+          if (textPart) {
+            delegation.description = textPart.text.slice(0, 150);
+            delegation.title = textPart.text.split("\n")[0].slice(0, 50);
+          }
+        }
+      }
+    } catch {
+    }
+    showToast(
+      this.client,
+      "Task Completed",
+      `"${delegation.id}" finished in ${delegation.duration}`,
+      "success",
+      5e3
+    );
+    await this.notifyParent(delegation);
+  }
+  // ---- Read delegation results ----
+  async readDelegation(args) {
+    const delegation = this.delegations.get(args.id);
+    if (!delegation) {
+      throw new Error(`Delegation "${args.id}" not found.
+
+Use delegation_list() to see available delegations.`);
+    }
+    if (delegation.status === "running") {
+      return `Delegation "${args.id}" is still running.
+
+Status: ${delegation.status}
+Started: ${delegation.startedAt.toISOString()}
+
+Wait for completion notification, then call delegation_read() again.`;
+    }
+    if (delegation.status !== "completed") {
+      let statusMessage = `Delegation "${args.id}" ended with status: ${delegation.status}`;
+      if (delegation.error) statusMessage += `
+
+Error: ${delegation.error}`;
+      if (delegation.duration) statusMessage += `
+
+Duration: ${delegation.duration}`;
+      return statusMessage;
+    }
+    if (!args.mode || args.mode === "simple") {
+      return await this.getSimpleResult(delegation);
+    }
+    if (args.mode === "full") {
+      return await this.getFullSession(delegation, args);
+    }
+    return "Invalid mode. Use 'simple' or 'full'.";
+  }
+  async getSimpleResult(delegation) {
+    try {
+      const messages = await this.client.session.messages({
+        path: { id: delegation.sessionID }
+      });
+      const messageData = messages.data;
+      if (!messageData || messageData.length === 0) {
+        return `Delegation "${delegation.id}" completed but produced no output.`;
+      }
+      const assistantMessages = messageData.filter(
+        (m) => m.info.role === "assistant"
+      );
+      if (assistantMessages.length === 0) {
+        return `Delegation "${delegation.id}" completed but produced no assistant response.`;
+      }
+      const lastMessage = assistantMessages[assistantMessages.length - 1];
+      const textParts = lastMessage.parts.filter((p) => p.type === "text");
+      if (textParts.length === 0) {
+        return `Delegation "${delegation.id}" completed but produced no text content.`;
+      }
+      const result = textParts.map((p) => p.text).join("\n");
+      const header = `# Task Result: ${delegation.id}
+
+**Agent:** ${delegation.agent}
+**Status:** ${delegation.status}
+**Duration:** ${delegation.duration || "N/A"}
+**Started:** ${delegation.startedAt.toISOString()}
+${delegation.completedAt ? `**Completed:** ${delegation.completedAt.toISOString()}` : ""}
+
+---
+
+`;
+      return header + result;
+    } catch (error) {
+      return `Error retrieving result: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  }
+  async getFullSession(delegation, args) {
+    try {
+      const messages = await this.client.session.messages({
+        path: { id: delegation.sessionID }
+      });
+      const messageData = messages.data;
+      if (!messageData || messageData.length === 0) {
+        return `Delegation "${delegation.id}" has no messages.`;
+      }
+      const sortedMessages = [...messageData].sort((a, b) => {
+        const timeA = String(a.info.time || "");
+        const timeB = String(b.info.time || "");
+        return timeA.localeCompare(timeB);
+      });
+      let filteredMessages = sortedMessages;
+      if (args.since_message_id) {
+        const index = sortedMessages.findIndex((m) => m.info.id === args.since_message_id);
+        if (index !== -1) {
+          filteredMessages = sortedMessages.slice(index + 1);
+        }
+      }
+      const limit = args.limit ? Math.min(args.limit, 100) : void 0;
+      const hasMore = limit !== void 0 && filteredMessages.length > limit;
+      const visibleMessages = limit !== void 0 ? filteredMessages.slice(0, limit) : filteredMessages;
+      const lines = [];
+      lines.push(`# Full Session: ${delegation.id}`);
+      lines.push("");
+      lines.push(`**Agent:** ${delegation.agent}`);
+      lines.push(`**Status:** ${delegation.status}`);
+      lines.push(`**Duration:** ${delegation.duration || "N/A"}`);
+      lines.push(`**Total messages:** ${sortedMessages.length}`);
+      lines.push(`**Returned:** ${visibleMessages.length}`);
+      lines.push(`**Has more:** ${hasMore ? "true" : "false"}`);
+      lines.push("");
+      lines.push("## Messages");
+      lines.push("");
+      for (const message of visibleMessages) {
+        const role = message.info.role;
+        const time = message.info.time || "unknown";
+        const id = message.info.id || "unknown";
+        lines.push(`### [${role}] ${time} (id: ${id})`);
+        lines.push("");
+        for (const part of message.parts) {
+          if (part.type === "text" && part.text) {
+            lines.push(part.text.trim());
+            lines.push("");
+          }
+          if (args.include_thinking && (part.type === "thinking" || part.type === "reasoning")) {
+            const thinkingText = part.thinking || part.text || "";
+            if (thinkingText) {
+              lines.push(`[thinking] ${thinkingText.slice(0, 2e3)}`);
+              lines.push("");
+            }
+          }
+          if (args.include_tools && part.type === "tool_result") {
+            const content = part.content || part.output || "";
+            if (content) {
+              lines.push(`[tool result] ${content}`);
+              lines.push("");
+            }
+          }
+        }
+      }
+      return lines.join("\n");
+    } catch (error) {
+      return `Error fetching session: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+  }
+  // ---- Notification ----
+  async notifyParent(delegation) {
+    try {
+      const pendingSet = this.pendingByParent.get(delegation.parentSessionID);
+      if (pendingSet) {
+        pendingSet.delete(delegation.id);
+      }
+      const allComplete = !pendingSet || pendingSet.size === 0;
+      const remainingCount = pendingSet?.size || 0;
+      const statusText = delegation.status === "completed" ? "COMPLETED" : delegation.status === "cancelled" ? "CANCELLED" : delegation.status === "error" ? "ERROR" : delegation.status === "timeout" ? "TIMEOUT" : delegation.status.toUpperCase();
+      const duration = delegation.duration || "N/A";
+      const errorInfo = delegation.error ? `
+**Error:** ${delegation.error}` : "";
+      let notification;
+      if (allComplete) {
+        const completedTasks = [];
+        for (const d of this.delegations.values()) {
+          if (d.parentSessionID === delegation.parentSessionID && d.status !== "running") {
+            completedTasks.push(d);
+          }
+        }
+        const completedList = completedTasks.map((t) => `- \`${t.id}\`: ${t.title || t.prompt.slice(0, 80)}`).join("\n");
+        const sessionHints = completedTasks.map((t) => `opencode -s ${t.id}`).join("\n");
+        notification = `<system-reminder>
+[ALL BACKGROUND TASKS COMPLETE]
+
+**Completed:**
+${completedList || `- \`${delegation.id}\`: ${delegation.title || delegation.prompt.slice(0, 80)}`}
+
+Use \`delegation_read(id="<id>")\` to retrieve each result.
+</system-reminder>
+To inspect session content(human): ${sessionHints || `opencode -s ${delegation.id}`}`;
+      } else {
+        notification = `<system-reminder>
+[BACKGROUND TASK ${statusText}]
+**ID:** \`${delegation.id}\`
+**Agent:** ${delegation.agent}
+**Duration:** ${duration}${errorInfo}
+
+**${remainingCount} task${remainingCount === 1 ? "" : "s"} still in progress.** You WILL be notified when ALL complete.
+Do NOT poll - continue productive work.
+
+Use \`delegation_read(id="${delegation.id}")\` to retrieve this result when ready.
+</system-reminder>
+To inspect session content(human): opencode -s ${delegation.id}`;
+      }
+      this.client.session.prompt({
+        path: { id: delegation.parentSessionID },
+        body: {
+          noReply: !allComplete,
+          agent: delegation.parentAgent,
+          parts: [{ type: "text", text: notification }]
+        }
+      }).catch(() => {
+      });
+      await this.debugLog(
+        `Notified parent session ${delegation.parentSessionID} (status=${statusText}, remaining=${remainingCount})`
+      );
+    } catch (error) {
+      await this.debugLog(
+        `Failed to notify parent: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  // ---- Queries ----
+  async listDelegations(parentSessionID) {
+    const results = [];
+    for (const delegation of this.delegations.values()) {
+      if (delegation.parentSessionID === parentSessionID) {
+        results.push({
+          id: delegation.id,
+          status: delegation.status,
+          title: delegation.title,
+          description: delegation.description,
+          agent: delegation.agent,
+          duration: delegation.duration,
+          startedAt: delegation.startedAt
+        });
+      }
+    }
+    return results.sort((a, b) => (b.startedAt?.getTime() || 0) - (a.startedAt?.getTime() || 0));
+  }
+  listAllDelegations() {
+    const results = [];
+    for (const delegation of this.delegations.values()) {
+      results.push({
+        id: delegation.id,
+        status: delegation.status,
+        title: delegation.title,
+        description: delegation.description,
+        agent: delegation.agent,
+        duration: delegation.duration,
+        startedAt: delegation.startedAt
+      });
+    }
+    return results.sort((a, b) => (b.startedAt?.getTime() || 0) - (a.startedAt?.getTime() || 0));
+  }
+  findBySession(sessionID) {
+    return Array.from(this.delegations.values()).find((d) => d.sessionID === sessionID);
+  }
+  handleMessageEvent(sessionID, messageText) {
+    const delegation = this.findBySession(sessionID);
+    if (!delegation || delegation.status !== "running") return;
+    delegation.progress.lastUpdate = /* @__PURE__ */ new Date();
+    if (messageText) {
+      delegation.progress.lastMessage = messageText;
+      delegation.progress.lastMessageAt = /* @__PURE__ */ new Date();
+    }
+  }
+  getPendingCount(parentSessionID) {
+    const pendingSet = this.pendingByParent.get(parentSessionID);
+    return pendingSet ? pendingSet.size : 0;
+  }
+  getRunningDelegations() {
+    return Array.from(this.delegations.values()).filter((d) => d.status === "running");
+  }
+  async debugLog(msg) {
+    this.log.debug(msg);
+  }
+};
+
+// src/plugin/tools.ts
+import { tool } from "@opencode-ai/plugin";
+function createDelegate(manager) {
+  return tool({
+    description: `Delegate a task to an agent. Returns immediately with the session ID.
+
+Use this for:
+- Research tasks (will be auto-saved)
+- Parallel work that can run in background
+- Any task where you want persistent, retrievable output
+
+On completion, a notification will arrive with the session ID, status, duration.
+Use \`delegation_read\` with the session ID to retrieve the result.`,
+    args: {
+      prompt: tool.schema.string().describe("The full detailed prompt for the agent. Must be in English."),
+      agent: tool.schema.string().describe(
+        'Agent to delegate to: "explore" (codebase search), "researcher" (external research), etc.'
+      ),
+      model: tool.schema.string().optional().describe(
+        'Override model for this delegation. Format: "provider/model" (e.g. "minimax/MiniMax-M2.5"). If not set, uses the agent default.'
+      )
+    },
+    async execute(args, toolCtx) {
+      if (!toolCtx?.sessionID) {
+        return "\u274C delegate requires sessionID. This is a system error.";
+      }
+      if (!toolCtx?.messageID) {
+        return "\u274C delegate requires messageID. This is a system error.";
+      }
+      if (manager.findBySession(toolCtx.sessionID)) {
+        return "\u274C Sub-agents cannot delegate tasks. Only the main agent can use delegation tools.";
+      }
+      try {
+        const delegation = await manager.delegate({
+          parentSessionID: toolCtx.sessionID,
+          parentMessageID: toolCtx.messageID,
+          parentAgent: toolCtx.agent,
+          prompt: args.prompt,
+          agent: args.agent,
+          model: args.model
+        });
+        const pendingCount = manager.getPendingCount(toolCtx.sessionID);
+        let response = `Delegation started: ${delegation.id}
+Agent: ${args.agent}`;
+        if (pendingCount > 1) {
+          response += `
+
+${pendingCount} delegations now active.`;
+        }
+        response += `
+
+You WILL be notified via <system-reminder> when complete. Do NOT poll delegation_list().`;
+        return response;
+      } catch (error) {
+        return `\u274C Delegation failed:
+
+${error instanceof Error ? error.message : "Unknown error"}`;
+      }
+    }
+  });
+}
+function createDelegationRead(manager) {
+  return tool({
+    description: `Read the output of a delegation by its ID.
+
+Modes:
+- simple (default): Returns just the final result
+- full: Returns all messages in the session with timestamps
+
+Use filters to get specific parts of the conversation.`,
+    args: {
+      id: tool.schema.string().describe("The delegation session ID"),
+      mode: tool.schema.enum(["simple", "full"]).optional().describe("Output mode: 'simple' for result only, 'full' for all messages"),
+      include_thinking: tool.schema.boolean().optional().describe("Include thinking/reasoning blocks in full mode"),
+      include_tools: tool.schema.boolean().optional().describe("Include tool results in full mode"),
+      since_message_id: tool.schema.string().optional().describe("Return only messages after this message ID (full mode only)"),
+      limit: tool.schema.number().optional().describe("Max messages to return, capped at 100 (full mode only)")
+    },
+    async execute(args, toolCtx) {
+      if (!toolCtx?.sessionID) {
+        return "\u274C delegation_read requires sessionID. This is a system error.";
+      }
+      try {
+        return await manager.readDelegation(args);
+      } catch (error) {
+        return `\u274C Error reading delegation: ${error instanceof Error ? error.message : "Unknown error"}`;
+      }
+    }
+  });
+}
+function createDelegationList(manager) {
+  return tool({
+    description: `List all delegations for the current session.
+Shows running, completed, cancelled, and error tasks with metadata.`,
+    args: {},
+    async execute(_args, toolCtx) {
+      if (!toolCtx?.sessionID) {
+        return "\u274C delegation_list requires sessionID. This is a system error.";
+      }
+      const delegations = await manager.listDelegations(toolCtx.sessionID);
+      if (delegations.length === 0) {
+        return "No delegations found for this session.";
+      }
+      const lines = delegations.map((d) => {
+        const titlePart = d.title ? ` | ${d.title}` : "";
+        const durationPart = d.duration ? ` (${d.duration})` : "";
+        const descPart = d.description ? `
+  \u2192 ${d.description.slice(0, 100)}${d.description.length > 100 ? "..." : ""}` : "";
+        return `- **${d.id}**${titlePart} [${d.status}]${durationPart}${descPart}`;
+      });
+      return `## Delegations
+
+${lines.join("\n")}`;
+    }
+  });
+}
+function createDelegationCancel(manager) {
+  return tool({
+    description: `Cancel a running delegation by ID, or cancel all running delegations.
+
+Cancelled tasks can be resumed later with delegation_resume().`,
+    args: {
+      id: tool.schema.string().optional().describe("Task ID to cancel"),
+      all: tool.schema.boolean().optional().describe("Cancel ALL running delegations")
+    },
+    async execute(args, toolCtx) {
+      if (!toolCtx?.sessionID) {
+        return "\u274C delegation_cancel requires sessionID. This is a system error.";
+      }
+      try {
+        if (args.all) {
+          const cancelled = await manager.cancelAll(toolCtx.sessionID);
+          if (cancelled.length === 0) {
+            return "No running delegations to cancel.";
+          }
+          return `Cancelled ${cancelled.length} delegation(s):
+${cancelled.map((id) => `- ${id}`).join("\n")}`;
+        }
+        if (!args.id) {
+          return "\u274C Must provide either 'id' or 'all=true'";
+        }
+        const success = await manager.cancel(args.id);
+        if (!success) {
+          return `\u274C Could not cancel "${args.id}". Task may not exist or is not running.`;
+        }
+        return `\u2705 Cancelled delegation: ${args.id}
+
+You can resume it later with delegation_resume(id="${args.id}")`;
+      } catch (error) {
+        return `\u274C Error cancelling: ${error instanceof Error ? error.message : "Unknown error"}`;
+      }
+    }
+  });
+}
+function createDelegationResume(manager) {
+  return tool({
+    description: `Resume a cancelled or errored delegation by sending a new prompt to the same session.
+
+The agent will have access to the previous conversation context.`,
+    args: {
+      id: tool.schema.string().describe("Task ID to resume"),
+      prompt: tool.schema.string().optional().describe("Optional prompt to send (default: 'Continue from where you left off.')")
+    },
+    async execute(args, toolCtx) {
+      if (!toolCtx?.sessionID) {
+        return "\u274C delegation_resume requires sessionID. This is a system error.";
+      }
+      try {
+        const delegation = await manager.resume(args.id, args.prompt);
+        return `\u2705 Resumed delegation: ${delegation.id}
+Agent: ${delegation.agent}
+Status: ${delegation.status}`;
+      } catch (error) {
+        return `\u274C Error resuming: ${error instanceof Error ? error.message : "Unknown error"}`;
+      }
+    }
+  });
+}
+
+// src/plugin/rules.ts
+var DELEGATION_RULES = `<system-reminder>
+<delegation-system>
+
+## Async Delegation
+
+You have tools for parallel background work:
+- \`delegate(prompt, agent)\` - Launch task, returns ID immediately
+- \`delegate(prompt, agent, model)\` - Launch task with specific model override
+- \`delegation_read(id)\` - Retrieve completed result
+- \`delegation_list()\` - List delegations (use sparingly)
+- \`delegation_cancel(id|all)\` - Cancel running task(s)
+- \`delegation_resume(id, prompt?)\` - Continue cancelled task (same session)
+
+## How It Works
+
+1. Call \`delegate()\` - Get task ID immediately, continue working
+2. Receive \`<system-reminder>\` notification when complete
+3. Call \`delegation_read(id)\` to get the actual result
+
+## Model Override
+
+The \`delegate\` tool accepts an optional \`model\` parameter in "provider/model" format.
+Example: \`delegate(prompt, agent, model="minimax/MiniMax-M2.5")\`
+If not specified, the agent's default model is used.
+
+## Critical Constraints
+
+**NEVER poll \`delegation_list\` to check completion.**
+You WILL be notified via \`<system-reminder>\`. Polling wastes tokens.
+
+**NEVER wait idle.** Always have productive work while delegations run.
+
+**Cancelled tasks can be resumed** with \`delegation_resume()\` - same session, full context.
+
+</delegation-system>
+</system-reminder>`;
+async function readBgAgentsConfig() {
+  const { homedir } = await import("os");
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const configDir = join(homedir(), ".config", "opencode");
+  for (const name of ["async-agents.md", "async-agent.md"]) {
+    try {
+      return await readFile(join(configDir, name), "utf-8");
+    } catch {
+    }
+  }
+  return "";
+}
+function formatDelegationContext(running, completed) {
+  const sections = ["<delegation-context>"];
+  if (running.length > 0) {
+    sections.push("## Running Delegations");
+    sections.push("");
+    for (const d of running) {
+      sections.push(`### \`${d.id}\`${d.agent ? ` (${d.agent})` : ""}`);
+      if (d.startedAt) {
+        sections.push(`**Started:** ${d.startedAt.toISOString()}`);
+      }
+      sections.push("");
+    }
+    sections.push(
+      "> **Note:** You WILL be notified via `<system-reminder>` when delegations complete."
+    );
+    sections.push("> Do NOT poll `delegation_list` - continue productive work.");
+    sections.push("");
+  }
+  if (completed.length > 0) {
+    sections.push("## Recent Completed Delegations");
+    sections.push("");
+    for (const d of completed) {
+      const statusEmoji = d.status === "completed" ? "\u2705" : d.status === "error" ? "\u274C" : d.status === "timeout" ? "\u23F1\uFE0F" : "\u{1F6AB}";
+      sections.push(`### ${statusEmoji} \`${d.id}\``);
+      sections.push(`**Status:** ${d.status}`);
+      if (d.duration) sections.push(`**Duration:** ${d.duration}`);
+      sections.push("");
+    }
+    sections.push("> Use `delegation_list()` to see all delegations.");
+    sections.push("");
+  }
+  sections.push("## Retrieval");
+  sections.push('Use `delegation_read("id")` to access results.');
+  sections.push('Use `delegation_read(id, mode="full")` for full conversation.');
+  sections.push("</delegation-context>");
+  return sections.join("\n");
+}
+
+// src/plugin/plugin.ts
+var delegationCommand = "delegation";
+var AsyncAgentPlugin = async (ctx) => {
+  const { client } = ctx;
+  const log = createLogger(client);
+  const manager = new DelegationManager(client, log);
+  await manager.debugLog("AsyncAgentPlugin initialized");
+  return {
+    // Handle /delegation slash command execution
+    "command.execute.before": async (input) => {
+      if (input.command !== delegationCommand) return;
+      const typedClient = client;
+      let childSessions = [];
+      try {
+        const result = await typedClient.session.children({
+          path: { id: input.sessionID }
+        });
+        childSessions = result.data ?? [];
+      } catch {
+      }
+      const delegationSessions = childSessions.filter(
+        (s) => s.title?.startsWith("Delegation:")
+      );
+      const inMemory = manager.listAllDelegations();
+      const inMemoryMap = new Map(inMemory.map((d) => [d.id, d]));
+      let message;
+      if (delegationSessions.length === 0 && inMemory.length === 0) {
+        message = "No delegations found for this session.";
+      } else {
+        const lines = [];
+        const seen = /* @__PURE__ */ new Set();
+        const entries = [];
+        for (const s of delegationSessions) {
+          seen.add(s.id);
+          const mem = inMemoryMap.get(s.id);
+          const agent = mem?.agent ?? s.title?.replace("Delegation: ", "") ?? "unknown";
+          const status = mem?.status?.toUpperCase() ?? "PERSISTED";
+          const duration = mem?.duration ?? "\u2014";
+          const created = s.time?.created ? new Date(s.time.created).toISOString() : mem?.startedAt?.toISOString() ?? "\u2014";
+          entries.push({
+            id: s.id,
+            title: mem?.title ?? s.title ?? "\u2014",
+            agent,
+            status,
+            duration,
+            started: created
+          });
+        }
+        for (const d of inMemory) {
+          if (seen.has(d.id)) continue;
+          entries.push({
+            id: d.id,
+            title: d.title ?? d.description?.slice(0, 60) ?? "\u2014",
+            agent: d.agent ?? "unknown",
+            status: d.status?.toUpperCase() ?? "UNKNOWN",
+            duration: d.duration ?? "\u2014",
+            started: d.startedAt?.toISOString() ?? "\u2014"
+          });
+        }
+        lines.push(`## Delegations (${entries.length})
+`);
+        for (const e of entries) {
+          lines.push(`**[${e.id}]** ${e.title}`);
+          lines.push(`  Status: ${e.status} | Agent: ${e.agent} | Duration: ${e.duration}`);
+          lines.push(`  Started: ${e.started}`);
+          lines.push(`  \`opencode -s ${e.id}\``);
+          lines.push("");
+        }
+        message = lines.join("\n");
+      }
+      await typedClient.session.prompt({
+        path: { id: input.sessionID },
+        body: {
+          noReply: true,
+          parts: [{ type: "text", text: message }]
+        }
+      });
+      throw new Error("Command handled by async-agent plugin");
+    },
+    tool: {
+      delegate: createDelegate(manager),
+      delegation_read: createDelegationRead(manager),
+      delegation_list: createDelegationList(manager),
+      delegation_cancel: createDelegationCancel(manager),
+      delegation_resume: createDelegationResume(manager)
+    },
+    // Register /delegation slash command
+    config: async (input) => {
+      if (!input.command) input.command = {};
+      input.command[delegationCommand] = {
+        template: "Show all background delegation sessions with their status, IDs, agents, and metadata.",
+        description: "List all background delegations"
+      };
+    },
+    // Inject delegation rules + async-agent.md config into system prompt
+    "experimental.chat.system.transform": async (_input, output) => {
+      output.system.push(DELEGATION_RULES);
+      const bgConfig = await readBgAgentsConfig();
+      if (bgConfig.trim()) {
+        output.system.push(`<async-agent-config>
+${bgConfig}
+</async-agent-config>`);
+      }
+    },
+    // Inject active delegation context during session compaction
+    "experimental.session.compacting": async (_input, output) => {
+      const running = manager.getRunningDelegations().map((d) => ({
+        id: d.id,
+        agent: d.agent,
+        status: d.status,
+        startedAt: d.startedAt
+      }));
+      if (running.length > 0) {
+        output.context.push(formatDelegationContext(running, []));
+      }
+    },
+    event: async (input) => {
+      const { event } = input;
+      if (event.type === "session.idle") {
+        const sessionID = event.properties?.sessionID;
+        const delegation = manager.findBySession(sessionID);
+        if (delegation) {
+          await manager.handleSessionIdle(sessionID);
+        }
+      }
+    }
+  };
+};
+var plugin_default = AsyncAgentPlugin;
+export {
+  AsyncAgentPlugin,
+  plugin_default as default
+};