@desplega.ai/agent-swarm 2.7.5 → 2.7.7

package/src/tools/task-dedup.ts

@@ -34,11 +34,53 @@ const HIGH_SIMILARITY_THRESHOLD = 0.8;
 /** Lower threshold used when the tasks also target the same agent */
 const SAME_AGENT_SIMILARITY_THRESHOLD = 0.6;
 
+/**
+ * Rows one duplicate check scans. The JS similarity match needs more than the
+ * query's default 50 (an older duplicate can sit behind newer unrelated tasks),
+ * but the scan must stay bounded: send-task runs it twice per call, once inside
+ * the write transaction.
+ */
+export const DEDUP_SCAN_LIMIT = 500;
+
 export interface DedupMatch {
   task: AgentTask;
   reason: string;
 }
 
+/**
+ * The description-similarity rules shared by the duplicate check and the
+ * follow-up re-delegation guard: a very similar description matches any
+ * target, a moderately similar one matches only the same target agent.
+ */
+export function matchSimilarTask(
+  existing: AgentTask,
+  opts: { taskDescription: string; targetAgentId?: string },
+): DedupMatch | null {
+  const similarity = jaccardSimilarity(existing.task, opts.taskDescription);
+
+  // Very similar task description: likely duplicate regardless of target
+  if (similarity > HIGH_SIMILARITY_THRESHOLD) {
+    return {
+      task: existing,
+      reason: `similar task description (${(similarity * 100).toFixed(0)}% match)`,
+    };
+  }
+
+  // Same target agent + moderately similar task: lower threshold
+  if (
+    opts.targetAgentId &&
+    existing.agentId === opts.targetAgentId &&
+    similarity > SAME_AGENT_SIMILARITY_THRESHOLD
+  ) {
+    return {
+      task: existing,
+      reason: `similar task to same agent (${(similarity * 100).toFixed(0)}% match)`,
+    };
+  }
+
+  return null;
+}
+
 /**
  * Check for duplicate tasks created recently.
  * Returns the first matching duplicate, or null if none found.
@@ -54,6 +96,7 @@ export async function findDuplicateTask(opts: {
   const recentTasks = await findRecentSimilarTasks({
     creatorAgentId: opts.creatorAgentId,
     windowMinutes: opts.windowMinutes ?? 10,
+    limit: DEDUP_SCAN_LIMIT,
   });
 
   for (const existing of recentTasks) {
@@ -70,27 +113,8 @@ export async function findDuplicateTask(opts: {
       };
     }
 
-    const similarity = jaccardSimilarity(existing.task, opts.taskDescription);
-
-    // 2. Very similar task description — likely duplicate regardless of target
-    if (similarity > HIGH_SIMILARITY_THRESHOLD) {
-      return {
-        task: existing,
-        reason: `similar task description (${(similarity * 100).toFixed(0)}% match)`,
-      };
-    }
-
-    // 3. Same target agent + moderately similar task — lower threshold
-    if (
-      opts.targetAgentId &&
-      existing.agentId === opts.targetAgentId &&
-      similarity > SAME_AGENT_SIMILARITY_THRESHOLD
-    ) {
-      return {
-        task: existing,
-        reason: `similar task to same agent (${(similarity * 100).toFixed(0)}% match)`,
-      };
-    }
+    const match = matchSimilarTask(existing, opts);
+    if (match) return match;
   }
 
   return null;

package/src/tools/utils.ts

@@ -22,6 +22,7 @@ import { upsertKv } from "../be/db";
 import { MCP_OVERFLOW_NAMESPACE, mcpOverflowNamespace } from "../kv-overflow";
 import { joinKvPath, type KvShapeEntry, splitKvPath, summarizeKvShape } from "../kv-view";
 import { withSpan } from "../otel";
+import { COLOR_LITERAL_THRESHOLD } from "../pages/color-literals";
 import type { PermissionVerb } from "../rbac/permissions";
 import { SCRIPT_LONG_TIMEOUT_HINT_MS } from "../scripts-runtime/executors/types";
 import { scrubObject, scrubSecrets } from "../utils/secret-scrubber";
@@ -314,6 +315,37 @@ const workflowLongScriptTimeoutNudge = (r: SwarmToolResult): string | undefined
   return hint ? WORKFLOW_LONG_SCRIPT_TIMEOUT_NUDGE : undefined;
 };
 
+/**
+ * One call can fall into more than one create_page trap, and a result carries
+ * one nudge, so this entry joins one sentence per trap that applies: a
+ * design version 1 page that uses the design system, theme tokens that set
+ * light colors only, and hardcoded colors. The tool computes the flags.
+ */
+const createPageNudge = (r: SwarmToolResult): string | undefined => {
+  if (!r.ok) return undefined;
+  const data = r.data as
+    | {
+        designVersion?: unknown;
+        usesDesignSystem?: unknown;
+        lightOnlyColors?: unknown;
+        colorLiteralCount?: unknown;
+      }
+    | undefined;
+  const count = data?.colorLiteralCount;
+  const sentences = [
+    data?.designVersion === 1 && data.usesDesignSystem === true
+      ? "This page is on designVersion 1 (the original look), so design system classes, tokens and themes have no effect. Pass designVersion: 2."
+      : undefined,
+    data?.lightOnlyColors === true
+      ? "Your themeTokens set colors for light mode only. Dark mode keeps the preset's dark colors; add a dark map (or a .dark block) to restyle it too."
+      : undefined,
+    typeof count === "number" && count >= COLOR_LITERAL_THRESHOLD
+      ? `This page hardcodes ${count} color values. Use theme tokens (var(--color-primary), bg-primary, text-muted-foreground) so theme and dark-mode switches restyle it. Until then the page stays light in a dark dashboard.`
+      : undefined,
+  ].filter((sentence) => sentence !== undefined);
+  return sentences.length > 0 ? sentences.join(" ") : undefined;
+};
+
 /**
  * Central conditional nudges, keyed by tool name. Applied by the finalize
  * pipeline when the tool did not set an explicit nudge. Keep entries to a
@@ -333,6 +365,7 @@ export const NUDGES: Record<string, (result: SwarmToolResult) => string | undefi
   "patch-workflow-node": workflowLongScriptTimeoutNudge,
   "slack-download-file": slackDownloadFileNudge,
   "slack-read": slackReadNudge,
+  create_page: createPageNudge,
   "script-search": (r) => {
     if (!r.ok) return undefined;
     // proxyScriptsApi wraps the parsed HTTP body as data = { status, data },

package/src/types.ts

@@ -4,6 +4,7 @@
 
 import { normalizeAssetKey } from "./assets/key";
 import { isSafeBundlePath } from "./extensions/bundle-path";
+import { THEME_IMPORT_FORMATS } from "./themes/import";
 import { MAX_PROFILE_FILE_LENGTH } from "./utils/constants";
 import { z } from "./utils/zod-openapi";
 
@@ -1695,6 +1696,8 @@ export const AgentLogEventTypeSchema = z.enum([
   "task_deferred_wait_woke",
   // The lead follow-up was skipped because the woken waiter already carries the result
   "task_follow_up_suppressed",
+  // Shadow follow-up gate: what a verifier said about a gated run (never skips the follow-up)
+  "task_follow_up_gate_shadow",
   // store-progress refused a completion once because its citations were inaccurate
   "task_citation_check_refused",
   "channel_message",
@@ -2212,6 +2215,39 @@ export const RuntimeControllerSchema = RuntimeControllerCreateSchema.omit({ secr
   .openapi("RuntimeController");
 export type RuntimeController = z.infer<typeof RuntimeControllerSchema>;
 
+export const RuntimePoolCacheSchema = z
+  .object({
+    mountPath: z
+      .string()
+      .min(2)
+      .refine((path) => {
+        const parts = path.split("/").filter(Boolean);
+        const normalized = `/${parts.join("/")}`;
+        const protectedPaths = [
+          "/workspace/personal",
+          "/workspace/shared",
+          ...["/home/worker", "/root"].flatMap((home) =>
+            [".ssh", ".codex", ".claude", ".claude.json", ".pi", ".config", ".local"].map(
+              (directory) => `${home}/${directory}`,
+            ),
+          ),
+        ];
+        return (
+          path.startsWith("/") &&
+          parts.length > 0 &&
+          !path.includes("\0") &&
+          !parts.some((part) => part === "." || part === "..") &&
+          !protectedPaths.some(
+            (protectedPath) =>
+              protectedPath === normalized ||
+              protectedPath.startsWith(`${normalized}/`) ||
+              normalized.startsWith(`${protectedPath}/`),
+          )
+        );
+      }, "Cache mountPath must be absolute, without . or .., and must not cover worker homes, workspaces or credential directories"),
+  })
+  .strict();
+
 export const RuntimePoolCreateSchema = z
   .object({
     name: z.string().min(1).max(200),
@@ -2226,6 +2262,7 @@ export const RuntimePoolCreateSchema = z
     delivery: DeliveryModeSchema.nullable().default(null),
     env: z.record(z.string(), z.string()).default({}),
     resources: RuntimeResourcesSchema.nullable().default(null),
+    cache: RuntimePoolCacheSchema.nullable().default(null),
     ttlSec: z.number().int().positive().nullable().default(null),
     enabled: z.boolean().default(true),
   })
@@ -2239,6 +2276,7 @@ export const RuntimePoolUpdateSchema = RuntimePoolCreateSchema.partial().extend(
   delivery: DeliveryModeSchema.nullable().optional(),
   env: z.record(z.string(), z.string()).optional(),
   resources: RuntimeResourcesSchema.nullable().optional(),
+  cache: RuntimePoolCacheSchema.nullable().optional(),
   ttlSec: z.number().int().positive().nullable().optional(),
   enabled: z.boolean().optional(),
 });
@@ -2738,10 +2776,36 @@ export type PageContentType = z.infer<typeof PageContentTypeSchema>;
 export const PageAuthModeSchema = z.enum(["public", "authed", "password"]);
 export type PageAuthMode = z.infer<typeof PageAuthModeSchema>;
 
+// Per-page theme overrides as stored: page token names (`--color-primary`,
+// `--radius-lg`) mapped to CSS values, per mode. Writes go through
+// `importThemeTokens` (src/themes/import.ts), which maps outside names onto the
+// token contract and checks every value, so the stored form is always normalized.
+export const PageThemeTokensSchema = z
+  .object({
+    light: z.record(z.string(), z.string()),
+    dark: z.record(z.string(), z.string()),
+  })
+  .openapi("PageThemeTokens");
+
+// Write-side `themeTokens` input, mirroring `ThemeImportInput` (src/themes/import.ts)
+// as one flat object: the default `tokens` format sends `light` / `dark` maps,
+// the `css` format sends a CSS variable block. `importThemeTokens` checks which
+// fields go with which format, so a mismatch gets a precise error message. The
+// `format` enum is the importer's own list, so a new importer needs no change
+// here unless it takes a new payload field.
+export const PageThemeTokensInputSchema = z.strictObject({
+  format: z.enum(THEME_IMPORT_FORMATS).optional(),
+  light: z.record(z.string(), z.string()).optional(),
+  dark: z.record(z.string(), z.string()).optional(),
+  css: z.string().optional(),
+});
+export type PageThemeTokensInput = z.infer<typeof PageThemeTokensInputSchema>;
+
 // PageSnapshot captures the mutable content fields frozen per-version in
 // page_versions.snapshot. Omits id / agentId / slug / timestamps (these are
 // invariant across versions for a given page id; the slug is a parent-only
-// identifier).
+// identifier). The design fields are optional because snapshots taken before
+// design version 2 do not carry them (they read as design version 1).
 export const PageSnapshotSchema = z
   .object({
     title: z.string(),
@@ -2751,6 +2815,9 @@ export const PageSnapshotSchema = z
     passwordHash: z.string().optional(),
     body: z.string(),
     needsCredentials: z.array(z.string()).optional(),
+    theme: z.string().nullable().optional(),
+    themeTokens: PageThemeTokensSchema.nullable().optional(),
+    designVersion: z.number().int().min(1).optional(),
   })
   .openapi("PageSnapshot");
 export type PageSnapshot = z.infer<typeof PageSnapshotSchema>;
@@ -2768,6 +2835,9 @@ export const PageSchema = z
     passwordHash: z.string().optional(),
     body: z.string(),
     needsCredentials: z.array(z.string()).optional(),
+    theme: z.string().nullable(),
+    themeTokens: PageThemeTokensSchema.nullable(),
+    designVersion: z.number().int().min(1),
     viewCount: z.number().int().min(0).default(0),
     createdAt: z.string(),
     updatedAt: z.string(),
@@ -2791,8 +2861,15 @@ export type WorkflowSummary = Omit<
   "definition" | "triggers" | "cooldown" | "input" | "triggerSchema"
 > & { nodeCount: number };
 
-/** `/api/pages` list item — drops the (potentially huge) `body` and `passwordHash`. */
-export type PageSummary = Omit<Page, "body" | "passwordHash">;
+/**
+ * `/api/pages` list item: drops the (potentially huge) `body` and `passwordHash`,
+ * plus the design fields (`theme`, `themeTokens`, `designVersion`). List views do
+ * not render a page, so those only come with `?fields=full` or the get-by-id route.
+ */
+export type PageSummary = Omit<
+  Page,
+  "body" | "passwordHash" | "theme" | "themeTokens" | "designVersion"
+>;
 
 /** `/api/schedules` list item — swaps the full `taskTemplate` for a short preview. */
 export type ScheduledTaskSummary = Omit<ScheduledTask, "taskTemplate"> & {
@@ -3114,6 +3191,8 @@ export const ScriptRunSchema = z
     lastHeartbeatAt: z.string().optional(),
     idempotencyKey: z.string().optional(),
     requestedByUserId: z.string().optional(),
+    /** Task whose session launched the run; the follow-up re-delegation guard reads it. */
+    sourceTaskId: z.string().optional(),
   })
   .openapi("ScriptRun");
 export type ScriptRun = z.infer<typeof ScriptRunSchema>;
