@desplega.ai/agent-swarm 1.171.0 → 1.172.0

package/src/providers/opencode-swarm-plugin.ts

@@ -0,0 +1,88 @@
+/**
+ * Agent Swarm plugin for OpenCode 2.
+ *
+ * OpenCode 2 runs in-process (`@opencode/sdk`), so this plugin is a plain
+ * object passed to `OpenCode.create({ plugins })`. It closes over the task's
+ * swarm config and reuses the pi extension's swarm-hook helpers; no env vars,
+ * no plugin file on disk, no vendored copies.
+ *
+ * Session-end work (identity sync, session summary, session close) runs from
+ * the adapter's event loop, not from here.
+ */
+
+import type { Plugin } from "@opencode/plugin";
+import { renderGoalReminder } from "../prompts/goal-reminder";
+import {
+  apiHeaders,
+  checkShouldBlockPolling,
+  fetchConcurrentContext,
+  fetchTaskDetails,
+  fireAndForget,
+  isTaskCancelled,
+  type SwarmHooksConfig,
+} from "./pi-mono-extension";
+
+/** The host's registered tools (MCP tools included), keyed by effective name. */
+export type OpencodeToolLister = () => Promise<ReadonlyArray<{ readonly id: string }>>;
+
+export interface OpencodeSwarmPluginOptions {
+  /** Receives the tool lister once OpenCode sets the plugin up. */
+  onToolRegistry?: (listTools: OpencodeToolLister) => void;
+}
+
+export function createOpencodeSwarmPlugin(
+  config: SwarmHooksConfig,
+  options: OpencodeSwarmPluginOptions = {},
+): Plugin.Plugin {
+  return {
+    id: "agent-swarm",
+    async setup(ctx) {
+      options.onToolRegistry?.(() => ctx.tool.list());
+
+      // A throw blocks the tool; OpenCode hands the message back to the model.
+      await ctx.tool.hook("execute.before", async (event) => {
+        if (!config.isLead && config.taskId) {
+          const { cancelled, reason } = await isTaskCancelled(config);
+          if (cancelled) {
+            const cancelReason = reason || "Task cancelled by lead or creator";
+            throw new Error(
+              `🛑 TASK CANCELLED: Your current task (${config.taskId.slice(0, 8)}) has been cancelled. Reason: "${cancelReason}". ` +
+                "Stop working on this task immediately. Do NOT continue making tool calls. " +
+                "Use store-progress to acknowledge the cancellation and mark the task as failed, then wait for new tasks.",
+            );
+          }
+        }
+        if (event.tool.includes("poll-task") && (await checkShouldBlockPolling(config))) {
+          throw new Error(
+            "🛑 POLLING LIMIT REACHED: You have exceeded the maximum empty poll attempts. " +
+              "EXIT NOW - do not make any more tool calls.",
+          );
+        }
+      });
+
+      await ctx.tool.hook("execute.after", () => {
+        if (config.isLead || !config.taskId) return;
+        fireAndForget(`${config.apiUrl}/api/agents/${config.agentId}/activity`, {
+          method: "PUT",
+          headers: apiHeaders(config),
+        });
+      });
+
+      // Lead only: tell the model what other sessions are already handling.
+      await ctx.session.hook("context", async (event) => {
+        if (!config.isLead) return;
+        const concurrent = await fetchConcurrentContext(config);
+        if (concurrent) event.system.push({ type: "text", text: concurrent });
+      });
+
+      // PreCompact parity: keep the task goal in the checkpoint summary.
+      await ctx.session.hook("compaction", async (event) => {
+        if (!config.taskId) return;
+        const task = await fetchTaskDetails(config);
+        if (!task) return;
+        const reminder = await renderGoalReminder(task);
+        if (reminder) event.system.push({ type: "text", text: reminder });
+      });
+    },
+  };
+}

package/src/providers/pi-mono-extension.ts

