@desplega.ai/agent-swarm 1.91.0 → 1.92.0

package/src/tests/claude-adapter-binary.test.ts

@@ -6,10 +6,12 @@
  *   1. Binary resolution — argv[0..n] tracks `parseClaudeBinary(process.env.CLAUDE_BINARY)`,
  *      with `["claude"]` as the default. Same flags follow. Supports
  *      whitespace-separated command strings (e.g. `"bunx @dexh/shannon"`).
- *   2. Tmux fail-fast — when the resolved binary string contains "shannon"
- *      (anywhere — including inside a command string), createSession throws
- *      if `tmux` is not on PATH.
- *   3. Trust pre-seed — when the resolved binary contains "shannon", the
+ *   2. Claude Bridge routing — SWARM_USE_CLAUDE_BRIDGE=true/1 forces the
+ *      installed `claude-bridge` argv prefix and wins over
+ *      `CLAUDE_BINARY`.
+ *   3. Tmux fail-fast — when the resolved binary string contains "shannon"
+ *      or claude-bridge is enabled, createSession throws if `tmux` is not on PATH.
+ *   4. Trust pre-seed — when the resolved binary contains "shannon", the
  *      adapter writes `projects[cwd].hasTrustDialogAccepted: true` to
  *      `$HOME/.claude.json` before spawning. Idempotent. No-op for "claude".
  *
@@ -27,8 +29,10 @@ import { join } from "node:path";
 import {
   ClaudeAdapter,
   parseClaudeBinary,
+  parseClaudeBridgeEnabled,
   preseedClaudeTrustDialog,
   resolveClaudeBinary,
+  resolveClaudeBridgeEnabled,
 } from "../providers/claude-adapter";
 import type { ProviderSessionConfig } from "../providers/types";
 
@@ -150,6 +154,45 @@ describe("resolveClaudeBinary precedence", () => {
   });
 });
 
