@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/src/providers/codex-adapter.ts

@@ -6,7 +6,7 @@
  *
  * Each task owns a fresh thread inside an isolated session subprocess.
  * Native resume remains disabled. Follow-up tasks use the context preamble.
- * The adapter resolves skills, maintains AGENTS.md, and reports swarm events.
+ * The adapter resolves skills, supplies session instructions, and reports swarm events.
  *
  * Per-session configuration travels in `thread/start` over stdin. This keeps
  * MCP credentials out of process arguments. The configuration overrides the
@@ -48,7 +48,7 @@ import {
   terminateProcessGroup,
 } from "../utils/process-group";
 import { scrubSecrets } from "../utils/secret-scrubber";
-import { type CodexAgentsMdHandle, writeCodexAgentsMd } from "./codex-agents-md";
+import { recoverLegacyCodexAgentsMd } from "./codex-agents-md";
 import {
   CodexAppServer,
   type CodexAppServerNotification,
@@ -951,7 +951,6 @@ export interface SummarizeSessionForCodexDeps {
 export class CodexSession implements ProviderSession {
   private readonly thread: CodexThread;
   private readonly config: ProviderSessionConfig;
-  private readonly agentsMdHandle: CodexAgentsMdHandle;
   private readonly resolvedModel: string;
   private readonly contextWindow: number;
   private readonly skillsDir: string;
@@ -991,7 +990,7 @@ export class CodexSession implements ProviderSession {
   /**
    * Result captured by `settle` but held back from `resolveCompletion` until
    * `runSession`'s `finally` block has fully cleaned up (log writer flush,
-   * AGENTS.md cleanup, session summary). Without this, callers awaiting
+   * app-server close, session summary). Without this, callers awaiting
    * `waitForCompletion` would race the cleanup. Phase 3 added the session
    * summary path which materially relies on this ordering for testability.
    */
@@ -1000,7 +999,6 @@ export class CodexSession implements ProviderSession {
   constructor(
     thread: CodexThread,
     config: ProviderSessionConfig,
-    agentsMdHandle: CodexAgentsMdHandle,
     resolvedModel: string,
     initialEvents: ProviderEvent[] = [],
     skillsDir?: string,
@@ -1008,7 +1006,6 @@ export class CodexSession implements ProviderSession {
   ) {
     this.thread = thread;
     this.config = config;
-    this.agentsMdHandle = agentsMdHandle;
     this.resolvedModel = resolvedModel;
     this.contextWindow = getCodexContextWindow(resolvedModel);
     // `CODEX_SKILLS_DIR` lets tests / non-Docker installs point at a custom
@@ -1739,7 +1736,7 @@ export class CodexSession implements ProviderSession {
     } finally {
       // Session-end summarization. Pure addition for codex — no behavior to
       // preserve. Wrapped in its own try/catch so summary failure must NOT
-      // block the existing log/AGENTS.md cleanup below. `SKIP_SESSION_SUMMARY` is
+      // block the existing log/transport cleanup below. `SKIP_SESSION_SUMMARY` is
       // read with `isSessionSummarySkipped`, the same as the claude Stop hook + pi/opencode.
       //
       // Skip the summary entirely when the session was aborted. The transcript
@@ -1778,7 +1775,6 @@ export class CodexSession implements ProviderSession {
       } catch {
         // Ignore log writer cleanup failures.
       }
-      await this.agentsMdHandle.cleanup();
 
       // Resolve `waitForCompletion()` only AFTER all cleanup has finished so
       // downstream observers (tests + the runner's `.then(...)` chain) don't
@@ -1941,123 +1937,114 @@ export async function createInProcessCodexSession(
     threadFactory?: CodexThreadFactory;
   } = {},
 ): Promise<CodexSession> {
-  // Codex ingests per-session instructions via AGENTS.md in the cwd. Write
-  // (or refresh) the managed block before we spin up the thread.
-  const agentsMdHandle = await writeCodexAgentsMd(config.cwd, config.systemPrompt);
-
-  try {
-    // Resolve the model once and thread it through. Claude shortnames map
-    // to Codex equivalents; everything else passes through verbatim — the
-    // CLI is the source of truth for valid model identifiers.
-    const resolvedModel = resolveCodexModel(config.model);
-
-    // Buffer warnings emitted during config-building so they're not lost
-    // before `CodexSession.onEvent` attaches a listener. The buffer is
-    // replayed into the session's event stream right after construction
-    // via the `initialEvents` constructor parameter.
-    const preSessionEvents: ProviderEvent[] = [];
-    const bufferedEmit = (event: ProviderEvent) => {
-      preSessionEvents.push(event);
-    };
+  await recoverLegacyCodexAgentsMd(config.cwd);
+
+  // Resolve the model once and thread it through. Claude shortnames map
+  // to Codex equivalents; everything else passes through verbatim — the
+  // CLI is the source of truth for valid model identifiers.
+  const resolvedModel = resolveCodexModel(config.model);
+
+  // Buffer warnings emitted during config-building so they're not lost
+  // before `CodexSession.onEvent` attaches a listener. The buffer is
+  // replayed into the session's event stream right after construction
+  // via the `initialEvents` constructor parameter.
+  const preSessionEvents: ProviderEvent[] = [];
+  const bufferedEmit = (event: ProviderEvent) => {
+    preSessionEvents.push(event);
+  };
 
-    const mergedConfig = await buildCodexConfig(config, resolvedModel, bufferedEmit);
-
-    // Auth resolution. `codex_oauth` (in the swarm config store) wins over
-    // `OPENAI_API_KEY` so users can keep an OpenAI key set for embeddings
-    // without it shadowing their ChatGPT login. The entrypoint already runs
-    // this same precedence at boot — this block handles local dev (where
-    // the entrypoint didn't run) and any case where auth.json is stale.
-    const authMode = await resolveCodexAuthMode(config, bufferedEmit);
-
-    // The app-server receives an explicit environment. Construct a
-    // minimal env explicitly so the spawned Codex CLI can find its binary
-    // (PATH) and HOME (for ~/.codex/auth.json). `OPENAI_API_KEY` is only
-    // forwarded when auth.json is NOT in chatgpt mode — otherwise it would
-    // override the OAuth login at the Codex CLI layer.
-    const env: Record<string, string> = {
-      PATH: process.env.PATH ?? "",
-      HOME: process.env.HOME ?? "",
-      ...(authMode !== "chatgpt" && process.env.OPENAI_API_KEY
-        ? { OPENAI_API_KEY: process.env.OPENAI_API_KEY }
-        : {}),
-      ...(process.env.NODE_EXTRA_CA_CERTS
-        ? { NODE_EXTRA_CA_CERTS: process.env.NODE_EXTRA_CA_CERTS }
-        : {}),
-      CONTEXT_MODE_EXTERNAL_MCP_NUDGE_EVERY: CTX_MODE_NUDGE_EVERY,
-      ...(config.env ?? {}),
-      // Gated cross-service OTel linking: when SWARM_ENABLE_HARNESS_OTEL (or
-      // the deprecated SWARM_ENABLE_CLAUDE_CODE_OTEL alias) is on, inject
-      // TRACEPARENT from the active worker span so Codex's spans nest under
-      // our worker.session trace. Codex's Rust OTEL SDK reads W3C trace
-      // context from the env via the default tracecontext propagator.
-      // Returns {} (no-op) when off; spread last so the computed value wins.
-      ...buildOtelTraceparentEnv(config.env ?? process.env),
-      SWARM_CODEX_APP_SERVER: "1",
-    };
-    if (authMode === "chatgpt") delete env.OPENAI_API_KEY;
+  const mergedConfig = await buildCodexConfig(config, resolvedModel, bufferedEmit);
+
+  // Auth resolution. `codex_oauth` (in the swarm config store) wins over
+  // `OPENAI_API_KEY` so users can keep an OpenAI key set for embeddings
+  // without it shadowing their ChatGPT login. The entrypoint already runs
+  // this same precedence at boot — this block handles local dev (where
+  // the entrypoint didn't run) and any case where auth.json is stale.
+  const authMode = await resolveCodexAuthMode(config, bufferedEmit);
+
+  // The app-server receives an explicit environment. Construct a
+  // minimal env explicitly so the spawned Codex CLI can find its binary
+  // (PATH) and HOME (for ~/.codex/auth.json). `OPENAI_API_KEY` is only
+  // forwarded when auth.json is NOT in chatgpt mode — otherwise it would
+  // override the OAuth login at the Codex CLI layer.
+  const env: Record<string, string> = {
+    PATH: process.env.PATH ?? "",
+    HOME: process.env.HOME ?? "",
+    ...(authMode !== "chatgpt" && process.env.OPENAI_API_KEY
+      ? { OPENAI_API_KEY: process.env.OPENAI_API_KEY }
+      : {}),
+    ...(process.env.NODE_EXTRA_CA_CERTS
+      ? { NODE_EXTRA_CA_CERTS: process.env.NODE_EXTRA_CA_CERTS }
+      : {}),
+    CONTEXT_MODE_EXTERNAL_MCP_NUDGE_EVERY: CTX_MODE_NUDGE_EVERY,
+    ...(config.env ?? {}),
+    // Gated cross-service OTel linking: when SWARM_ENABLE_HARNESS_OTEL (or
+    // the deprecated SWARM_ENABLE_CLAUDE_CODE_OTEL alias) is on, inject
+    // TRACEPARENT from the active worker span so Codex's spans nest under
+    // our worker.session trace. Codex's Rust OTEL SDK reads W3C trace
+    // context from the env via the default tracecontext propagator.
+    // Returns {} (no-op) when off; spread last so the computed value wins.
+    ...buildOtelTraceparentEnv(config.env ?? process.env),
+    SWARM_CODEX_APP_SERVER: "1",
+  };
+  if (authMode === "chatgpt") delete env.OPENAI_API_KEY;
 
-    const codexPathOverride = process.env.CODEX_PATH_OVERRIDE;
+  const codexPathOverride = process.env.CODEX_PATH_OVERRIDE;
 
-    // Native resume is deprecated. Follow-up continuity is delivered via the
-    // context preamble (see src/commands/context-preamble.ts). Any stray
-    // resumeSessionId is logged and ignored — we always start a fresh thread.
-    if (config.resumeSessionId) {
-      console.warn(
-        "[codex-adapter] resumeSessionId ignored — native resume is disabled by deprecation plan",
-      );
-    }
-    let thread: CodexThread;
-    let liveSession: CodexSession | undefined;
-    if (opts.threadFactory) {
-      thread = await opts.threadFactory({
-        config,
-        resolvedModel,
-        env,
-        codexConfig: mergedConfig,
-      });
-    } else {
-      const appServerFactory = opts.appServerFactory ?? ((options) => new CodexAppServer(options));
-      const client = appServerFactory({
-        ...(codexPathOverride ? { codexPath: codexPathOverride } : {}),
-        env,
-        onStderr: (line) => {
-          if (liveSession) liveSession.emitTransportStderr(line);
-          else bufferedEmit({ type: "raw_stderr", content: `${line}\n` });
-        },
-      });
-      try {
-        const response = await client.request<{ thread: { id: string } }>("thread/start", {
-          model: resolvedModel,
-          cwd: config.cwd,
-          approvalPolicy: "never",
-          sandbox: "danger-full-access",
-          config: mergedConfig,
-          ephemeral: true,
-        });
-        thread = new AppServerCodexThread(client, response.thread.id);
-      } catch (error) {
-        await client.close();
-        throw error;
-      }
-    }
-
-    const session = new CodexSession(
-      thread,
+  // Native resume is deprecated. Follow-up continuity is delivered via the
+  // context preamble (see src/commands/context-preamble.ts). Any stray
+  // resumeSessionId is logged and ignored — we always start a fresh thread.
+  if (config.resumeSessionId) {
+    console.warn(
+      "[codex-adapter] resumeSessionId ignored — native resume is disabled by deprecation plan",
+    );
+  }
+  let thread: CodexThread;
+  let liveSession: CodexSession | undefined;
+  if (opts.threadFactory) {
+    thread = await opts.threadFactory({
       config,
-      agentsMdHandle,
       resolvedModel,
-      preSessionEvents,
-      opts.skillsDir,
-      opts.summarizeDeps ?? {},
-    );
-    liveSession = session;
-    return session;
-  } catch (err) {
-    // If we failed to construct the thread, clean up the managed AGENTS.md
-    // block so we don't leak state on the filesystem.
-    await agentsMdHandle.cleanup();
-    throw err;
+      env,
+      codexConfig: mergedConfig,
+    });
+  } else {
+    const appServerFactory = opts.appServerFactory ?? ((options) => new CodexAppServer(options));
+    const client = appServerFactory({
+      ...(codexPathOverride ? { codexPath: codexPathOverride } : {}),
+      env,
+      onStderr: (line) => {
+        if (liveSession) liveSession.emitTransportStderr(line);
+        else bufferedEmit({ type: "raw_stderr", content: `${line}\n` });
+      },
+    });
+    try {
+      const response = await client.request<{ thread: { id: string } }>("thread/start", {
+        model: resolvedModel,
+        cwd: config.cwd,
+        developerInstructions: config.systemPrompt,
+        approvalPolicy: "never",
+        sandbox: "danger-full-access",
+        config: mergedConfig,
+        ephemeral: true,
+      });
+      thread = new AppServerCodexThread(client, response.thread.id);
+    } catch (error) {
+      await client.close();
+      throw error;
+    }
   }
+
+  const session = new CodexSession(
+    thread,
+    config,
+    resolvedModel,
+    preSessionEvents,
+    opts.skillsDir,
+    opts.summarizeDeps ?? {},
+  );
+  liveSession = session;
+  return session;
 }
 
 /**

package/src/providers/codex-agents-md.ts

@@ -1,242 +1,48 @@
-/**
- * Codex AGENTS.md helper.
- *
- * Codex reads `AGENTS.md` from the session cwd at startup and uses its contents
- * as the agent's base instructions. There is no `ThreadStartParams.systemPrompt`
- * / `developerInstructions` equivalent wired through the SDK 0.118 public
- * surface, so the only way to inject our per-session `config.systemPrompt` is
- * to write it into `AGENTS.md` before `thread.runStreamed()` is called.
- *
- * To avoid stomping on any existing `AGENTS.md` content (or any `CLAUDE.md`
- * that the repo already ships with), we manage a delimited block:
- *
- *   <swarm_system_prompt>
- *   ...our prompt...
- *   </swarm_system_prompt>
- *
- * Rules:
- * - No existing `AGENTS.md`:
- *     - If `CLAUDE.md` exists in cwd, prepend the block to the CLAUDE.md
- *       contents so Codex sees our prompt plus the repo's existing Claude
- *       instructions.
- *     - Otherwise, write just the block.
- *     - Mark `createdFresh: true` so cleanup removes the file entirely.
- * - `AGENTS.md` is a symlink (many repos ship `AGENTS.md -> CLAUDE.md`):
- *     never write through it. Swap in a real file holding the block plus the
- *     link target's contents, and restore the symlink on cleanup. The target is
- *     only read, and edits only carried back to it, when its real path is a
- *     regular file inside the cwd. A crash-recovery record (cwd + link target)
- *     is kept OUTSIDE the repo, so the next session can restore the link if
- *     this one crashed before cleanup. Repo content never names a path.
- * - Existing `AGENTS.md` already contains the block: replace the block with
- *   the fresh contents.
- * - Existing `AGENTS.md` without the block: prepend the block.
- *
- * Cleanup mirrors the creation logic — if we created the file fresh, delete
- * it; if we swapped out a symlink, restore it; otherwise re-read the current
- * AGENTS.md and strip just the managed block so anything the agent appended
- * during the session is preserved.
- *
- * The helper is deliberately isolated from the adapter so it can be
- * unit-tested without pulling in the Codex SDK.
- */
-
-import { lstat, mkdir, readlink, realpath, symlink, unlink } from "node:fs/promises";
+/** Recover AGENTS.md changes left by sessions from before native instructions. */
+import { lstat, realpath, symlink, unlink } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join, resolve, sep } from "node:path";
+import { join, resolve, sep } from "node:path";
 
-const BLOCK_OPEN = "<swarm_system_prompt>";
-const BLOCK_CLOSE = "</swarm_system_prompt>";
 const BLOCK_REGEX = /<swarm_system_prompt>[\s\S]*?<\/swarm_system_prompt>\n?/;
-const DEFAULT_STATE_DIR = join(homedir(), ".cache", "agent-swarm", "codex-agents-md");
-
-export interface CodexAgentsMdHandle {
-  cleanup(): Promise<void>;
-}
-
-export interface CodexAgentsMdOptions {
-  /** Where symlink crash-recovery records live. Must be outside any repo. */
-  stateDir?: string;
-}
-
-interface SymlinkRecord {
-  cwd: string;
-  linkTarget: string;
-}
-
-const NOOP_HANDLE: CodexAgentsMdHandle = {
-  cleanup: async () => {},
-};
-
-async function readIfExists(path: string): Promise<string | null> {
-  const file = Bun.file(path);
-  return (await file.exists()) ? await file.text() : null;
-}
-
-function recordPathFor(stateDir: string, realCwd: string): string {
-  const key = new Bun.CryptoHasher("sha256").update(realCwd).digest("hex");
-  return join(stateDir, `${key}.json`);
-}
-
-async function readRecord(recordPath: string, realCwd: string): Promise<SymlinkRecord | null> {
-  try {
-    const record = JSON.parse(await Bun.file(recordPath).text()) as Partial<SymlinkRecord>;
-    if (record.cwd === realCwd && typeof record.linkTarget === "string") {
-      return { cwd: record.cwd, linkTarget: record.linkTarget };
-    }
-  } catch {
-    // Missing or unreadable record: nothing to recover.
-  }
-  return null;
-}
+const STATE_DIR = join(homedir(), ".cache", "agent-swarm", "codex-agents-md");
 
 /**
- * Real path of the symlink target when it is a regular file inside the cwd,
- * otherwise null. Out-of-tree and dangling targets are never read or written.
+ * Strip a legacy prompt block and restore a swapped symlink from the old
+ * out-of-repo recovery record. New sessions never create blocks or records.
  */
-async function inTreeTarget(
-  realCwd: string,
-  agentsMdPath: string,
-  linkTarget: string,
-): Promise<string | null> {
-  const target = await realpath(resolve(dirname(agentsMdPath), linkTarget)).catch(() => null);
-  const prefix = realCwd.endsWith(sep) ? realCwd : `${realCwd}${sep}`;
-  if (target === null || !target.startsWith(prefix)) {
-    return null;
-  }
-  const stat = await lstat(target).catch(() => null);
-  return stat?.isFile() ? target : null;
-}
-
-/**
- * Put the `AGENTS.md -> linkTarget` symlink back in place of our swapped-in
- * real file. Edits the agent made to AGENTS.md during the session would have
- * landed in the link target had the link been in place, so carry them over
- * (block stripped) when the target is in-tree and its contents differ.
- */
-async function restoreSymlink(
-  agentsMdPath: string,
-  realCwd: string,
-  linkTarget: string,
-): Promise<void> {
+export async function recoverLegacyCodexAgentsMd(cwd: string | undefined): Promise<void> {
+  if (!cwd) return;
+  const realCwd = await realpath(cwd).catch(() => resolve(cwd));
+  const agentsMdPath = join(realCwd, "AGENTS.md");
+  const key = new Bun.CryptoHasher("sha256").update(realCwd).digest("hex");
+  const recordPath = join(STATE_DIR, `${key}.json`);
+  const record = (await Bun.file(recordPath)
+    .json()
+    .catch(() => null)) as { cwd?: unknown; linkTarget?: unknown } | null;
+  const linkTarget =
+    record?.cwd === realCwd && typeof record.linkTarget === "string" ? record.linkTarget : null;
   const stat = await lstat(agentsMdPath).catch(() => null);
   const current = stat?.isFile() ? await Bun.file(agentsMdPath).text() : null;
-  await unlink(agentsMdPath).catch(() => {});
-  await symlink(linkTarget, agentsMdPath);
-  if (current === null) {
-    return;
-  }
-  const target = await inTreeTarget(realCwd, agentsMdPath, linkTarget);
-  if (target === null) {
-    return;
-  }
-  const stripped = current.replace(BLOCK_REGEX, "");
-  if (stripped !== (await Bun.file(target).text())) {
-    await Bun.write(target, stripped);
-  }
-}
-
-/**
- * Write (or refresh) a managed `<swarm_system_prompt>` block inside
- * `${cwd}/AGENTS.md`. Returns a handle whose `cleanup()` reverses the edit.
- *
- * No-ops gracefully when `cwd` or `systemPrompt` is falsy.
- */
-export async function writeCodexAgentsMd(
-  cwd: string | undefined,
-  systemPrompt: string | undefined,
-  options: CodexAgentsMdOptions = {},
-): Promise<CodexAgentsMdHandle> {
-  if (!cwd || !systemPrompt) {
-    return NOOP_HANDLE;
-  }
-
-  const agentsMdPath = join(cwd, "AGENTS.md");
-  const claudeMdPath = join(cwd, "CLAUDE.md");
-  const stateDir = options.stateDir ?? DEFAULT_STATE_DIR;
-  const realCwd = await realpath(cwd).catch(() => resolve(cwd));
-  const recordPath = recordPathFor(stateDir, realCwd);
-  const block = `${BLOCK_OPEN}\n${systemPrompt}\n${BLOCK_CLOSE}`;
-
-  let stat = await lstat(agentsMdPath).catch(() => null);
-
-  // A previous session swapped a symlink out and crashed before cleanup. Only
-  // our own out-of-repo record can trigger a restore, and only while AGENTS.md
-  // is still the real file holding our block.
-  const record = await readRecord(recordPath, realCwd);
-  if (record) {
-    if (stat?.isFile() && BLOCK_REGEX.test(await Bun.file(agentsMdPath).text())) {
-      await restoreSymlink(agentsMdPath, realCwd, record.linkTarget);
-      stat = await lstat(agentsMdPath);
-    }
-    await unlink(recordPath).catch(() => {});
-  }
-
-  if (stat?.isSymbolicLink()) {
-    const linkTarget = await readlink(agentsMdPath);
-    const target = await inTreeTarget(realCwd, agentsMdPath, linkTarget);
-    const targetContent = target !== null ? await Bun.file(target).text() : "";
-    // Record before swapping, so a crash at any later point stays recoverable.
-    await mkdir(stateDir, { recursive: true });
-    await Bun.write(recordPath, JSON.stringify({ cwd: realCwd, linkTarget }));
-    // Never write through the link: replace it with a real file for the session.
-    await unlink(agentsMdPath);
-    await Bun.write(agentsMdPath, `${block}\n${targetContent.replace(BLOCK_REGEX, "")}`);
-
-    return {
-      async cleanup(): Promise<void> {
-        try {
-          await restoreSymlink(agentsMdPath, realCwd, linkTarget);
-          await unlink(recordPath).catch(() => {});
-        } catch {
-          // Cleanup is best-effort; the record lets the next session finish
-          // the restore.
+  const stripped = current === null ? null : current.replace(BLOCK_REGEX, "");
+
+  if (linkTarget !== null && (!stat || (stripped !== null && stripped !== current))) {
+    // Carry edits back before removing the recovery copy, so a failed write
+    // leaves both the copy and the record available for the next attempt.
+    if (stripped !== null) {
+      const target = await realpath(resolve(realCwd, linkTarget)).catch(() => null);
+      const prefix = realCwd.endsWith(sep) ? realCwd : `${realCwd}${sep}`;
+      if (target !== null && target !== agentsMdPath && target.startsWith(prefix)) {
+        const targetStat = await lstat(target);
+        if (targetStat.isFile() && stripped !== (await Bun.file(target).text())) {
+          await Bun.write(target, stripped);
         }
-      },
-    };
-  }
-
-  let createdFresh = false;
-  let newContent: string;
-
-  if (!stat) {
-    // No AGENTS.md yet — prefer CLAUDE.md content as a base if present.
-    const claudeContent = await readIfExists(claudeMdPath);
-    newContent = claudeContent !== null ? `${block}\n\n${claudeContent}` : `${block}\n`;
-    createdFresh = true;
-  } else {
-    const existingContent = await Bun.file(agentsMdPath).text();
-    if (BLOCK_REGEX.test(existingContent)) {
-      // Replace the stale block in place.
-      newContent = existingContent.replace(BLOCK_REGEX, `${block}\n`);
-    } else {
-      // Prepend the block with a single newline so cleanup's strip restores
-      // the original bytes exactly.
-      newContent = `${block}\n${existingContent}`;
+      }
     }
+    if (stat) await unlink(agentsMdPath);
+    await symlink(linkTarget, agentsMdPath);
+  } else if (stripped !== null && stripped !== current) {
+    await Bun.write(agentsMdPath, stripped);
   }
 
-  await Bun.write(agentsMdPath, newContent);
-
-  return {
-    async cleanup(): Promise<void> {
-      try {
-        if (createdFresh) {
-          // Best-effort delete — ignore errors so we never throw from finally.
-          await Bun.$`rm -f ${agentsMdPath}`.quiet().nothrow();
-          return;
-        }
-        const currentFile = Bun.file(agentsMdPath);
-        if (!(await currentFile.exists())) {
-          return;
-        }
-        const currentContent = await currentFile.text();
-        const stripped = currentContent.replace(BLOCK_REGEX, "");
-        await Bun.write(agentsMdPath, stripped);
-      } catch {
-        // Cleanup is best-effort; swallow errors so we don't mask the real
-        // completion/failure path.
-      }
-    },
-  };
+  if (linkTarget !== null) await unlink(recordPath);
 }

package/src/providers/cursor-adapter.ts

@@ -35,7 +35,7 @@ import type {
 } from "./types";
 
 /** Pinned in package.json and Dockerfile.worker; bump all three together. */
-export const CURSOR_SDK_VERSION = "1.0.38";
+export const CURSOR_SDK_VERSION = "1.0.40";
 
 /** MCP server name; Cursor reports its tools as `mcp` calls with this `providerIdentifier`. */
 const CURSOR_MCP_SERVER_NAME = "agent-swarm";

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

@@ -1523,8 +1523,10 @@ const DEFAULT_CODEMODE_LIMITS: CodemodeLimits = {
  * pi has no option for either: a script runs until it returns unless its own
  * `// @options` line sets `timeout_ms`. Both limits abort the signal pi hands
  * the sandbox, which interrupts the QuickJS worker and fails the codemode call.
- * A call refused by pi's process-wide worker cap waits for a free worker
- * within the same deadline instead of failing.
+ * pi 1.4 caps live codemode workers per process (two unless
+ * `PI_CODEMODE_MAX_WORKERS` raises it) and queues a script for a free one for
+ * at most 60 seconds. The deadline's abort also ends that wait, before the
+ * script starts.
  *
  * "on" keeps declared tools declared; "only" would hide the lifecycle tools
  * behind scripts. `models` stays off unless `PI_CODEMODE_MODELS` asks for it.
@@ -1551,43 +1553,6 @@ export function createBoundedCodemodeExtension(
     );
 }
 
-const CODEMODE_WORKER_RETRY_MIN_MS = 25;
-const CODEMODE_WORKER_RETRY_MAX_MS = 250;
-
-/**
- * pi 1.3 admits at most two live codemode workers per process, across all
- * sessions, and counts a stopped worker until its thread exits. A call over
- * that cap fails before the script runs. The runner hosts every task's pi
- * session in one process and pi runs a turn's tool calls in parallel, so a
- * third concurrent script, or one started right after another, can be
- * refused. Nothing ran (no nested calls, no store writes), so it is safe to
- * retry until a worker frees up, within the same deadline.
- */
-function isCodemodeWorkerLimitRefusal(result: {
-  content: Array<{ type: string; text?: string }>;
-  details?: unknown;
-  isError?: boolean;
-}): boolean {
-  if (!result.isError) return false;
-  const calls = (result.details as { calls?: unknown[] } | undefined)?.calls;
-  if (calls && calls.length > 0) return false;
-  return result.content.some((item) =>
-    item.text?.includes("Script sandbox failed: Codemode worker limit reached"),
-  );
-}
-
-function abortableSleep(ms: number, signal: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    const timer = setTimeout(done, ms);
-    function done() {
-      clearTimeout(timer);
-      signal.removeEventListener("abort", done);
-      resolve();
-    }
-    signal.addEventListener("abort", done, { once: true });
-  });
-}
-
 export function boundCodemodeTool(tool: ToolDefinition, limits: CodemodeLimits): ToolDefinition {
   return {
     ...tool,
@@ -1653,20 +1618,7 @@ export function boundCodemodeTool(tool: ToolDefinition, limits: CodemodeLimits):
         : ctx;
 
       try {
-        let delayMs = CODEMODE_WORKER_RETRY_MIN_MS;
-        for (;;) {
-          const result = await tool.execute(
-            toolCallId,
-            params,
-            script.signal,
-            onUpdate,
-            boundedCtx,
-          );
-          if (!isCodemodeWorkerLimitRefusal(result) || script.signal.aborted) return result;
-          await abortableSleep(delayMs, script.signal);
-          if (script.signal.aborted) return result;
-          delayMs = Math.min(delayMs * 2, CODEMODE_WORKER_RETRY_MAX_MS);
-        }
+        return await tool.execute(toolCallId, params, script.signal, onUpdate, boundedCtx);
       } finally {
         clearTimeout(timer);
         signal?.removeEventListener("abort", onOuterAbort);