@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/src/tasks/worker-follow-up.ts

@@ -1,4 +1,5 @@
 import {
+  buildRoutingAffinityFromAgent,
   createTaskExtended,
   getActiveTaskCount,
   getAgentById,
@@ -10,7 +11,7 @@ import {
 } from "../be/db";
 import { repointTrackerSyncBySwarmId } from "../be/db-queries/tracker";
 import { resolveTemplate } from "../prompts/resolver";
-import type { AgentTask, ResumeReason, TaskAttachment } from "../types";
+import type { Agent, AgentTask, ResumeReason, TaskAttachment } from "../types";
 import { taskAttachmentDisplayUrl } from "../utils/task-attachment-links";
 // Side-effect import: registers task lifecycle templates in the in-memory registry.
 import "../tools/templates";
@@ -69,6 +70,26 @@ export const CRASH_RECOVERY_PIN_TAG = "crash-recovery-pin";
  */
 export const GRACEFUL_SHUTDOWN_PIN_TAG = "graceful-shutdown-pin";
 
+/**
+ * Tag set on a reboot-sweep retry child that was pinned back to its
+ * original agent (routing-affinity Phase 3). Same reaper-scoping purpose as
+ * `CRASH_RECOVERY_PIN_TAG`/`GRACEFUL_SHUTDOWN_PIN_TAG` — kept in sync with
+ * the literal duplicated in `getStalePinnedResumes` (src/be/db.ts).
+ */
+export const REBOOT_RETRY_PIN_TAG = "reboot-retry-pin";
+
+/**
+ * Shared "is this agent even a pin candidate" gate: the row still exists and
+ * is not `offline`. Used identically by `createResumeFollowUp`'s same-agent
+ * pin and the heartbeat's reboot-retry pin (`runRebootSweep`) — both then
+ * apply their own capacity (and, for resumes, freshness) rules on top.
+ */
+export function getPinCandidateAgent(agentId: string): Agent | null {
+  const candidate = getAgentById(agentId);
+  if (!candidate || candidate.status === "offline") return null;
+  return candidate;
+}
+
 export function getResumeGeneration(task: Pick<AgentTask, "tags">): number {
   const tag = task.tags.find((value) => value.startsWith(RESUME_GENERATION_TAG_PREFIX));
   if (!tag) return 0;
@@ -264,8 +285,8 @@ export function createResumeFollowUp(args: {
   //     responsive, so keep requiring `fresh`.
   let preferredAgentId: string | undefined;
   if (parent.agentId) {
-    const candidate = getAgentById(parent.agentId);
-    if (candidate && candidate.status !== "offline") {
+    const candidate = getPinCandidateAgent(parent.agentId);
+    if (candidate) {
       const lastActivity = candidate.lastActivityAt ? Date.parse(candidate.lastActivityAt) : 0;
       const fresh =
         Number.isFinite(lastActivity) &&
@@ -328,6 +349,17 @@ export function createResumeFollowUp(args: {
   // deliberately excluded there so the resume task resolves to the claiming
   // agent's own provider/model — never the parent's concrete model string.
   // We only override what's SPECIFIC to the resume task here.
+  //
+  // Routing affinity: stamp a FRESH snapshot from the parent's own agent —
+  // this covers every leg (pinned AND the pool-fallback legs) so a resume
+  // that falls to the unassigned pool is still role/capability-gated. When
+  // the agent row is already gone, `buildRoutingAffinityFromAgent` returns
+  // `null` and we pass `undefined`, letting `createTaskExtended`'s
+  // parentTaskId inheritance block fall back to the parent's OWN
+  // (already-inherited) `routingAffinity` instead.
+  const routingAffinity = parent.agentId
+    ? (buildRoutingAffinityFromAgent(parent.agentId) ?? undefined)
+    : undefined;
   const created = createTaskExtended(followUpDescription, {
     agentId: preferredAgentId,
     creatorAgentId: parent.creatorAgentId,
@@ -336,6 +368,7 @@ export function createResumeFollowUp(args: {
     tags,
     priority,
     parentTaskId: parent.id,
+    routingAffinity,
   });
 
   // Repoint Linear / Jira `tracker_sync` rows from the (now terminal) parent
@@ -447,3 +480,67 @@ export function createRerouteDecisionTask(args: {
 
   return { kind: "created", task: created };
 }
+
+/** Result of `createPoolStarvationDecisionTask`. */
+export type CreatePoolStarvationDecisionResult =
+  | { kind: "created"; task: AgentTask }
+  | { kind: "skipped"; reason: "lead_not_found" | "duplicate_exists" };
+
+/**
+ * Hand the Lead a re-delegation DECISION task for a pooled, affinity-tagged
+ * task that has sat `unassigned` past `POOL_AFFINITY_ESCALATION_MIN` with
+ * ZERO eligible registered agents (routing affinity Phase 3). This is the
+ * "queue, then escalate" fallback for the pool legs (7/8) that `createResumeFollowUp`
+ * and the reboot-retry pin can fall to — mirrors `createRerouteDecisionTask`'s
+ * shape (same `taskType: "reroute-decision"` discriminator, so it reuses the
+ * same idempotency check and Slack re-delegation carve-out) but for a task
+ * that was never pinned in the first place, so there is no `staleResume` /
+ * resume-generation budget to derive.
+ *
+ * Invoked by the heartbeat (`escalateStarvedPoolTasks`), which has already
+ * confirmed no registered agent (any status) satisfies `isAgentEligibleForTask`
+ * for this task.
+ */
+export function createPoolStarvationDecisionTask(args: {
+  original: AgentTask;
+}): CreatePoolStarvationDecisionResult {
+  const { original } = args;
+
+  const leadAgent = getLeadAgent();
+  if (!leadAgent) return { kind: "skipped", reason: "lead_not_found" };
+
+  if (hasNonTerminalRerouteDecisionChild(original.id)) {
+    return { kind: "skipped", reason: "duplicate_exists" };
+  }
+
+  const affinity = original.routingAffinity;
+  const requiredRole = affinity?.role ?? "(none declared)";
+  const requiredCapabilities =
+    affinity?.capabilities && affinity.capabilities.length > 0
+      ? affinity.capabilities.join(", ")
+      : "(none declared)";
+  const attachmentsBlock = formatAttachmentsBlock(getTaskAttachments(original.id));
+
+  const decision = resolveTemplate("task.pool.starved.decision", {
+    original_task_id: original.id,
+    task_desc: original.task.slice(0, 200),
+    required_role: requiredRole,
+    required_capabilities: requiredCapabilities,
+    artifacts_block: attachmentsBlock,
+  });
+
+  const created = createTaskExtended(decision.text, {
+    agentId: leadAgent.id,
+    creatorAgentId: original.creatorAgentId,
+    source: "system",
+    taskType: "reroute-decision",
+    tags: ["reroute-decision", "pool-starvation"],
+    priority: Math.min(100, (original.priority ?? 50) + 10),
+    parentTaskId: original.id,
+    // Same rationale as createRerouteDecisionTask: don't hold the Lead's
+    // re-delegation decision to the original work's output contract.
+    inheritParentOutputSchema: false,
+  });
+
+  return { kind: "created", task: created };
+}

package/src/tests/agentmail-handlers.test.ts

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlinkSync } from "node:fs";
 import { handleMessageReceived } from "../agentmail/handlers";
 import type { AgentMailWebhookPayload } from "../agentmail/types";
@@ -69,7 +69,19 @@ function makePayload(opts: {
   };
 }
 
-beforeAll(() => {
+// Per-test (not per-file) DB reset: bun's default `retry` (bunfig.toml) retries
+// a failing test in place, re-invoking beforeEach/afterEach around each
+// attempt. With a file-level beforeAll/afterAll instead, a transient failure
+// on attempt 1 (of any cause) leaves its side effects (the just-created user)
+// in place for the retry, which then finds that user already resolved and
+// silently no-ops the create — turning one flaky attempt into a deterministic
+// "before+1 != after" mismatch on every subsequent attempt. Resetting to a
+// fresh DB (and re-registering the lead) before every test/retry makes each
+// attempt idempotent regardless of how many times it's retried, and also
+// re-runs initDb's global resolver registration right before this file's own
+// resolveTemplate() calls, minimizing the window for another concurrently
+// executing test file's own initDb() to have repointed it in between.
+beforeEach(async () => {
   for (const suffix of ["", "-wal", "-shm"]) {
     try {
       unlinkSync(`${TEST_DB_PATH}${suffix}`);
@@ -79,9 +91,17 @@ beforeAll(() => {
   // Ensure a lead exists so handler's findLeadAgent() returns truthy and a
   // task gets created on the "no inbox mapping" path.
   createAgent({ name: "LeadAgent", isLead: true, status: "idle" });
+  // Re-register agentmail templates — prompt-template-resolver.test.ts and
+  // prompt-template-session.test.ts call clearTemplateDefinitions() and never
+  // restore the shared (process-wide) registry, so if either runs first in
+  // the same bun worker, resolveTemplate("agentmail.email.*", ...) silently
+  // returns { text: "", skipped: true } here instead of throwing — producing
+  // a task with an empty body rather than a visible failure. Same defensive
+  // pattern as heartbeat-checklist.test.ts's beforeEach.
+  await import(`../agentmail/templates?t=${Date.now()}`);
 });
 
-afterAll(() => {
+afterEach(() => {
   closeDb();
   for (const suffix of ["", "-wal", "-shm"]) {
     try {
@@ -111,6 +131,10 @@ describe("handleMessageReceived — identity auto-link via findOrCreateUserByEma
     const task = getTaskById(result.taskId!);
     expect(task).not.toBeNull();
     expect(task!.requestedByUserId).toBe(user!.id);
+    // The resolved canonical name renders in the task text — never the raw
+    // From header (Alice's display name + email as typed by the sender).
+    expect(task!.task).toContain("Alice Newcomer (email:alice.newcomer@example.com)");
+    expect(task!.task).not.toContain("Alice Newcomer <alice.newcomer@example.com>");
   });
 
   test("KNOWN sender (existing users.email) → no duplicate row, auto_merge event, task requestedByUserId populated", async () => {
@@ -162,5 +186,10 @@ describe("handleMessageReceived — identity auto-link via findOrCreateUserByEma
 
     const task = getTaskById(result.taskId!);
     expect(task!.requestedByUserId).toBeFalsy();
+    // No display name — not even the raw provider label — is ever rendered
+    // for an unresolved sender. The task text carries only the non-name
+    // sentinel shape, never the raw From header.
+    expect(task!.task).toContain("email:unknown (unknown user)");
+    expect(task!.task).not.toContain("Unknown Sender (no address)");
   });
 });

package/src/tests/approval-requests.test.ts

@@ -6,6 +6,7 @@ import {
   createAgent,
   createApprovalRequest,
   createTaskExtended,
+  createUser,
   getAgentCurrentTask,
   getApprovalRequestById,
   getApprovalRequestByStepId,
@@ -257,6 +258,24 @@ describe("Approval Requests", () => {
       const result = createApprovalRequest(data);
       expect(result.questions).toEqual(questions);
     });
+
+    test("stamps createdBy when provided, round-trips through getApprovalRequestById", () => {
+      const requester = createUser({
+        name: "Approval Provenance User",
+        email: "approval-provenance@example.com",
+      });
+      const data = makeApprovalData({ createdBy: requester.id });
+      const created = createApprovalRequest(data);
+      expect(created.createdBy).toBe(requester.id);
+
+      const fetched = getApprovalRequestById(created.id);
+      expect(fetched?.createdBy).toBe(requester.id);
+    });
+
+    test("createdBy is undefined when not provided", () => {
+      const result = createApprovalRequest(makeApprovalData());
+      expect(result.createdBy).toBeUndefined();
+    });
   });
 
   describe("DB: getApprovalRequestById", () => {
@@ -588,6 +607,48 @@ describe("Approval Requests", () => {
       expect(created!.workflowRunStepId).toBe(stepId);
     });
 
+    test("stamps createdBy from meta.requestedByUserId (workflow-run provenance)", async () => {
+      const requester = createUser({
+        name: "HITL Requester",
+        email: "hitl-requester@example.com",
+      });
+      const stepId = crypto.randomUUID();
+      const meta = { ...mockMeta, stepId, requestedByUserId: requester.id };
+      const executor = new HumanInTheLoopExecutor(mockDeps);
+
+      await executor.run({
+        config: {
+          title: "Deploy approval",
+          questions: [{ id: "q1", type: "approval", label: "Approve?", required: true }],
+          approvers: { policy: "any" },
+        },
+        context: {},
+        meta,
+      });
+
+      const created = getApprovalRequestByStepId(stepId);
+      expect(created?.createdBy).toBe(requester.id);
+    });
+
+    test("leaves createdBy unset when the workflow run carries no requester", async () => {
+      const stepId = crypto.randomUUID();
+      const meta = { ...mockMeta, stepId };
+      const executor = new HumanInTheLoopExecutor(mockDeps);
+
+      await executor.run({
+        config: {
+          title: "Deploy approval",
+          questions: [{ id: "q1", type: "approval", label: "Approve?", required: true }],
+          approvers: { policy: "any" },
+        },
+        context: {},
+        meta,
+      });
+
+      const created = getApprovalRequestByStepId(stepId);
+      expect(created?.createdBy).toBeUndefined();
+    });
+
     test("idempotency: returns async marker for pending existing request", async () => {
       const stepId = crypto.randomUUID();
       // Pre-create an approval request for this step

package/src/tests/audit-user.test.ts

@@ -11,9 +11,12 @@ import { unlink } from "node:fs/promises";
 import type { IncomingMessage } from "node:http";
 import { Readable } from "node:stream";
 import { resolveHttpAuditUserId, resolveTaskAuditUserId } from "../be/audit-user";
-import { closeDb, createAgent, createTaskExtended, createUser, initDb } from "../be/db";
+import { closeDb, createAgent, createTaskExtended, createUser, initDb, startTask } from "../be/db";
+import { type IdentityActor, linkIdentity } from "../be/users";
 import { setRequestAuth } from "../utils/request-auth-context";
 
+const SYSTEM_ACTOR: IdentityActor = { kind: "system", id: "test" };
+
 const TEST_DB_PATH = "./test-audit-user.sqlite";
 
 let agentId: string;
@@ -95,6 +98,49 @@ describe("resolveTaskAuditUserId", () => {
   test("returns null when owned task has no human requester", () => {
     expect(resolveTaskAuditUserId(noRequesterTaskId, agentId)).toBeNull();
   });
+
+  test("ambient-task fallback: no sourceTaskId resolves via the caller's current in-progress task", () => {
+    const ambientAgent = createAgent({ name: "ambient-agent", isLead: false, status: "idle" });
+    const ambientTask = createTaskExtended("ambient task", {
+      agentId: ambientAgent.id,
+      requestedByUserId: humanUserId,
+    });
+    startTask(ambientTask.id);
+
+    expect(resolveTaskAuditUserId(undefined, ambientAgent.id)).toBe(humanUserId);
+  });
+
+  test("ambient-task fallback: no in-progress task for the caller still returns null", () => {
+    const idleAgent = createAgent({ name: "idle-agent", isLead: false, status: "idle" });
+    expect(resolveTaskAuditUserId(undefined, idleAgent.id)).toBeNull();
+  });
+
+  test("machine-carried external-ID fallback: no requestedByUserId but a linked Slack id resolves the user", () => {
+    const slackLinkedUser = createUser({ name: "Slack Fallback User" });
+    linkIdentity(slackLinkedUser.id, "slack", "U_AUDIT_FALLBACK", SYSTEM_ACTOR);
+
+    const fallbackAgent = createAgent({ name: "fallback-agent", isLead: false, status: "idle" });
+    const fallbackTask = createTaskExtended("slack-originated task, requester never stamped", {
+      agentId: fallbackAgent.id,
+      slackUserId: "U_AUDIT_FALLBACK",
+    });
+
+    expect(resolveTaskAuditUserId(fallbackTask.id, fallbackAgent.id)).toBe(slackLinkedUser.id);
+  });
+
+  test("machine-carried external-ID fallback: unlinked Slack id still returns null (no guess)", () => {
+    const fallbackAgent = createAgent({
+      name: "fallback-agent-unlinked",
+      isLead: false,
+      status: "idle",
+    });
+    const fallbackTask = createTaskExtended("slack-originated task, unlinked sender", {
+      agentId: fallbackAgent.id,
+      slackUserId: "U_NEVER_LINKED_AUDIT",
+    });
+
+    expect(resolveTaskAuditUserId(fallbackTask.id, fallbackAgent.id)).toBeNull();
+  });
 });
 
 // ─── resolveHttpAuditUserId ──────────────────────────────────────────────────

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

@@ -255,8 +255,8 @@ describe("CodexSession event mapping", () => {
     expect(contextUsage).toBeDefined();
     if (contextUsage && contextUsage.type === "context_usage") {
       expect(contextUsage.contextUsedTokens).toBe(150);
-      expect(contextUsage.contextTotalTokens).toBe(200_000);
-      expect(contextUsage.contextPercent).toBeCloseTo((150 / 200_000) * 100, 6);
+      expect(contextUsage.contextTotalTokens).toBe(1_050_000);
+      expect(contextUsage.contextPercent).toBeCloseTo((150 / 1_050_000) * 100, 6);
       expect(contextUsage.contextFormula).toBe("input-cache-output");
     }
 
@@ -282,7 +282,7 @@ describe("CodexSession event mapping", () => {
     expect(result.sessionId).toBe("thread-abc");
   });
 
-  test("Phase 9: chatty turn clamps contextPercent to 100% under the unified formula", async () => {
+  test("Phase 9: chatty turn uses the models.dev context window under the unified formula", async () => {
     // Phase 9 deliberately swapped Codex's per-adapter peak-proxy formula
     // (`(input - cached) + output`) for the unified `input + output` formula
     // shared with every other provider. The trade-off: a chatty Codex turn
@@ -303,7 +303,7 @@ describe("CodexSession event mapping", () => {
       {
         type: "turn.completed",
         usage: {
-          input_tokens: 357142, // total > 200k window — would clamp pre-fix
+          input_tokens: 357142, // total exceeded the old hardcoded 200k window
           cached_input_tokens: 278912, // most of input is cache reuse
           output_tokens: 2156,
         },
@@ -320,11 +320,10 @@ describe("CodexSession event mapping", () => {
     const contextUsage = emitted.find((e) => e.type === "context_usage");
     expect(contextUsage).toBeDefined();
     if (contextUsage && contextUsage.type === "context_usage") {
-      // Phase 9 unified: input + output = 357142 + 2156 = 359298 (above 200k).
+      // Phase 9 unified: input + output = 357142 + 2156 = 359298.
       expect(contextUsage.contextUsedTokens).toBe(359298);
-      expect(contextUsage.contextTotalTokens).toBe(200_000);
-      // Above 100% raw → clamped to exactly 100.
-      expect(contextUsage.contextPercent).toBe(100);
+      expect(contextUsage.contextTotalTokens).toBe(1_050_000);
+      expect(contextUsage.contextPercent).toBeCloseTo((359298 / 1_050_000) * 100, 6);
       expect(contextUsage.contextFormula).toBe("input-cache-output");
     }
 
@@ -438,7 +437,7 @@ describe("CodexSession event mapping", () => {
     if (errorEvent && errorEvent.type === "error") {
       expect(errorEvent.message).toContain("[context-overflow]");
       expect(errorEvent.message).toContain("gpt-5.4");
-      expect(errorEvent.message).toContain("200,000 tokens");
+      expect(errorEvent.message).toContain("1,050,000 tokens");
       // original error preserved at the end
       expect(errorEvent.message).toContain("context length exceeded");
     }
@@ -748,16 +747,16 @@ describe("resolveCodexModel", () => {
     expect(resolveCodexModel("")).toBe(CODEX_DEFAULT_MODEL);
   });
 
-  test("claude shortname 'opus' → gpt-5.4", () => {
-    expect(resolveCodexModel("opus")).toBe("gpt-5.4");
+  test("claude shortname 'opus' → gpt-5.6-sol", () => {
+    expect(resolveCodexModel("opus")).toBe("gpt-5.6-sol");
   });
 
-  test("claude shortname 'sonnet' → gpt-5.4", () => {
-    expect(resolveCodexModel("sonnet")).toBe("gpt-5.4");
+  test("claude shortname 'sonnet' → gpt-5.6-terra", () => {
+    expect(resolveCodexModel("sonnet")).toBe("gpt-5.6-terra");
   });
 
-  test("claude shortname 'haiku' → gpt-5.4-mini", () => {
-    expect(resolveCodexModel("haiku")).toBe("gpt-5.4-mini");
+  test("claude shortname 'haiku' → gpt-5.6-luna", () => {
+    expect(resolveCodexModel("haiku")).toBe("gpt-5.6-luna");
   });
 
   test("passthrough 'gpt-5.4-mini' → gpt-5.4-mini", () => {
@@ -768,6 +767,12 @@ describe("resolveCodexModel", () => {
     expect(resolveCodexModel("gpt-5.5")).toBe("gpt-5.5");
   });
 
+  test("passthrough GPT-5.6 Codex models", () => {
+    expect(resolveCodexModel("gpt-5.6-sol")).toBe("gpt-5.6-sol");
+    expect(resolveCodexModel("gpt-5.6-terra")).toBe("gpt-5.6-terra");
+    expect(resolveCodexModel("gpt-5.6-luna")).toBe("gpt-5.6-luna");
+  });
+
   test("passthrough 'gpt-5.3-codex' → gpt-5.3-codex", () => {
     expect(resolveCodexModel("gpt-5.3-codex")).toBe("gpt-5.3-codex");
   });
@@ -787,24 +792,30 @@ describe("resolveCodexModel", () => {
 });
 
 describe("getCodexContextWindow", () => {
-  test("gpt-5.4 → 200_000", () => {
-    expect(getCodexContextWindow("gpt-5.4")).toBe(200_000);
+  test("gpt-5.4 → models.dev context", () => {
+    expect(getCodexContextWindow("gpt-5.4")).toBe(1_050_000);
   });
 
-  test("gpt-5.4-mini → 200_000", () => {
-    expect(getCodexContextWindow("gpt-5.4-mini")).toBe(200_000);
+  test("gpt-5.4-mini → models.dev context", () => {
+    expect(getCodexContextWindow("gpt-5.4-mini")).toBe(400_000);
   });
 
   test("gpt-5.5 → 1_050_000", () => {
     expect(getCodexContextWindow("gpt-5.5")).toBe(1_050_000);
   });
 
-  test("gpt-5.3-codex → 1_000_000 (1M context)", () => {
-    expect(getCodexContextWindow("gpt-5.3-codex")).toBe(1_000_000);
+  test("GPT-5.6 Codex models → 1_050_000", () => {
+    expect(getCodexContextWindow("gpt-5.6-sol")).toBe(1_050_000);
+    expect(getCodexContextWindow("gpt-5.6-terra")).toBe(1_050_000);
+    expect(getCodexContextWindow("gpt-5.6-luna")).toBe(1_050_000);
   });
 
-  test("gpt-5.2-codex → 200_000", () => {
-    expect(getCodexContextWindow("gpt-5.2-codex")).toBe(200_000);
+  test("gpt-5.3-codex → models.dev context", () => {
+    expect(getCodexContextWindow("gpt-5.3-codex")).toBe(400_000);
+  });
+
+  test("gpt-5.2-codex → models.dev context", () => {
+    expect(getCodexContextWindow("gpt-5.2-codex")).toBe(400_000);
   });
 });
 
@@ -821,6 +832,12 @@ describe("computeCodexCostUsd", () => {
     expect(cost).toBeCloseTo(35, 4);
   });
 
+  test("GPT-5.6 Codex model pricing matches OpenAI model docs", () => {
+    expect(computeCodexCostUsd("gpt-5.6-sol", 1_000_000, 0, 1_000_000)).toBeCloseTo(35, 4);
+    expect(computeCodexCostUsd("gpt-5.6-terra", 1_000_000, 0, 1_000_000)).toBeCloseTo(17.5, 4);
+    expect(computeCodexCostUsd("gpt-5.6-luna", 1_000_000, 0, 1_000_000)).toBeCloseTo(7, 4);
+  });
+
   test("gpt-5.4 with cached input applies the cached discount", () => {
     // 1M input, 800k cached → 200k uncached.
     // 200_000 × $2.50/M = $0.50
@@ -1133,6 +1150,12 @@ describe("buildCodexConfig", () => {
     expect(merged.model_reasoning_effort).toBe("xhigh");
   });
 
+  test("reasoningEffort: 'max' on gpt-5.6-sol is applied", async () => {
+    globalThis.fetch = stubFetch({ servers: [] });
+    const merged = await buildCodexConfig(cfg({ reasoningEffort: "max" }), "gpt-5.6-sol", () => {});
+    expect(merged.model_reasoning_effort).toBe("max");
+  });
+
   test("reasoningEffort: 'xhigh' on gpt-5.1-codex (non-max) is rejected — noop, no model_reasoning_effort key", async () => {
     globalThis.fetch = stubFetch({ servers: [] });
     const merged = await buildCodexConfig(

package/src/tests/credential-broker.test.ts

@@ -85,6 +85,7 @@ describe("credential broker", () => {
         scope: "global",
         active: true,
         scopeId: null,
+        authKind: "config",
       },
       {
         configKey: "QUERY_KEY",
@@ -93,6 +94,7 @@ describe("credential broker", () => {
         scope: "global",
         active: true,
         scopeId: null,
+        authKind: "config",
       },
     ]);
   });
@@ -133,13 +135,14 @@ describe("credential broker", () => {
         scope: "global",
         scopeId: null,
         active: true,
+        authKind: "config",
         placeholder: "[REDACTED:GITHUB_TOKEN]",
         value: "ghp_test",
       },
     ]);
   });
 
-  test("registers resolved broker config values with the scrubber", () => {
+  test("registers resolved broker config values with the scrubber", async () => {
     const bindingsConfig = upsertSwarmConfig({
       scope: "global",
       key: CREDENTIAL_BINDINGS_CONFIG_KEY,
@@ -161,7 +164,7 @@ describe("credential broker", () => {
     });
 
     try {
-      const bindings = buildScriptCredentialBindings({});
+      const bindings = await buildScriptCredentialBindings({});
 
       expect(bindings.some((binding) => binding.configKey === "VENDOR_SPECIAL_API_KEY")).toBe(true);
       expect(scrubSecrets("echo not_a_standard_token_shape_12345")).toBe(