opencode-async-agent 1.0.0 → 1.0.2

package/dist/async-agent.js

@@ -0,0 +1,1289 @@
+// 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
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+function parseModel(model) {
+  const [providerID, ...rest] = model.split("/");
+  return { providerID, modelID: rest.join("/") };
+}
+var ANALYSIS_PROMPT = `You are a session analyst. Analyze the following AI task execution comprehensively so the main agent can make informed next decisions.
+
+## Analysis Criteria
+
+### 1. Anything AI Missed Based on Initial Prompt
+- Compare the original user prompt against what was actually accomplished
+- Identify any requirements, questions, or requests that were never addressed
+- List promises made by the agent that were left unfulfilled
+
+### 2. Wrong Doings
+- Identify incorrect assumptions or bad approaches taken
+- Note any factual errors or wrong technical decisions
+- Call out misinterpretations of the original prompt
+
+### 3. Gave Up / Shortcuts
+- Did the agent abandon parts of the task prematurely?
+- Were steps skipped or incomplete solutions used?
+- Did the agent stop without exhausting reasonable options?
+- Any signs of "good enough" attitude instead of thorough completion?
+
+### 4. Messed Up
+- Did the agent break existing functionality?
+- Were new problems introduced during the task?
+- Any destructive actions or unintended side effects?
+
+### 5. Good Points / Choices
+- What technical decisions were sound and should be replicated?
+- What approaches worked well that future tasks should follow?
+- Notable strengths in this session's execution
+
+### 6. Session Ended Properly or Stream Cut Out
+- **Proper finish:** Agent concluded with clear result or summary
+- **Stream cut out:** Session interrupted mid-task with no conclusion
+- **Ambiguous end:** Final state unclear or incomplete explanation
+
+### 7. Overall Status on the Session
+- Give the main agent a complete picture of what happened
+- Was this session successful, partial, or a failure?
+- Is the output reliable enough to base next decisions on?
+
+## Output Format
+
+Provide your analysis in **markdown** with these exact sections:
+
+### Summary
+[2-3 sentence summary of what happened]
+
+### What the AI Missed Based on Initial Prompt
+[List anything not covered from the original prompt]
+
+### Wrong Doings
+[Incorrect assumptions, bad approaches, factual errors]
+
+### Gave Up / Shortcuts
+[Premature abandonment, skipped steps, incomplete solutions]
+
+### Messed Up
+[Broke things, created new problems, unintended side effects]
+
+### Good Points / Choices
+[Sound decisions, approaches worth replicating, notable strengths]
+
+### Session Completion
+- **Status:** [Proper finish / Stream cut out / Ambiguous]
+- **Details:** [explanation of how the session ended]
+
+### Overall Status
+[Complete assessment: Is this session's output reliable for next decisions? What's the verdict?]
+
+### Next Action for Main Agent
+[Specific recommendation on what the main agent should do next based on this session's outcome]
+
+---
+
+## Session Data
+
+### Initial User Prompt
+\`\`\`
+\${initialPrompt}
+\`\`\`
+
+### Full Conversation
+\`\`\`
+\${formattedMessages}
+\`\`\`
+
+### Session Metadata
+- Agent: \${agent}
+- Model: \${model}
+- Duration: \${duration}
+- Status: \${status}
+- Started: \${startTime}
+- Completed: \${completedTime}
+`;
+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);
+  }
+  // ---- Parent session model ----
+  async getParentModel(parentSessionID) {
+    try {
+      const messagesResult = await this.client.session.messages({
+        path: { id: parentSessionID }
+      });
+      const messageData = messagesResult.data;
+      if (!messageData || messageData.length === 0) {
+        return null;
+      }
+      const lastUserMessage = [...messageData].reverse().find((m) => m.info.role === "user");
+      if (!lastUserMessage || !lastUserMessage.info.model) {
+        return null;
+      }
+      const model = lastUserMessage.info.model;
+      const modelString = `${model.providerID}/${model.modelID}`;
+      await this.debugLog(`Got parent model: ${modelString}`);
+      return modelString;
+    } catch (error) {
+      this.log.debug(`Failed to get parent model: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return null;
+    }
+  }
+  // ---- 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 parentModel = await this.getParentModel(input.parentSessionID);
+    const delegation = {
+      id: sessionID,
+      sessionID,
+      parentSessionID: input.parentSessionID,
+      parentMessageID: input.parentMessageID,
+      parentAgent: input.parentAgent,
+      parentModel,
+      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") {
+      if (args.ai) {
+        return `Delegation "${args.id}" is still running.
+
+Status: ${delegation.status}
+Started: ${delegation.startedAt.toISOString()}
+
+Wait for completion notification, then call delegation_read() again. AI analysis only available for completed sessions.`;
+      }
+      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.ai) {
+      let model = args.ai_model;
+      if (!model) {
+        model = delegation.parentModel || await this.getDefaultModel();
+        if (!model) {
+          return "\u274C ai_model required when ai=true and no default model configured (parent session has no model)";
+        }
+      }
+      return await this.analyzeSessionWithAI(delegation, model);
+    }
+    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);
+  }
+  // ---- AI Analysis ----
+  async getDefaultModel() {
+    try {
+      const result = await this.client.config.get();
+      const config = result.data;
+      return config?.model || null;
+    } catch (error) {
+      this.log.debug(`Failed to get default model: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return null;
+    }
+  }
+  getModelInfo(modelId) {
+    const [provider, ...rest] = modelId.split("/");
+    if (!provider) {
+      throw new Error(`Invalid model format: "${modelId}". Expected "provider/model"`);
+    }
+    const modelIdOnly = rest.join("/");
+    try {
+      const modelJsonPath = join(process.env.HOME || "", ".cache", "opencode", "models.json");
+      const content = readFileSync(modelJsonPath, "utf-8");
+      const modelsData = JSON.parse(content);
+      if (!modelsData[provider]) {
+        throw new Error(`Provider "${provider}" not found in models.json`);
+      }
+      const providerData = modelsData[provider];
+      const apiUrl = providerData.api || providerData.baseUrl;
+      if (!apiUrl) {
+        throw new Error(`No API URL found for provider "${provider}"`);
+      }
+      return { provider, apiUrl, modelId: modelIdOnly };
+    } catch (error) {
+      if (error instanceof Error) throw error;
+      throw new Error(`Failed to parse models.json: ${error}`);
+    }
+  }
+  getApiKey(provider) {
+    try {
+      const authJsonPath = join(process.env.HOME || "", ".local", "share", "opencode", "auth.json");
+      const content = readFileSync(authJsonPath, "utf-8");
+      const authData = JSON.parse(content);
+      if (!authData[provider]) {
+        throw new Error(`Provider "${provider}" not found in auth.json`);
+      }
+      const providerAuth = authData[provider];
+      if (providerAuth.type !== "api") {
+        throw new Error(`Provider "${provider}" is not an API key type`);
+      }
+      return providerAuth.key;
+    } catch (error) {
+      if (error instanceof Error) throw error;
+      throw new Error(`Failed to parse auth.json: ${error}`);
+    }
+  }
+  formatSessionForAI(messages, delegation) {
+    let initialPrompt = delegation.prompt;
+    const parts = [];
+    for (const msg of messages) {
+      const role = msg.info.role.toUpperCase();
+      const timestamp = msg.info.time?.created ? new Date(msg.info.time.created).toISOString() : "unknown";
+      parts.push(`[${role}] ${timestamp}`);
+      for (const part of msg.parts) {
+        switch (part.type) {
+          case "text":
+            if (part.text) {
+              parts.push(part.text.trim());
+            }
+            break;
+          case "reasoning":
+          case "thinking":
+            const thinkingText = part.thinking || part.text || "";
+            if (thinkingText) {
+              parts.push(`[REASONING] ${thinkingText.slice(0, 2e3)}`);
+            }
+            break;
+          case "tool":
+            if (part.state) {
+              const toolInput = part.state.status === "pending" || part.state.status === "running" ? JSON.stringify(part.state.input || {}) : JSON.stringify(part.state.input || {});
+              parts.push(`[TOOL CALL] ${part.tool}: ${toolInput}`);
+            }
+            break;
+          case "tool_result":
+            const content = part.content || part.output || "";
+            parts.push(`[TOOL RESULT] ${content}`);
+            break;
+          case "file":
+            parts.push(`[FILE] ${part.filename || "unknown file"} (${part.mime})`);
+            break;
+          case "patch":
+            parts.push(`[PATCH] Code diff applied`);
+            break;
+          case "snapshot":
+            parts.push(`[SNAPSHOT] State snapshot`);
+            break;
+          case "agent":
+            parts.push(`[AGENT] Switched to: ${part.name || "unknown"}`);
+            break;
+          default:
+            parts.push(`[${part.type}] ${JSON.stringify(part).slice(0, 200)}`);
+        }
+      }
+      parts.push("");
+    }
+    return `# Full Conversation
+
+${parts.join("\n")}`;
+  }
+  async callAIForAnalysis(apiUrl, apiKey, model, prompt, timeoutMs = 6e4) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const url = apiUrl.endsWith("/") ? `${apiUrl}chat/completions` : `${apiUrl}/chat/completions`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          messages: [{ role: "user", content: prompt }],
+          max_tokens: 4e3,
+          temperature: 0.3
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`API request failed: ${response.status} ${response.statusText}
+${errorText}`);
+      }
+      const data = await response.json();
+      if (!data.choices || !data.choices[0] || !data.choices[0].message) {
+        throw new Error("Invalid API response format");
+      }
+      return data.choices[0].message.content;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        throw new Error("AI analysis timed out after 60 seconds");
+      }
+      throw error;
+    }
+  }
+  logAnalysis(delegationId, model, result, error, duration) {
+    if (process.env.OC_ASYNC_DEBUG !== "true") {
+      return;
+    }
+    try {
+      const logDir = join(process.env.HOME || "", ".cache", "opencode-delegation-ai");
+      if (!existsSync(logDir)) {
+        mkdirSync(logDir, { recursive: true });
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const filename = `analysis-${delegationId}-${timestamp}.json`;
+      const logEntry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        delegationId,
+        model,
+        status: error ? "error" : "success",
+        durationMs: duration,
+        result: error ? void 0 : result,
+        error: error || void 0
+      };
+      writeFileSync(join(logDir, filename), JSON.stringify(logEntry, null, 2));
+    } catch (err) {
+      this.log.debug(`Failed to log analysis: ${err}`);
+    }
+  }
+  async analyzeSessionWithAI(delegation, model) {
+    const startTime = Date.now();
+    try {
+      const modelInfo = this.getModelInfo(model);
+      const apiKey = this.getApiKey(modelInfo.provider);
+      const messagesResult = await this.client.session.messages({
+        path: { id: delegation.sessionID }
+      });
+      const messageData = messagesResult.data;
+      if (!messageData || messageData.length === 0) {
+        return `Delegation "${delegation.id}" has no messages to analyze.`;
+      }
+      const formattedMessages = this.formatSessionForAI(messageData, delegation);
+      const initialPrompt = messageData.find((m) => m.info.role === "user")?.parts.filter((p) => p.type === "text").map((p) => p.text).join("\n") || delegation.prompt;
+      const sessionMetadata = `
+### Session Metadata
+- Agent: ${delegation.agent}
+- Model: ${delegation.model || "unknown"}
+- Duration: ${delegation.duration || "N/A"}
+- Status: ${delegation.status}
+- Started: ${delegation.startedAt.toISOString()}
+- Completed: ${delegation.completedAt?.toISOString() || "N/A"}
+`;
+      const fullPrompt = ANALYSIS_PROMPT.replace("${initialPrompt}", initialPrompt).replace("${formattedMessages}", formattedMessages).replace("${agent}", delegation.agent).replace("${model}", delegation.model || "unknown").replace("${duration}", delegation.duration || "N/A").replace("${status}", delegation.status).replace("${startTime}", delegation.startedAt.toISOString()).replace("${completedTime}", delegation.completedAt?.toISOString() || "N/A");
+      const analysis = await this.callAIForAnalysis(modelInfo.apiUrl, apiKey, modelInfo.modelId, fullPrompt);
+      const duration = Date.now() - startTime;
+      this.logAnalysis(delegation.id, model, analysis, void 0, duration);
+      const header = `# AI Analysis for Delegation: ${delegation.id}
+
+**Agent:** ${delegation.agent}
+**Analysis Model:** ${model}
+**Duration:** ${delegation.duration || "N/A"}
+**Analysis Time:** ${(duration / 1e3).toFixed(2)}s
+
+---
+
+`;
+      return header + analysis;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.logAnalysis(delegation.id, model, "", errorMessage, duration);
+      return `\u274C AI analysis failed:
+
+${errorMessage}`;
+    }
+  }
+};
+
+// 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
+- ai (requires ai=true): Use AI to analyze and summarize the entire session execution
+
+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)"),
+      ai: tool.schema.boolean().optional().describe("Use AI to analyze and summarize the session"),
+      ai_model: tool.schema.string().optional().describe("Model for AI analysis (e.g. 'minimax/MiniMax-M2.5'). Required when ai=true if no default model configured")
+    },
+    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: join2 } = await import("path");
+  const configDir = join2(homedir(), ".config", "opencode");
+  for (const name of ["async-agents.md", "async-agent.md"]) {
+    try {
+      return await readFile(join2(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
+};