@desplega.ai/agent-swarm 1.93.0 → 1.94.0

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/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/opencode-adapter.ts

@@ -286,6 +286,7 @@ export class OpencodeSession implements ProviderSession {
       type: "session_init",
       sessionId: this._sessionId,
       provider,
+      harnessVariant: "stock",
       ...(harnessVariantMeta ? { harnessVariantMeta } : {}),
     });
   }

package/src/providers/pi-mono-adapter.ts

@@ -25,6 +25,7 @@ import {
   SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import { type TSchema, Type } from "typebox";
+import { classifyAwsSdkError } from "../utils/aws-error-classifier";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { readPkgVersion } from "./harness-version";
 import { createSwarmHooksExtension } from "./pi-mono-extension";
@@ -361,6 +362,18 @@ export class PiMonoSession implements ProviderSession {
    * surface it directly.
    */
   private prevOutputTokens = 0;
+  /**
+   * Terminal error message captured from structured pi-coding-agent events.
+   *
+   * Set by `message_end` (assistant turn with `stopReason==='error'` — covers
+   * NON-retryable failures, including AWS auth which never enters pi's retry
+   * loop) and by `auto_retry_end` with `success:false` (the definitive terminal
+   * failure after the retryable class — throttle / 5xx / timeout — exhausts).
+   * Cleared on recovery: a successful `message_end` or an `auto_retry_end` with
+   * `success:true` resets it to null, so a recovered error never surfaces as a
+   * false failure. Evaluated once at session end in `runSession()`.
+   */
+  private terminalError: string | null = null;
 
   constructor(agentSession: AgentSession, config: ProviderSessionConfig, createdSymlink: boolean) {
     this.agentSession = agentSession;
@@ -376,6 +389,7 @@ export class PiMonoSession implements ProviderSession {
       type: "session_init",
       sessionId: this._sessionId,
       provider: "pi",
+      harnessVariant: "stock",
       ...(piVersion ? { harnessVariantMeta: { version: piVersion } } : {}),
     });
 
@@ -424,6 +438,25 @@ export class PiMonoSession implements ProviderSession {
     switch (event.type) {
       case "message_end": {
         // Pi emits message_end for user, assistant, and tool-result messages.
+        // An assistant turn that ended in `stopReason==='error'` is a failed
+        // turn — track it as the (so far) terminal error. This is the ONLY
+        // structured signal for NON-retryable failures (AWS auth: ExpiredToken
+        // / CredentialsProviderError), which never enter pi's retry loop.
+        const endMsg = event.message as {
+          role?: string;
+          stopReason?: string;
+          errorMessage?: string;
+        };
+        if (endMsg.role === "assistant") {
+          if (endMsg.stopReason === "error") {
+            // Candidate terminal failure. May still be cleared by a successful
+            // retry (auto_retry_end success / a later good message_end).
+            this.terminalError = endMsg.errorMessage ?? this.terminalError ?? "Unknown error";
+            break;
+          }
+          // A successful assistant turn means any prior error has recovered.
+          this.terminalError = null;
+        }
         // Only assistant text should be printed or used as fallback output.
         const text = extractPiAssistantText(event.message);
         if (text) {
@@ -517,12 +550,18 @@ export class PiMonoSession implements ProviderSession {
           result: event.result,
         });
         break;
-      case "auto_retry_start":
-        this.emit({
-          type: "raw_stderr",
-          content: `[pi-mono] Auto-retry attempt ${event.attempt}/${event.maxAttempts}: ${event.errorMessage}\n`,
-        });
+      case "auto_retry_end": {
+        // Definitive terminal signal for the RETRYABLE error class
+        // (throttle / 5xx / timeout). pi-coding-agent emits success:false with
+        // `finalError` only after every retry attempt is exhausted; success:true
+        // means the turn recovered, so clear any tracked error.
+        if (event.success) {
+          this.terminalError = null;
+        } else {
+          this.terminalError = event.finalError ?? this.terminalError ?? "Unknown error";
+        }
         break;
+      }
     }
   }
 
@@ -540,6 +579,26 @@ export class PiMonoSession implements ProviderSession {
       const stats = this.agentSession.getSessionStats();
       const cost = this.buildCostData(stats);
 
+      // A structured terminal error from pi-coding-agent events is failure by
+      // definition (the agent already exhausted retries or hit a non-retryable
+      // error). Surface it so the session-chat red box fires and the task fails,
+      // exactly like sibling adapters. AWS errors get a categorized, actionable
+      // message; anything else surfaces its raw error text.
+      if (this.terminalError) {
+        const classification = classifyAwsSdkError(this.terminalError);
+        const message = classification?.message ?? this.terminalError;
+        const category = classification?.category;
+        this.emit({ type: "error", message, category });
+        return {
+          exitCode: 1,
+          sessionId: this._sessionId,
+          cost,
+          isError: true,
+          errorCategory: category,
+          failureReason: message,
+        };
+      }
+
       this.emit({
         type: "result",
         cost,
@@ -555,13 +614,26 @@ export class PiMonoSession implements ProviderSession {
       };
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
+      // Defense-in-depth: AWS SDK failures surface as structured events (handled
+      // above in runSession), not thrown exceptions, so this catch is for genuine
+      // unexpected throws (MCP / transport / etc). Still classify in case an AWS
+      // signature ever reaches here, so the red box fires like sibling adapters.
+      const awsCatchError = classifyAwsSdkError(errorMessage);
+      if (awsCatchError) {
+        this.emit({
+          type: "error",
+          message: awsCatchError.message,
+          category: awsCatchError.category,
+        });
+      }
       this.emit({ type: "raw_stderr", content: `[pi-mono] Error: ${errorMessage}\n` });
 
       return {
         exitCode: 1,
         sessionId: this._sessionId,
         isError: true,
-        failureReason: errorMessage,
+        errorCategory: awsCatchError?.category,
+        failureReason: awsCatchError?.message ?? errorMessage,
       };
     } finally {
       await this.logFileHandle.end();

package/src/scheduler/scheduler.ts

@@ -3,7 +3,7 @@ import { CronExpressionParser } from "cron-parser";
 import { getDb, getDueScheduledTasks, getScheduledTaskById, updateScheduledTask } from "@/be/db";
 import { scheduleContextKey } from "@/tasks/context-key";
 import { createTaskWithSiblingAwareness } from "@/tasks/sibling-awareness";
-import type { ScheduledTask } from "@/types";
+import type { AgentTask, ScheduledTask } from "@/types";
 import type { ExecutorRegistry } from "@/workflows/executors/registry";
 import { handleScheduleTrigger } from "@/workflows/triggers";
 
@@ -11,6 +11,24 @@ let schedulerInterval: ReturnType<typeof setInterval> | null = null;
 let isProcessing = false;
 let executorRegistry: ExecutorRegistry | null = null;
 
+export function createStandaloneScheduleTask(
+  schedule: ScheduledTask,
+  extraTags: string[] = [],
+): AgentTask {
+  return createTaskWithSiblingAwareness(schedule.taskTemplate, {
+    creatorAgentId: schedule.createdByAgentId,
+    taskType: schedule.taskType,
+    tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, ...extraTags],
+    priority: schedule.priority,
+    agentId: schedule.targetAgentId,
+    model: schedule.model,
+    modelTier: schedule.modelTier,
+    scheduleId: schedule.id,
+    source: "schedule",
+    contextKey: scheduleContextKey({ scheduleId: schedule.id }),
+  });
+}
+
 /**
  * Recover missed scheduled task runs from downtime.
  * Fires ONE catch-up run per schedule (not N missed runs).
@@ -45,17 +63,7 @@ async function recoverMissedSchedules(): Promise<void> {
 
       if (!triggeredWorkflows) {
         const tx = getDb().transaction(() => {
-          createTaskWithSiblingAwareness(schedule.taskTemplate, {
-            creatorAgentId: schedule.createdByAgentId,
-            taskType: schedule.taskType,
-            tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "recovered"],
-            priority: schedule.priority,
-            agentId: schedule.targetAgentId,
-            model: schedule.model,
-            scheduleId: schedule.id,
-            source: "schedule",
-            contextKey: scheduleContextKey({ scheduleId: schedule.id }),
-          });
+          createStandaloneScheduleTask(schedule, ["recovered"]);
         });
         tx();
       }
@@ -150,17 +158,7 @@ async function executeSchedule(schedule: ScheduledTask): Promise<void> {
     if (!triggeredWorkflows) {
       // No workflows linked — create standalone task (existing behavior)
       getDb().transaction(() => {
-        createTaskWithSiblingAwareness(schedule.taskTemplate, {
-          creatorAgentId: schedule.createdByAgentId,
-          taskType: schedule.taskType,
-          tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`],
-          priority: schedule.priority,
-          agentId: schedule.targetAgentId,
-          model: schedule.model,
-          scheduleId: schedule.id,
-          source: "schedule",
-          contextKey: scheduleContextKey({ scheduleId: schedule.id }),
-        });
+        createStandaloneScheduleTask(schedule);
       })();
     }
 
@@ -341,17 +339,7 @@ export async function runScheduleNow(scheduleId: string): Promise<void> {
   if (!triggeredWorkflows) {
     // No workflows linked — create standalone task (existing behavior)
     getDb().transaction(() => {
-      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 }),
-      });
+      createStandaloneScheduleTask(schedule, ["manual-run"]);
     })();
   }
 

package/src/server-user.ts

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import pkg from "../package.json";
+import { ModelTierSchema } from "./model-tiers";
 import {
   cancelTaskHandler,
   cancelTaskInputSchema,
@@ -28,9 +29,14 @@ const userSendTaskInputSchema = z.object({
   tags: z.array(z.string()).optional().describe("Tags for filtering (e.g., ['urgent'])."),
   priority: z.number().int().min(0).max(100).optional().describe("Priority 0-100 (default: 50)."),
   model: z
-    .enum(["haiku", "sonnet", "opus", "fable"])
+    .string()
+    .trim()
+    .min(1)
     .optional()
-    .describe("Model to use for this task ('haiku', 'sonnet', 'opus', or 'fable')."),
+    .describe("Concrete model override interpreted by the assignee's harness/provider."),
+  modelTier: ModelTierSchema.optional().describe(
+    "Portable model tier: 'smol', 'regular', 'smart', or 'ultra'. Resolved by the assignee's harness/provider.",
+  ),
 });
 
 export function createUserServer(user: User): McpServer {