@desplega.ai/agent-swarm 1.94.0 → 1.96.0

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

@@ -171,6 +171,29 @@ describe("validateConfigValue", () => {
     );
     expect(validateConfigValue("SWARM_USE_CLAUDE_BRIDGE", true)).toMatch(/SWARM_USE_CLAUDE_BRIDGE/);
   });
+
+  test("accepts valid BEDROCK_AUTH_MODE values: sdk, bearer", () => {
+    expect(validateConfigValue("BEDROCK_AUTH_MODE", "sdk")).toBeNull();
+    expect(validateConfigValue("BEDROCK_AUTH_MODE", "bearer")).toBeNull();
+    // key lookup is case-insensitive
+    expect(validateConfigValue("bedrock_auth_mode", "sdk")).toBeNull();
+  });
+
+  test("rejects invalid BEDROCK_AUTH_MODE values with a helpful error", () => {
+    const badValues = ["Sdk", "SDK", "BEARER", "iam", "sso", "basic", "", " sdk"];
+    for (const bad of badValues) {
+      const err = validateConfigValue("BEDROCK_AUTH_MODE", bad);
+      expect(err).not.toBeNull();
+      expect(err).toMatch(/BEDROCK_AUTH_MODE/);
+      expect(err).toMatch(/sdk/);
+      expect(err).toMatch(/bearer/);
+    }
+  });
+
+  test("BEDROCK_AUTH_MODE is optional — absent key is not validated (returns null)", () => {
+    // Undefined / unset key → no validator → null (no error)
+    expect(validateConfigValue("OTHER_KEY", "sdk")).toBeNull();
+  });
 });
 
 // ─── getResolvedConfig — scope precedence for HARNESS_PROVIDER ───────────────

package/src/tests/mcp-oauth-queries.test.ts

@@ -1,6 +1,13 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, createMcpServer, createUser, initDb } from "../be/db";
+import {
+  closeDb,
+  createMcpServer,
+  createUser,
+  getMcpServerById,
+  initDb,
+  updateMcpServer,
+} from "../be/db";
 import {
   consumeMcpOAuthPending,
   deleteMcpOAuthToken,
@@ -221,6 +228,69 @@ describe("mcp_oauth_pending (state PK)", () => {
   });
 });
 
