@desplega.ai/agent-swarm 2.0.0 → 2.1.0

package/src/tests/workflow-llm.test.ts

@@ -77,6 +77,67 @@ describe("resolveWorkflowLlmConfig", () => {
     expect(config.model).toBe("gpt-5.4");
   });
 
+  test("routes a registry-provider model to that provider, not OpenRouter", async () => {
+    const config = await resolveWorkflowLlmConfig("nan/qwen3.8-flash", {
+      OPENROUTER_API_KEY: "sk-or-test",
+      NAN_API_KEY: "nan-test",
+    });
+
+    expect(config).toEqual({
+      apiKey: "nan-test",
+      baseURL: "https://api.nan.builders/v1",
+      headers: {},
+      model: "qwen3.8-flash",
+    });
+  });
+
+  test("reads a registry provider's alias key and base URL override", async () => {
+    const config = await resolveWorkflowLlmConfig("nan/deepseek-v4-flash", {
+      HELMCODE_API_NAN: "nan-alias",
+      NAN_BASE_URL: "https://nan.example.test/v1/",
+    });
+
+    expect(config.apiKey).toBe("nan-alias");
+    expect(config.baseURL).toBe("https://nan.example.test/v1");
+    expect(config.model).toBe("deepseek-v4-flash");
+  });
+
+  test("hands the SDK one key from a canonical NaN key pool", async () => {
+    const pool = ["nan-pool-a", "nan-pool-b", "nan-pool-c"];
+    for (let i = 0; i < 20; i++) {
+      const config = await resolveWorkflowLlmConfig("nan/qwen3.8-flash", {
+        NAN_API_KEY: ` ${pool.join(", ")} `,
+      });
+      expect(pool).toContain(config.apiKey);
+    }
+  });
+
+  test("hands the SDK one key from an alias NaN key pool", async () => {
+    const pool = ["nan-alias-a", "nan-alias-b"];
+    for (let i = 0; i < 20; i++) {
+      const config = await resolveWorkflowLlmConfig("nan/deepseek-v4-flash", {
+        HELMCODE_API_NAN: pool.join(","),
+      });
+      expect(pool).toContain(config.apiKey);
+    }
+  });
+
+  test("fails a registry-provider model without its key instead of falling back to OpenRouter", async () => {
+    await expect(
+      resolveWorkflowLlmConfig("nan/qwen3.8-flash", { OPENROUTER_API_KEY: "sk-or-test" }),
+    ).rejects.toThrow("No NaN credential found for nan/qwen3.8-flash. Set NAN_API_KEY.");
+  });
+
+  test("keeps OpenRouter vendor ids on OpenRouter", async () => {
+    const config = await resolveWorkflowLlmConfig("deepseek/deepseek-v4.1-flash", {
+      OPENROUTER_API_KEY: "sk-or-test",
+      NAN_API_KEY: "nan-test",
+    });
+
+    expect(config.apiKey).toBe("sk-or-test");
+    expect(config.model).toBe("deepseek/deepseek-v4.1-flash");
+  });
+
   test("rejects credential kinds without an OpenAI-compatible endpoint", async () => {
     await expect(
       resolveWorkflowLlmConfig(undefined, { ANTHROPIC_API_KEY: "example-sk-ant-test" }),

package/src/tools/model-profiles/list-model-profiles.ts

@@ -0,0 +1,54 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { listModelProfiles } from "@/be/db/model-profiles";
+import { createToolRegistrar, swarmToolOutputSchema, toolOk } from "@/tools/utils";
+import { ProviderNameSchema } from "@/types";
+
+export const registerListModelProfilesTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "list-model-profiles",
+    {
+      title: "List Model Profiles",
+      description:
+        "List model profiles: named harness + model + effort combinations. Pass a profile's name as `profile` on send-task to run that task on it, or set it as an agent's default through PATCH /api/agents/{id}/runtime. A profile runs only on its own harness. Filter by `harness` to see what an agent on that harness can run.",
+      annotations: { readOnlyHint: true },
+      inputSchema: z.object({
+        harness: ProviderNameSchema.optional().describe(
+          "Only profiles for this harness (claude, codex, pi, ...).",
+        ),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        profiles: z
+          .array(
+            z.looseObject({
+              name: z.string().optional(),
+              harness: z.string().optional(),
+              model: z.string().optional(),
+              effort: z.string().nullable().optional(),
+              description: z.string().nullable().optional(),
+            }),
+          )
+          .optional(),
+      }),
+    },
+    async ({ harness }) => {
+      const profiles = await listModelProfiles({ harness });
+      const lines = profiles.map(
+        (p) =>
+          `${p.name}: ${p.harness} / ${p.model}${p.effort ? ` / effort ${p.effort}` : ""}${p.description ? ` (${p.description})` : ""}`,
+      );
+      return toolOk(`${profiles.length} model profile(s)${harness ? ` for ${harness}` : ""}.`, {
+        details: lines.join("\n"),
+        data: {
+          profiles: profiles.map((p) => ({
+            name: p.name,
+            harness: p.harness,
+            model: p.model,
+            effort: p.effort,
+            description: p.description,
+          })),
+        },
+      });
+    },
+  );
+};

package/src/tools/request-human-input.ts

@@ -56,6 +56,12 @@ export const registerRequestHumanInputTool = (server: McpServer) => {
           .describe(
             "Seconds until the request expires. After that the request becomes 'timeout' and you get a hitl-follow-up task. A request with no timeout is cancelled after APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS days (default 7).",
           ),
+        detached: z
+          .boolean()
+          .optional()
+          .describe(
+            "Do not attach the request to your current task, so no hitl-follow-up task is created. For scripts that read the request's status themselves.",
+          ),
       }),
       outputSchema: swarmToolOutputSchema({
         yourAgentId: z.string().optional(),
@@ -63,7 +69,7 @@ export const registerRequestHumanInputTool = (server: McpServer) => {
         url: z.string().optional(),
       }),
     },
