@desplega.ai/agent-swarm 1.93.0 → 1.95.0

package/src/http/metrics.ts

@@ -48,12 +48,48 @@ function slugify(input: string): string {
 
 function validateMetricDefinition(definition: unknown) {
   const parsed = MetricDefinitionSchema.parse(definition);
+  for (const variable of parsed.variables ?? []) {
+    if (variable.optionsQuery) {
+      assertSelectOnlyQuery(variable.optionsQuery.sql);
+    }
+  }
   for (const widget of parsed.widgets) {
     assertSelectOnlyQuery(widget.query.sql);
   }
   return parsed;
 }
 
+function resolveVariableOptionValues(variable: MetricVariable) {
+  if (!variable.optionsQuery) return variable.options ?? [];
+  assertSelectOnlyQuery(variable.optionsQuery.sql);
+  const result = executeReadOnlyQuery(variable.optionsQuery.sql, [], HARD_METRIC_MAX_ROWS);
+  return result.rows.map((row) => {
+    const record = Object.fromEntries(
+      result.columns.map((column, index) => [column, row[index] as MetricParam]),
+    );
+    const value = record[variable.optionsQuery!.valueKey];
+    const labelKey = variable.optionsQuery!.labelKey ?? variable.optionsQuery!.valueKey;
+    const label = record[labelKey] ?? value;
+    return {
+      label: label == null ? "" : String(label),
+      value: value == null ? null : value,
+    };
+  });
+}
+
+function resolveVariableOptions(metric: Metric) {
+  const optionsByKey: Record<string, Array<{ label: string; value: MetricParam }>> = {};
+  const variables = (metric.definition.variables ?? []).map((variable) => {
+    if (!variable.optionsQuery) {
+      return variable;
+    }
+    const options = resolveVariableOptionValues(variable);
+    optionsByKey[variable.key] = options;
+    return { ...variable, options };
+  });
+  return { variables, optionsByKey };
+}
+
 function coerceVariableValue(variable: MetricVariable, raw: unknown): MetricParam {
   if (raw == null || raw === "") {
     return variable.defaultValue ?? null;
@@ -71,12 +107,21 @@ function coerceVariableValue(variable: MetricVariable, raw: unknown): MetricPara
   return String(raw);
 }
 
-function resolveMetricVariables(metric: Metric, provided: Record<string, unknown>) {
+function resolveMetricVariables(
+  metric: Metric,
+  provided: Record<string, unknown>,
+  dynamicOptionsByKey: Record<string, Array<{ label: string; value: MetricParam }>> = {},
+) {
   const values: Record<string, MetricParam> = {};
   for (const variable of metric.definition.variables ?? []) {
-    const value = coerceVariableValue(variable, provided[variable.key]);
-    if (variable.options?.length) {
-      const allowed = variable.options.some((option) => option.value === value);
+    const options = dynamicOptionsByKey[variable.key] ?? variable.options;
+    const raw = provided[variable.key];
+    const value =
+      (raw == null || raw === "") && variable.defaultValue === undefined && options?.length
+        ? options[0]!.value
+        : coerceVariableValue(variable, raw);
+    if (options?.length) {
+      const allowed = options.some((option) => option.value === value);
       if (!allowed) {
         throw new Error(`Metric variable "${variable.key}" must match one of its options`);
       }
@@ -125,10 +170,14 @@ function runMetricWidget(widget: MetricWidget, variables: Record<string, MetricP
 }
 
 function runMetric(metric: Metric, providedVariables: Record<string, unknown> = {}) {
-  const variables = resolveMetricVariables(metric, providedVariables);
+  const resolved = resolveVariableOptions(metric);
+  const variables = resolveMetricVariables(metric, providedVariables, resolved.optionsByKey);
   const widgets = metric.definition.widgets.map((widget) => runMetricWidget(widget, variables));
   return {
-    metric,
+    metric: {
+      ...metric,
+      definition: { ...metric.definition, variables: resolved.variables },
+    },
     variables,
     widgets,
     // Kept as the first widget result for older callers during the PR cycle.

package/src/http/schedules.ts

@@ -12,9 +12,8 @@ import {
   updateScheduledTask,
 } from "../be/db";
 import { mergeScheduleTiming, validateRecurringTiming } from "../be/schedules/validate";
-import { calculateNextRun } from "../scheduler/scheduler";
-import { scheduleContextKey } from "../tasks/context-key";
-import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
+import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
+import { calculateNextRun, createStandaloneScheduleTask } from "../scheduler/scheduler";
 import { getExecutorRegistry } from "../workflows";
 import { handleScheduleTrigger } from "../workflows/triggers";
 import { route } from "./route-def";
@@ -41,6 +40,7 @@ const createSchedule = route({
     enabled: z.boolean().optional(),
     timezone: z.string().optional(),
     model: z.string().optional(),
+    modelTier: ModelTierSchema.optional(),
     scheduleType: z.enum(["recurring", "one_time"]).optional(),
     delayMs: z.number().int().optional(),
     runAt: z.string().optional(),
@@ -126,6 +126,7 @@ const updateSchedule = route({
     enabled: z.boolean().optional(),
     timezone: z.string().optional(),
     model: z.string().optional(),
+    modelTier: ModelTierSchema.nullable().optional(),
     nextRunAt: z.string().nullable().optional(),
   }),
   responses: {
@@ -270,7 +271,7 @@ export async function handleSchedules(
         enabled: body.enabled,
         nextRunAt,
         timezone: body.timezone,
-        model: body.model,
+        ...splitLegacyModelAlias({ model: body.model, modelTier: body.modelTier }),
         scheduleType: body.scheduleType,
       });
 
@@ -333,17 +334,7 @@ export async function handleSchedules(
       const now = new Date().toISOString();
 
       const task = getDb().transaction(() => {
-        const createdTask = createTaskWithSiblingAwareness(schedule.taskTemplate, {
-          creatorAgentId: schedule.createdByAgentId,
-          taskType: schedule.taskType,
-          tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "manual-run"],
-          priority: schedule.priority,
-          agentId: schedule.targetAgentId,
-          model: schedule.model,
-          scheduleId: schedule.id,
-          source: "schedule",
-          contextKey: scheduleContextKey({ scheduleId: schedule.id }),
-        });
+        const createdTask = createStandaloneScheduleTask(schedule, ["manual-run"]);
 
         if (schedule.scheduleType === "one_time") {
           updateScheduledTask(schedule.id, {
@@ -388,6 +379,16 @@ export async function handleSchedules(
     const parsed = await updateSchedule.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
     const body = parsed.body as Record<string, unknown>;
+    if (parsed.body.model !== undefined || parsed.body.modelTier !== undefined) {
+      const normalizedModel = splitLegacyModelAlias({
+        model: parsed.body.model,
+        modelTier: parsed.body.modelTier,
+      });
+      if (parsed.body.model !== undefined) body.model = normalizedModel.model ?? null;
+      if (parsed.body.modelTier !== undefined || normalizedModel.modelTier) {
+        body.modelTier = normalizedModel.modelTier ?? null;
+      }
+    }
 
     const existing = getScheduledTaskById(parsed.params.id);
     if (!existing) {

package/src/http/script-runs.ts

@@ -51,6 +51,7 @@ const createScriptRunBodySchema = z.object({
 const listScriptRunsQuerySchema = z.object({
   status: ScriptRunStatusSchema.optional(),
   agentId: z.string().optional(),
+  scriptName: z.string().optional(),
   limit: z.coerce.number().int().min(1).max(500).optional(),
   offset: z.coerce.number().int().min(0).optional(),
 });
@@ -367,12 +368,17 @@ export async function handleScriptRuns(
     const opts = {
       status: parsed.query.status,
       agentId: parsed.query.agentId,
+      scriptName: parsed.query.scriptName,
       limit: parsed.query.limit ?? 50,
       offset: parsed.query.offset ?? 0,
     };
     json(res, {
       runs: listScriptRuns(opts),
-      total: countScriptRuns({ status: opts.status, agentId: opts.agentId }),
+      total: countScriptRuns({
+        status: opts.status,
+        agentId: opts.agentId,
+        scriptName: opts.scriptName,
+      }),
     });
     return true;
   }

package/src/http/scripts.ts

@@ -2,14 +2,23 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
 import { getAgentById, recordInlineScriptRun, upsertKv } from "../be/db";
 import { createEvent } from "../be/events";
-import { deleteScript, getScript, upsertScriptByName } from "../be/scripts/db";
+import {
+  deleteScript,
+  getScript,
+  getScriptById,
+  listScripts,
+  listScriptVersions,
+  upsertScriptByName,
+} from "../be/scripts/db";
 import { searchScripts } from "../be/scripts/embeddings";
 import { extractArgsJsonSchema } from "../be/scripts/extract-schema";
 import { SCRIPT_SDK_TYPES, SCRIPT_STDLIB_TYPES, typecheckScript } from "../be/scripts/typecheck";
 import { extractScriptSignature } from "../scripts-runtime/extract-signature";
 import { runScript } from "../scripts-runtime/loader";
 import {
+  type ScriptDetail,
   ScriptFsModeSchema,
+  type ScriptListItem,
   type ScriptRecord,
   type ScriptScope,
   ScriptScopeSchema,
@@ -52,6 +61,11 @@ const searchBodySchema = z.object({
 const nameParamsSchema = z.object({ name: scriptNameSchema });
 const scopeQuerySchema = z.object({ scope: ScriptScopeSchema.default("agent") });
 const optionalScopeQuerySchema = z.object({ scope: ScriptScopeSchema.optional() });
+const idParamsSchema = z.object({ id: z.string().uuid() });
+const listScriptsQuerySchema = z.object({
+  scope: ScriptScopeSchema.optional(),
+  includeScratch: z.enum(["true", "false"]).optional(),
+});
 
 const upsertRoute = route({
   method: "post",
@@ -133,6 +147,74 @@ const typesRoute = route({
   },
 });
 
+// ── Dashboard read routes ──
+// The worker-facing routes above resolve scripts relative to the calling agent
+// and therefore requireAgent (X-Agent-ID). The routes below are cross-scope
+// admin reads for the dashboard: API-key auth only, no agent identity — the
+// same model as /api/script-runs.
+
+const listScriptsRoute = route({
+  method: "get",
+  path: "/api/scripts",
+  pattern: ["api", "scripts"],
+  operationId: "scripts_list",
+  summary: "List saved scripts",
+  description:
+    "Dashboard read: lean projection without source. Scratch scripts are excluded unless includeScratch=true.",
+  tags: ["Scripts"],
+  query: listScriptsQuerySchema,
+  responses: {
+    200: { description: "Saved scripts" },
+    400: { description: "Validation error" },
+  },
+});
+
+// Declared (and matched) BEFORE the by-id route: the by-id pattern
+// ["api", "scripts", null] matches any single segment, so the literal
+// "type-defs" segment must win first.
+const typeDefsRoute = route({
+  method: "get",
+  path: "/api/scripts/type-defs",
+  pattern: ["api", "scripts", "type-defs"],
+  operationId: "scripts_type_defs",
+  summary: "Get script SDK and stdlib type definitions",
+  description: "Static .d.ts blobs for editor integration (e.g. Monaco extraLibs). Cacheable.",
+  tags: ["Scripts"],
+  responses: {
+    200: { description: "SDK and stdlib type definition blobs" },
+  },
+});
+
+const getScriptByIdRoute = route({
+  method: "get",
+  path: "/api/scripts/{id}",
+  pattern: ["api", "scripts", null],
+  operationId: "scripts_get",
+  summary: "Get a saved script by id",
+  description: "Dashboard read: full record including source and parsed signature.",
+  tags: ["Scripts"],
+  params: idParamsSchema,
+  responses: {
+    200: { description: "Script detail" },
+    404: { description: "Script not found" },
+  },
+});
+
+const listVersionsRoute = route({
+  method: "get",
+  path: "/api/scripts/{id}/versions",
+  pattern: ["api", "scripts", null, "versions"],
+  operationId: "scripts_versions",
+  summary: "List versions of a saved script",
+  description: "Dashboard read: version history, newest first.",
+  tags: ["Scripts"],
+  params: idParamsSchema,
+  responses: {
+    200: { description: "Script versions" },
+    404: { description: "Script not found" },
+  },
+});
+
 function requireAgent(res: ServerResponse, agentId: string | undefined) {
   if (!agentId) {
     jsonError(res, "X-Agent-ID required for scripts API", 400);
@@ -413,6 +495,70 @@ export async function handleScripts(
     return true;
   }
 
+  // ── Dashboard reads (no requireAgent — API-key auth only, like /api/script-runs) ──
+
+  if (listScriptsRoute.match(req.method, pathSegments)) {
+    const parsed = await listScriptsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const scripts: ScriptListItem[] = listScripts({
+      scope: parsed.query.scope,
+      includeScratch: parsed.query.includeScratch === "true",
+    }).map((script) => ({
+      id: script.id,
+      name: script.name,
+      scope: script.scope,
+      scopeId: script.scopeId,
+      description: script.description,
+      intent: script.intent,
+      version: script.version,
+      isScratch: script.isScratch,
+      typeChecked: script.typeChecked,
+      fsMode: script.fsMode,
+      createdByAgentId: script.createdByAgentId,
+      createdAt: script.createdAt,
+      updatedAt: script.updatedAt,
+    }));
+    json(res, { scripts });
+    return true;
+  }
+
+  // Must be matched before getScriptByIdRoute — its ["api", "scripts", null]
+  // pattern would otherwise swallow the literal "type-defs" segment.
+  if (typeDefsRoute.match(req.method, pathSegments)) {
+    json(res, { sdkTypes: SCRIPT_SDK_TYPES, stdlibTypes: SCRIPT_STDLIB_TYPES });
+    return true;
+  }
+
+  if (getScriptByIdRoute.match(req.method, pathSegments)) {
+    const parsed = await getScriptByIdRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const script = getScriptById(parsed.params.id);
+    if (!script) {
+      jsonError(res, "Script not found", 404);
+      return true;
+    }
+    // `source` is author-supplied TS (same trust surface as script_runs.source,
+    // already served raw by GET /api/script-runs/{id}) — no env/secret material.
+    const detail: ScriptDetail = {
+      ...script,
+      signature: JSON.parse(script.signatureJson) as unknown,
+      argsJsonSchema: script.argsJsonSchema ? (JSON.parse(script.argsJsonSchema) as unknown) : null,
+    };
+    json(res, { script: detail });
+    return true;
+  }
+
+  if (listVersionsRoute.match(req.method, pathSegments)) {
+    const parsed = await listVersionsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    if (!getScriptById(parsed.params.id)) {
+      jsonError(res, "Script not found", 404);
+      return true;
+    }
+    json(res, { versions: listScriptVersions(parsed.params.id) });
+    return true;
+  }
+
   if (typesRoute.match(req.method, pathSegments)) {
     const parsed = await typesRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;

package/src/http/tasks.ts

@@ -23,6 +23,7 @@ import {
   updateTaskProgress,
   updateTaskVcs,
 } from "../be/db";
+import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { createResumeFollowUp, createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
 import { telemetry } from "../telemetry";
@@ -91,6 +92,8 @@ const createTask = route({
     outputSchema: z.record(z.string(), z.unknown()).optional(),
     contextKey: z.string().optional(),
     requestedByUserId: z.string().optional(),
+    model: z.string().optional(),
+    modelTier: ModelTierSchema.optional(),
   }),
   responses: {
     201: { description: "Task created" },
@@ -395,6 +398,10 @@ export async function handleTasks(
         outputSchema: parsed.body.outputSchema || undefined,
         contextKey: parsed.body.contextKey || undefined,
         requestedByUserId,
+        ...splitLegacyModelAlias({
+          model: parsed.body.model,
+          modelTier: parsed.body.modelTier,
+        }),
       });
 
       ensure({

package/src/model-tiers.ts

@@ -0,0 +1,140 @@
+import { z } from "zod";
+import type { ProviderName } from "./types";
+
+export const ModelTierSchema = z.enum(["smol", "regular", "smart", "ultra"]);
+export type ModelTier = z.infer<typeof ModelTierSchema>;
+
+export const MODEL_TIERS = ModelTierSchema.options;
+
+export const LEGACY_MODEL_TO_TIER: Record<string, ModelTier> = {
+  haiku: "smol",
+  sonnet: "regular",
+  opus: "smart",
+  fable: "ultra",
+};
+
+export const MODEL_TIER_LABELS: Record<ModelTier, string> = {
+  smol: "Smol",
+  regular: "Regular",
+  smart: "Smart",
+  ultra: "Ultra",
+};
+
+export const DEFAULT_MODEL_TIER_MAP: Record<ProviderName, Record<ModelTier, string>> = {
+  claude: {
+    smol: "haiku",
+    regular: "sonnet",
+    smart: "opus",
+    ultra: "fable",
+  },
+  "claude-managed": {
+    smol: "claude-haiku-4-5",
+    regular: "claude-sonnet-4-6",
+    smart: "claude-opus-4-8",
+    ultra: "claude-fable-5",
+  },
+  codex: {
+    smol: "gpt-5.4-mini",
+    regular: "gpt-5.4",
+    smart: "gpt-5.5",
+    ultra: "gpt-5.5",
+  },
+  pi: {
+    smol: "openrouter/deepseek/deepseek-v4-flash",
+    regular: "openrouter/deepseek/deepseek-v4-flash",
+    smart: "openrouter/deepseek/deepseek-v4-pro",
+    ultra: "openrouter/anthropic/claude-opus-4.8",
+  },
+  opencode: {
+    smol: "openrouter/deepseek/deepseek-v4-flash",
+    regular: "openrouter/deepseek/deepseek-v4-flash",
+    smart: "openrouter/deepseek/deepseek-v4-pro",
+    ultra: "openrouter/anthropic/claude-opus-4.8",
+  },
+  devin: {
+    smol: "devin",
+    regular: "devin",
+    smart: "devin",
+    ultra: "devin",
+  },
+};
+
+export function parseModelTier(value: string | null | undefined): ModelTier | undefined {
+  if (!value) return undefined;
+  const normalized = value.trim().toLowerCase();
+  return ModelTierSchema.safeParse(normalized).success
+    ? (normalized as ModelTier)
+    : LEGACY_MODEL_TO_TIER[normalized];
+}
+
+export function splitLegacyModelAlias(input: {
+  model?: string | null;
+  modelTier?: string | null;
+}): { model?: string; modelTier?: ModelTier } {
+  const explicitTier = parseModelTier(input.modelTier);
+  const model = input.model?.trim();
+  if (!model) return { modelTier: explicitTier };
+
+  const legacyTier = parseModelTier(model);
+  if (legacyTier && !explicitTier) {
+    return { modelTier: legacyTier };
+  }
+
+  return {
+    model,
+    modelTier: explicitTier,
+  };
+}
+
+function parseTierMapJson(value: string | undefined): Partial<Record<ModelTier, string>> {
+  if (!value) return {};
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const result: Partial<Record<ModelTier, string>> = {};
+    for (const tier of MODEL_TIERS) {
+      const model = (parsed as Record<string, unknown>)[tier];
+      if (typeof model === "string" && model.trim()) result[tier] = model.trim();
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+export function resolveModelTier(opts: {
+  tier?: string | null;
+  harnessProvider: ProviderName;
+  env?: Record<string, string | undefined>;
+}): string | undefined {
+  const tier = parseModelTier(opts.tier);
+  if (!tier) return undefined;
+
+  const env = opts.env ?? {};
+  const jsonOverrides = parseTierMapJson(env.MODEL_TIER_MAP);
+  const envKey = `MODEL_TIER_${tier.toUpperCase()}`;
+  const directOverride = env[envKey]?.trim();
+  if (directOverride) return directOverride;
+  if (jsonOverrides[tier]) return jsonOverrides[tier];
+
+  return DEFAULT_MODEL_TIER_MAP[opts.harnessProvider]?.[tier];
+}
+
+export function resolveTaskModelSelection(opts: {
+  model?: string | null;
+  modelTier?: string | null;
+  harnessProvider: ProviderName;
+  env?: Record<string, string | undefined>;
+}): { model?: string; source: "model" | "modelTier" | "none" } {
+  const model = opts.model?.trim();
+  if (model) return { model, source: "model" };
+
+  const tierModel = resolveModelTier({
+    tier: opts.modelTier,
+    harnessProvider: opts.harnessProvider,
+    env: opts.env,
+  });
+  if (tierModel) return { model: tierModel, source: "modelTier" };
+
+  return { source: "none" };
+}

package/src/oauth/mcp-wrapper.ts

@@ -287,7 +287,21 @@ export async function buildAuthorizeUrl(input: BuildAuthorizeInput): Promise<Bui
   url.searchParams.set("resource", input.resource);
 
   if (input.extraParams) {
+    const RESERVED = new Set([
+      "response_type",
+      "client_id",
+      "redirect_uri",
+      "scope",
+      "state",
+      "code_challenge",
+      "code_challenge_method",
+      "resource",
+    ]);
     for (const [k, v] of Object.entries(input.extraParams)) {
+      if (RESERVED.has(k.toLowerCase())) {
+        console.warn(`[mcp-oauth] extraParams key "${k}" is reserved and skipped`);
+        continue;
+      }
       url.searchParams.set(k, v);
     }
   }

package/src/providers/claude-managed-models.ts

@@ -26,6 +26,7 @@
 /** Models supported by the managed-agents surface for the swarm worker. */
 export const CLAUDE_MANAGED_MODELS = [
   "claude-fable-5",
+  "claude-mythos-5",
   "claude-sonnet-4-6",
   "claude-opus-4-8",
   "claude-opus-4-7",
@@ -51,6 +52,8 @@ export interface ClaudeManagedModelPricing {
  * Anthropic public list pricing. Source:
  * https://platform.claude.com/docs/en/about-claude/pricing
  *
+ * - claude-fable-5:   $10 / $50 / $1.00 / $12.50   (verified 2026-06-10)
+ * - claude-mythos-5:  $10 / $50 / $1.00 / $12.50   (limited availability, verified 2026-06-10)
  * - claude-sonnet-4-6: $3 / $15 / $0.30 / $3.75    (in / out / cache-read / cache-write)
  * - claude-opus-4-8:   $5 / $25 / $0.50 / $6.25    (verified 2026-05-28)
  * - claude-opus-4-7:   $15 / $75 / $1.50 / $18.75  (STALE — was correct at launch, Anthropic has since dropped Opus to $5/$25)
@@ -64,6 +67,12 @@ export const CLAUDE_MANAGED_MODEL_PRICING: Record<ClaudeManagedModel, ClaudeMana
     cacheReadPerMillion: 1.0,
     cacheWritePerMillion: 12.5,
   },
+  "claude-mythos-5": {
+    inputPerMillion: 10.0,
+    outputPerMillion: 50.0,
+    cacheReadPerMillion: 1.0,
+    cacheWritePerMillion: 12.5,
+  },
   "claude-sonnet-4-6": {
     inputPerMillion: 3.0,
     outputPerMillion: 15.0,

package/src/providers/codex-skill-resolver.ts

@@ -63,6 +63,21 @@ export async function resolveCodexPrompt(
   prompt: string,
   skillsDir?: string,
   emit?: (event: ProviderEvent) => void,
+): Promise<string> {
+  return resolveSlashSkillPrompt(prompt, {
+    providerLabel: "codex",
+    skillsDir: skillsDir ?? defaultSkillsDir(),
+    emit,
+  });
+}
+
+export async function resolveSlashSkillPrompt(
+  prompt: string,
+  opts: {
+    providerLabel: string;
+    skillsDir: string;
+    emit?: (event: ProviderEvent) => void;
+  },
 ): Promise<string> {
   if (!prompt) {
     return prompt;
@@ -81,15 +96,14 @@ export async function resolveCodexPrompt(
 
   const commandName: string = match[1];
   const trailingArgs: string = match[2] ?? "";
-  const dir = skillsDir ?? defaultSkillsDir();
-  const skillPath = join(dir, commandName, "SKILL.md");
+  const skillPath = join(opts.skillsDir, commandName, "SKILL.md");
 
   const file = Bun.file(skillPath);
   const exists = await file.exists();
   if (!exists) {
-    emit?.({
+    opts.emit?.({
       type: "raw_stderr",
-      content: `[codex] skill resolver: SKILL.md not found for /${commandName} (looked in ${skillPath})\n`,
+      content: `[${opts.providerLabel}] skill resolver: SKILL.md not found for /${commandName} (looked in ${skillPath})\n`,
     });
     return prompt;
   }
@@ -99,17 +113,17 @@ export async function resolveCodexPrompt(
     skillContent = await file.text();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    emit?.({
+    opts.emit?.({
       type: "raw_stderr",
-      content: `[codex] skill resolver: failed to read SKILL.md for /${commandName}: ${message}\n`,
+      content: `[${opts.providerLabel}] skill resolver: failed to read SKILL.md for /${commandName}: ${message}\n`,
     });
     return prompt;
   }
 
   if (skillContent.length > MAX_SKILL_CHARS) {
-    emit?.({
+    opts.emit?.({
       type: "raw_stderr",
-      content: `[codex] skill resolver: SKILL.md for /${commandName} exceeds ${MAX_SKILL_CHARS} chars (${skillContent.length}), truncating\n`,
+      content: `[${opts.providerLabel}] skill resolver: SKILL.md for /${commandName} exceeds ${MAX_SKILL_CHARS} chars (${skillContent.length}), truncating\n`,
     });
     skillContent = skillContent.slice(0, MAX_SKILL_CHARS);
   }