+describe("mcp_servers.extraAuthorizeParams round-trip", () => {
+  test("createMcpServer persists extraAuthorizeParams", () => {
+    const server = createMcpServer({
+      name: "bigquery-mcp",
+      transport: "http",
+      url: "https://bigquery.googleapis.com/",
+      scope: "swarm",
+      extraAuthorizeParams: '{"access_type":"offline","prompt":"consent"}',
+    });
+    expect(server.extraAuthorizeParams).toBe('{"access_type":"offline","prompt":"consent"}');
+
+    const fetched = getMcpServerById(server.id);
+    expect(fetched).not.toBeNull();
+    expect(fetched!.extraAuthorizeParams).toBe('{"access_type":"offline","prompt":"consent"}');
+  });
+
+  test("createMcpServer with no extraAuthorizeParams defaults to null", () => {
+    const server = createMcpServer({
+      name: "hubspot-mcp",
+      transport: "http",
+      url: "https://api.hubspot.com/",
+      scope: "swarm",
+    });
+    expect(server.extraAuthorizeParams).toBeNull();
+  });
+
+  test("updateMcpServer persists extraAuthorizeParams and bumps version", () => {
+    const server = createMcpServer({
+      name: "gdrive-mcp",
+      transport: "http",
+      url: "https://www.googleapis.com/drive/v3/",
+      scope: "swarm",
+    });
+    const versionBefore = server.version;
+
+    const updated = updateMcpServer(server.id, {
+      extraAuthorizeParams: '{"access_type":"offline","prompt":"consent"}',
+    });
+    expect(updated).not.toBeNull();
+    expect(updated!.extraAuthorizeParams).toBe('{"access_type":"offline","prompt":"consent"}');
+    expect(updated!.version).toBe(versionBefore + 1);
+  });
+
+  test("updateMcpServer can clear extraAuthorizeParams to null without bumping version twice", () => {
+    const server = createMcpServer({
+      name: "sheets-mcp",
+      transport: "http",
+      url: "https://sheets.googleapis.com/",
+      scope: "swarm",
+      extraAuthorizeParams: '{"access_type":"offline"}',
+    });
+
+    const cleared = updateMcpServer(server.id, { extraAuthorizeParams: undefined });
+    // No extraAuthorizeParams key → no version bump, field untouched
+    expect(cleared!.extraAuthorizeParams).toBe('{"access_type":"offline"}');
+    expect(cleared!.version).toBe(server.version);
+
+    const nulled = updateMcpServer(server.id, { extraAuthorizeParams: null as unknown as string });
+    expect(nulled!.extraAuthorizeParams).toBeNull();
+    expect(nulled!.version).toBe(server.version + 1);
+  });
+});
+
 describe("mcp_servers.authMethod accessor", () => {
   test("default is 'static' for newly created servers", () => {
     const server = makeServer("mcp-auth-default");

package/src/tests/mcp-oauth-wrapper.test.ts

@@ -137,6 +137,115 @@ describe("buildAuthorizeUrl (PKCE S256, RFC 8707)", () => {
     });
     expect(new URL(result.url).searchParams.has("scope")).toBe(false);
   });
+
+  test("extraParams are appended to the authorize URL (e.g. BigQuery offline access)", async () => {
+    const result = await buildAuthorizeUrl({
+      authorizeUrl: "https://as.example.com/authorize",
+      tokenUrl: "https://as.example.com/token",
+      clientId: "bq-client",
+      redirectUri: "https://swarm.example.com/callback",
+      scopes: ["https://www.googleapis.com/auth/bigquery"],
+      resource: "https://bigquery.googleapis.com/",
+      extraParams: { access_type: "offline", prompt: "consent" },
+    });
+
+    const u = new URL(result.url);
+    expect(u.searchParams.get("access_type")).toBe("offline");
+    expect(u.searchParams.get("prompt")).toBe("consent");
+  });
+
+  test("extraParams cannot override reserved OAuth params (redirect_uri, state, etc.)", async () => {
+    const result = await buildAuthorizeUrl({
+      authorizeUrl: "https://as.example.com/authorize",
+      tokenUrl: "https://as.example.com/token",
+      clientId: "c",
+      redirectUri: "https://swarm.example.com/cb",
+      scopes: ["read"],
+      resource: "https://mcp.example.com/",
+      state: "safe-state",
+      extraParams: {
+        redirect_uri: "https://evil.com",
+        state: "injected",
+        code_challenge: "malicious",
+        code_challenge_method: "plain",
+        response_type: "token",
+        client_id: "attacker",
+        scope: "admin",
+        resource: "https://evil.com/",
+      },
+    });
+    const u = new URL(result.url);
+    expect(u.searchParams.get("redirect_uri")).toBe("https://swarm.example.com/cb");
+    expect(u.searchParams.get("state")).toBe("safe-state");
+    expect(u.searchParams.get("code_challenge_method")).toBe("S256");
+    expect(u.searchParams.get("response_type")).toBe("code");
+    expect(u.searchParams.get("client_id")).toBe("c");
+    expect(u.searchParams.get("resource")).toBe("https://mcp.example.com/");
+    // Attacker values must not have landed
+    const challenge = u.searchParams.get("code_challenge");
+    expect(challenge).not.toBeNull();
+    expect(challenge).not.toBe("malicious");
+    expect(u.searchParams.get("scope")).toBe("read");
+  });
+
+  test("mixed-case reserved keys in extraParams are rejected (case-insensitive guard)", async () => {
+    const result = await buildAuthorizeUrl({
+      authorizeUrl: "https://as.example.com/authorize",
+      tokenUrl: "https://as.example.com/token",
+      clientId: "c",
+      redirectUri: "https://swarm.example.com/cb",
+      scopes: ["read"],
+      resource: "https://mcp.example.com/",
+      state: "safe-state",
+      extraParams: {
+        Redirect_Uri: "https://evil.example",
+        STATE: "evil-state",
+        Code_Challenge: "malicious-challenge",
+        SCOPE: "admin",
+      },
+    });
+    const u = new URL(result.url);
+    // Attacker mixed-case keys must NOT appear in the URL
+    expect(u.searchParams.get("Redirect_Uri")).toBeNull();
+    expect(u.searchParams.get("STATE")).toBeNull();
+    expect(u.searchParams.get("Code_Challenge")).toBeNull();
+    expect(u.searchParams.get("SCOPE")).toBeNull();
+    // Core params must retain their original legitimate values
+    expect(u.searchParams.get("redirect_uri")).toBe("https://swarm.example.com/cb");
+    expect(u.searchParams.get("state")).toBe("safe-state");
+    expect(u.searchParams.get("scope")).toBe("read");
+  });
+
+  test("null/undefined extraParams leaves URL unchanged (no blast radius for existing servers)", async () => {
+    const withExtra = await buildAuthorizeUrl({
+      authorizeUrl: "https://as.example.com/authorize",
+      tokenUrl: "https://as.example.com/token",
+      clientId: "c",
+      redirectUri: "https://swarm.example.com/cb",
+      scopes: ["read"],
+      resource: "https://mcp.example.com/",
+      extraParams: { access_type: "offline" },
+      state: "fixed-state",
+    });
+
+    const withoutExtra = await buildAuthorizeUrl({
+      authorizeUrl: "https://as.example.com/authorize",
+      tokenUrl: "https://as.example.com/token",
+      clientId: "c",
+      redirectUri: "https://swarm.example.com/cb",
+      scopes: ["read"],
+      resource: "https://mcp.example.com/",
+      state: "fixed-state",
+    });
+
+    const uWith = new URL(withExtra.url);
+    const uWithout = new URL(withoutExtra.url);
+    expect(uWith.searchParams.has("access_type")).toBe(true);
+    expect(uWithout.searchParams.has("access_type")).toBe(false);
+    // Core params are identical
+    expect(uWith.searchParams.get("client_id")).toBe(uWithout.searchParams.get("client_id"));
+    expect(uWith.searchParams.get("state")).toBe(uWithout.searchParams.get("state"));
+  });
 });
 
 // ─── Discovery (PRMD + AS metadata) ──────────────────────────────────────────

