@desplega.ai/agent-swarm 1.92.2 → 1.94.0

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

@@ -470,6 +470,8 @@ class ClaudeSession implements ProviderSession {
     private sessionMcpConfig: string | null = null,
     private claudeBinaryArgv: readonly string[] = ["claude"],
     systemPromptFile: string | null = null,
+    private harnessVariant?: string,
+    private harnessVariantMeta?: Record<string, unknown>,
   ) {
     this.taskFilePid = taskFilePid;
     this.contextWindowSize = getContextWindowSize(model);
@@ -682,7 +684,13 @@ class ClaudeSession implements ProviderSession {
       // Session ID from init message
       if (json.type === "system" && json.subtype === "init" && json.session_id) {
         this._sessionId = json.session_id;
-        this.emit({ type: "session_init", sessionId: json.session_id, provider: "claude" });
+        this.emit({
+          type: "session_init",
+          sessionId: json.session_id,
+          provider: "claude",
+          ...(this.harnessVariant ? { harnessVariant: this.harnessVariant } : {}),
+          ...(this.harnessVariantMeta ? { harnessVariantMeta: this.harnessVariantMeta } : {}),
+        });
         if (json.model) {
           // Phase 4: the CLI's `init.model` reflects the actual model after any
           // backoff/fallback. Update `this.model` so subsequent CostData rows
@@ -970,6 +978,28 @@ export class ClaudeAdapter implements ProviderAdapter {
       }
     }
 
+    const harnessVariant = useClaudeBridge ? "bridge" : "stock";
+    let harnessVariantMeta: Record<string, unknown> | undefined;
+    if (useClaudeBridge) {
+      try {
+        const bin = effectiveClaudeBinaryArgv[0] ?? "claude-bridge";
+        const result = await Bun.$`${bin} --version`.quiet();
+        const trimmed = result.text().trim();
+        if (trimmed) harnessVariantMeta = { version: trimmed };
+      } catch {
+        // bridge version is best-effort
+      }
+    } else {
+      try {
+        const bin = effectiveClaudeBinaryArgv[0] ?? "claude";
+        const result = await Bun.$`${bin} --version`.quiet();
+        const trimmed = result.text().trim();
+        if (trimmed) harnessVariantMeta = { version: trimmed };
+      } catch {
+        // stock version is best-effort
+      }
+    }
+
     return new ClaudeSession(
       config,
       model,
@@ -978,6 +1008,8 @@ export class ClaudeAdapter implements ProviderAdapter {
       sessionMcpConfig,
       effectiveClaudeBinaryArgv,
       systemPromptFile,
+      harnessVariant,
+      harnessVariantMeta,
     );
   }
 

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

@@ -69,6 +69,7 @@ import { scrubSecrets } from "../utils/secret-scrubber";
 import { computeClaudeManagedCostUsd } from "./claude-managed-models";
 import { getRuntimeFeePerHour } from "./claude-managed-pricing";
 import { createClaudeManagedSwarmEventHandler } from "./claude-managed-swarm-events";
+import { readPkgVersion } from "./harness-version";
 import type {
   CostData,
   CredStatus,
@@ -639,11 +640,13 @@ class ClaudeManagedSession implements ProviderSession {
       // 3. Emit `session_init` once the session is wired up. Listeners
       //    attached via `onEvent` will see this either immediately (if they
       //    attached pre-emit) or via the queue flush.
+      const sdkVersion = readPkgVersion("@anthropic-ai/sdk");
       this.emit({
         type: "session_init",
         sessionId: this._sessionId,
         provider: "claude-managed",
         providerMeta: { managed: true },
+        ...(sdkVersion ? { harnessVariantMeta: { version: sdkVersion } } : {}),
       });
 
       // 4. Drain the SSE stream.

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

@@ -25,6 +25,8 @@
 
 /** 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",
@@ -50,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)
@@ -57,6 +61,18 @@ export interface ClaudeManagedModelPricing {
  * - claude-haiku-4-5:  $1 / $5 / $0.10 / $1.25
  */
 export const CLAUDE_MANAGED_MODEL_PRICING: Record<ClaudeManagedModel, ClaudeManagedModelPricing> = {
+  "claude-fable-5": {
+    inputPerMillion: 10.0,
+    outputPerMillion: 50.0,
+    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-adapter.ts

@@ -83,6 +83,7 @@ import { getValidCodexOAuth } from "./codex-oauth/storage.js";
 import { resolveCodexPrompt } from "./codex-skill-resolver";
 import { createCodexSwarmEventHandler } from "./codex-swarm-events";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
+import { readPkgVersion } from "./harness-version";
 import { buildOtelTraceparentEnv } from "./otel-env";
 import type {
   CostData,
@@ -694,7 +695,13 @@ export class CodexSession implements ProviderSession {
     switch (event.type) {
       case "thread.started": {
         this._sessionId = event.thread_id;
-        this.emit({ type: "session_init", sessionId: event.thread_id, provider: "codex" });
+        const codexVersion = readPkgVersion("@openai/codex-sdk");
+        this.emit({
+          type: "session_init",
+          sessionId: event.thread_id,
+          provider: "codex",
+          ...(codexVersion ? { harnessVariantMeta: { version: codexVersion } } : {}),
+        });
         break;
       }
       case "turn.started": {

package/src/providers/codex-models.ts

@@ -36,6 +36,7 @@ export const CODEX_DEFAULT_MODEL: CodexModel = "gpt-5.4";
  * a task authored for Claude works unchanged when pointed at a Codex worker.
  */
 const CLAUDE_SHORTNAMES: Record<string, CodexModel> = {
+  fable: "gpt-5.5",
   opus: "gpt-5.4",
   sonnet: "gpt-5.4",
   haiku: "gpt-5.4-mini",

package/src/providers/codex-oauth/auth-json.ts

@@ -48,6 +48,7 @@ export function authJsonToCredentialSelection(auth: CodexAuthJson, slot = 0, tot
     total,
     keySuffix: suffixSource.slice(-5),
     keyType: "CODEX_OAUTH",
+    isRateLimitFallback: false,
   };
 }
 

package/src/providers/harness-version.ts

@@ -0,0 +1,7 @@
+export function readPkgVersion(packageName: string): string | undefined {
+  try {
+    return require(`${packageName}/package.json`).version;
+  } catch {
+    return undefined;
+  }
+}

package/src/providers/opencode-adapter.ts

@@ -21,6 +21,7 @@ import { validateOpencodeCredentials } from "../utils/credentials";
 import { fetchInstalledMcpServers } from "../utils/mcp-server-fetcher";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
+import { readPkgVersion } from "./harness-version";
 import type {
   CostData,
   CredCheckOptions,
@@ -210,7 +211,7 @@ export class OpencodeSession implements ProviderSession {
   // The runner attaches its listener after `await adapter.createSession(...)`
   // resolves, but events queued via Promise.resolve().then(...) inside
   // createSession fire on the next microtask — *before* that listener call —
-  // so the runner would miss session_init and never PUT /claude-session,
+  // so the runner would miss session_init and never PUT /session,
   // leaving agent_tasks.provider/.model NULL. Buffer + flush on first attach.
   private pendingEvents: ProviderEvent[] = [];
   private completionResolve!: (result: ProviderResult) => void;
@@ -280,8 +281,14 @@ export class OpencodeSession implements ProviderSession {
 
   /** Emit the synthetic session_init event. Called by the adapter immediately
    * after construction; buffers if no listener is attached yet. */
-  emitSessionInit(provider: "opencode"): void {
-    this.emit({ type: "session_init", sessionId: this._sessionId, provider });
+  emitSessionInit(provider: "opencode", harnessVariantMeta?: Record<string, unknown>): void {
+    this.emit({
+      type: "session_init",
+      sessionId: this._sessionId,
+      provider,
+      harnessVariant: "stock",
+      ...(harnessVariantMeta ? { harnessVariantMeta } : {}),
+    });
   }
 
   onEvent(listener: (event: ProviderEvent) => void): void {
@@ -767,7 +774,8 @@ export class OpencodeAdapter implements ProviderAdapter {
 
     // Emit session_init synchronously; the session buffers events until the
     // runner's `onEvent(listener)` call attaches a listener.
-    session.emitSessionInit("opencode");
+    const opcVersion = readPkgVersion("@opencode-ai/sdk");
+    session.emitSessionInit("opencode", opcVersion ? { version: opcVersion } : undefined);
 
     // Subscribe to SSE events and drive the session
     client.event

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

@@ -25,7 +25,9 @@ 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";
 import { McpHttpClient } from "./pi-mono-mcp-client";
 import type {
@@ -173,6 +175,7 @@ function mcpToolsToDefinitions(
  * (`anthropic/claude-{opus,sonnet,haiku}-*`).
  */
 const ANTHROPIC_SHORTNAME_OPENROUTER_MIRROR: Record<string, string> = {
+  fable: "anthropic/claude-fable-5",
   opus: "anthropic/claude-opus-4",
   sonnet: "anthropic/claude-sonnet-4",
   haiku: "anthropic/claude-haiku-4.5",
@@ -233,7 +236,8 @@ export function resolveModel(
   if (!modelStr) return undefined;
 
   const lower = modelStr.toLowerCase();
-  const isAnthropicShortname = lower === "opus" || lower === "sonnet" || lower === "haiku";
+  const isAnthropicShortname =
+    lower === "opus" || lower === "sonnet" || lower === "haiku" || lower === "fable";
 
   // Reroute anthropic shortnames through OpenRouter when no anthropic cred
   // is available. The OpenRouter mirror IDs (`anthropic/claude-sonnet-4`,
@@ -251,6 +255,7 @@ export function resolveModel(
 
   // Map common shortnames to provider/model pairs (native anthropic path).
   const shortnames: Record<string, [string, string]> = {
+    fable: ["anthropic", "claude-fable-5"],
     opus: ["anthropic", "claude-opus-4-20250514"],
     sonnet: ["anthropic", "claude-sonnet-4-20250514"],
     haiku: ["anthropic", "claude-haiku-4-5-20251001"],
@@ -357,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;
@@ -367,7 +384,14 @@ export class PiMonoSession implements ProviderSession {
     this.sessionStartedAt = Date.now();
 
     // Emit session_init immediately
-    this.emit({ type: "session_init", sessionId: this._sessionId, provider: "pi" });
+    const piVersion = readPkgVersion("@earendil-works/pi-coding-agent");
+    this.emit({
+      type: "session_init",
+      sessionId: this._sessionId,
+      provider: "pi",
+      harnessVariant: "stock",
+      ...(piVersion ? { harnessVariantMeta: { version: piVersion } } : {}),
+    });
 
     // Subscribe to agent events and normalize
     this.agentSession.subscribe((event) => this.handleAgentEvent(event));
@@ -414,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) {
@@ -507,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;
+      }
     }
   }
 
@@ -530,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,
@@ -545,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/providers/types.ts

@@ -42,6 +42,8 @@ export type ProviderEvent =
       sessionId: string;
       provider?: ProviderName;
       providerMeta?: Record<string, unknown>;
+      harnessVariant?: string;
+      harnessVariantMeta?: Record<string, unknown>;
     }
   | { type: "message"; role: "assistant" | "user"; content: string }
   | { type: "tool_start"; toolCallId: string; toolName: string; args: unknown }

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"]);
     })();
   }