@@ -3122,6 +3201,7 @@ export const ScriptRunListItemSchema = ScriptRunSchema.omit({
   source: true,
   args: true,
   output: true,
+  sourceTaskId: true,
 });
 export type ScriptRunListItem = z.infer<typeof ScriptRunListItemSchema>;
 

package/src/utils/constants.ts

@@ -3,6 +3,7 @@
  */
 
 import { isEnvFlagEnabled, parseEnvFlag } from "./env-flag";
+import { isDevOrTestNodeEnv } from "./node-env";
 
 /** Maximum profile-file length in JavaScript characters (not UTF-8 bytes). */
 export const MAX_PROFILE_FILE_LENGTH = 256 * 1024;
@@ -45,6 +46,24 @@ export function getAppUrl(fallback = DEFAULT_APP_URL): string {
   return (getConfiguredAppUrls()[0] || fallback).replace(/\/+$/, "");
 }
 
+/**
+ * Local dashboard origins (Vite ports and portless `*.localhost`) that may
+ * iframe pages without being listed in `APP_URL`. Returned only when NODE_ENV
+ * is explicitly development or test: deployed images leave NODE_ENV unset, and
+ * an unset value must not let a localhost origin frame production pages.
+ */
+export function getLocalDevAppOrigins(): string[] {
+  if (!isDevOrTestNodeEnv()) return [];
+  return [
+    "http://localhost:5274",
+    "http://localhost:5175",
+    "http://127.0.0.1:5274",
+    "http://127.0.0.1:5175",
+    "https://*.localhost",
+    "http://*.localhost",
+  ];
+}
+
 /**
  * Internal API/MCP base URL — how workers/agents and in-process callers reach
  * the API server. May be a private/cluster address (e.g. the Helm ClusterIP

package/src/utils/follow-up-gate-schedule-ids.ts

@@ -0,0 +1,13 @@
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/** Split `FOLLOW_UP_GATE_SCHEDULE_IDS`, a comma-separated id list. Blank entries are dropped. */
+export function parseFollowUpGateScheduleIds(raw: string | undefined): string[] {
+  return (raw ?? "")
+    .split(",")
+    .map((id) => id.trim())
+    .filter(Boolean);
+}
+
+export function isFollowUpGateScheduleId(id: string): boolean {
+  return UUID_RE.test(id);
+}