package/src/tests/opencode-adapter.test.ts

@@ -7,7 +7,7 @@
  */
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Event as OpencodeEvent } from "@opencode-ai/sdk";
 import type { ProviderEvent, ProviderResult, ProviderSessionConfig } from "../providers/types";
@@ -614,16 +614,22 @@ describe("OpencodeSession — context_usage emission (phase 9 fix)", () => {
 // ── DES-300: per-task isolation ────────────────────────────────────────────────
 
 describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
+  let prevOpencodeSkillsDir: string | undefined;
+
   beforeEach(() => {
+    prevOpencodeSkillsDir = process.env.OPENCODE_SKILLS_DIR;
     lastPromptArgs = undefined;
     lastCreateOpencodeConfig = undefined;
     mock.restore();
   });
 
   afterEach(() => {
+    if (prevOpencodeSkillsDir === undefined) delete process.env.OPENCODE_SKILLS_DIR;
+    else process.env.OPENCODE_SKILLS_DIR = prevOpencodeSkillsDir;
     // Clean up any written files from tests
     Bun.$`rm -rf /tmp/opencode-task-1.json /tmp/opencode-data-task-1`.quiet().nothrow();
     Bun.$`rm -rf /tmp/test/.opencode`.quiet().nothrow();
+    rmSync("/tmp/opencode-skills-test", { recursive: true, force: true });
   });
 
   test("session.prompt receives agent=swarm-<taskId>", async () => {
@@ -638,6 +644,28 @@ describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
     expect(args.body?.agent).toBe("swarm-task-1");
   });
 
+  test("inlines a leading slash skill before sending prompt", async () => {
+    const skillDir = "/tmp/opencode-skills-test/work-on-task";
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), "Use the task worker procedure.");
+    process.env.OPENCODE_SKILLS_DIR = "/tmp/opencode-skills-test";
+
+    const events: OpencodeEvent[] = [
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+    const cfg = testConfig({
+      taskId: "task-1",
+      prompt: "/work-on-task task-123\n\nTask body.",
+    });
+    await driveSession(events, cfg);
+
+    const args = lastPromptArgs as { body?: { parts?: Array<{ type: string; text: string }> } };
+    const text = args.body?.parts?.[0]?.text ?? "";
+    expect(text).toStartWith("Use the task worker procedure.");
+    expect(text).toContain("User request: task-123\n\nTask body.");
+    expect(text).not.toContain("/work-on-task task-123");
+  });
+
   test("createOpencode receives config with model, mcp.swarm, and permission", async () => {
     const events: OpencodeEvent[] = [
       { type: "session.idle", properties: { sessionID: "sess-abc-123" } },

package/src/tests/provider-command-format.test.ts

@@ -2,12 +2,14 @@ import { describe, expect, test } from "bun:test";
 import { ClaudeAdapter } from "../providers/claude-adapter";
 import { CodexAdapter } from "../providers/codex-adapter";
 import { createProviderAdapter } from "../providers/index";
+import { OpencodeAdapter } from "../providers/opencode-adapter";
 import { PiMonoAdapter } from "../providers/pi-mono-adapter";
 
 describe("ProviderAdapter.formatCommand", () => {
   const claude = new ClaudeAdapter();
   const pi = new PiMonoAdapter();
   const codex = new CodexAdapter();
+  const opencode = new OpencodeAdapter();
 
   test("claude formats commands with / prefix", () => {
     expect(claude.formatCommand("work-on-task")).toBe("/work-on-task");
@@ -31,22 +33,32 @@ describe("ProviderAdapter.formatCommand", () => {
     expect(codex.formatCommand("swarm-chat")).toBe("/swarm-chat");
   });
 
+  test("opencode formats commands with / prefix (skill resolver inlines SKILL.md at runtime)", () => {
+    expect(opencode.formatCommand("work-on-task")).toBe("/work-on-task");
+    expect(opencode.formatCommand("review-offered-task")).toBe("/review-offered-task");
+    expect(opencode.formatCommand("swarm-chat")).toBe("/swarm-chat");
+  });
+
   test("adapter name matches expected provider", () => {
     expect(claude.name).toBe("claude");
     expect(pi.name).toBe("pi");
     expect(codex.name).toBe("codex");
+    expect(opencode.name).toBe("opencode");
   });
 
   test("createProviderAdapter returns adapters that implement formatCommand", async () => {
     const claudeAdapter = await createProviderAdapter("claude");
     const piAdapter = await createProviderAdapter("pi");
     const codexAdapter = await createProviderAdapter("codex");
+    const opencodeAdapter = await createProviderAdapter("opencode");
     expect(typeof claudeAdapter.formatCommand).toBe("function");
     expect(typeof piAdapter.formatCommand).toBe("function");
     expect(typeof codexAdapter.formatCommand).toBe("function");
+    expect(typeof opencodeAdapter.formatCommand).toBe("function");
     expect(claudeAdapter.formatCommand("work-on-task")).toBe("/work-on-task");
     expect(piAdapter.formatCommand("work-on-task")).toBe("/skill:work-on-task");
     expect(codexAdapter.formatCommand("work-on-task")).toBe("/work-on-task");
+    expect(opencodeAdapter.formatCommand("work-on-task")).toBe("/work-on-task");
   });
 });
 

package/src/tests/secret-scrubber.test.ts

@@ -1,5 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { refreshSecretScrubberCache, scrubObject, scrubSecrets } from "../utils/secret-scrubber";
+import {
+  clearVolatileSecretsForTesting,
+  refreshSecretScrubberCache,
+  registerVolatileSecret,
+  scrubObject,
+  scrubSecrets,
+} from "../utils/secret-scrubber";
 
 // Snapshot/restore process.env between tests so env-derived cache entries
 // don't leak across cases.
@@ -221,6 +227,52 @@ describe("scrubSecrets — regex patterns", () => {
 
     expect(out).toBe("OTEL_EXPORTER_OTLP_HEADERS=[REDACTED:signoz_ingestion_key]");
   });
+
+  test("redacts Linear OAuth tokens", () => {
+    const out = scrubSecrets("Authorization: Bearer lin_oauth_test123abcdef end");
+    expect(out).toContain("[REDACTED:linear_oauth]");
+    expect(out).not.toContain("lin_oauth_test123");
+  });
+
+  test("redacts Linear API keys", () => {
+    const out = scrubSecrets("key=lin_api_test123abcdef tail");
+    expect(out).toContain("[REDACTED:linear_api]");
+    expect(out).not.toContain("lin_api_test123");
+  });
+
+  test("redacts npm tokens", () => {
+    const out = scrubSecrets("npm=npm_abcdefghijklmnopqrstuvwxyz01234");
+    expect(out).toContain("[REDACTED:npm_token]");
+    expect(out).not.toContain("npm_abcdefghijklmnopqr");
+  });
+
+  test("redacts Atlassian/Jira API tokens", () => {
+    const out = scrubSecrets("jira=ATATT3xFfGF0abcdefghijklmnopqrstuvwxyz");
+    expect(out).toContain("[REDACTED:atlassian_token]");
+    expect(out).not.toContain("ATATT3xFfGF0");
+  });
+
+  test("redacts tokens adjacent to JSON escape sequences (\\n)", () => {
+    const content = "data\\nlin_oauth_test123abcdef\\nmore";
+    const out = scrubSecrets(content);
+    expect(out).toContain("[REDACTED:linear_oauth]");
+    expect(out).not.toContain("lin_oauth_test123");
+  });
+
+  test("redacts tokens adjacent to JSON escape sequences (\\t, \\r)", () => {
+    const outT = scrubSecrets("field\\tlin_oauth_test123abcdef");
+    expect(outT).toContain("[REDACTED:linear_oauth]");
+    const outR = scrubSecrets("line\\rlin_oauth_test123abcdef");
+    expect(outR).toContain("[REDACTED:linear_oauth]");
+  });
+
+  test("redacts tokens in double-encoded JSON with escape sequences", () => {
+    const inner = JSON.stringify({ access_token: "lin_oauth_test123abcdef", scope: "read" });
+    const content = `{"output":${JSON.stringify(inner)}}`;
+    const out = scrubSecrets(content);
+    expect(out).toContain("[REDACTED:linear_oauth]");
+    expect(out).not.toContain("lin_oauth_test123");
+  });
 });
 
 describe("scrubSecrets — does not over-scrub", () => {
@@ -300,3 +352,23 @@ describe("scrubObject", () => {
     expect(scrubObject(value)).toEqual({ a: "ok", self: "[Circular]" });
   });
 });
+
+describe("registerVolatileSecret", () => {
+  afterEach(() => {
+    clearVolatileSecretsForTesting();
+  });
+
+  test("scrubs a runtime-registered volatile secret", () => {
+    const secret = "volatile_runtime_token_1234567890abcdef";
+    registerVolatileSecret(secret, "RUNTIME_TOKEN");
+    const out = scrubSecrets(`key=${secret}`);
+    expect(out).toBe("key=[REDACTED:RUNTIME_TOKEN]");
+    expect(out).not.toContain(secret);
+  });
+
+  test("ignores values shorter than the minimum length", () => {
+    registerVolatileSecret("short", "TOO_SHORT");
+    const out = scrubSecrets("contains short somewhere");
+    expect(out).toBe("contains short somewhere");
+  });
+});

package/src/tests/skill-fs-writer.test.ts

@@ -41,6 +41,8 @@ describe("writeSkillsToFilesystem", () => {
     rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
     rmSync(join(FAKE_HOME, ".pi"), { recursive: true, force: true });
     rmSync(join(FAKE_HOME, ".codex"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".opencode"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".agents"), { recursive: true, force: true });
   });
 
   afterAll(() => {
@@ -71,12 +73,16 @@ describe("writeSkillsToFilesystem", () => {
     const entries = [skillEntry({ name: "multi-skill", content: "# Multi" })];
     const result = writeSkillsToFilesystem(entries, "all", FAKE_HOME);
 
-    expect(result.synced).toBe(3); // claude + pi + codex
+    expect(result.synced).toBe(5); // claude + pi + codex + opencode + .agents
     expect(existsSync(join(FAKE_HOME, ".claude", "skills", "multi-skill", "SKILL.md"))).toBe(true);
     expect(existsSync(join(FAKE_HOME, ".pi", "agent", "skills", "multi-skill", "SKILL.md"))).toBe(
       true,
     );
     expect(existsSync(join(FAKE_HOME, ".codex", "skills", "multi-skill", "SKILL.md"))).toBe(true);
+    expect(existsSync(join(FAKE_HOME, ".opencode", "skills", "multi-skill", "SKILL.md"))).toBe(
+      true,
+    );
+    expect(existsSync(join(FAKE_HOME, ".agents", "skills", "multi-skill", "SKILL.md"))).toBe(true);
   });
 
   test("writes complex skill SKILL.md plus non-binary bundled files", () => {

package/src/tests/skill-sync.test.ts

@@ -121,23 +121,29 @@ describe("syncSkillsToFilesystem", () => {
     expect(existsSync(piOnlyFile)).toBe(false);
   });
 
-  test("syncs to claude, pi, and codex when harnessType is 'all'", () => {
+  test("syncs to all local harness skill trees when harnessType is 'all'", () => {
     // Clean up first to get accurate count
     rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
     rmSync(join(FAKE_HOME, ".pi"), { recursive: true, force: true });
     rmSync(join(FAKE_HOME, ".codex"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".opencode"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".agents"), { recursive: true, force: true });
 
     const result = syncSkillsToFilesystem(agentId, "all", FAKE_HOME);
 
     expect(result.errors).toHaveLength(0);
-    expect(result.synced).toBe(6); // 2 DB-backed skills × 3 dirs
+    expect(result.synced).toBe(10); // 2 DB-backed skills × 5 dirs
 
     const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
     const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
     const codexFile = join(FAKE_HOME, ".codex", "skills", "test-skill", "SKILL.md");
+    const opencodeFile = join(FAKE_HOME, ".opencode", "skills", "test-skill", "SKILL.md");
+    const agentsFile = join(FAKE_HOME, ".agents", "skills", "test-skill", "SKILL.md");
     expect(existsSync(claudeFile)).toBe(true);
     expect(existsSync(piFile)).toBe(true);
     expect(existsSync(codexFile)).toBe(true);
+    expect(existsSync(opencodeFile)).toBe(true);
+    expect(existsSync(agentsFile)).toBe(true);
   });
 
   test("syncs DB-backed complex skill files and skips binary placeholders", () => {
@@ -299,19 +305,25 @@ describe("syncSkillsToFilesystem", () => {
     rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
     rmSync(join(FAKE_HOME, ".pi"), { recursive: true, force: true });
     rmSync(join(FAKE_HOME, ".codex"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".opencode"), { recursive: true, force: true });
+    rmSync(join(FAKE_HOME, ".agents"), { recursive: true, force: true });
 
     // Use 'all' explicitly with homeOverride (default harnessType would use real home)
     const result = syncSkillsToFilesystem(agentId, "all", FAKE_HOME);
 
     expect(result.errors).toHaveLength(0);
-    expect(result.synced).toBeGreaterThanOrEqual(6);
+    expect(result.synced).toBeGreaterThanOrEqual(10);
 
     const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
     const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
     const codexFile = join(FAKE_HOME, ".codex", "skills", "test-skill", "SKILL.md");
+    const opencodeFile = join(FAKE_HOME, ".opencode", "skills", "test-skill", "SKILL.md");
+    const agentsFile = join(FAKE_HOME, ".agents", "skills", "test-skill", "SKILL.md");
     expect(existsSync(claudeFile)).toBe(true);
     expect(existsSync(piFile)).toBe(true);
     expect(existsSync(codexFile)).toBe(true);
+    expect(existsSync(opencodeFile)).toBe(true);
+    expect(existsSync(agentsFile)).toBe(true);
   });
 
   test("returns empty result for agent with no skills", () => {

package/src/tools/mcp-servers/mcp-server-create.ts

@@ -35,6 +35,12 @@ export const registerMcpServerCreateTool = (server: McpServer) => {
           .string()
           .optional()
           .describe("JSON object mapping header names to config key paths for secret headers"),
+        extraAuthorizeParams: z
+          .string()
+          .optional()
+          .describe(
+            'JSON object string of extra OAuth authorize-request params, e.g. {"access_type":"offline","prompt":"consent"}',
+          ),
       }),
       outputSchema: z.object({
         yourAgentId: z.string().uuid().optional(),
@@ -108,6 +114,7 @@ export const registerMcpServerCreateTool = (server: McpServer) => {
           headers: args.headers,
           envConfigKeys: args.envConfigKeys,
           headerConfigKeys: args.headerConfigKeys,
+          extraAuthorizeParams: args.extraAuthorizeParams,
         });
 
         // Auto-install for the creating agent

package/src/tools/mcp-servers/mcp-server-update.ts

@@ -21,6 +21,12 @@ export const registerMcpServerUpdateTool = (server: McpServer) => {
         headers: z.string().optional().describe("New JSON object of non-secret headers"),
         envConfigKeys: z.string().optional().describe("New env config key mappings"),
         headerConfigKeys: z.string().optional().describe("New header config key mappings"),
+        extraAuthorizeParams: z
+          .string()
+          .optional()
+          .describe(
+            'JSON object string of extra OAuth authorize-request params, e.g. {"access_type":"offline","prompt":"consent"}',
+          ),
         isEnabled: z.boolean().optional().describe("Toggle enabled/disabled"),
       }),
       outputSchema: z.object({
@@ -76,6 +82,8 @@ export const registerMcpServerUpdateTool = (server: McpServer) => {
         if (args.headers !== undefined) updates.headers = args.headers;
         if (args.envConfigKeys !== undefined) updates.envConfigKeys = args.envConfigKeys;
         if (args.headerConfigKeys !== undefined) updates.headerConfigKeys = args.headerConfigKeys;
+        if (args.extraAuthorizeParams !== undefined)
+          updates.extraAuthorizeParams = args.extraAuthorizeParams;
         if (args.isEnabled !== undefined) updates.isEnabled = args.isEnabled;
 
         const updated = updateMcpServer(args.id, updates);

package/src/tools/swarm-config/get-config.ts

@@ -3,6 +3,7 @@ import * as z from "zod";
 import { getResolvedConfig, maskSecrets } from "@/be/db";
 import { createToolRegistrar } from "@/tools/utils";
 import { SwarmConfigSchema } from "@/types";
+import { registerVolatileSecret } from "@/utils/secret-scrubber";
 
 export const registerGetConfigTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -10,7 +11,7 @@ export const registerGetConfigTool = (server: McpServer) => {
     {
       title: "Get Config",
       description:
-        "Get resolved configuration values with scope resolution (repo > agent > global). Returns one entry per unique key with the most-specific scope winning. Use includeSecrets=true to see secret values.",
+        "Get resolved configuration values with scope resolution (repo > agent > global). Returns one entry per unique key with the most-specific scope winning. Use includeSecrets=true to see secret values. IMPORTANT: never pass returned secret values directly on a command line — write them to a temp .env file and source it instead, so the literal value stays out of logged commands.",
       annotations: { readOnlyHint: true },
 
       inputSchema: z.object({
@@ -62,6 +63,13 @@ export const registerGetConfigTool = (server: McpServer) => {
         }
 
         const result = includeSecrets ? configs : maskSecrets(configs);
+        if (includeSecrets) {
+          for (const c of result) {
+            if (c.isSecret && c.value) {
+              registerVolatileSecret(c.value, `config:${c.key}`);
+            }
+          }
+        }
         const count = result.length;
 
         const configList =

package/src/tools/swarm-config/list-config.ts

@@ -3,6 +3,7 @@ import * as z from "zod";
 import { getSwarmConfigs, maskSecrets } from "@/be/db";
 import { createToolRegistrar } from "@/tools/utils";
 import { SwarmConfigSchema, SwarmConfigScopeSchema } from "@/types";
+import { registerVolatileSecret } from "@/utils/secret-scrubber";
 
 export const registerListConfigTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -53,6 +54,13 @@ export const registerListConfigTool = (server: McpServer) => {
         });
 
         const result = includeSecrets ? configs : maskSecrets(configs);
+        if (includeSecrets) {
+          for (const c of result) {
+            if (c.isSecret && c.value) {
+              registerVolatileSecret(c.value, `config:${c.key}`);
+            }
+          }
+        }
         const count = result.length;
 
         const configList =

package/src/types.ts

@@ -553,6 +553,25 @@ export const AgentLatestModelSchema = z.object({
 });
 export type AgentLatestModel = z.infer<typeof AgentLatestModelSchema>;
 
+/**
+ * Worker-reported Bedrock enumeration block. Only present when the pi harness
+ * is in Bedrock SDK mode (`BEDROCK_AUTH_MODE=sdk` or
+ * `MODEL_OVERRIDE=amazon-bedrock/*`). Rides inside `cred_status` JSON (no new
+ * DB column). `models` is the intersection of the models invocable by this
+ * account/region (on-demand/ACTIVE foundation models ∪ inference profiles) with
+ * the set the pi-ai Converse harness can actually drive — Converse-incompatible
+ * entries (e.g. OpenAI models listed in the account) are excluded. An empty
+ * `region` means Bedrock mode with `AWS_REGION` unset (no region fabricated).
+ */
+export const AgentBedrockStatusSchema = z.object({
+  region: z.string(),
+  probedAt: z.number(), // unix ms
+  ready: z.boolean(),
+  models: z.array(z.object({ id: z.string(), name: z.string() })).default([]),
+  error: z.string().optional(),
+});
+export type AgentBedrockStatus = z.infer<typeof AgentBedrockStatusSchema>;
+
 export const AgentCredStatusSchema = z.object({
   ready: z.boolean(),
   missing: z.array(z.string()).default([]),
@@ -565,6 +584,8 @@ export const AgentCredStatusSchema = z.object({
   latestModel: AgentLatestModelSchema.nullable().default(null),
   reportedAt: z.number(), // unix ms
   reportKind: z.enum(["boot", "post_task"]).default("boot"),
+  /** Pi-mono Bedrock enumeration block — null when not in Bedrock mode. */
+  bedrock: AgentBedrockStatusSchema.nullable().default(null),
 });
 export type AgentCredStatus = z.infer<typeof AgentCredStatusSchema>;
 
@@ -1878,6 +1899,7 @@ export const McpServerSchema = z.object({
   headers: z.string().nullable(),
   envConfigKeys: z.string().nullable(),
   headerConfigKeys: z.string().nullable(),
+  extraAuthorizeParams: z.string().nullable(),
   authMethod: McpAuthMethodSchema.default("static"),
   isEnabled: z.boolean(),
   version: z.number(),