@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/tests/slack-render-v2.test.ts

@@ -6,6 +6,7 @@ import {
   completeTask,
   createAgent,
   createLogEntry,
+  createScheduledTask,
   createTaskExtended,
   ensureSlackDelegationActivation,
   ensureSlackRenderV2Activation,
@@ -19,12 +20,14 @@ import {
   getSlackTreeMessages,
   getTaskById,
   initDb,
+  insertTaskAttachment,
   isPendingSlackMessage,
   markTaskSlackReplySent,
   startTask,
   supersedeTask,
   upsertSwarmConfig,
 } from "../be/db";
+import { createStandaloneScheduleTask } from "../scheduler/schedule-task";
 import { getTaskLink, MAX_SECTION_LENGTH } from "../slack/blocks";
 import {
   _resetSlackRenderV2ForTests,
@@ -39,7 +42,7 @@ import {
 } from "../slack/render-v2";
 import { getAgentDisplayName, getAgentEmoji } from "../slack/responses";
 import { slackContextKey } from "../tasks/context-key";
-import type { AgentTask } from "../types";
+import type { AgentTask, TaskAttachment } from "../types";
 import { clearVolatileSecretsForTesting } from "../utils/secret-scrubber";
 
 const TEST_DB_PATH = "./test-slack-render-v2.sqlite";
@@ -299,12 +302,83 @@ describe("Slack renderer v2", () => {
     });
   });
 