package/src/utils/internal-ai/credentials.ts

@@ -108,6 +108,30 @@ export interface ResolveCredentialOptions {
   _persistCodexOAuth?: typeof persistCodexOAuth;
 }
 
+/**
+ * Credential kinds in precedence order. `resolveCredentials` walks this list;
+ * `resolveCredential` returns the first hit.
+ */
+export const CREDENTIAL_KIND_PRECEDENCE: readonly CredentialKind[] = [
+  "openrouter",
+  "anthropic",
+  "openai",
+  "openai-codex",
+  "claude-cli",
+];
+
+export interface ResolveCredentialsOptions extends ResolveCredentialOptions {
+  /**
+   * Only resolve these kinds (in precedence order). Lets a caller probe one
+   * provider at a time, so the codex OAuth lookup (an HTTP call that can
+   * rotate a refresh token) runs only when that kind is actually needed.
+   * Default: every kind.
+   */
+  kinds?: readonly CredentialKind[];
+  /** Stop after this many credentials. Default: no limit. */
+  limit?: number;
+}
+
 /**
  * Resolve a credential according to the documented precedence. Returns `null`
  * if no credential could be resolved — callers MUST treat null as a graceful
@@ -125,112 +149,141 @@ export interface ResolveCredentialOptions {
 export async function resolveCredential(
   opts: ResolveCredentialOptions = {},
 ): Promise<ResolvedCredential | null> {
+  const [first] = await resolveCredentials({ ...opts, limit: 1 });
+  return first ?? null;
+}
+
+/**
+ * Every credential the environment offers, in the precedence order documented
+ * on {@link resolveCredential}. Callers that can fall back across providers
+ * (task titles) walk the list; `resolveCredential` is the `limit: 1` case.
+ * The codex OAuth probe runs only when `openai-codex` is reached, so an env
+ * key ahead of it (or `kinds` that exclude it) never triggers the HTTP call.
+ */
+export async function resolveCredentials(
+  opts: ResolveCredentialsOptions = {},
+): Promise<ResolvedCredential[]> {
   const env = opts.env ?? process.env;
   const getEnvKey = opts._getEnvApiKey ?? getEnvApiKey;
-  const getCodex = opts._getValidCodexOAuth ?? getValidCodexOAuth;
-  const getOAuth = opts._getOAuthApiKey ?? resolveOAuthApiKey;
-  const persistCodex = opts._persistCodexOAuth ?? persistCodexOAuth;
+  const wanted = opts.kinds ?? CREDENTIAL_KIND_PRECEDENCE;
+  const limit = opts.limit ?? Number.POSITIVE_INFINITY;
+  const found: ResolvedCredential[] = [];
 
-  // 1. OpenRouter.
-  const openrouterKey = env.OPENROUTER_API_KEY ?? getEnvKey("openrouter");
-  if (openrouterKey) {
-    return {
-      kind: "openrouter",
-      apiKey: selectCredential(openrouterKey, undefined, "OPENROUTER_API_KEY").selected,
-      modelDefault: resolveRaterModelString("openrouter"),
-    };
+  for (const kind of CREDENTIAL_KIND_PRECEDENCE) {
+    if (found.length >= limit) break;
+    if (!wanted.includes(kind)) continue;
+    const cred = await resolveKind(kind, opts, env, getEnvKey);
+    if (cred) found.push(cred);
   }
+  return found;
+}
 
-  // 2. Anthropic. pi-ai sends this key to api.anthropic.com, so skip it when
-  // ANTHROPIC_BASE_URL names a gateway: the key belongs to the gateway (#1800).
-  const anthropicBaseUrl = env.ANTHROPIC_BASE_URL?.trim();
-  const anthropicKeyIsForGateway =
-    Boolean(anthropicBaseUrl) && !isFirstPartyAnthropicUrl(anthropicBaseUrl ?? "");
-  const anthropicKey = anthropicKeyIsForGateway
-    ? undefined
-    : (env.ANTHROPIC_API_KEY ?? getEnvKey("anthropic"));
-  if (anthropicKey) {
-    return {
-      kind: "anthropic",
-      apiKey: selectCredential(anthropicKey, undefined, "ANTHROPIC_API_KEY").selected,
-      modelDefault: resolveRaterModelString("anthropic"),
-    };
+async function resolveKind(
+  kind: CredentialKind,
+  opts: ResolveCredentialOptions,
+  env: NodeJS.ProcessEnv,
+  getEnvKey: typeof getEnvApiKey,
+): Promise<ResolvedCredential | null> {
+  switch (kind) {
+    case "openrouter": {
+      const key = env.OPENROUTER_API_KEY ?? getEnvKey("openrouter");
+      if (!key) return null;
+      return {
+        kind,
+        apiKey: selectCredential(key, undefined, "OPENROUTER_API_KEY").selected,
+        modelDefault: resolveRaterModelString(kind),
+      };
+    }
+    case "anthropic": {
+      // pi-ai sends this key to api.anthropic.com, so skip it when
+      // ANTHROPIC_BASE_URL names a gateway: the key belongs to the gateway (#1800).
+      const anthropicBaseUrl = env.ANTHROPIC_BASE_URL?.trim();
+      const keyIsForGateway =
+        Boolean(anthropicBaseUrl) && !isFirstPartyAnthropicUrl(anthropicBaseUrl ?? "");
+      const key = keyIsForGateway ? undefined : (env.ANTHROPIC_API_KEY ?? getEnvKey("anthropic"));
+      if (!key) return null;
+      return {
+        kind,
+        apiKey: selectCredential(key, undefined, "ANTHROPIC_API_KEY").selected,
+        modelDefault: resolveRaterModelString(kind),
+      };
+    }
+    case "openai": {
+      const key = env.OPENAI_API_KEY ?? getEnvKey("openai");
+      if (!key) return null;
+      return {
+        kind,
+        apiKey: selectCredential(key, undefined, "OPENAI_API_KEY").selected,
+        modelDefault: resolveRaterModelString(kind),
+      };
+    }
+    case "openai-codex":
+      // Only if we have apiUrl + apiKey to probe the config store.
+      if (!opts.apiUrl || !opts.apiKey) return null;
+      return resolveCodexOAuthCredential(opts, opts.apiUrl, opts.apiKey);
+    case "claude-cli":
+      // `AGENT_SWARM_CLAUDE_OAUTH_TOKEN` is the mirror set by claude-adapter.ts
+      // before spawning `claude` — the CLI strips `CLAUDE_CODE_OAUTH_TOKEN` from
+      // hook subprocesses (security), so the hook reads the mirror instead.
+      if (!env.AGENT_SWARM_CLAUDE_OAUTH_TOKEN && !env.CLAUDE_CODE_OAUTH_TOKEN) return null;
+      return { kind, modelDefault: resolveRaterModelString(kind) };
   }
+}
 
-  // 3. OpenAI.
-  const openaiKey = env.OPENAI_API_KEY ?? getEnvKey("openai");
-  if (openaiKey) {
-    return {
-      kind: "openai",
-      apiKey: selectCredential(openaiKey, undefined, "OPENAI_API_KEY").selected,
-      modelDefault: resolveRaterModelString("openai"),
+async function resolveCodexOAuthCredential(
+  opts: ResolveCredentialOptions,
+  apiUrl: string,
+  apiKey: string,
+): Promise<ResolvedCredential | null> {
+  const getCodex = opts._getValidCodexOAuth ?? getValidCodexOAuth;
+  const getOAuth = opts._getOAuthApiKey ?? resolveOAuthApiKey;
+  const persistCodex = opts._persistCodexOAuth ?? persistCodexOAuth;
+  try {
+    const codexCreds = await getCodex(apiUrl, apiKey);
+    if (!codexCreds) return null;
+    // pi-ai expects a Record<providerID, OAuthCredentials>.
+    const credMap: Record<string, OAuthCredentials> = {
+      "openai-codex": {
+        access: codexCreds.access,
+        refresh: codexCreds.refresh,
+        expires: codexCreds.expires,
+      },
     };
-  }
-
-  // 4. Codex OAuth — only if we have apiUrl + apiKey to probe the config store.
-  if (opts.apiUrl && opts.apiKey) {
-    try {
-      const codexCreds = await getCodex(opts.apiUrl, opts.apiKey);
-      if (codexCreds) {
-        // pi-ai expects a Record<providerID, OAuthCredentials>.
-        const credMap: Record<string, OAuthCredentials> = {
-          "openai-codex": {
-            access: codexCreds.access,
-            refresh: codexCreds.refresh,
-            expires: codexCreds.expires,
-          },
-        };
-        const oauthResult = await getOAuth("openai-codex", credMap);
-        if (oauthResult) {
-          // Persist any rotated refresh token — best-effort, must not block.
-          // Wrap defensively here even though the production helper already
-          // swallows; tests may inject a throwing hook, and persistence
-          // failure must never prevent the current call from succeeding.
-          if (oauthResult.newCredentials) {
-            const updated = oauthResult.newCredentials;
-            try {
-              await persistCodex(opts.apiUrl, opts.apiKey, {
-                access: String(updated.access),
-                refresh: String(updated.refresh),
-                expires: Number(updated.expires),
-                accountId: codexCreds.accountId,
-              });
-            } catch (err) {
-              console.error(
-                `internal-ai: persistCodexOAuth failed (callerTag=${opts.callerTag ?? "<unset>"}):`,
-                err,
-              );
-            }
-          }
-          return {
-            kind: "openai-codex",
-            apiKey: oauthResult.apiKey,
-            modelDefault: resolveRaterModelString("openai-codex"),
-          };
-        }
+    const oauthResult = await getOAuth("openai-codex", credMap);
+    if (!oauthResult) return null;
+    // Persist any rotated refresh token — best-effort, must not block.
+    // Wrap defensively here even though the production helper already
+    // swallows; tests may inject a throwing hook, and persistence
+    // failure must never prevent the current call from succeeding.
+    if (oauthResult.newCredentials) {
+      const updated = oauthResult.newCredentials;
+      try {
+        await persistCodex(apiUrl, apiKey, {
+          access: String(updated.access),
+          refresh: String(updated.refresh),
+          expires: Number(updated.expires),
+          accountId: codexCreds.accountId,
+        });
+      } catch (err) {
+        console.error(
+          `internal-ai: persistCodexOAuth failed (callerTag=${opts.callerTag ?? "<unset>"}):`,
+          err,
+        );
       }
-    } catch (err) {
-      console.error(
-        `internal-ai: codex OAuth probe failed (callerTag=${opts.callerTag ?? "<unset>"}):`,
-        err,
-      );
-      // Fall through to claude-cli fallback below.
     }
-  }
-
-  // 5. CLAUDE_CODE_OAUTH_TOKEN → claude-cli fallback.
-  // `AGENT_SWARM_CLAUDE_OAUTH_TOKEN` is the mirror set by claude-adapter.ts
-  // before spawning `claude` — the CLI strips `CLAUDE_CODE_OAUTH_TOKEN` from
-  // hook subprocesses (security), so the hook reads the mirror instead.
-  if (env.AGENT_SWARM_CLAUDE_OAUTH_TOKEN || env.CLAUDE_CODE_OAUTH_TOKEN) {
     return {
-      kind: "claude-cli",
-      modelDefault: resolveRaterModelString("claude-cli"),
+      kind: "openai-codex",
+      apiKey: oauthResult.apiKey,
+      modelDefault: resolveRaterModelString("openai-codex"),
     };
+  } catch (err) {
+    console.error(
+      `internal-ai: codex OAuth probe failed (callerTag=${opts.callerTag ?? "<unset>"}):`,
+      err,
+    );
+    // The caller falls through to the claude-cli fallback.
+    return null;
   }
-
-  // 6. No creds.
-  return null;
 }
 
 // Re-export for convenience to keep imports flat.

package/src/utils/internal-ai/index.ts

@@ -19,11 +19,14 @@ export {
   completeStructuredWithModel,
 } from "./complete-structured.js";
 export {
+  CREDENTIAL_KIND_PRECEDENCE,
   type CredentialKind,
   DEFAULT_MODEL,
   type ResolveCredentialOptions,
+  type ResolveCredentialsOptions,
   type ResolvedCredential,
   resolveCredential,
+  resolveCredentials,
 } from "./credentials.js";
 export {
   MEMORY_RATER_DEFAULT_MODEL,
@@ -36,3 +39,10 @@ export {
   summarizeSession,
   summaryToolSchema,
 } from "./summarize-session.js";
+export {
+  type GenerateTaskTitleOptions,
+  type GenerateTaskTitleResult,
+  generateTaskTitle,
+  TASK_TITLE_MODEL_CANDIDATES,
+  TASK_TITLE_MODEL_ENV,
+} from "./task-title.js";

package/src/utils/internal-ai/models.ts

@@ -59,6 +59,24 @@ export function resolveRaterModelString(kind: CredentialKind): string {
   return process.env.MEMORY_RATER_MODEL ?? MEMORY_RATER_DEFAULT_MODEL[kind];
 }
 
+const PROVIDER_TO_KIND: Record<string, CredentialKind> = {
+  openrouter: "openrouter",
+  anthropic: "anthropic",
+  openai: "openai",
+  "openai-codex": "openai-codex",
+};
+
+/**
+ * Credential kind a model string belongs to. `provider/model-id` maps through
+ * the provider prefix; a bare alias (`haiku`) is a `claude -p` model. `null`
+ * for a provider the internal-ai layer cannot call.
+ */
+export function kindForModelString(modelStr: string): CredentialKind | null {
+  const slash = modelStr.indexOf("/");
+  if (slash < 0) return "claude-cli";
+  return PROVIDER_TO_KIND[modelStr.slice(0, slash)] ?? null;
+}
+
 /**
  * Split a `provider/model-id` string on the FIRST `/` so that OpenRouter
  * compound IDs like `openrouter/deepseek/deepseek-v4.1-flash` parse as