@pify/swarm 0.9.0 → 0.9.2

package/extensions/swarm.ts

@@ -32,13 +32,23 @@ import {
   decideConsent,
   envConsent,
   parseConsent,
+  persistConsent,
   readConsent,
-  writeConsent,
 } from "../src/consent.ts";
 import { LiveChildren, cancelNote, type CancelReason } from "../src/cancel.ts";
 import { DELIVERY_TYPE, deliveryMessage, pendingResult } from "../src/pending.ts";
 import { createIsolationWorktree, isolationNote, removeIfUnchanged } from "../src/isolate.ts";
-import { formatInbox, mailboxDir, mailboxPrompt, postMessage, readInbox } from "../src/mailbox.ts";
+import {
+  MAILBOX_INBOX_TOOL,
+  MAILBOX_POST_TOOL,
+  MAILBOX_TOOL_NAMES,
+  formatInbox,
+  mailboxDir,
+  mailboxKey,
+  mailboxPrompt,
+  postMessage,
+  readInbox,
+} from "../src/mailbox.ts";
 import { parseAgentFile } from "../src/frontmatter.ts";
 import { buildReport, buildStatusLine } from "../src/report.ts";
 import { routeItem } from "../src/routing.ts";
@@ -53,7 +63,7 @@ import {
   type ItemState,
   type SwarmRun,
 } from "../src/types.ts";
-import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { basename, join } from "node:path";
 
 const RUN_ENTRY = "swarm-run";