-  test("defaults off and accepts an explicit opt-in", () => {
+  for (const delegationEnabled of [false, true]) {
+    test(`relays a deferred schedule continuation with delegation=${delegationEnabled}`, async () => {
+      process.env.SLACK_RENDER_V2_DELEGATION = String(delegationEnabled);
+      if (delegationEnabled) await ensureSlackDelegationActivation();
+      const lead = await createAgent({ name: "Continuation Lead", isLead: true, status: "idle" });
+      const { channelId, threadTs } = uniqueSlackAddress("C_CONTINUATION");
+      const ask = await createTaskExtended("answer when ready", {
+        agentId: lead.id,
+        source: "slack",
+        slackChannelId: channelId,
+        slackThreadTs: threadTs,
+        contextKey: slackContextKey({ channelId, threadTs }),
+      });
+      await startTask(ask.id);
+      await completeTask(ask.id, "Waiting for the result.", { addTags: ["deferred"] });
+      await backdateLastUpdated([ask.id], 20);
+      await processSlackRenderV2();
+      expect((await getSlackOutcomeMessage(ask.id))?.finalizedAt).toBeTruthy();
+
+      const schedule = await createScheduledTask({
+        name: "deferred-answer",
+        scheduleType: "one_time",
+        taskTemplate: "Deliver the result",
+        taskType: "deferred",
+        tags: ["deferred"],
+        parentTaskId: ask.id,
+        targetAgentId: lead.id,
+        createdByAgentId: lead.id,
+        nextRunAt: new Date().toISOString(),
+      });
+      const continuation = await createStandaloneScheduleTask(schedule);
+      expect(continuation.source).toBe("schedule");
+      expect(continuation.scheduleId).toBe(schedule.id);
+      expect(continuation.slackChannelId).toBe(channelId);
+      expect(continuation.slackThreadTs).toBe(threadTs);
+      await startTask(continuation.id);
+      await processSlackRenderV2();
+      expect(await getSlackOutcomeMessage(continuation.id)).toBeNull();
+      await completeTask(continuation.id, "Here is the complete answer.");
+      calls.length = 0;
+
+      await processSlackRenderV2();
+      await processSlackRenderV2();
+
+      expect((await getSlackOutcomeMessage(continuation.id))?.finalizedAt).toBeTruthy();
+      const streams = calls.filter((call) => call.method === "chat.startStream");
+      expect(streams).toHaveLength(1);
+      expect(streams[0]?.payload).toMatchObject({
+        channel: channelId,
+        thread_ts: threadTs,
+        markdown_text: "✅\n\nHere is the complete answer.",
+      });
+    });
+  }
+
+  test("does not relay an ordinary scheduled task without Slack context", async () => {
+    const schedule = await createScheduledTask({
+      name: "ordinary-maintenance",
+      scheduleType: "one_time",
+      taskTemplate: "Run maintenance",
+      taskType: "maintenance",
+      nextRunAt: new Date().toISOString(),
+    });
+    const task = await createStandaloneScheduleTask(schedule);
+    await startTask(task.id);
+    await completeTask(task.id, "Maintenance completed.");
+    await processSlackRenderV2();
+    expect(await getSlackOutcomeMessage(task.id)).toBeNull();
+    expect(calls).toHaveLength(0);
+  });
+
+  test("defaults on and accepts an explicit opt-out", () => {
     const previous = process.env.SLACK_RENDER_V2;
     delete process.env.SLACK_RENDER_V2;
-    expect(isSlackRenderV2Enabled()).toBe(false);
-    process.env.SLACK_RENDER_V2 = "true";
     expect(isSlackRenderV2Enabled()).toBe(true);
+    process.env.SLACK_RENDER_V2 = "false";
+    expect(isSlackRenderV2Enabled()).toBe(false);
     if (previous === undefined) delete process.env.SLACK_RENDER_V2;
     else process.env.SLACK_RENDER_V2 = previous;
   });
@@ -1183,6 +1257,95 @@ describe("Slack renderer v2", () => {
     expect(calls.some((call) => call.method === "chat.appendStream")).toBe(false);
   });
 
+  test.each<{
+    label: string;
+    attachment: Partial<TaskAttachment> & Pick<TaskAttachment, "kind" | "name">;
+    expected: string;
+  }>([
+    {
+      label: "plain ASCII positive control",
+      attachment: { kind: "agent-fs", name: "report.txt", path: "/reports/report.txt" },
+      expected:
+        "📎 [report.txt](https://files.example.test/file/~/org-1/drive-1/reports/report.txt)",
+    },
+    {
+      label: "raw path spaces and parentheses",
+      attachment: { kind: "agent-fs", name: "final report", path: "/shared reports/final (v1).md" },
+      expected:
+        "📎 [final report](https://files.example.test/file/~/org-1/drive-1/shared%20reports/final%20%28v1%29.md)",
+    },
+    {
+      label: "already encoded positive control",
+      attachment: { kind: "agent-fs", name: "report", path: "/reports/final%20%28v1%29.md" },
+      expected:
+        "📎 [report](https://files.example.test/file/~/org-1/drive-1/reports/final%20%28v1%29.md)",
+    },
+    {
+      label: "label delimiters, backslashes, and whitespace",
+      attachment: {
+        kind: "url",
+        name: " \t[report] (final)\\\r\n\t copy  ",
+        url: "https://example.test/report",
+      },
+      expected: "📎 [\\[report\\] \\(final\\)\\\\ copy](https://example.test/report)",
+    },
+    {
+      label: "URL positive control with an IPv6 host",
+      attachment: { kind: "url", name: "report", url: "http://[::1]/report.txt?q=a%20b&x=1#part" },
+      expected: "📎 [report](http://[::1]/report.txt?q=a%20b&x=1#part)",
+    },
+    {
+      label: "URL delimiters with existing escapes and query parameters",
+      attachment: {
+        kind: "url",
+        name: "report",
+        url: "https://example.test/a%20b) [c]<(d)>\\file?q=one two&x=1#part",
+      },
+      expected:
+        "📎 [report](https://example.test/a%20b%29%20[c]%3C%28d%29%3E%5Cfile?q=one%20two&x=1#part)",
+    },
+    {
+      label: "non-HTTP fallback stays omitted",
+      attachment: { kind: "url", name: "report", url: "agent-fs:/reports/report.md" },
+      expected: "",
+    },
+  ])("streams safe attachment Markdown: $label", async ({ attachment, expected }) => {
+    const originalHost = process.env.AGENT_FS_LIVE_URL;
+    process.env.AGENT_FS_LIVE_URL = "https://files.example.test";
+    try {
+      const lead = await createAgent({ name: "Attachment Lead", isLead: true, status: "idle" });
+      const { channelId, threadTs } = uniqueSlackAddress("C_OUTCOME_ATTACHMENT");
+      const ask = await createTaskExtended("render attachment link", {
+        agentId: lead.id,
+        source: "slack",
+        slackChannelId: channelId,
+        slackThreadTs: threadTs,
+        contextKey: slackContextKey({ channelId, threadTs }),
+      });
+      await insertTaskAttachment({
+        ...attachment,
+        taskId: ask.id,
+        agentId: lead.id,
+        orgId: "org-1",
+        driveId: "drive-1",
+        isPrimary: true,
+      });
+      await startTask(ask.id);
+      await ensureSlackThreadTree([ask.id]);
+      await completeTask(ask.id, "Done");
+      calls.length = 0;
+      _resetSlackRenderV2ForTests();
+
+      await processSlackRenderV2();
+
+      const started = calls.find((call) => call.method === "chat.startStream");
+      expect(started?.payload.markdown_text).toBe(`✅\n\nDone${expected ? `\n\n${expected}` : ""}`);
+    } finally {
+      if (originalHost === undefined) delete process.env.AGENT_FS_LIVE_URL;
+      else process.env.AGENT_FS_LIVE_URL = originalHost;
+    }
+  });
+
   test("truncates oversized Markdown before a code fence and links the full task", async () => {
     const lead = await createAgent({ name: "Overflow Lead", isLead: true, status: "idle" });
     const { channelId, threadTs } = uniqueSlackAddress("C_OUTCOME_OVERFLOW");
@@ -1626,6 +1789,35 @@ describe("Slack renderer v2", () => {
     expect(outcome?.finalizedAt).toBeDefined();
   });
 
+  test("keeps a deferral's human-facing line even when the agent already sent a slack-reply", async () => {
+    const lead = await createAgent({ name: "Deferring Lead", isLead: true, status: "idle" });
+    const { channelId, threadTs } = uniqueSlackAddress("C_RENDER_DEFER_AFTER_REPLY");
+    const ask = await createTaskExtended("defer after replying by hand", {
+      agentId: lead.id,
+      source: "slack",
+      slackChannelId: channelId,
+      slackThreadTs: threadTs,
+      contextKey: slackContextKey({ channelId, threadTs }),
+    });
+    await startTask(ask.id);
+    await ensureSlackThreadTree([ask.id]);
+    // Agent posts a hand-written slack-reply first (e.g. a transcription),
+    // then defer-task completes the task with the engine-authored deferral
+    // line and tags it "deferred" (mirrors defer-task.ts's completeTask call).
+    await markTaskSlackReplySent(ask.id);
+    const deferralLine =
+      "Deferred until today 17:30:19 UTC ([715bf847](https://app.agent-swarm.dev/schedules/715bf847-fe3e-40e9-9fef-3297a62d9afd)) -> checking the new defer card";
+    await completeTask(ask.id, deferralLine, { addTags: ["deferred"] });
+    calls.length = 0;
+    _resetSlackRenderV2ForTests();
+
+    await processSlackRenderV2();
+
+    const started = calls.find((call) => call.method === "chat.startStream");
+    expect(started?.payload.markdown_text).toBe(`✅\n\n${deferralLine}`);
+    expect(started?.payload.markdown_text).not.toBe(`✅ ${lead.name} completed`);
+  });
+
   test("refreshes a stream started with stale content before finalizing it", async () => {
     const lead = await createAgent({ name: "Refresh Lead", isLead: true, status: "idle" });
     const { channelId, threadTs } = uniqueSlackAddress("C_RENDER_REFRESH_STALE");

package/src/tests/slack-router.test.ts

@@ -1,7 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlinkSync } from "node:fs";
-import { closeDb, createAgent, createTaskExtended, initDb } from "../be/db";
-import { routeMessage } from "../slack/router";
+import { closeDb, createAgent, createTaskExtended, getAllAgents, initDb } from "../be/db";
+import { broadcastMatches, routeMessage } from "../slack/router";
 import type { Agent } from "../types";
 
 const TEST_DB_PATH = "./test-slack-router.sqlite";
@@ -169,6 +169,21 @@ describe("Slack router — thread follow-up routing", () => {
       // Lead should not be in the matches
       expect(matches.every((m) => !m.agent.isLead)).toBe(true);
     });
+
+    test("swarm#all includes offline non-lead agents", async () => {
+      const offlineWorker = await createAgent({
+        name: "offline-broadcast-worker",
+        isLead: false,
+        status: "offline",
+        capabilities: [],
+      });
+
+      const matches = broadcastMatches(await getAllAgents());
+
+      expect(matches.map((match) => match.agent.id)).toContain(offlineWorker.id);
+      expect(matches.every((match) => !match.agent.isLead)).toBe(true);
+      expect(matches.every((match) => match.matchedText === "swarm#all")).toBe(true);
+    });
   });
 
   describe("no thread context behaves normally", () => {

package/src/tests/slack-steering.test.ts

@@ -105,6 +105,25 @@ describe("Slack thread steering", () => {
     expect(await getChildTasks(leadTask.id)).toHaveLength(1);
   });
 
+  test("unset configuration steers the lead with queued delivery", async () => {
+    delete process.env.SLACK_THREAD_STEERING;
+    delete process.env.SLACK_THREAD_STEERING_MODE;
+    const channelId = "C_DEFAULT_STEER";
+    const threadTs = "1500.0001";
+    const task = await createRunningSlackTask(leadId, channelId, threadTs);
+    const result = await requestSlackThreadSteering({
+      channelId,
+      threadTs,
+      message: "new context",
+    });
+    expect(result).toMatchObject({
+      task: { id: task.id },
+      result: { outcome: "queued", effectiveMode: "queue" },
+    });
+    expect(await getSteeringMessagesForTask(task.id)).toHaveLength(1);
+    expect(await getChildTasks(task.id)).toEqual([]);
+  });
+
   test("lead mode sends one steering message to an in-progress lead and creates no task", async () => {
     process.env.SLACK_THREAD_STEERING = "lead";
     process.env.SLACK_THREAD_STEERING_MODE = "steer";

package/src/tests/status.test.ts

@@ -31,6 +31,7 @@ import {
   updateAgentCredStatus,
 } from "../be/db";
 import { storeOAuthTokens, upsertOAuthApp } from "../be/db-queries/oauth";
+import { resetEmbeddingProvider } from "../be/memory";
 import { validateProviderCredentials } from "../commands/provider-credentials";
 import {
   _resetTestConnectionCache,
@@ -123,6 +124,11 @@ function clearEnv() {
   for (const k of ENV_KEYS_TO_RESET) {
     delete process.env[k];
   }
+  // The embedding provider memoizes its API key at construction (see
+  // OpenAIEmbeddingProvider); reset the singleton so embeddingsMilestone()
+  // (which now reads the live provider, not process.env directly) reflects
+  // whatever this test just set/cleared instead of a stale prior test's key.
+  resetEmbeddingProvider();
 }
 
 function restoreEnv() {
@@ -245,14 +251,20 @@ describe("setup milestones", () => {
       hint: "Memory search is off. Set OPENAI_API_KEY (or EMBEDDING_API_KEY) on the API server to enable it; it is cheap.",
     });
 
-    process.env.OPENAI_API_KEY = "openai-embedding-key";
+    // The provider memoizes its API key at construction; in production a
+    // config reload resets it (see resetEmbeddingProvider in src/http/core.ts).
+    // Mirror that here after each direct env mutation.
+    process.env.OPENAI_API_KEY = "example-openai-embedding-key";
+    resetEmbeddingProvider();
     expect(getMilestone(await buildStatusPayload(), "embeddings").state).toBe("configured");
 
     process.env.EMBEDDING_API_KEY = "";
+    resetEmbeddingProvider();
     expect(getMilestone(await buildStatusPayload(), "embeddings").state).toBe("unverified");
 
-    process.env.EMBEDDING_API_KEY = "dedicated-embedding-key";
+    process.env.EMBEDDING_API_KEY = "example-dedicated-embedding-key";
     delete process.env.OPENAI_API_KEY;
+    resetEmbeddingProvider();
     expect(getMilestone(await buildStatusPayload(), "embeddings").state).toBe("configured");
   });
 
@@ -417,7 +429,7 @@ describe("setup milestones", () => {
     const a = await buildStatusPayload();
     expect(getMilestone(a, "github").state).toBe("unverified");
 
-    process.env.GITHUB_APP_PRIVATE_KEY = "-----BEGIN PRIVATE KEY-----\n...";
+    process.env.GITHUB_APP_PRIVATE_KEY = "[REDACTED:github_app_private_key]";
     const b = await buildStatusPayload();
     expect(getMilestone(b, "github").state).toBe("verified");
   });
@@ -456,7 +468,7 @@ describe("setup milestones", () => {
       scopes: "read",
     });
     await storeOAuthTokens("linear", {
-      accessToken: "lin-tok-xyz",
+      accessToken: "example-lin-tok-xyz",
       refreshToken: "ref",
       expiresAt: new Date(Date.now() + 3600_000).toISOString(),
       scope: "read",
@@ -475,7 +487,7 @@ describe("setup milestones", () => {
       // metadata intentionally omitted on first upsert
     });
     await storeOAuthTokens("jira", {
-      accessToken: "jira-tok",
+      accessToken: "example-jira-tok",
       refreshToken: null,
       expiresAt: new Date(Date.now() + 3600_000).toISOString(),
       scope: null,
@@ -831,7 +843,7 @@ describe("validateProviderCredentials — error scrubbing", () => {
   });
 
   test("devin hits v3/self (not the deprecated v1 endpoint) and passes on 2xx", async () => {
-    process.env.DEVIN_API_KEY = "cog_fake-devin-key-1234";
+    process.env.DEVIN_API_KEY = "example-cog_fake-devin-key-1234";
     let capturedUrl = "";
     globalThis.fetch = (async (url) => {
       capturedUrl = String(url);
@@ -851,7 +863,7 @@ describe("validateProviderCredentials — error scrubbing", () => {
   });
 
   test("scrubs api key from error message on 401 response", async () => {
-    const fakeKey = "sk-ant-fakekey-DO-NOT-LEAK-1234567890abcdef";
+    const fakeKey = "example-anthropic-key-do-not-leak";
     process.env.ANTHROPIC_API_KEY = fakeKey;
     globalThis.fetch = (async () =>
       new Response(`Unauthorized: invalid key ${fakeKey}`, {

package/src/tests/steering-core.test.ts

@@ -413,7 +413,7 @@ describe("task steering core", () => {
 
   test("scrubs secrets before persisting the steering body", async () => {
     const previous = process.env.OPENAI_API_KEY;
-    const secret = "sk-proj-steering-secret-value-1234567890";
+    const secret = "example-steering-secret-value";
     process.env.OPENAI_API_KEY = secret;
     try {
       const task = await runningTask("pi", "secret scrubbing");

package/src/tests/steering-enabled.test.ts

@@ -48,12 +48,11 @@ function restoreEnv(name: string, value: string | undefined): void {
 }
 
 /**
- * Steering is opt-in (disabled unless STEERING_ENABLED=true|1), so "disabled"
- * is simply the default: unset the flag for the duration of the callback.
+ * Exercise an explicit opt-out without depending on the deployment default.
  */
 async function withSteeringDisabled<T>(run: () => Promise<T> | T): Promise<T> {
   const previous = process.env.STEERING_ENABLED;
-  delete process.env.STEERING_ENABLED;
+  process.env.STEERING_ENABLED = "false";
   try {
     return await run();
   } finally {
@@ -116,8 +115,7 @@ async function api(
 const originalSteeringEnabled = process.env.STEERING_ENABLED;
 
 beforeAll(async () => {
-  // The "enabled" halves of these tests opt in explicitly (steering is off by
-  // default); withSteeringDisabled() drops the flag to exercise the default.
+  // Pin both branches explicitly so inherited configuration cannot affect them.
   process.env.STEERING_ENABLED = "true";
   await removeTestDb();
   process.env.DATABASE_PATH = TEST_DB_PATH;
@@ -147,9 +145,9 @@ afterAll(async () => {
   await removeTestDb();
 });
 
-describe("STEERING_ENABLED opt-in", () => {
-  test("steering is disabled by default (flag unset) and on falsy values", () => {
-    expect(isSteeringEnabled({})).toBe(false);
+describe("STEERING_ENABLED defaults and overrides", () => {
+  test("steering defaults on and accepts explicit opt-outs", () => {
+    expect(isSteeringEnabled({})).toBe(true);
     expect(isSteeringEnabled({ STEERING_ENABLED: "false" })).toBe(false);
     expect(isSteeringEnabled({ STEERING_ENABLED: "0" })).toBe(false);
     expect(isSteeringEnabled({ STEERING_ENABLED: "true" })).toBe(true);

package/src/tests/steering-transport.test.ts

@@ -233,7 +233,7 @@ describe("steering worker transport", () => {
 
   test("scrubs provider errors before reporting an undeliverable reason", async () => {
     const pending = pendingMessage();
-    const secret = "sk-proj-steering-transport-secret-1234567890";
+    const secret = `sk-proj-${"steering".repeat(4)}`;
     let reportedBody = "";
     const fetchImpl = (async (input: string | URL | Request, init?: RequestInit) => {
       if (String(input).includes("/api/steering-messages?")) {
@@ -280,7 +280,7 @@ describe("steering worker transport", () => {
     expect(requested.outcome).toBe("queued");
 
     await pollAndDispatchSteering(
-      { apiUrl: baseUrl, apiKey: "test-key", agentId: agent.id },
+      { apiUrl: baseUrl, apiKey: "example-test-key", agentId: agent.id },
       task.id,
       session(),
       createSteeringDispatchState(),
@@ -327,7 +327,7 @@ describe("steering worker transport", () => {
     // undeliverable — but the external-delivery flag short-circuits the poll.
     const codexLikeSession = { ...session(), steeringDeliveredExternally: true };
     await pollAndDispatchSteering(
-      { apiUrl: baseUrl, apiKey: "test-key", agentId: agent.id },
+      { apiUrl: baseUrl, apiKey: "example-test-key", agentId: agent.id },
       task.id,
       codexLikeSession,
       createSteeringDispatchState(),
@@ -343,7 +343,7 @@ describe("steering worker transport", () => {
     const previousBaseUrl = process.env.MCP_BASE_URL;
     const previousApiKey = process.env.AGENT_SWARM_API_KEY;
     process.env.MCP_BASE_URL = baseUrl;
-    process.env.AGENT_SWARM_API_KEY = "test-key";
+    process.env.AGENT_SWARM_API_KEY = "example-test-key";
     try {
       const agent = await createAgent({
         name: "accept steering worker",

package/src/tests/store-progress-output-guidance.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type * as z from "zod";
+import { registerStoreProgressTool } from "../tools/store-progress";
+
+describe("store-progress output guidance", () => {
+  const server = new McpServer({ name: "output-guidance-test", version: "1.0.0" });
+  registerStoreProgressTool(server);
+  const tools = (
+    server as unknown as {
+      _registeredTools: Record<string, { inputSchema: z.ZodObject }>;
+    }
+  )._registeredTools;
+  const outputSchema = tools["store-progress"].inputSchema.shape.output;
+
+  test("the exposed output field carries the same budget and exceptions as the prompts", () => {
+    expect(outputSchema.description).toContain("Keep free-text output under 120 words by default");
+    expect(outputSchema.description).toContain("published verbatim in the thread's outcome card");
+    expect(outputSchema.description).toContain("every artifact link");
+    expect(outputSchema.description).toContain("Link documents instead of inlining them");
+    expect(outputSchema.description).toContain(
+      "requested depth, enumerated results, essential evidence",
+    );
+    expect(outputSchema.description).toContain("the task's outputSchema requires longer output");
+    expect(outputSchema.description).toContain("output must be JSON matching it");
+  });
+
+  test("the style target does not reject longer requested or schema-constrained output", () => {
+    const longResult = "Required result. ".repeat(150);
+    for (const output of [longResult, JSON.stringify({ results: [longResult] })]) {
+      expect(outputSchema.parse(output)).toBe(output);
+    }
+  });
+});

package/src/tests/swarm-tool-result-gate.test.ts

@@ -111,38 +111,38 @@ describe("finalizeSwarmToolResult", () => {
   });
 
   test("secrets are scrubbed from message, details, and data at the egress point", async () => {
-    registerVolatileSecret("sk-super-secret-token-123", "TEST_TOKEN");
+    registerVolatileSecret("example-sk-super-secret-token-123", "TEST_TOKEN");
     try {
       const result = await finalizeSwarmToolResult("some-tool", {
         ok: false,
-        message: "Auth failed with sk-super-secret-token-123",
-        details: "header was sk-super-secret-token-123",
-        data: { token: "sk-super-secret-token-123" },
+        message: "Auth failed with example-sk-super-secret-token-123",
+        details: "header was example-sk-super-secret-token-123",
+        data: { token: "example-sk-super-secret-token-123" },
       });
       const serialized = JSON.stringify(result);
-      expect(serialized).not.toContain("sk-super-secret-token-123");
+      expect(serialized).not.toContain("example-sk-super-secret-token-123");
     } finally {
       clearVolatileSecretsForTesting();
     }
   });
 
   test("allowSecretEgress skips scrubbing for deliberate credential reveals only", async () => {
-    registerVolatileSecret("xsk_reveal_me_once_456", "TEST_REVEAL");
+    registerVolatileSecret("example-xsk_reveal_me_once_456", "TEST_REVEAL");
     try {
       const revealed = await finalizeSwarmToolResult("script-apis", {
         ok: true,
         message: "Endpoint created.",
-        details: "Bearer token (shown once — save it now): xsk_reveal_me_once_456",
-        data: { token: "xsk_reveal_me_once_456" },
+        details: "Bearer token (shown once — save it now): example-xsk_reveal_me_once_456",
+        data: { token: "example-xsk_reveal_me_once_456" },
         allowSecretEgress: true,
       });
-      expect(JSON.stringify(revealed)).toContain("xsk_reveal_me_once_456");
+      expect(JSON.stringify(revealed)).toContain("example-xsk_reveal_me_once_456");
 
       const scrubbed = await finalizeSwarmToolResult("some-tool", {
         ok: true,
-        message: "leaky xsk_reveal_me_once_456",
+        message: "leaky example-xsk_reveal_me_once_456",
       });
-      expect(JSON.stringify(scrubbed)).not.toContain("xsk_reveal_me_once_456");
+      expect(JSON.stringify(scrubbed)).not.toContain("example-xsk_reveal_me_once_456");
     } finally {
       clearVolatileSecretsForTesting();
     }

package/src/tests/swarm-x-tool.test.ts

@@ -36,12 +36,14 @@ afterEach(() => {
 
 describe("swarm_x MCP tool", () => {
   test("routes composio requests with server-side auth and scrubbed output", async () => {
-    process.env.COMPOSIO_API_KEY = "ck_tool_secret_value";
+    process.env.COMPOSIO_API_KEY = "example-ck_tool_secret_value";
     const fetchMock = mock(async (url: string | URL | Request, init?: RequestInit) => {
       expect(String(url)).toBe("https://backend.composio.dev/api/v3.1/tools?limit=1");
       expect(init?.method).toBe("GET");
-      expect((init?.headers as Record<string, string>)["x-api-key"]).toBe("ck_tool_secret_value");
-      return jsonResponse({ ok: true, token: "ck_tool_secret_value" });
+      expect((init?.headers as Record<string, string>)["x-api-key"]).toBe(
+        "example-ck_tool_secret_value",
+      );
+      return jsonResponse({ ok: true, token: "example-ck_tool_secret_value" });
     });
     globalThis.fetch = fetchMock;
 
@@ -65,11 +67,11 @@ describe("swarm_x MCP tool", () => {
     expect(JSON.stringify(result.structuredContent.response)).toContain(
       "[REDACTED:COMPOSIO_API_KEY]",
     );
-    expect(result.structuredContent.responseText).not.toContain("ck_tool_secret_value");
+    expect(result.structuredContent.responseText).not.toContain("example-ck_tool_secret_value");
   });
 
   test("rejects absolute composio paths", async () => {
-    process.env.COMPOSIO_API_KEY = "ck_tool_secret_value";
+    process.env.COMPOSIO_API_KEY = "example-ck_tool_secret_value";
     const fetchMock = mock(async () => jsonResponse({ ok: true }));
     globalThis.fetch = fetchMock;
 

package/src/tests/sync-ai-toolbox-skills.test.ts

@@ -10,6 +10,7 @@ import {
   type Manifest,
   type PathRewrite,
   parseSkillMd,
+  rewriteBundledFileComments,
   rewriteSkillReferences,
   sanitizeSyncedVia,
   stableJson,
@@ -215,6 +216,24 @@ describe("ai-toolbox skill sync pure transforms", () => {
     ).toThrow("exceed 10485760 bytes total");
   });
 
+  test("clarifies only the Codex helper comment and preserves executable sandbox settings", () => {
+    const comment =
+      "#   CODEX_SANDBOX default: workspace-write      read-only | workspace-write | danger-full-access";
+    const executable = `SANDBOX="\${CODEX_SANDBOX:-workspace-write}"\nargs+=( --dangerously-bypass-approvals-and-sandbox )\n`;
+    const source = `${comment}\n${executable}`;
+    expect(rewriteBundledFileComments("delegate-work", "scripts/codex-exec.sh", source)).toBe(
+      `#   CODEX_SANDBOX default: workspace-write (passed to codex's -s option)\n${executable}`,
+    );
+    expect(rewriteBundledFileComments("other", "scripts/codex-exec.sh", source)).toBe(source);
+    expect(rewriteBundledFileComments("delegate-work", "scripts/other.sh", source)).toBe(source);
+    expect(() =>
+      rewriteBundledFileComments("delegate-work", "scripts/codex-exec.sh", executable),
+    ).toThrow("expected one upstream sandbox default comment");
+    expect(() =>
+      rewriteBundledFileComments("delegate-work", "scripts/codex-exec.sh", `${comment}\n${source}`),
+    ).toThrow("expected one upstream sandbox default comment");
+  });
+
   test("reports executable text downgrades and rejects binary files", () => {
     const executable = validateBundledFileBytes(
       "fixture",

package/src/tests/task-supersede-resume.test.ts

@@ -645,7 +645,7 @@ describe("Task Supersede + Resume", () => {
     test("scrubs secret-shaped values from session-log summaries", async () => {
       // GitHub PAT-shaped token — matches a structural pattern in
       // scrubSecrets (regardless of env state).
-      const fakeToken = "ghp_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+      const fakeToken = `ghp_${"a".repeat(36)}`;
       mockSessionLogs = [
         {
           createdAt: new Date().toISOString(),

package/src/tests/task-tool-preload-mcp.test.ts

@@ -73,11 +73,14 @@ async function pins(client: Client): Promise<string[]> {
     .sort();
 }
 
-test("wire response is default-off, per-task, additive, and fixed for one MCP session", async () => {
+test("wire response is default-on, per-task, additive, and fixed for one MCP session", async () => {
   const task = await createTaskExtended("review fixture", { agentId, taskType: "review" });
   const other = await createTaskExtended("other fixture", { agentId, taskType: "other" });
   const foreign = await createTaskExtended("unowned", { taskType: "review" });
   await configure("TASK_TOOL_MANIFESTS", '{"taskTypes":{"review":["script-run","get-tasks"]}}');
+  const defaultOn = await connect(task.id);
+  expect(await pins(defaultOn)).toEqual(["get-tasks", "script-run"]);
+  await configure("TASK_TOOL_PRELOAD_ENABLED", "false");
   const off = await connect(task.id);
   const baseline = (await off.listTools()).tools;
   expect(baseline.some((tool) => tool.name === "script-run")).toBe(true);