@@ -9,6 +9,7 @@
 import type { ExtensionFactory, McpServerConfig } from "@earendil-works/pi-coding-agent";
 import { buildRatingsFromLlm, fetchRetrievalsForTask, postRatings } from "../be/memory/raters/llm";
 import { checkToolLoop, clearToolHistory } from "../hooks/tool-loop-detection";
+import { renderGoalReminder } from "../prompts/goal-reminder";
 import { summarizeSession as runSummarize } from "../utils/internal-ai";
 import { getMemoryRaterNames } from "../utils/memory-raters";
 import { getOpenRouterAttributionHeaders } from "../utils/openrouter-base-url";
@@ -34,7 +35,7 @@ export interface SwarmHooksConfig {
 }
 
 /** Standard headers for swarm API requests */
-function apiHeaders(config: SwarmHooksConfig): Record<string, string> {
+export function apiHeaders(config: SwarmHooksConfig): Record<string, string> {
   return {
     "Content-Type": "application/json",
     ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}),
@@ -43,12 +44,12 @@ function apiHeaders(config: SwarmHooksConfig): Record<string, string> {
 }
 
 /** Fire-and-forget fetch — logs nothing, swallows errors */
-function fireAndForget(url: string, init: RequestInit): void {
+export function fireAndForget(url: string, init: RequestInit): void {
   void fetch(url, init).catch(() => {});
 }
 
 /** Check if a task has been cancelled */
-async function isTaskCancelled(
+export async function isTaskCancelled(
   config: SwarmHooksConfig,
 ): Promise<{ cancelled: boolean; reason?: string }> {
   try {
@@ -68,7 +69,7 @@ async function isTaskCancelled(
 }
 
 /** Check if agent should stop polling */
-async function checkShouldBlockPolling(config: SwarmHooksConfig): Promise<boolean> {
+export async function checkShouldBlockPolling(config: SwarmHooksConfig): Promise<boolean> {
   try {
     const resp = await fetch(`${config.apiUrl}/me`, {
       method: "GET",
@@ -83,7 +84,7 @@ async function checkShouldBlockPolling(config: SwarmHooksConfig): Promise<boolea
 }
 
 /** Fetch task details for goal reminder */
-async function fetchTaskDetails(
+export async function fetchTaskDetails(
   config: SwarmHooksConfig,
 ): Promise<{ id: string; task: string; progress?: string } | null> {
   try {
@@ -99,9 +100,10 @@ async function fetchTaskDetails(
 }
 
 /** Sync identity files (SOUL.md, IDENTITY.md, TOOLS.md) to server */
-async function syncIdentityFilesToServer(
+export async function syncIdentityFilesToServer(
   config: SwarmHooksConfig,
   changeSource: "self_edit" | "session_sync" = "session_sync",
+  signal?: AbortSignal,
 ): Promise<void> {
   const updates: Record<string, string> = {};
   const paths: Record<string, string> = {
@@ -131,6 +133,7 @@ async function syncIdentityFilesToServer(
       method: "PUT",
       headers: apiHeaders(config),
       body: JSON.stringify({ ...updates, changeSource }),
+      signal,
     });
   } catch {
     /* silently fail */
@@ -174,7 +177,10 @@ async function syncSetupScriptToServer(
 }
 
 /** Auto-index a file written to memory directory */
-async function autoIndexMemoryFile(config: SwarmHooksConfig, editedPath: string): Promise<void> {
+export async function autoIndexMemoryFile(
+  config: SwarmHooksConfig,
+  editedPath: string,
+): Promise<void> {
   try {
     const fileContent = await Bun.file(editedPath).text();
     const isShared = editedPath.startsWith("/workspace/shared/");
@@ -198,7 +204,7 @@ async function autoIndexMemoryFile(config: SwarmHooksConfig, editedPath: string)
 }
 
 /** Fetch concurrent context for lead agents */
-async function fetchConcurrentContext(config: SwarmHooksConfig): Promise<string | null> {
+export async function fetchConcurrentContext(config: SwarmHooksConfig): Promise<string | null> {
   try {
     const resp = await fetch(`${config.apiUrl}/api/concurrent-context`, {
       method: "GET",
@@ -313,26 +319,38 @@ export async function summarizeSessionForPi(
     return;
   }
 
+  let transcript = "";
+  try {
+    const fullTranscript = await Bun.file(sessionFile).text();
+    transcript = fullTranscript.length > 20000 ? fullTranscript.slice(-20000) : fullTranscript;
+  } catch (err) {
+    console.warn(
+      scrubSecrets(`session_summary skipped (pi): cannot read ${sessionFile}: ${String(err)}`),
+    );
+    return;
+  }
+  await summarizeTranscript(config, "pi", transcript, deps);
+}
+
+/**
+ * Summarize an already-loaded session transcript and index the result. Shared
+ * by pi (transcript file) and opencode (transcript read from its session API).
+ */
+export async function summarizeTranscript(
+  config: SwarmHooksConfig,
+  harness: "pi" | "opencode",
+  transcript: string,
+  deps: SummarizeSessionForPiDeps = {},
+): Promise<void> {
   const _runSummarize = deps.runSummarize ?? runSummarize;
   const _fetchRetrievals = deps.fetchRetrievalsForTask ?? fetchRetrievalsForTask;
   const _postRatings = deps.postRatings ?? postRatings;
   const _buildRatings = deps.buildRatingsFromLlm ?? buildRatingsFromLlm;
 
   try {
-    let transcript = "";
-    try {
-      const fullTranscript = await Bun.file(sessionFile).text();
-      transcript = fullTranscript.length > 20000 ? fullTranscript.slice(-20000) : fullTranscript;
-    } catch (err) {
-      console.warn(
-        scrubSecrets(`session_summary skipped (pi): cannot read ${sessionFile}: ${String(err)}`),
-      );
-      return;
-    }
-
     if (transcript.length <= 100) {
       console.warn(
-        `session_summary skipped (pi): transcript too short (${transcript.length} chars)`,
+        `session_summary skipped (${harness}): transcript too short (${transcript.length} chars)`,
       );
       return;
     }
@@ -341,7 +359,7 @@ export async function summarizeSessionForPi(
     const agentId = config.agentId;
     if (!sourceTaskId || !agentId) {
       console.warn(
-        `session_summary skipped (pi): ${!sourceTaskId ? "task id unavailable" : "agent id unavailable"}`,
+        `session_summary skipped (${harness}): ${!sourceTaskId ? "task id unavailable" : "agent id unavailable"}`,
       );
       return;
     }
@@ -359,7 +377,7 @@ export async function summarizeSessionForPi(
       : [];
 
     const result = await _runSummarize({
-      harness: "pi",
+      harness,
       transcript,
       retrievals,
       taskContext: {
@@ -375,14 +393,14 @@ export async function summarizeSessionForPi(
     });
     // null = no auth resolved or wrapper exhausted retries (already logged inside)
     if (!result) {
-      console.warn("session_summary skipped (pi): summarizer returned no result");
+      console.warn(`session_summary skipped (${harness}): summarizer returned no result`);
       return;
     }
 
     const summary = result.summary.trim();
     if (summary.length <= 20 || summary.toLowerCase().includes("no significant learnings")) {
       console.debug(
-        `session_summary skipped (pi): summary failed quality gate (${summary.length} chars)`,
+        `session_summary skipped (${harness}): summary failed quality gate (${summary.length} chars)`,
       );
       return;
     }
@@ -401,7 +419,11 @@ export async function summarizeSessionForPi(
     });
     if (!indexResp.ok) {
       const text = await indexResp.text().catch(() => "");
-      console.error("session_summary: /api/memory/index POST failed (pi):", indexResp.status, text);
+      console.error(
+        `session_summary: /api/memory/index POST failed (${harness}):`,
+        indexResp.status,
+        scrubSecrets(text),
+      );
       return;
     }
 
@@ -414,14 +436,21 @@ export async function summarizeSessionForPi(
           agentId,
           taskId: sourceTaskId,
           events: ratingEvents,
-        }).catch((err) => console.error("session_summary: postRatings failed (pi):", err));
+        }).catch((err) =>
+          console.error(`session_summary: postRatings failed (${harness}):`, scrubError(err)),
+        );
       }
     }
   } catch (err) {
-    console.error("session_summary failed (pi):", err);
+    console.error(`session_summary failed (${harness}):`, scrubError(err));
   }
 }
 
+/** An error as scrubbed text: the session-summary diagnostics go to stderr. */
+function scrubError(err: unknown): string {
+  return scrubSecrets(err instanceof Error ? (err.stack ?? err.message) : String(err));
+}
+
 /** `customType` of the advisory messages this extension sends to the model. */
 export const SWARM_NUDGE_CUSTOM_TYPE = "swarm-nudge";
 
@@ -629,16 +658,8 @@ export function createSwarmHooksExtension(config: SwarmHooksConfig): ExtensionFa
 
       const taskDetails = await fetchTaskDetails(config);
       if (taskDetails) {
-        const reminder = [
-          "=== GOAL REMINDER (injected before context compaction) ===",
-          `Task ID: ${taskDetails.id}`,
-          `Task: ${taskDetails.task}`,
-        ];
-        if (taskDetails.progress) {
-          reminder.push(`Current Progress: ${taskDetails.progress}`);
-        }
-        reminder.push("=== Continue working on this task after compaction ===");
-        sendNudge(pi, reminder.join("\n"));
+        const reminder = await renderGoalReminder(taskDetails);
+        if (reminder) sendNudge(pi, reminder);
       }
     });
 

package/src/scripts-runtime/executors/native.ts

@@ -1,4 +1,4 @@
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import {
   detachedProcessGroup,
   registerProcessGroup,
@@ -112,6 +112,7 @@ async function writeBareImportShims(tmpdir: string): Promise<void> {
       ["stdlib", `${runtimeDir}/stdlib.bundle.js`],
       ["swarm-sdk", `${runtimeDir}/swarm-sdk.bundle.js`],
       ["zod", `${runtimeDir}/zod.bundle.js`],
+      ["zod/mini", `${runtimeDir}/zod-mini.bundle.js`],
     ];
     for (const [name, bundlePath] of shims) {
       const dir = `${tmpdir}/node_modules/${name}`;
@@ -119,16 +120,16 @@ async function writeBareImportShims(tmpdir: string): Promise<void> {
       await Bun.write(`${dir}/package.json`, JSON.stringify({ type: "module", main: "index.js" }));
       await Bun.write(
         `${dir}/index.js`,
-        `export * from ${JSON.stringify(`file://${bundlePath}`)};\n`,
+        `export * from ${JSON.stringify(pathToFileURL(bundlePath).href)};\n`,
       );
     }
     return;
   }
   await writeBareImportShim(tmpdir, "stdlib", new URL("../stdlib/index.ts", import.meta.url));
   await writeBareImportShim(tmpdir, "swarm-sdk", new URL("../swarm-sdk.ts", import.meta.url));
-  // Allow `import { z } from "zod"` in user scripts (for argsSchema definitions).
-  const zodEntry = Bun.resolveSync("zod", import.meta.dir);
-  await writeBareImportShim(tmpdir, "zod", new URL(`file://${zodEntry}`));
+  for (const name of ["zod", "zod/mini"]) {
+    await writeBareImportShim(tmpdir, name, pathToFileURL(Bun.resolveSync(name, import.meta.dir)));
+  }
 }
 
 function harnessCommand(

package/src/scripts-runtime/executors/quickjs-bundle.ts

@@ -37,33 +37,38 @@ export type QuickJSBundle =
 
 type BuildConfigWithFiles = Parameters<typeof Bun.build>[0] & { files: Record<string, string> };
 
-let zodEntryCache: string | null | undefined;
+const zodEntryCache = new Map<string, string | null>();
 
 /**
  * Prefer zod's real ESM sources, which tree-shake well. The prebuilt
  * `zod.bundle.js` of the API image barely tree-shakes (~340 KB against ~87 KB
  * for z.object + z.string().email()), so it is only the last fallback.
  */
-export async function resolveZodEntry(): Promise<string | null> {
-  if (zodEntryCache !== undefined) return zodEntryCache;
+export async function resolveZodEntry(
+  moduleName: "zod" | "zod/mini" = "zod",
+): Promise<string | null> {
   const runtimeDir = process.env.SCRIPT_RUNTIME_DIR;
+  const cacheKey = `${runtimeDir ?? ""}:${moduleName}`;
+  if (zodEntryCache.has(cacheKey)) return zodEntryCache.get(cacheKey)!;
+  const esmPath = moduleName === "zod" ? "index.js" : "mini/index.js";
+  const bundleName = moduleName === "zod" ? "zod" : "zod-mini";
   const candidates: Array<() => string | undefined> = [
-    () => (runtimeDir ? `${runtimeDir}/zod-esm/index.js` : undefined),
-    () => Bun.resolveSync("zod", import.meta.dir),
-    () => (runtimeDir ? `${runtimeDir}/zod.bundle.js` : undefined),
+    () => (runtimeDir ? `${runtimeDir}/zod-esm/${esmPath}` : undefined),
+    () => Bun.resolveSync(moduleName, import.meta.dir),
+    () => (runtimeDir ? `${runtimeDir}/${bundleName}.bundle.js` : undefined),
   ];
   for (const candidate of candidates) {
     try {
       const path = candidate();
       if (path && (await Bun.file(path).exists())) {
-        zodEntryCache = path;
+        zodEntryCache.set(cacheKey, path);
         return path;
       }
     } catch {
       // Try the next candidate. Bun.resolveSync throws inside the compiled binary.
     }
   }
-  zodEntryCache = null;
+  zodEntryCache.set(cacheKey, null);
   return null;
 }
 
@@ -89,7 +94,6 @@ export async function bundleForQuickJS(source: string): Promise<QuickJSBundle> {
     return cached;
   }
 
-  const zodEntry = await resolveZodEntry();
   let result: Awaited<ReturnType<typeof Bun.build>>;
   try {
     result = await Bun.build({
@@ -117,9 +121,12 @@ export async function bundleForQuickJS(source: string): Promise<QuickJSBundle> {
               contents: args.path === "stdlib" ? STDLIB_MODULE : SWARM_SDK_MODULE,
               loader: "js",
             }));
-            build.onResolve({ filter: /^zod$/ }, () => {
+            build.onResolve({ filter: /^zod(?:\/mini)?$/ }, async (args) => {
+              const zodEntry = await resolveZodEntry(args.path as "zod" | "zod/mini");
               if (!zodEntry) {
-                throw new Error("zod is not available to the quickjs executor in this deployment");
+                throw new Error(
+                  `${args.path} is not available to the quickjs executor in this deployment`,
+                );
               }
               return { path: zodEntry };
             });

package/src/scripts-runtime/extract-args-schema.ts

@@ -7,14 +7,32 @@
  *   SWARM_SCHEMA_RESULT_FILE  path where JSON Schema (or "null") is written
  *   SWARM_SCHEMA_TMPDIR       tmpdir used for shims + the user module
  */
+import { pathToFileURL } from "node:url";
 import { toJSONSchema } from "zod";
 
 async function createShims(tmpdir: string): Promise<void> {
-  const zodEntry = Bun.resolveSync("zod", import.meta.dir);
+  const runtimeDir = process.env.SCRIPT_RUNTIME_DIR;
   const shims: [string, URL][] = [
-    ["stdlib", new URL("./stdlib/index.ts", import.meta.url)],
-    ["swarm-sdk", new URL("./swarm-sdk.ts", import.meta.url)],
-    ["zod", new URL(`file://${zodEntry}`)],
+    [
+      "stdlib",
+      runtimeDir
+        ? pathToFileURL(`${runtimeDir}/stdlib.bundle.js`)
+        : new URL("./stdlib/index.ts", import.meta.url),
+    ],
+    [
+      "swarm-sdk",
+      runtimeDir
+        ? pathToFileURL(`${runtimeDir}/swarm-sdk.bundle.js`)
+        : new URL("./swarm-sdk.ts", import.meta.url),
+    ],
+    ...["zod", "zod/mini"].map((name): [string, URL] => [
+      name,
+      pathToFileURL(
+        runtimeDir
+          ? `${runtimeDir}/${name === "zod" ? "zod" : "zod-mini"}.bundle.js`
+          : Bun.resolveSync(name, import.meta.dir),
+      ),
+    ]),
   ];
   for (const [name, url] of shims) {
     const dir = `${tmpdir}/node_modules/${name}`;

package/src/scripts-runtime/import-allowlist.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-const SCRIPT_ALLOWED_BARE_IMPORTS = ["swarm-sdk", "stdlib", "zod"] as const;
+const SCRIPT_ALLOWED_BARE_IMPORTS = ["swarm-sdk", "stdlib", "zod", "zod/mini"] as const;
 const FORBIDDEN_HINTS = new Set(["node:", "bun:", "fs", "child_process", "crypto", "bun:sqlite"]);
 
 export type ImportAllowlistOptions = {

package/src/scripts-runtime/zod-mini-bundle.ts

@@ -0,0 +1,5 @@
+// Keep Mini's namespace export live in Bun's standalone bundle.
+import * as mini from "zod/mini";
+
+export * from "zod/mini";
+export const z = mini.z;

package/src/slack/render-v2.ts

@@ -1016,7 +1016,7 @@ async function conclusionResultsLines(closure: AgentTask[]): Promise<string[]> {
     const agentName = await agentDisplayNameFor(member);
     const card = await getSlackOutcomeMessage(member.id);
     if (card?.permalink) {
-      lines.push(`↳ ${glyph} ${agentName} — ${card.permalink}`);
+      lines.push(`↳ ${glyph} ${agentName} — [result](${card.permalink})`);
       continue;
     }
     const raw = outcomeText(
@@ -1452,7 +1452,7 @@ async function resolvedDeferralContent(
     return { text: presentation, blocks: [{ type: "markdown", text: presentation }, ...captions] };
   }
   const card = await getSlackOutcomeMessage(wake.id);
-  const pointer = card?.permalink ? ` — ${card.permalink}` : ".";
+  const pointer = card?.permalink ? ` — <${card.permalink}|next update>` : ".";
   return { text: `↪️ Resumed by ${await agentDisplayNameFor(wake)} and deferred again${pointer}` };
 }
 

package/src/tests/entrypoint-acp-target-binary.test.ts

@@ -393,7 +393,6 @@ describe("docker-entrypoint.sh: provider binary chain contract", () => {
   test.each([
     ["claude", "Claude CLI:"],
     ["codex", "Codex CLI:"],
-    ["opencode", "opencode CLI:"],
     ["dsh", "dsh CLI:"],
     ["claude-managed", "no local CLI required"],
     ["devin", "cloud API"],
@@ -408,6 +407,25 @@ describe("docker-entrypoint.sh: provider binary chain contract", () => {
     CHILD_PROCESS_TEST_BUDGET_MS,
   );
 
+  test(
+    "checks the opencode branch for the in-process SDK, not a CLI",
+    async () => {
+      const sdkPath = join(getStubDir(), "opencode-sdk-index.js");
+      writeFileSync(sdkPath, "");
+      const found = await runChain({ HARNESS_PROVIDER: "opencode", OPENCODE_SDK_PATH: sdkPath });
+      expect(found.exitCode).toBe(0);
+      expect(found.stdout).toContain(`OpenCode SDK: ${sdkPath}`);
+
+      const missing = await runChain({
+        HARNESS_PROVIDER: "opencode",
+        OPENCODE_SDK_PATH: join(getStubDir(), "no-such-sdk.js"),
+      });
+      expect(missing.exitCode).not.toBe(0);
+      expect(missing.stdout).toContain("FATAL: @opencode/sdk not found");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
   test(
     "leaves the pi provider unchecked",
     async () => {