@@ -136,7 +146,7 @@ export default function swarm(pi: ExtensionAPI) {
     let seen = 0;
     return [
       {
-        name: "swarm_post",
+        name: MAILBOX_POST_TOOL,
         label: "Post to swarm",
         description:
           "Tell the other agents in this swarm something that changes their work: a shared file you " +
@@ -154,7 +164,7 @@ export default function swarm(pi: ExtensionAPI) {
         },
       },
       {
-        name: "swarm_inbox",
+        name: MAILBOX_INBOX_TOOL,
         label: "Read swarm inbox",
         description:
           "Read what the other agents in this swarm have posted since you last checked. Call it " +
@@ -227,7 +237,11 @@ export default function swarm(pi: ExtensionAPI) {
         sessionManager: SessionManager.inMemory(workDir ?? ctx.cwd),
         model,
         thinkingLevel: (def.thinking ?? pi.getThinkingLevel()) as never,
-        tools: def.tools,
+        // `tools` is an allowlist and it filters customTools too, so a mailbox
+        // tool that is not named here is registered and then dropped — the
+        // child is told it has no such tool, and mailbox:true does nothing.
+        // Admit them exactly as @pify/subagent admits ask_supervisor.
+        tools: mailbox ? [...def.tools, ...MAILBOX_TOOL_NAMES] : def.tools,
         ...(mailbox ? { customTools: mailboxTools(mailbox, item.agent + "-" + item.index) } : {}),
         resourceLoader: loader,
       });
@@ -343,8 +357,12 @@ export default function swarm(pi: ExtensionAPI) {
     isolate?: boolean,
     useMailbox?: boolean,
   ): Promise<void> {
-    // One shared log per run; only created when the caller asked for it.
-    const mailbox = useMailbox ? mailboxDir(getAgentDir(), run.runId) : undefined;
+    // One shared log per run; only created when the caller asked for it. Keyed
+    // on a per-run token (not the reused "s1" run id), so one run never reads a
+    // previous run's stale messages, and removed at the end so it never leaks.
+    const mailbox = useMailbox
+      ? mailboxDir(getAgentDir(), mailboxKey(run.runId, run.startedAt))
+      : undefined;
 
     // A dependent structurally receives each upstream's output — the thing a
     // hand-sequenced coordinator forgets. Prepended to the shared preamble.
@@ -359,33 +377,45 @@ export default function swarm(pi: ExtensionAPI) {
 
     // Run each item once its needs finish, up to the concurrency cap; a flat
     // run (no needs) has everything ready at once, exactly like the old pool.
-    await runGraph(
-      run.items,
-      DEFAULT_CONCURRENCY,
-      async (item, upstream) => {
-        const def = routeItem(item.item, defs, fixed);
-        item.agent = def.name;
-        const itemContext = contextFor(upstream);
-        if (isolate) {
-          try {
-            const iso = createIsolationWorktree(ctx.cwd, run.runId + "-i" + (item.index + 1));
-            await runItem(ctx, run.runId, def, item, itemContext, iso.path, mailbox);
-            // Remove the worktree when the item changed nothing (the leak
-            // removeIfUnchanged fixes); keep it when there is work to merge.
-            const removed = removeIfUnchanged(ctx.cwd, iso);
-            if (item.result !== null) {
-              item.result = `${item.result}\n\n${removed ? CLEAN_WORKTREE_NOTE : isolationNote(iso)}`;
+    try {
+      await runGraph(
+        run.items,
+        DEFAULT_CONCURRENCY,
+        async (item, upstream) => {
+          const def = routeItem(item.item, defs, fixed);
+          item.agent = def.name;
+          const itemContext = contextFor(upstream);
+          if (isolate) {
+            try {
+              const iso = createIsolationWorktree(ctx.cwd, run.runId + "-i" + (item.index + 1));
+              await runItem(ctx, run.runId, def, item, itemContext, iso.path, mailbox);
+              // Remove the worktree when the item changed nothing (the leak
+              // removeIfUnchanged fixes); keep it when there is work to merge.
+              const removed = removeIfUnchanged(ctx.cwd, iso);
+              if (item.result !== null) {
+                item.result = `${item.result}\n\n${removed ? CLEAN_WORKTREE_NOTE : isolationNote(iso)}`;
+              }
+            } catch (err) {
+              item.status = "error";
+              item.error = err instanceof Error ? err.message : String(err);
             }
-          } catch (err) {
-            item.status = "error";
-            item.error = err instanceof Error ? err.message : String(err);
+          } else {
+            await runItem(ctx, run.runId, def, item, itemContext, undefined, mailbox);
           }
-        } else {
-          await runItem(ctx, run.runId, def, item, itemContext, undefined, mailbox);
+        },
+        () => run.status === "cancelled",
+      );
+    } finally {
+      // The mailbox is per-run scratch: reclaim it however the run ends
+      // (finished, cancelled, or thrown) so a directory never accumulates.
+      if (mailbox) {
+        try {
+          rmSync(mailbox, { recursive: true, force: true });
+        } catch {
+          // best-effort: an unremovable scratch dir is not worth failing a run
         }
-      },
-      () => run.status === "cancelled",
-    );
+      }
+    }
 
     if (run.status !== "cancelled") run.status = "done";
     run.finishedAt = Date.now();
@@ -630,8 +660,7 @@ export default function swarm(pi: ExtensionAPI) {
       ),
     );
     try {
-      writeFileSync(file, `${JSON.stringify(writeConsent(store, ctx.cwd, "agents", approved), null, 2)}
-`);
+      persistConsent(file, ctx.cwd, "agents", approved);
     } catch {
       // An unwritable consent file costs us the memory of the answer, not the answer.
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pify/swarm",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Coordinate multiple pi agents in parallel: swarm_run fan-out with per-item auto-routing, concurrency queue, aggregated reports",
   "keywords": [
     "pi-package",

package/src/consent.ts

@@ -16,6 +16,8 @@
  * around the first.
  */
 
+import { readFileSync, writeFileSync } from "node:fs";
+
 /** What to do with a project-supplied file this session. */
 export type ConsentVerdict = "allow" | "refuse" | "ask";
 
@@ -80,6 +82,30 @@ export function writeConsent(
   return { ...file, [key]: { ...(file[key] ?? {}), [scope]: allowed } };
 }
 
+/**
+ * Record a consent answer to disk without losing a concurrent writer's scope.
+ *
+ * Several @pify packages share this one file (keyed by cwd → {scope: bool}), and
+ * each asks the user with an `await` between reading the file and writing it
+ * back. If two flows both read the old file, then both write, the second write
+ * drops the scope the first added. So re-read and re-parse the file HERE, right
+ * before writing, with no `await` in between — the merge always starts from the
+ * freshest on-disk state, and within a single (single-threaded) process the
+ * read-modify-write can no longer interleave. Cross-process races remain
+ * theoretically possible but fail safe: the worst case is a re-prompt, never a
+ * silently-granted consent.
+ */
+export function persistConsent(file: string, cwd: string, scope: string, allowed: boolean): void {
+  let raw: string | null = null;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch {
+    raw = null;
+  }
+  const next = writeConsent(parseConsent(raw), cwd, scope, allowed);
+  writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`);
+}
+
 /** Tolerate anything on disk: a corrupt consent file means "never asked". */
 export function parseConsent(raw: string | null): ConsentFile {
   if (!raw) return {};

package/src/mailbox.ts

@@ -23,6 +23,30 @@ export interface MailMessage {
 export const MAX_MESSAGE_CHARS = 1200;
 export const MAX_INBOX_MESSAGES = 30;
 
+/**
+ * The two mailbox tool names. pi's child-session `tools` allowlist filters
+ * customTools too, so a mailbox tool that is not also named in the child's
+ * allowlist is registered and then silently dropped — the child is told it has
+ * no such tool. Naming them here keeps the allowlist and the tool definitions
+ * from drifting apart (mirrors how @pify/subagent wires ask_supervisor).
+ */
+export const MAILBOX_POST_TOOL = "swarm_post";
+export const MAILBOX_INBOX_TOOL = "swarm_inbox";
+export const MAILBOX_TOOL_NAMES = [MAILBOX_POST_TOOL, MAILBOX_INBOX_TOOL] as const;
+
+/**
+ * A per-run key for the mailbox directory. The run id ("s1", "s2", …) restarts
+ * at "s1" every session, so keying the dir on it alone made two different runs
+ * — a fresh "s1" and a previous session's "s1" — share one directory: the new
+ * run read the old run's stale messages, and the old dir was never reclaimed.
+ * Folding in the run's start time (base36-compact, and derived from the clock
+ * rather than Math.random so it stays deterministic and testable) gives every
+ * run its own directory, even two "s1"s from different sessions.
+ */
+export function mailboxKey(runId: string, startedAt: number): string {
+  return `${runId}-${Math.trunc(startedAt).toString(36)}`;
+}
+
 /**
  * One directory per run under the agent dir. Run ids are generated locally,
  * but this builds a filesystem path, so it stays a single flat segment: no