-    async ({ title, questions, timeoutSeconds }, requestInfo) => {
+    async ({ title, questions, timeoutSeconds, detached }, requestInfo) => {
       if (!requestInfo.agentId) {
         return toolErr(
           'Agent ID not found. The MCP client should define the "X-Agent-ID" header.',
@@ -74,8 +80,10 @@ export const registerRequestHumanInputTool = (server: McpServer) => {
       // Resolve sourceTaskId: prefer header, fall back to agent's current in-progress task.
       // The X-Source-Task-Id header may be missing when the per-session MCP config wasn't
       // created (e.g. .mcp.json not found, session resumed, or lead agent on a non-task trigger).
-      let sourceTaskId = requestInfo.sourceTaskId;
-      if (!sourceTaskId && requestInfo.agentId) {
+      // A detached request has no source task: a script call carries no task
+      // header, and the agent's current task is unrelated to the script.
+      let sourceTaskId = detached ? undefined : requestInfo.sourceTaskId;
+      if (!sourceTaskId && !detached && requestInfo.agentId) {
         const currentTask = await getAgentCurrentTask(requestInfo.agentId);
         if (currentTask) {
           sourceTaskId = currentTask.id;

package/src/tools/script-apis.ts

@@ -149,7 +149,11 @@ export const registerScriptApisTool = (server: McpServer) => {
             agentId: args.agentId,
           },
           requestInfo,
-          successMessage: (data) => `Endpoint ${(data as ScriptApiWithSecret).id} created.`,
+          successMessage: (data) => {
+            const warnings = (data as { warnings?: string[] }).warnings ?? [];
+            const note = warnings.length > 0 ? `\n${warnings.join("\n")}` : "";
+            return `Endpoint ${(data as ScriptApiWithSecret).id} created.${note}`;
+          },
           successDetails: (data) => {
             const token = (data as ScriptApiWithSecret).token;
             return token ? `Bearer token (shown once — save it now): ${token}` : undefined;

package/src/tools/script-upsert.ts

@@ -47,11 +47,14 @@ export const registerScriptUpsertTool = (server: McpServer) => {
             name?: unknown;
             version?: unknown;
             contentDeduped?: unknown;
+            warnings?: unknown;
           };
           const name = typeof body.name === "string" ? body.name : args.name;
           const version = typeof body.version === "number" ? ` v${body.version}` : "";
           const deduped = body.contentDeduped ? " (content unchanged — deduped)" : "";
-          return `Script \`${name}\`${version} saved.${deduped}`;
+          const warnings = Array.isArray(body.warnings) ? body.warnings.map(String) : [];
+          const note = warnings.length > 0 ? `\n${warnings.join("\n")}` : "";
+          return `Script \`${name}\`${version} saved.${deduped}${note}`;
         },
       }),
   );

package/src/tools/send-task.ts

@@ -18,6 +18,7 @@ import {
   isExtensionAgent,
   isLinearTrackerContextKey,
 } from "@/be/db";
+import { modelProfileRefError, taskProfileError } from "@/be/db/model-profiles";
 import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
 import { explicitModelErrorForAgent } from "@/be/model-validation";
 import { applyPreTaskCreate } from "@/extensions/apply-task-create";
@@ -150,6 +151,14 @@ export const sendTaskInputSchema = z
     effort: ReasoningEffortSchema.optional().describe(
       "Reasoning effort for this task: 'off', 'low', 'medium', 'high', 'xhigh', or 'max'. If omitted, the assignee's REASONING_EFFORT_OVERRIDE/default applies.",
     ),
+    profile: z
+      .string()
+      .trim()
+      .min(1)
+      .optional()
+      .describe(
+        "Model profile name (see list-model-profiles): a named harness + model + effort, applied when the task is claimed. Must run on the assignee's harness. Exclusive with model and modelTier. A set `effort` still wins over the profile's.",
+      ),
     allowDuplicate: z
       .boolean()
       .default(false)
@@ -281,6 +290,7 @@ export async function sendTaskHandler(
     modelTier,
     allowCustomModel,
     effort,
+    profile,
     allowDuplicate,
     slackChannelId,
     slackThreadTs,
@@ -474,6 +484,13 @@ export async function sendTaskHandler(
     agentId: effectiveAgentId,
   });
   if (modelError) return toolErr(modelError, { data: { yourAgentId: creatorAgentId } });
+  const profileError = await taskProfileError({
+    profile,
+    model: normalizedModel.model,
+    modelTier: normalizedModel.modelTier,
+    agentId: effectiveAgentId,
+  });
+  if (profileError) return toolErr(profileError, { data: { yourAgentId: creatorAgentId } });
   const effectiveRoutingReason =
     requestedAgentId !== undefined
       ? requestedRoutingReason
@@ -508,6 +525,7 @@ export async function sendTaskHandler(
     model: normalizedModel.model,
     modelTier: normalizedModel.modelTier,
     effort,
+    profile,
     slackChannelId,
     slackThreadTs,
     slackUserId,
@@ -647,7 +665,7 @@ export async function sendTaskHandler(
       : toolErr(guard.message, { data: guardData });
   }
 
-  const result = await getDbClient().transaction(async () => {
+  const created = getDbClient().transaction(async () => {
     // Authoritative re-check: the reads above are separated from the INSERT by
     // the whole handler, so only a guard inside this transaction can see a
     // concurrent send-task's committed task.
@@ -743,6 +761,11 @@ export async function sendTaskHandler(
       task: newTask,
     };
   });
+  const result = await created.catch((error: unknown) => {
+    // The profile was deleted between taskProfileError and the insert.
+    if (modelProfileRefError(error) !== "missing") throw error;
+    return { success: false, message: `Unknown model profile "${profile}".`, task: undefined };
+  });
 
   const data = {
     yourAgentId: creatorAgentId,

package/src/tools/system-one-decide.ts

@@ -0,0 +1,104 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
+import { getExecutorRegistry } from "@/workflows";
+import {
+  SYSTEM_ONE_DECISION_NODE_TYPE,
+  SystemOneDecisionConfigSchema,
+  SystemOneDecisionExecutor,
+} from "@/workflows/executors/system-one-decision";
+import { SYSTEM_ONE_PROVIDER_IDS } from "@/workflows/executors/system-one-providers";
+
+/**
+ * One typed decision (Jev and the other SystemOne hosts) made in the API
+ * process, the same way a `system-one-decision` workflow node makes it. The
+ * provider credential is read and sent here and never reaches the caller, so a
+ * script can ask for a decision without a credential binding in its own realm.
+ */
+export const registerSystemOneDecideTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "system-one-decide",
+    {
+      title: "Ask a SystemOne decision model",
+      annotations: { destructiveHint: false, openWorldHint: true },
+      description:
+        "Send a state and typed questions (noul, choice, score) to a SystemOne decision host such as Jev, and return the validated answers. " +
+        "Same request, provider list, credentials and validation as the `system-one-decision` workflow node, without its human review band. " +
+        "The provider credential is a global secret that stays on the server; this tool never returns it.",
+      inputSchema: z.object({
+        provider: z
+          .enum(SYSTEM_ONE_PROVIDER_IDS)
+          .optional()
+          .describe("Decision host (default typesafe)"),
+        model: z.string().min(1).optional().describe("Provider model id (default: the provider's)"),
+        state: z
+          .union([z.string(), z.array(z.string()), z.record(z.string(), z.unknown())])
+          .describe("The state to decide on"),
+        questions: z
+          .record(z.string(), z.record(z.string(), z.unknown()))
+          .describe(
+            "Questions by id, each `{ type: 'noul' | 'choice' | 'score', instructions, criteria }`",
+          ),
+        timeoutMs: z
+          .number()
+          .int()
+          .optional()
+          .describe("Time budget for the call, retries included (default 30000)"),
+        maxRetries: z
+          .number()
+          .int()
+          .optional()
+          .describe("Retries on transient failures inside the time budget (default 2)"),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        model: z.string().optional(),
+        answers: z.record(z.string(), z.unknown()).optional(),
+        usage: z.record(z.string(), z.unknown()).optional(),
+        requestId: z.string().optional(),
+      }),
+    },
+    async ({ provider, model, state, questions, timeoutMs, maxRetries }, requestInfo) => {
+      if (!requestInfo.agentId) {
+        return toolErr('Agent ID not found. The MCP client should define the "X-Agent-ID" header.');
+      }
+
+      // `returns` mirrors the questions: the caller reads answers directly, so
+      // there is no downstream port to declare.
+      const returns = Object.fromEntries(
+        Object.entries(questions).map(([id, question]) => [id, { type: question.type }]),
+      );
+      const parsed = SystemOneDecisionConfigSchema.safeParse({
+        provider,
+        model,
+        state,
+        questions,
+        returns,
+        timeoutMs,
+        maxRetries,
+      });
+      if (!parsed.success) {
+        const issues = parsed.error.issues
+          .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
+          .join("; ");
+        return toolErr(`Invalid decision request: ${issues}`.slice(0, 1000));
+      }
+
+      const executor = getExecutorRegistry().get(SYSTEM_ONE_DECISION_NODE_TYPE);
+      if (!(executor instanceof SystemOneDecisionExecutor)) {
+        return toolErr("The system-one-decision executor is not available");
+      }
+      const decided = await executor.decide(parsed.data);
+      if (!decided.ok) return toolErr(decided.error);
+
+      const { output } = decided;
+      return toolOk(`Decision from ${output.model}`, {
+        data: {
+          model: output.model,
+          answers: output.answers,
+          usage: output.usage,
+          requestId: output.requestId,
+        },
+      });
+    },
+  );
+};

package/src/tools/task-action.ts

@@ -28,6 +28,7 @@ import {
   releaseTask,
   updateTaskClaudeSessionId,
 } from "@/be/db";
+import { modelProfileRefError, taskProfileError } from "@/be/db/model-profiles";
 import { explicitModelErrorForAgent } from "@/be/model-validation";
 import { touchRuntimeInstance } from "@/be/multi-runtime";
 import { applyPreTaskCreate } from "@/extensions/apply-task-create";
@@ -109,6 +110,14 @@ export const taskActionInputSchema = z.object({
   effort: ReasoningEffortSchema.optional().describe(
     "Reasoning effort for the created task: 'off', 'low', 'medium', 'high', 'xhigh', or 'max'. Only used with 'create' action.",
   ),
+  profile: z
+    .string()
+    .trim()
+    .min(1)
+    .optional()
+    .describe(
+      "Model profile name for the created pool task (see list-model-profiles); only workers on its harness claim it. Exclusive with model and modelTier. Only used with 'create' action.",
+    ),
   requiredCapabilities: z
     .array(z.string())
     .optional()
@@ -296,6 +305,12 @@ export async function taskActionHandler(
       allowCustomModel: input.allowCustomModel,
     });
     if (modelError) return taskActionResult({ success: false, message: modelError }, agentId);
+    const profileError = await taskProfileError({
+      profile: input.profile,
+      model: normalizedModel.model,
+      modelTier: normalizedModel.modelTier,
+    });
+    if (profileError) return taskActionResult({ success: false, message: profileError }, agentId);
     try {
       assetKey = key
         ? await authorizeAssetKeyWrite(key, await resolveTaskAuditUserId(ctx.sourceTaskId, agentId))
@@ -324,6 +339,7 @@ export async function taskActionHandler(
         model: normalizedModel.model,
         modelTier: normalizedModel.modelTier,
         effort: input.effort,
+        profile: input.profile,
         routingAffinity:
           leadOnly || requiredCapabilities?.length
             ? { leadOnly, capabilities: requiredCapabilities ?? [] }
@@ -342,7 +358,7 @@ export async function taskActionHandler(
     };
   }
 
-  const result = await getDbClient().transaction(async (): Promise<TaskActionResult> => {
+  const transacted = getDbClient().transaction(async (): Promise<TaskActionResult> => {
     switch (action) {
       case "create": {
         const newTask = await createTaskExtended(
@@ -644,6 +660,11 @@ export async function taskActionHandler(
         return { success: false, message: `Unknown action: ${action}` };
     }
   });
+  const result = await transacted.catch((error: unknown): TaskActionResult => {
+    // A create whose profile was deleted between taskProfileError and the insert.
+    if (modelProfileRefError(error) !== "missing") throw error;
+    return { success: false, message: `Unknown model profile "${input.profile}".` };
+  });
 
   // Phase 5: when the accept gate refused, run after-commit side
   // effects (lead follow-up + workflow bus). The dedup row was recorded

package/src/tools/tool-config.ts

@@ -81,6 +81,9 @@ export const DEFERRED_TOOLS = new Set([
   "model-catalog-refresh",
   "model-catalog-overlay-upsert",
 
+  // Model profiles (1)
+  "list-model-profiles",
+
   // Repos (1)
   "update-repo",
 
@@ -151,6 +154,9 @@ export const DEFERRED_TOOLS = new Set([
   "request-human-input",
   "cancel-approval-request",
 
+  // Decisions (1)
+  "system-one-decide",
+
   // Skills (12)
   "skill-create",
   "skill-update",

package/src/types.ts

@@ -428,6 +428,31 @@ export const ProviderNameSchema = z.enum([
 ]);
 export type ProviderName = z.infer<typeof ProviderNameSchema>;
 
+// ============================================================================
+// Model Profiles (runbooks/model-tiers.md § Model profiles)
+// ============================================================================
+
+/** Lowercase, starts with a letter or digit; dots, dashes and underscores allowed. */
+export const ModelProfileNameSchema = z
+  .string()
+  .trim()
+  .regex(/^[a-z0-9][a-z0-9._-]{0,99}$/, "lowercase letters, digits, '.', '_' or '-', max 100");
+
+export const ModelProfileSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  harness: ProviderNameSchema,
+  model: z.string(),
+  effort: ReasoningEffortSchema.nullable(),
+  allowCustomModel: z.boolean(),
+  description: z.string().nullable(),
+  /** `tier:<tier>` (boot seed), `agent-config` (made from an agent's MODEL_OVERRIDE), or null. */
+  seededFrom: z.string().nullable(),
+  createdAt: z.string(),
+  lastUpdatedAt: z.string(),
+});
+export type ModelProfile = z.infer<typeof ModelProfileSchema>;
+
 // ============================================================================
 // Task Steering Messages
 // ============================================================================
@@ -686,6 +711,11 @@ export const AgentTaskSchema = z
     // REASONING_EFFORT_OVERRIDE, dropped when the harness/model cannot take
     // it). Reported at session start; unset when the harness default applied.
     resolvedEffort: ReasoningEffortSchema.optional(),
+    // Model profile (runbooks/model-tiers.md § Model profiles): `profile` is
+    // the creator's ask, `resolvedProfile` the name claim applied (the ask or
+    // the agent's default). Unset when no profile applied.
+    profile: z.string().optional(),
+    resolvedProfile: z.string().optional(),
 
     // Schedule linking (optional — set when task was created by a schedule).
     // z.string(): also reachable verbatim from the create-task query param.
@@ -817,6 +847,7 @@ export const CreateTaskOptionsSchema = z.object({
   model: z.string().optional(),
   modelTier: ModelTierSchema.optional(),
   effort: ReasoningEffortSchema.optional(),
+  profile: z.string().optional(),
   scheduleId: z.string().optional(),
   workflowRunId: z.string().optional(),
   workflowRunStepId: z.string().optional(),
@@ -2403,7 +2434,11 @@ export const TriggerConfigSchema = z
     }),
     z.object({
       type: z.literal("event"),
-      eventName: z.literal("slack.message"),
+      eventName: z.enum([
+        "slack.message",
+        "azure-devops.work_item.assigned",
+        "azure-devops.work_item.commented",
+      ]),
     }),
   ])
   .superRefine((trigger, ctx) => {

package/src/utils/secret-scrubber.ts

@@ -808,6 +808,21 @@ function computeIsSensitiveKey(key: string): boolean {
   return false;
 }
 
+/**
+ * Every form of a credential value a consumer may send: the raw value, its
+ * trimmed form, and each trimmed member of a comma pool. `selectCredential`
+ * trims the key it hands out, so a padded singleton reaches the provider (and
+ * its error echo) without the padding.
+ */
+function credentialCandidates(value: string): string[] {
+  const candidates = new Set([value, value.trim()]);
+  if (value.includes(",")) {
+    for (const member of value.split(",")) candidates.add(member.trim());
+  }
+  candidates.delete("");
+  return [...candidates];
+}
+
 function buildCache(): ScrubCache {
   const entries: EnvValueEntry[] = [];
   const seen = new Set<string>();
@@ -816,14 +831,7 @@ function buildCache(): ScrubCache {
     if (!rawValue) continue;
     if (!isSensitiveKey(key)) continue;
 
-    // Credential pools: a single env var may hold a comma-separated list of
-    // tokens that the runner rotates through. Scrub each component too.
-    const candidates = rawValue.includes(",")
-      ? [rawValue, ...rawValue.split(",").map((s) => s.trim())]
-      : [rawValue];
-
-    for (const candidate of candidates) {
-      if (!candidate) continue;
+    for (const candidate of credentialCandidates(rawValue)) {
       if (candidate.length < MIN_VALUE_LENGTH) continue;
       for (const form of escapedForms(candidate)) {
         if (seen.has(form)) continue;
@@ -1089,14 +1097,13 @@ export function registerVolatileSecret(value: string, name: string): void {
  * Register the sensitive values of an env map that is not `process.env`
  * (a runner's per-task env, an adapter's session env). A key picked from a
  * credential pool, or a row admitted after boot, lives only there, so the
- * env pass never sees it. Comma-separated pools register each member too.
+ * env pass never sees it. Comma-separated pools register each member too,
+ * and padded values register their trimmed form.
  */
 export function registerEnvSecrets(env: Record<string, string | undefined>): void {
   for (const [key, value] of Object.entries(env)) {
     if (!value || !isSensitiveKey(key)) continue;
-    registerVolatileSecret(value, key);
-    if (!value.includes(",")) continue;
-    for (const member of value.split(",")) registerVolatileSecret(member.trim(), key);
+    for (const candidate of credentialCandidates(value)) registerVolatileSecret(candidate, key);
   }
 }
 

package/src/utils/vcs-repo-match.ts

@@ -0,0 +1,29 @@
+/**
+ * How a task's `vcsRepo` names a registered repo (`swarm_repos`). The worker
+ * loads that repo's scoped config with it (`fetchRepoConfig`), and the API
+ * reads the same repo at claim, so both sides must match the same way.
+ */
+
+/** `vcsRepo` without surrounding spaces, trailing slashes or `.git`. */
+export function normalizeVcsRepo(vcsRepo: string): string {
+  return vcsRepo
+    .trim()
+    .replace(/\/+$/, "")
+    .replace(/\.git$/, "");
+}
+
+/** The `swarm_repos.name` candidates are looked up by: the last path segment. */
+export function vcsRepoName(vcsRepo: string): string {
+  const requested = normalizeVcsRepo(vcsRepo);
+  return requested.split("/").pop() || requested;
+}
+
+/** Whether a registered repo URL is exactly the repo `vcsRepo` names. */
+export function vcsRepoUrlMatches(url: string, vcsRepo: string): boolean {
+  const requested = normalizeVcsRepo(vcsRepo);
+  const normalized = normalizeVcsRepo(url);
+  if (normalized === requested) return true;
+  // Qualified URLs must retain their host. Only shorthand references use suffix matching.
+  if (requested.includes(":")) return false;
+  return normalized.endsWith(`/${requested}`) || normalized.endsWith(`:${requested}`);
+}

package/src/workflows/executors/raw-llm.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { ExecutorMeta } from "../../types";
+import { scrubSecrets } from "../../utils/secret-scrubber";
 import { BaseExecutor, type ExecutorResult } from "./base";
 import { resolveWorkflowLlmConfig } from "./workflow-llm";
 
@@ -72,7 +73,7 @@ export async function executeRawLlm(
     const isRateLimited =
       httpStatus === 429 ||
       httpStatus === 529 ||
-      (err instanceof Error && /rate.?limit|too many requests|529/i.test(err.message));
+      (err instanceof Error && /rate.?limit|too many requests|\b529\b/i.test(err.message));
     if (isRateLimited) {
       throw err;
     }
@@ -80,12 +81,16 @@ export async function executeRawLlm(
       return {
         status: "success",
         output: { result: null, model: modelName },
-        error: `LLM call failed, using fallback port: ${err instanceof Error ? err.message : String(err)}`,
+        error: scrubSecrets(
+          `LLM call failed, using fallback port: ${err instanceof Error ? err.message : String(err)}`,
+        ),
       };
     }
     return {
       status: "failed",
-      error: `LLM call failed: ${err instanceof Error ? err.message : String(err)}`,
+      // Provider errors can echo the request key back; scrub before any
+      // consumer (journal, HTTP route, workflow step) sees the text.
+      error: scrubSecrets(`LLM call failed: ${err instanceof Error ? err.message : String(err)}`),
     };
   }
 }