+describe("SWARM_USE_CLAUDE_BRIDGE boolean parsing", () => {
+  test("true/1 enable claude-bridge", () => {
+    expect(parseClaudeBridgeEnabled("true")).toBe(true);
+    expect(parseClaudeBridgeEnabled("TRUE")).toBe(true);
+    expect(parseClaudeBridgeEnabled(" 1 ")).toBe(true);
+  });
+
+  test("false/0/unset and invalid values are disabled", () => {
+    expect(parseClaudeBridgeEnabled("false")).toBe(false);
+    expect(parseClaudeBridgeEnabled("0")).toBe(false);
+    expect(parseClaudeBridgeEnabled(undefined)).toBe(false);
+    expect(parseClaudeBridgeEnabled("yes")).toBe(false);
+  });
+
+  test("resolvedEnv wins over fallbackEnv", () => {
+    expect(
+      resolveClaudeBridgeEnabled(
+        { SWARM_USE_CLAUDE_BRIDGE: "false" },
+        { SWARM_USE_CLAUDE_BRIDGE: "true" },
+      ),
+    ).toBe(false);
+    expect(
+      resolveClaudeBridgeEnabled(
+        { SWARM_USE_CLAUDE_BRIDGE: "1" },
+        { SWARM_USE_CLAUDE_BRIDGE: "0" },
+      ),
+    ).toBe(true);
+  });
+
+  test("empty resolvedEnv value falls through to fallbackEnv", () => {
+    expect(
+      resolveClaudeBridgeEnabled(
+        { SWARM_USE_CLAUDE_BRIDGE: " " },
+        { SWARM_USE_CLAUDE_BRIDGE: "true" },
+      ),
+    ).toBe(true);
+  });
+});
+
 describe("preseedClaudeTrustDialog", () => {
   let homeDir: string;
 
@@ -241,6 +284,7 @@ describe("preseedClaudeTrustDialog", () => {
 describe("CLAUDE_BINARY env override", () => {
   // Cache the originals and restore after each test so the suite stays clean.
   let originalClaudeBinary: string | undefined;
+  let originalUseClaudeBridge: string | undefined;
   let originalOauthToken: string | undefined;
   let originalHome: string | undefined;
   let homeDir: string;
@@ -250,11 +294,13 @@ describe("CLAUDE_BINARY env override", () => {
 
   beforeEach(async () => {
     originalClaudeBinary = process.env.CLAUDE_BINARY;
+    originalUseClaudeBridge = process.env.SWARM_USE_CLAUDE_BRIDGE;
     originalOauthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
     originalHome = process.env.HOME;
     homeDir = await mkdtemp(join(tmpdir(), "claude-adapter-test-home-"));
     process.env.HOME = homeDir;
     delete process.env.CLAUDE_BINARY;
+    delete process.env.SWARM_USE_CLAUDE_BRIDGE;
     // Credential check runs before binary resolution; satisfy it.
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "test-token";
 
@@ -285,6 +331,11 @@ describe("CLAUDE_BINARY env override", () => {
     } else {
       process.env.CLAUDE_BINARY = originalClaudeBinary;
     }
+    if (originalUseClaudeBridge === undefined) {
+      delete process.env.SWARM_USE_CLAUDE_BRIDGE;
+    } else {
+      process.env.SWARM_USE_CLAUDE_BRIDGE = originalUseClaudeBridge;
+    }
     if (originalOauthToken === undefined) {
       delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
     } else {
@@ -422,10 +473,65 @@ describe("CLAUDE_BINARY env override", () => {
 
     expect(spawnedArgs[0][0]).toBe("shannon");
   });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=true routes through installed claude-bridge", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(makeConfig());
+
+    const argv = spawnedArgs[0];
+    expect(argv[0]).toBe("claude-bridge");
+    expect(argv).toContain("--model");
+    expect(argv).toContain("-p");
+  });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=1 wins over CLAUDE_BINARY=shannon", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "1";
+    process.env.CLAUDE_BINARY = "shannon";
+
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(makeConfig());
+
+    expect(spawnedArgs[0][0]).toBe("claude-bridge");
+  });
+
+  test("config.env SWARM_USE_CLAUDE_BRIDGE=true is reloadable and wins over process.env false", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "false";
+
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(
+      makeConfig({
+        env: {
+          SWARM_USE_CLAUDE_BRIDGE: "true",
+          CLAUDE_CODE_OAUTH_TOKEN: "test-token",
+        } as Record<string, string>,
+      }),
+    );
+
+    expect(spawnedArgs[0][0]).toBe("claude-bridge");
+  });
+
+  test("config.env SWARM_USE_CLAUDE_BRIDGE=false disables process.env true", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(
+      makeConfig({
+        env: {
+          SWARM_USE_CLAUDE_BRIDGE: "false",
+          CLAUDE_CODE_OAUTH_TOKEN: "test-token",
+        } as Record<string, string>,
+      }),
+    );
+
+    expect(spawnedArgs[0][0]).toBe("claude");
+  });
 });
 
 describe("Shannon tmux fail-fast gate", () => {
   let originalClaudeBinary: string | undefined;
+  let originalUseClaudeBridge: string | undefined;
   let originalOauthToken: string | undefined;
   let originalHome: string | undefined;
   let homeDir: string;
@@ -434,11 +540,13 @@ describe("Shannon tmux fail-fast gate", () => {
 
   beforeEach(async () => {
     originalClaudeBinary = process.env.CLAUDE_BINARY;
+    originalUseClaudeBridge = process.env.SWARM_USE_CLAUDE_BRIDGE;
     originalOauthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
     originalHome = process.env.HOME;
     homeDir = await mkdtemp(join(tmpdir(), "claude-adapter-test-home-"));
     process.env.HOME = homeDir;
     delete process.env.CLAUDE_BINARY;
+    delete process.env.SWARM_USE_CLAUDE_BRIDGE;
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "test-token";
     spawnSpy = spyOn(Bun, "spawn").mockImplementation((() => makeFakeProc()) as typeof Bun.spawn);
     whichSpy = spyOn(Bun, "which");
@@ -458,6 +566,11 @@ describe("Shannon tmux fail-fast gate", () => {
     } else {
       process.env.CLAUDE_BINARY = originalClaudeBinary;
     }
+    if (originalUseClaudeBridge === undefined) {
+      delete process.env.SWARM_USE_CLAUDE_BRIDGE;
+    } else {
+      process.env.SWARM_USE_CLAUDE_BRIDGE = originalUseClaudeBridge;
+    }
     if (originalOauthToken === undefined) {
       delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
     } else {
@@ -520,10 +633,22 @@ describe("Shannon tmux fail-fast gate", () => {
     const adapter = new ClaudeAdapter();
     await expect(adapter.createSession(makeConfig())).rejects.toThrow(/tmux/i);
   });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=true triggers the tmux check", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+    whichSpy.mockImplementation((name: string) => {
+      if (name === "tmux") return null;
+      return null;
+    });
+
+    const adapter = new ClaudeAdapter();
+    await expect(adapter.createSession(makeConfig())).rejects.toThrow(/SWARM_USE_CLAUDE_BRIDGE/);
+  });
 });
 
 describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
   let originalClaudeBinary: string | undefined;
+  let originalUseClaudeBridge: string | undefined;
   let originalOauthToken: string | undefined;
   let originalHome: string | undefined;
   let homeDir: string;
@@ -532,11 +657,13 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
 
   beforeEach(async () => {
     originalClaudeBinary = process.env.CLAUDE_BINARY;
+    originalUseClaudeBridge = process.env.SWARM_USE_CLAUDE_BRIDGE;
     originalOauthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
     originalHome = process.env.HOME;
     homeDir = await mkdtemp(join(tmpdir(), "claude-adapter-trust-test-"));
     process.env.HOME = homeDir;
     delete process.env.CLAUDE_BINARY;
+    delete process.env.SWARM_USE_CLAUDE_BRIDGE;
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "test-token";
     spawnSpy = spyOn(Bun, "spawn").mockImplementation((() => makeFakeProc()) as typeof Bun.spawn);
     whichSpy = spyOn(Bun, "which").mockImplementation((name: string) => {
@@ -559,6 +686,11 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
     } else {
       process.env.CLAUDE_BINARY = originalClaudeBinary;
     }
+    if (originalUseClaudeBridge === undefined) {
+      delete process.env.SWARM_USE_CLAUDE_BRIDGE;
+    } else {
+      process.env.SWARM_USE_CLAUDE_BRIDGE = originalUseClaudeBridge;
+    }
     if (originalOauthToken === undefined) {
       delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
     } else {
@@ -625,4 +757,15 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
     const exists = await Bun.file(join(homeDir, ".claude.json")).exists();
     expect(exists).toBe(false);
   });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=true does NOT use the legacy shannon trust pre-seed", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(makeConfig({ cwd: "/some/abs/cwd" }));
+
+    // claude-bridge owns its own pre-clear flow; the adapter should not write
+    // the legacy shannon pre-seed file before spawning.
+    const exists = await Bun.file(join(homeDir, ".claude.json")).exists();
+    expect(exists).toBe(false);
+  });
 });

package/src/tests/db-query.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { DbQueryInputSchema, resolveDbQuerySql } from "../http/db-query";
+
+describe("db-query input compatibility", () => {
+  test("canonical sql input resolves to sql", () => {
+    const parsed = DbQueryInputSchema.parse({ sql: "SELECT 1", params: [] });
+
+    expect(resolveDbQuerySql(parsed)).toBe("SELECT 1");
+  });
+
+  test("legacy query input remains a runtime alias", () => {
+    const parsed = DbQueryInputSchema.parse({ query: "SELECT 2" });
+
+    expect(resolveDbQuerySql(parsed)).toBe("SELECT 2");
+  });
+
+  test("sql takes precedence when both sql and query are present", () => {
+    const parsed = DbQueryInputSchema.parse({ sql: "SELECT 3", query: "SELECT 4" });
+
+    expect(resolveDbQuerySql(parsed)).toBe("SELECT 3");
+  });
+
+  test("rejects input without sql or query", () => {
+    const parsed = DbQueryInputSchema.safeParse({});
+
+    expect(parsed.success).toBe(false);
+  });
+});

package/src/tests/error-tracker.test.ts

@@ -1,8 +1,14 @@
 import { describe, expect, test } from "bun:test";
 import {
+  CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
+  isCodexCreditsExhaustedMessage,
+  isRateLimitMessage,
+  MAX_RATE_LIMIT_RESET_MS,
+  MIN_CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
   parseCodexRateLimitResetTime,
   parseRateLimitResetTime,
   parseStderrForErrors,
+  resolveCodexCreditsExhaustedCooldownMs,
   SessionErrorTracker,
   trackErrorFromJson,
 } from "../utils/error-tracker";
@@ -567,6 +573,121 @@ describe("parseRateLimitResetTime", () => {
   });
 });
 
+describe("isCodexCreditsExhaustedMessage", () => {
+  const CANONICAL =
+    "Your workspace is out of credits. Ask your workspace owner to refill in order to continue.";
+
+  test("returns true for the canonical credits-exhausted message", () => {
+    expect(isCodexCreditsExhaustedMessage(CANONICAL)).toBe(true);
+  });
+
+  test("matches 'out of credits' fragment", () => {
+    expect(isCodexCreditsExhaustedMessage("Your workspace is out of credits.")).toBe(true);
+  });
+
+  test("matches 'refill in order to continue' fragment", () => {
+    expect(isCodexCreditsExhaustedMessage("Please refill in order to continue.")).toBe(true);
+  });
+
+  test("matches 'workspace owner to refill' fragment", () => {
+    expect(isCodexCreditsExhaustedMessage("Ask your workspace owner to refill credits.")).toBe(
+      true,
+    );
+  });
+
+  test("is case-insensitive", () => {
+    expect(isCodexCreditsExhaustedMessage("OUT OF CREDITS")).toBe(true);
+  });
+
+  test("returns false for unrelated errors", () => {
+    expect(isCodexCreditsExhaustedMessage("No conversation found with session ID abc123")).toBe(
+      false,
+    );
+    expect(isCodexCreditsExhaustedMessage("Authentication failed")).toBe(false);
+    expect(isCodexCreditsExhaustedMessage("Rate limit exceeded")).toBe(false);
+    expect(isCodexCreditsExhaustedMessage("Connection timeout")).toBe(false);
+  });
+
+  test("returns false for bare 'refill' without qualifying context", () => {
+    expect(isCodexCreditsExhaustedMessage("Please refill your coffee")).toBe(false);
+  });
+});
+
+describe("isRateLimitMessage — Codex credits-exhausted integration", () => {
+  const CANONICAL =
+    "Your workspace is out of credits. Ask your workspace owner to refill in order to continue.";
+
+  test("returns true for canonical Codex credits-exhausted message", () => {
+    expect(isRateLimitMessage(CANONICAL)).toBe(true);
+  });
+
+  test("still returns true for standard rate-limit messages", () => {
+    expect(isRateLimitMessage("Rate limit exceeded")).toBe(true);
+    expect(isRateLimitMessage("429 Too Many Requests")).toBe(true);
+    expect(isRateLimitMessage("You've hit your weekly limit")).toBe(true);
+  });
+
+  test("still returns false for unrelated errors", () => {
+    expect(isRateLimitMessage("No conversation found with session ID abc123")).toBe(false);
+    expect(isRateLimitMessage("Authentication failed")).toBe(false);
+    expect(isRateLimitMessage("Server error 500")).toBe(false);
+  });
+});
+
+describe("resolveCodexCreditsExhaustedCooldownMs", () => {
+  test("absent (undefined) → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs(undefined)).toBe(
+      CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
+    );
+  });
+
+  test("null → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs(null)).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("empty string → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("")).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("non-numeric string → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("abc")).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("zero → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("0")).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("negative → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("-5")).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("valid in-range string (30m) → parsed value", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("1800000")).toBe(1_800_000);
+  });
+
+  test("valid in-range number (30m) → parsed value", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs(1_800_000)).toBe(1_800_000);
+  });
+
+  test("below floor → clamped to MIN", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("1000")).toBe(
+      MIN_CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
+    );
+  });
+
+  test("above ceiling (8d) → clamped to MAX", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs(String(8 * 24 * 60 * 60 * 1000))).toBe(
+      MAX_RATE_LIMIT_RESET_MS,
+    );
+  });
+
+  test("partial-numeric strings → default constant (not silently truncated)", () => {
+    for (const bad of ["60000ms", "1.5", "123abc", "1e5"]) {
+      expect(resolveCodexCreditsExhaustedCooldownMs(bad)).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+    }
+  });
+});
+
 describe("Codex/Claude coexistence — single tracker handles both providers", () => {
   test("processRateLimitEvent (Claude) and processCodexUsageLimitMessage (Codex) both stash into getRateLimitResetAt", () => {
     // Claude path: processRateLimitEvent

package/src/tests/harness-provider-resolution.test.ts

@@ -138,6 +138,39 @@ describe("validateConfigValue", () => {
     expect(validateConfigValue("HARNESS_PROVIDER", 42)).not.toBeNull();
     expect(validateConfigValue("HARNESS_PROVIDER", null)).not.toBeNull();
   });
+
+  test("accepts a valid CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", () => {
+    expect(validateConfigValue("CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", "7200000")).toBeNull();
+    expect(validateConfigValue("CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", "1800000")).toBeNull();
+    // case-insensitive key lookup
+    expect(validateConfigValue("codex_credits_exhausted_cooldown_ms", "60000")).toBeNull();
+  });
+
+  test("rejects non-positive / non-numeric CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", () => {
+    for (const bad of ["abc", "0", "-5", ""]) {
+      const err = validateConfigValue("CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", bad);
+      expect(err).not.toBeNull();
+      expect(err).toMatch(/CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS/);
+    }
+  });
+
+  test("rejects partial-numeric CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS values", () => {
+    for (const bad of ["60000ms", "1.5", "123abc", "1e5", " 60000 ms"]) {
+      const err = validateConfigValue("CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", bad);
+      expect(err).not.toBeNull();
+      expect(err).toMatch(/CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS/);
+    }
+  });
+
+  test("accepts only boolean-like SWARM_USE_CLAUDE_BRIDGE values", () => {
+    for (const value of ["true", "false", "1", "0", " TRUE "]) {
+      expect(validateConfigValue("SWARM_USE_CLAUDE_BRIDGE", value)).toBeNull();
+    }
+    expect(validateConfigValue("SWARM_USE_CLAUDE_BRIDGE", "yes")).toMatch(
+      /SWARM_USE_CLAUDE_BRIDGE/,
+    );
+    expect(validateConfigValue("SWARM_USE_CLAUDE_BRIDGE", true)).toMatch(/SWARM_USE_CLAUDE_BRIDGE/);
+  });
 });
 
 // ─── getResolvedConfig — scope precedence for HARNESS_PROVIDER ───────────────

package/src/tests/mcp-tools.test.ts

@@ -55,6 +55,12 @@ describe("script MCP tools", () => {
         "Remove a swarm-shared script from the catalog. Versions table preserves history.",
       "script-query-types":
         "Fetch the signature + the auto-generated `swarm-sdk.d.ts` (derived from the live MCP tool registry) + the `stdlib.d.ts` blobs — for IDE-style introspection before authoring or running a script. The same types are used by `script-upsert`'s typecheck pass, so they are authoritative.",
+      "launch-script-run":
+        "Launch a durable one-off script workflow run. The run executes in the background and can be inspected with get-script-run for terminal status and journal entries.",
+      "get-script-run":
+        "Get a durable script workflow run by ID, including its journal entries for swarm-script, raw-llm, and agent-task steps.",
+      "list-script-runs":
+        "List durable script workflow runs, optionally filtered by status or agent ID.",
     };
 
     for (const [name, description] of Object.entries(expected)) {

package/src/tests/prompt-template-session.test.ts

@@ -54,7 +54,7 @@ describe("Session templates — registration", () => {
     await ensureTemplatesRegistered();
   });
 
-  test("all 14 system templates are registered", () => {
+  test("all 15 system templates are registered", () => {
     const systemTemplates = [
       "system.agent.role",
       "system.agent.register",
@@ -66,6 +66,7 @@ describe("Session templates — registration", () => {
       "system.agent.agent_fs",
       "system.agent.self_awareness",
       "system.agent.context_mode",
+      "system.agent.seed_scripts",
 
       "system.agent.system",
       "system.agent.services",
@@ -90,12 +91,12 @@ describe("Session templates — registration", () => {
     }
   });
 
-  test("total of 20 session/system templates registered", () => {
+  test("total of 21 session/system templates registered", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    // 20 = the original 19 + `system.session.worker.pi` (a pi-specific worker
-    // composite that omits the context_mode block — see session-templates.ts).
-    expect(sessionSystem.length).toBe(20);
+    // 21 = the original 19 + `system.session.worker.pi` + `system.agent.seed_scripts`.
+    // The pi composite omits script nudges because pi workers do not have MCP.
+    expect(sessionSystem.length).toBe(21);
   });
 });
 
@@ -187,6 +188,15 @@ describe("Session templates — individual resolution", () => {
     expect(result.text).toContain("batch_execute");
   });
 
+  test("system.agent.seed_scripts points agents at task-start scripts", () => {
+    const result = resolveTemplate("system.agent.seed_scripts", {});
+    expect(result.text).toContain("Pre-built Seed Scripts");
+    expect(result.text).toContain("task-context-gathering");
+    expect(result.text).toContain("smart-recall");
+    expect(result.text).toContain("script-search");
+    expect(result.text).not.toContain("compound-insights");
+  });
+
   // system.agent.guidelines was removed — its content was redundant with worker/lead templates
 
   test("system.agent.system contains package info", () => {
@@ -240,6 +250,7 @@ describe("Session templates — composite resolution", () => {
 
     // Contains context_mode
     expect(result.text).toContain("Context Window Management");
+    expect(result.text).toContain("Pre-built Seed Scripts");
 
     // Guidelines template was removed (redundant with lead/worker templates)
 
@@ -275,6 +286,7 @@ describe("Session templates — composite resolution", () => {
 
     // Contains context_mode
     expect(result.text).toContain("Context Window Management");
+    expect(result.text).toContain("Pre-built Seed Scripts");
 
     // Guidelines template was removed (redundant with lead/worker templates)
 
@@ -309,6 +321,8 @@ describe("Session templates — composite resolution", () => {
     expect(workerResult.text).toContain("join-swarm");
     expect(leadResult.text).toContain("How You Are Built");
     expect(workerResult.text).toContain("How You Are Built");
+    expect(leadResult.text).toContain("Pre-built Seed Scripts");
+    expect(workerResult.text).toContain("Pre-built Seed Scripts");
 
     // Lead has lead content, not worker
     expect(leadResult.text).toContain("CRITICAL: You are a coordinator");
@@ -343,6 +357,7 @@ describe("Session templates — getBasePrompt integration", () => {
     expect(result).toContain("join-swarm");
     expect(result).toContain("store-progress");
     expect(result).toContain("How You Are Built");
+    expect(result).toContain("Pre-built Seed Scripts");
     expect(result).toContain("System packages available");
 
     // Conditional sections (services included by default)
@@ -365,8 +380,22 @@ describe("Session templates — getBasePrompt integration", () => {
     expect(result).toContain("your role is: lead");
     expect(result).toContain("integration-test-lead");
     expect(result).toContain("CRITICAL: You are a coordinator");
+    expect(result).toContain("Pre-built Seed Scripts");
 
     // Should NOT have worker content
     expect(result).not.toContain("task-action");
   });
+
+  test("getBasePrompt excludes seed_scripts for pi worker", async () => {
+    const { getBasePrompt } = await import("../prompts/base-prompt");
+    const result = await getBasePrompt({
+      role: "worker",
+      agentId: "integration-test-pi",
+      swarmUrl: "swarm.test.com",
+      provider: "pi",
+    });
+
+    expect(result).not.toContain("Pre-built Seed Scripts");
+    expect(result).not.toContain("task-context-gathering");
+  });
 });