@desplega.ai/agent-swarm 1.152.2 → 1.154.0

package/src/slack/task-output.ts

@@ -1,6 +1,22 @@
 import type { AgentTask } from "../types";
 
-/** Keep the stored deferral ETA for task details, but omit it from Slack. */
+/**
+ * Legacy deferral output, written before `defer-task` started storing the
+ * human-facing card directly:
+ *   `Deferred until {date} {time} ([shortId](url)) -> {note excerpt}`
+ * Group 1 is the ETA; the schedule link and the note excerpt are dropped.
+ */
+const LEGACY_DEFERRAL_NOTICE = /^Deferred until ([^\n(]+?) \([^\n]*?\) -> .*$/;
+
+/**
+ * The Slack-facing form of a task's stored output.
+ *
+ * For a deferral this is the stored text verbatim — `defer-task` already
+ * writes the human card (`Checking back today at 18:38`, or
+ * `Waiting on Researcher — or today at 18:38 at the latest`). Rows written
+ * before that change carried the agent's internal handoff note plus a raw
+ * schedule UUID link instead, so they are rewritten to the ETA alone.
+ */
 export function slackTaskOutput(
   task: Pick<AgentTask, "output" | "tags" | "outputSchema" | "status">,
 ): string | undefined {
@@ -9,13 +25,55 @@ export function slackTaskOutput(
     return output;
   }
   // Only match the engine-authored line from defer-task, not continuation results.
-  const notice = output?.match(/^Deferred until [^\n]+? \([^\n]+?\) -> (.*)$/);
-  if (!notice) return output;
-  const pending = notice[1]?.trim();
-  return pending ? `Pending: ${pending}` : "";
+  const legacy = output?.match(LEGACY_DEFERRAL_NOTICE);
+  if (!legacy) return output;
+  const eta = legacy[1]?.trim();
+  return eta ? `Checking back ${eta}` : output;
+}
+
+/**
+ * A task that ENDED in a deferral. It is stored `completed` — `defer-task`
+ * ends the task and books a wake-up — but to a human reading the thread the
+ * work is still outstanding, so every glyph and card treats it as waiting.
+ *
+ * `deferredAt` is the exact signal. The `deferred` tag is not: `defer-task`
+ * puts it on both the deferring task and the wake-up schedule, so a wake-up
+ * child that simply finished is tag-identical to one that deferred again.
+ * The tag is still consulted for rows written before `deferredAt` existed,
+ * narrowed to tasks the scheduler did not create (`taskType !== "deferred"`),
+ * where it is unambiguous.
+ */
+export function isDeferredTask(
+  task: Pick<AgentTask, "tags" | "status" | "deferredAt" | "taskType">,
+): boolean {
+  if (task.status !== "completed") return false;
+  if (task.deferredAt) return true;
+  return !!task.tags?.includes("deferred") && task.taskType !== "deferred";
+}
+
+/** The wake-up tasks `defer-task` booked to continue `task`. */
+export function deferralWakes<T extends Pick<AgentTask, "parentTaskId" | "taskType">>(
+  task: Pick<AgentTask, "id">,
+  threadTasks: readonly T[],
+): T[] {
+  return threadTasks.filter(
+    (candidate) => candidate.parentTaskId === task.id && candidate.taskType === "deferred",
+  );
 }
 
-/** An ETA-only notice has no useful content left to post. */
-export function isSlackEtaOnlyNotice(task: AgentTask): boolean {
-  return !!task.output && slackTaskOutput(task) === "";
+/**
+ * A deferred task that is still parked: none of its wake-ups has settled.
+ * Once one has, the deferral is over — the answer (or the next deferral)
+ * lives on the wake-up, and the deferring task reads as the `completed` it
+ * is stored as.
+ */
+export function isAwaitingWake(
+  task: Pick<AgentTask, "id" | "tags" | "status" | "deferredAt" | "taskType">,
+  threadTasks: readonly Pick<AgentTask, "parentTaskId" | "taskType" | "status">[],
+): boolean {
+  if (!isDeferredTask(task)) return false;
+  return !deferralWakes(task, threadTasks).some(
+    (wake) =>
+      wake.status === "completed" || wake.status === "failed" || wake.status === "cancelled",
+  );
 }

package/src/slack/thread-buffer.ts

@@ -4,11 +4,12 @@ import {
   getLeadAgent,
   getMostRecentTaskInThread,
 } from "../be/db";
+import { findUserByExternalId } from "../be/users";
 import { createAdditiveBuffer } from "../tasks/additive-buffer";
 import { slackContextKey } from "../tasks/context-key";
 import { getSlackApp } from "./app";
 import { buildBufferFlushBlocks } from "./blocks";
-import { rewriteSlackMentions } from "./enrich";
+import { resolveSlackUserId, rewriteSlackMentions } from "./enrich";
 import type { SlackFile } from "./files";
 import {
   bufferedFileFailures,
@@ -204,6 +205,18 @@ async function slackFlush(
     );
   }
 
+  const requestedByUserId = app
+    ? await resolveSlackUserId(app.client, originalRequesterId, {
+        sampleEventType: "buffered_thread_reply",
+        sampleContext: items[0]!.text,
+      })
+    : (await findUserByExternalId("slack", originalRequesterId))?.id;
+
+  // A steering row has one sender. Keep consecutive messages from that sender
+  // together, then flush the remaining senders in order after successful delivery.
+  const nextSenderIndex = items.findIndex((item) => item.userId !== originalRequesterId);
+  const steeringItems = nextSenderIndex === -1 ? items : items.slice(0, nextSenderIndex);
+
   // Steering carries text only. As on the mention path, files need a follow-up
   // task so its attachments exist before a worker can claim it.
   const steering =
@@ -211,8 +224,15 @@ async function slackFlush(
       ? await requestSlackThreadSteering({
           channelId,
           threadTs,
-          message: combinedText,
-          messageTimestamps: items.map((item) => item.ts),
+          message:
+            nextSenderIndex === -1
+              ? combinedText
+              : await rewriteSlackMentions(
+                  steeringItems.map((item) => item.text).join("\n---\n"),
+                  botUserId,
+                ),
+          messageTimestamps: steeringItems.map((item) => item.ts),
+          requestedByUserId,
         })
       : null;
   if (steering) {
@@ -239,6 +259,9 @@ async function slackFlush(
         }
       }
     }
+    if (nextSenderIndex !== -1) {
+      await slackFlush(items.slice(nextSenderIndex), key, immediate);
+    }
     return;
   }
 
@@ -267,6 +290,7 @@ async function slackFlush(
       slackThreadTs: threadTs,
       slackTriggerMessageTs: items.at(-1)!.ts,
       slackUserId: originalRequesterId,
+      requestedByUserId,
       dependsOn,
       parentTaskId: mostRecentTask?.id,
       contextKey: slackContextKey({ channelId, threadTs }),

package/src/telemetry.ts

@@ -8,6 +8,7 @@
  */
 import { randomUUID } from "node:crypto";
 import pkg from "../package.json";
+import { isSlackConfigured } from "./slack/config";
 import { isEnvFlagEnabled } from "./utils/env-flag";
 
 const TELEMETRY_ENDPOINT = "https://proxy.desplega.sh/v1/events";
@@ -269,9 +270,7 @@ export function _hasEmbeddingKey(env: NodeJS.ProcessEnv = process.env): boolean
  * Exported for tests; not part of the public API.
  */
 export function _hasSlackChannel(env: NodeJS.ProcessEnv = process.env): boolean {
-  return (
-    !!(env.SLACK_BOT_TOKEN && env.SLACK_APP_TOKEN) && !isEnvFlagEnabled("SLACK_DISABLE", false, env)
-  );
+  return isSlackConfigured(env);
 }
 
 /**

package/src/tests/agent-fs-provision-seeder.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, afterEach, beforeAll, describe, expect, spyOn, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import {
   closeDb,
@@ -110,6 +110,7 @@ function createFetchStub(
         orgId: "personal-org",
       });
     }
+    if (url.pathname === "/auth/profile" && method === "PATCH") return Response.json(body);
     if (url.pathname === "/auth/me" && method === "GET") {
       return Response.json({
         userId: "admin-user",
@@ -502,11 +503,64 @@ describe("agent-fs provisioning seeder", () => {
       role: "editor",
     });
 
+    expect(records.find((r) => r.path === "/auth/profile")).toMatchObject({
+      method: "PATCH",
+      body: { displayName: worker.name },
+      authorization: "Bearer example-afs-agent-key",
+      hasSignal: true,
+    });
     records.length = 0;
     const second = await ensureAgentFsCredentialsForAgent(worker.id);
 
     expect(second.created).toBe(false);
-    expect(records).toEqual([]);
+    expect(records).toEqual([
+      {
+        method: "PATCH",
+        path: "/auth/profile",
+        body: { displayName: "Credential Worker" },
+        authorization: "Bearer example-afs-agent-key",
+        hasSignal: true,
+      },
+    ]);
+  });
+
+  test("profile sync failures leave existing credentials usable and retry later", async () => {
+    process.env.AGENT_FS_API_URL = "https://agent-fs.example.test";
+    const worker = await createAgent({
+      name: "Legacy Worker",
+      description: "Profile compatibility",
+      role: "worker",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      capabilities: [],
+    });
+    await upsertSwarmConfig({
+      scope: "agent",
+      scopeId: worker.id,
+      key: "AGENT_FS_API_KEY",
+      value: "example-profile-key",
+      isSecret: true,
+    });
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      for (const status of [404, 405, 500, 0]) {
+        setAgentFsProvisionFetchForTests((async (_input, init) => {
+          expect(init?.signal).toBeInstanceOf(AbortSignal);
+          if (!status) throw new DOMException("Timed out", "TimeoutError");
+          return Response.json({ error: "unsupported" }, { status });
+        }) as typeof fetch);
+        expect((await ensureAgentFsCredentialsForAgent(worker.id)).created).toBe(false);
+      }
+      expect(warn).toHaveBeenCalledTimes(4);
+      const records: RequestRecord[] = [];
+      setAgentFsProvisionFetchForTests(createFetchStub(records));
+      await ensureAgentFsCredentialsForAgent(worker.id);
+      expect(records[0].body).toEqual({ displayName: "Legacy Worker" });
+      expect(records[0].authorization).toBe("Bearer example-profile-key");
+    } finally {
+      warn.mockRestore();
+    }
   });
 
   test("recovers a lost agent credential by registering an alias after a 409", async () => {

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

@@ -333,6 +333,25 @@ describe("PATCH /api/agents/:id/harness-provider", () => {
 });
 
 describe("PATCH /api/agents/:id/runtime", () => {
+  test("accepts dsh and persists its harness and model for the worker", async () => {
+    const agent = await createAgent({
+      name: "dsh-worker",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const res = await fetch(`${baseUrl}/api/agents/${agent.id}/runtime`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ harness_provider: "dsh", model: "deepseek-flash" }),
+    });
+    expect(res.status).toBe(200);
+    expect((await getAgentById(agent.id))?.harnessProvider).toBe("dsh");
+    const rows = await getSwarmConfigs({ scope: "agent", scopeId: agent.id });
+    expect(rows.find((row) => row.key === "HARNESS_PROVIDER")?.value).toBe("dsh");
+    expect(rows.find((row) => row.key === "MODEL_OVERRIDE")?.value).toBe("deepseek-flash");
+  });
+
   test("updates harness_provider and agent-scoped runtime config rows", async () => {
     const a = await createAgent({
       name: "runtime-target-1",

package/src/tests/agents-list-model-display.test.ts

@@ -1,9 +1,38 @@
 import { describe, expect, test } from "bun:test";
+import type { LiveModelsCatalog } from "../../apps/ui/src/lib/agent-runtime-models";
 import {
   getAgentModelDisplay,
   getAgentModelPresentation,
 } from "../../apps/ui/src/lib/agents-list-model-display";
 
+const liveCatalog: LiveModelsCatalog = {
+  openrouter: {
+    id: "openrouter",
+    name: "OpenRouter",
+    models: {
+      "deepseek/deepseek-v4-pro": { id: "deepseek/deepseek-v4-pro", name: "DeepSeek V4 Pro" },
+      "deepseek/deepseek-v4.1-flash": {
+        id: "deepseek/deepseek-v4.1-flash",
+        name: "DeepSeek V4.1 Flash",
+      },
+    },
+  },
+  opencode: {
+    id: "opencode",
+    name: "OpenCode Zen",
+    models: {
+      "glm-5.3-flash": { id: "glm-5.3-flash", name: "GLM-5.3-Flash" },
+    },
+  },
+  anthropic: {
+    id: "anthropic",
+    name: "Anthropic",
+    models: {
+      "claude-opus-5-5": { id: "claude-opus-5-5", name: "Claude Opus 5.5" },
+    },
+  },
+};
+
 describe("agents list model display", () => {
   test("shows configured and last-used models when they diverge", () => {
     const display = getAgentModelDisplay("claude-opus-4-7", "claude-sonnet-4-6");
@@ -43,6 +72,31 @@ describe("agents list model display", () => {
     });
   });
 
+  test.each([
+    ["openrouter/deepseek/deepseek-v4-pro", "DeepSeek V4 Pro", "OpenRouter"],
+    ["openrouter/deepseek/deepseek-v4.1-flash", "DeepSeek V4.1 Flash", "OpenRouter"],
+    ["opencode/glm-5.3-flash", "GLM-5.3-Flash", "OpenCode Zen"],
+    ["claude-opus-5-5", "Claude Opus 5.5", "Anthropic"],
+  ])("resolves %s from the live catalog", (model, label, provider) => {
+    expect(getAgentModelPresentation(model, liveCatalog)).toMatchObject({
+      raw: model,
+      label,
+      provider,
+    });
+  });
+
+  test("title-cases an uncatalogued model id without a maintained label entry", () => {
+    expect(
+      getAgentModelPresentation("opencode/future-model-v8.2-preview", liveCatalog),
+    ).toMatchObject({
+      label: "Future Model V8.2 Preview",
+      provider: null,
+    });
+    expect(
+      getAgentModelPresentation("openrouter/deepseek/deepseek-v5.1-flash", liveCatalog)?.label,
+    ).toBe("Deepseek V5.1 Flash");
+  });
+
   test("presents latest Anthropic direct model ids as readable labels", () => {
     expect(getAgentModelPresentation("claude-fable-5-1")).toMatchObject({
       label: "Claude Fable 5.1",
@@ -54,6 +108,11 @@ describe("agents list model display", () => {
       provider: "Anthropic",
       providerId: "anthropic",
     });
+    expect(getAgentModelPresentation("claude-opus-5-5")).toMatchObject({
+      label: "Claude Opus 5.5",
+      provider: "Anthropic",
+      providerId: "anthropic",
+    });
     expect(getAgentModelPresentation("claude-opus-5")).toMatchObject({
       label: "Claude Opus 5",
       provider: "Anthropic",
@@ -75,7 +134,7 @@ describe("agents list model display", () => {
       providerId: "anthropic",
     });
     expect(getAgentModelPresentation("opus")).toMatchObject({
-      label: "Claude Opus 5",
+      label: "Claude Opus 5.5",
       provider: "Anthropic",
       providerId: "anthropic",
     });

package/src/tests/base-prompt.test.ts

@@ -25,6 +25,8 @@ const ENV_KEYS = [
   "SLACK_DISABLE",
   "SLACK_BOT_TOKEN",
   "SLACK_APP_TOKEN",
+  "SLACK_MODE",
+  "SLACK_SIGNING_SECRET",
   "STEERING_ENABLED",
   "AGENT_FS_API_URL",
   "SCRIPTS_ONLY_MCP",
@@ -561,6 +563,29 @@ describe("getBasePrompt: slack section", () => {
     expect(result).toContain(SLACK_HEADER);
   });
 
+  test("a tool capability alone does not bypass the default socket credential gate", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core", "slack"],
+    });
+    expect(result).not.toContain(SLACK_HEADER);
+  });
+
+  test("supports the HTTP prompt contract without distributing Slack secrets to the worker", async () => {
+    process.env.SLACK_MODE = "http";
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core", "slack"],
+    });
+    expect(result).toContain(SLACK_HEADER);
+
+    const withoutCapability = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core"],
+    });
+    expect(withoutCapability).not.toContain(SLACK_HEADER);
+  });
+
   test("a scripts-only worker with a Slack task gets the scripts-only variant only", async () => {
     enableSlack();
     const result = await getBasePrompt({

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

@@ -898,6 +898,12 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
       cacheReadPerMillion: 0.25,
       cacheWritePerMillion: 12.5,
     });
+    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-5-5"]).toEqual({
+      inputPerMillion: 4.0,
+      outputPerMillion: 20.0,
+      cacheReadPerMillion: 0.2,
+      cacheWritePerMillion: 5.0,
+    });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-5"]).toEqual({
       inputPerMillion: 5.0,
       outputPerMillion: 25.0,

package/src/tests/codex-gpt6-release.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test";
+import { modelGroupsForHarness } from "../../apps/ui/src/lib/agent-runtime-models";
+import { buildModelsCatalog } from "../be/models-catalog";
+import cache from "../be/modelsdev-cache.json";
+import { buildModelsDevSeedRows } from "../be/seed-pricing";
+import {
+  CODEX_DEFAULT_MODEL,
+  CODEX_MODELS,
+  computeCodexCostUsd,
+  FALLBACK_CODEX_MODEL_PRICING,
+  getCodexContextWindow,
+  resolveCodexModel,
+} from "../providers/codex-models";
+import { applyReasoningEffort, reasoningCapability } from "../providers/reasoning-effort";
+
+const releases = [
+  { id: "gpt-6-sol", label: "GPT-6 Sol", input: 2, output: 10, read: 0.2, write: 2.5 },
+  { id: "gpt-6-luna", label: "GPT-6 Luna", input: 0.1, output: 0.5, read: 0.01, write: 0.125 },
+] as const;
+
+for (const release of releases) {
+  describe(release.id, () => {
+    test("uses the exact bare CLI ID with verified context and base costs", () => {
+      expect(CODEX_MODELS).toContain(release.id);
+      expect(resolveCodexModel(release.id.toUpperCase())).toBe(release.id);
+      expect(getCodexContextWindow(release.id)).toBe(1_050_000);
+      expect(cache.openai.models[release.id].limit.output).toBe(128_000);
+      expect(FALLBACK_CODEX_MODEL_PRICING[release.id]).toEqual({
+        inputPerMillion: release.input,
+        cachedInputPerMillion: release.read,
+        outputPerMillion: release.output,
+      });
+      expect(computeCodexCostUsd(release.id, 1_000_000, 250_000, 100_000)).toBeCloseTo(
+        release.input * 0.75 + release.read * 0.25 + release.output * 0.1,
+        8,
+      );
+    });
+
+    test("exposes the full reasoning range and transports none/max correctly", () => {
+      expect(reasoningCapability("codex", release.id)).toEqual({
+        supported: true,
+        levels: ["off", "low", "medium", "high", "xhigh", "max"],
+        default: "medium",
+      });
+      for (const [effort, value] of [
+        ["off", "none"],
+        ["max", "max"],
+      ] as const) {
+        expect(applyReasoningEffort("codex", release.id, effort)).toEqual({
+          kind: "codex-config",
+          config: { model_reasoning_effort: value },
+        });
+      }
+    });
+
+    test("seeds all four token classes under canonical Codex IDs", () => {
+      const rows = buildModelsDevSeedRows(cache).filter(
+        (row) => row.provider === "codex" && row.model === release.id,
+      );
+      expect(
+        Object.fromEntries(rows.map((row) => [row.tokenClass, row.pricePerMillionUsd])),
+      ).toEqual({
+        input: release.input,
+        output: release.output,
+        cached_input: release.read,
+        cache_write: release.write,
+      });
+      expect(cache.openai.models[release.id].cost.tiers).toEqual([
+        {
+          input: release.input * 2,
+          output: release.output * 1.5,
+          cache_read: release.read * 2,
+          cache_write: release.write * 2,
+          tier: { type: "context", size: 272000 },
+        },
+      ]);
+    });
+
+    test("is available through the catalog and direct UI selector", () => {
+      const model = buildModelsCatalog(cache).openai?.models[release.id];
+      expect(model?.limit?.context).toBe(1_050_000);
+      expect(model?.cost).toEqual({ input: release.input, output: release.output });
+      const option = modelGroupsForHarness("codex", undefined, undefined)
+        .flatMap((group) => group.models)
+        .find((entry) => entry.id === release.id);
+      expect(option?.label).toBe(release.label);
+      expect(option?.reasoningLevels).toEqual(["off", "low", "medium", "high", "xhigh", "max"]);
+    });
+  });
+}
+
+test("release additions preserve rollout-safe defaults and aliases", () => {
+  expect(CODEX_DEFAULT_MODEL).toBe("gpt-5.6-terra");
+  expect(resolveCodexModel("sonnet")).toBe("gpt-5.6-terra");
+  expect(resolveCodexModel("haiku")).toBe("gpt-5.6-luna");
+  expect(resolveCodexModel("opus")).toBe("gpt-5.6-sol");
+});

package/src/tests/codex-steering-hook.test.ts

@@ -101,7 +101,7 @@ describe("codex steering hook", () => {
   );
 
   test("PostToolUse injects the envelope and marks the row delivered first", async () => {
-    const pending = message();
+    const pending = message({ createdByKind: "user", senderLabel: "Taras (user)" });
     const deliveredCalls: string[] = [];
     const output = await handleCodexHookEvent(
       { hook_event_name: "PostToolUse" },
@@ -116,7 +116,7 @@ describe("codex steering hook", () => {
       additionalContext: string;
     };
     expect(hookOutput.hookEventName).toBe("PostToolUse");
-    expect(hookOutput.additionalContext).toContain(pending.body);
+    expect(hookOutput.additionalContext).toContain(`From Taras (user): ${pending.body}`);
     expect(hookOutput.additionalContext).toContain(`[steering ${pending.id}]`);
     expect(hookOutput.additionalContext).toContain("accept-steer");
   });

package/src/tests/config-api-only-keys.test.ts

@@ -50,6 +50,12 @@ beforeAll(async () => {
     value: BOOTSTRAP_VALUE,
     isSecret: true,
   });
+  await upsertSwarmConfig({
+    scope: "global",
+    key: "SLACK_SIGNING_SECRET",
+    value: "synthetic-api-only-signing-secret",
+    isSecret: true,
+  });
   await upsertSwarmConfig({
     scope: "global",
     key: "SOME_WORKER_SECRET",
@@ -86,6 +92,7 @@ describe("API-only config keys are never served over HTTP", () => {
   test("GET /api/config/resolved WITHOUT agentId strips the bootstrap key", async () => {
     const { configs } = await getJson("/api/config/resolved?includeSecrets=true");
     expect(configs.some((c) => c.key === BOOTSTRAP_KEY)).toBe(false);
+    expect(configs.some((c) => c.key === "SLACK_SIGNING_SECRET")).toBe(false);
     // A legitimate worker secret still comes through.
     expect(configs.some((c) => c.key === "SOME_WORKER_SECRET")).toBe(true);
   });
@@ -95,11 +102,13 @@ describe("API-only config keys are never served over HTTP", () => {
       `/api/config/resolved?includeSecrets=true&agentId=${agentId}`,
     );
     expect(configs.some((c) => c.key === BOOTSTRAP_KEY)).toBe(false);
+    expect(configs.some((c) => c.key === "SLACK_SIGNING_SECRET")).toBe(false);
   });
 
   test("GET /api/config?scope=global strips the bootstrap key", async () => {
     const { configs } = await getJson("/api/config?scope=global&includeSecrets=true");
     expect(configs.some((c) => c.key === BOOTSTRAP_KEY)).toBe(false);
+    expect(configs.some((c) => c.key === "SLACK_SIGNING_SECRET")).toBe(false);
     expect(configs.some((c) => c.key === "SOME_WORKER_SECRET")).toBe(true);
   });
 });

package/src/tests/context-window.test.ts

@@ -18,6 +18,7 @@ describe("getContextWindowSize", () => {
   });
 
   test("returns 1M for opus models", () => {
+    expect(getContextWindowSize("claude-opus-5-5")).toBe(1_000_000);
     expect(getContextWindowSize("claude-opus-5")).toBe(1_000_000);
     expect(getContextWindowSize("claude-opus-4-8")).toBe(1_000_000);
     expect(getContextWindowSize("claude-opus-4-7")).toBe(1_000_000);

package/src/tests/db-task-read-contract.test.ts

@@ -94,8 +94,12 @@ type:UpsertAssetKeyMappingInput
 type:WorkflowFilters
 type:WorkflowRunListOptions
 type:WorkflowRunPage
+value:EXTENSION_AGENT_ROLE
+value:ExtensionAgentAssignmentError
 value:KvTypeCollisionError
 value:MAX_EMPTY_POLLS
+value:NOT_EXTENSION_AGENT_SQL
+value:ReservedAgentRoleError
 value:SKILL_FILE_LIMITS
 value:UNATTRIBUTED_USER_ID
 value:__resetSqliteVecExtensionPathCacheForTests
@@ -195,6 +199,7 @@ value:emitBuiltInIntegrationConnectedOnce
 value:emitMcpServerConnectedTelemetry
 value:ensureSlackDelegationActivation
 value:ensureSlackRenderV2Activation
+value:extensionAgentAssignmentError
 value:failPendingResumeIfUnclaimed
 value:failTask
 value:findCompletedTaskInThread
@@ -326,6 +331,7 @@ value:getRecentFailedTasks
 value:getRecentlyCancelledTasksForAgent
 value:getRecentlyFinishedWorkerTasks
 value:getRemainingCapacity
+value:getResolvableDeferralOutcomes
 value:getResolvedConfig
 value:getRetryableSteps
 value:getRootTaskChain
@@ -418,6 +424,7 @@ value:installMcpServer
 value:installSkill
 value:installSystemDefaultSkillsForAgent
 value:isAgentEligibleForTask
+value:isExtensionAgent
 value:isPendingSlackMessage
 value:isPoolAffinityEnforcementEnabled
 value:isSqliteVecAvailable
@@ -449,6 +456,7 @@ value:markInboxMessageDelegated
 value:markInboxMessageRead
 value:markInboxMessageResponded
 value:markKeyRateLimited
+value:markSlackDeferralResolved
 value:markSlackRelayAttempted
 value:markSlackRelayDelivered
 value:markSlackTreeRendered
@@ -485,6 +493,7 @@ value:releaseStaleReviewingTasks
 value:releaseTask
 value:replaceTaskAttachment
 value:reserveSlackMessage
+value:reservedRoleViolation
 value:resetEmptyPollCount
 value:resetOrphanedInProgressTasksForAgent
 value:resetPromptTemplateToDefault