@jackchen_me/open-multi-agent 0.1.0 → 1.0.0

package/src/orchestrator/orchestrator.ts

@@ -52,8 +52,10 @@ import type {
   TeamRunResult,
   TokenUsage,
 } from '../types.js'
+import type { RunOptions } from '../agent/runner.js'
 import { Agent } from '../agent/agent.js'
 import { AgentPool } from '../agent/pool.js'
+import { emitTrace, generateRunId } from '../utils/trace.js'
 import { ToolRegistry } from '../tool/framework.js'
 import { ToolExecutor } from '../tool/executor.js'
 import { registerBuiltInTools } from '../tool/built-in/index.js'
@@ -92,6 +94,105 @@ function buildAgent(config: AgentConfig): Agent {
   return new Agent(config, registry, executor)
 }
 
+/** Promise-based delay. */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/** Maximum delay cap to prevent runaway exponential backoff (30 seconds). */
+const MAX_RETRY_DELAY_MS = 30_000
+
+/**
+ * Compute the retry delay for a given attempt, capped at {@link MAX_RETRY_DELAY_MS}.
+ */
+export function computeRetryDelay(
+  baseDelay: number,
+  backoff: number,
+  attempt: number,
+): number {
+  return Math.min(baseDelay * backoff ** (attempt - 1), MAX_RETRY_DELAY_MS)
+}
+
+/**
+ * Execute an agent task with optional retry and exponential backoff.
+ *
+ * Exported for testability — called internally by {@link executeQueue}.
+ *
+ * @param run      - The function that executes the task (typically `pool.run`).
+ * @param task     - The task to execute (retry config read from its fields).
+ * @param onRetry  - Called before each retry sleep with event data.
+ * @param delayFn  - Injectable delay function (defaults to real `sleep`).
+ * @returns The final {@link AgentRunResult} from the last attempt.
+ */
+export async function executeWithRetry(
+  run: () => Promise<AgentRunResult>,
+  task: Task,
+  onRetry?: (data: { attempt: number; maxAttempts: number; error: string; nextDelayMs: number }) => void,
+  delayFn: (ms: number) => Promise<void> = sleep,
+): Promise<AgentRunResult> {
+  const rawRetries = Number.isFinite(task.maxRetries) ? task.maxRetries! : 0
+  const maxAttempts = Math.max(0, rawRetries) + 1
+  const baseDelay = Math.max(0, Number.isFinite(task.retryDelayMs) ? task.retryDelayMs! : 1000)
+  const backoff = Math.max(1, Number.isFinite(task.retryBackoff) ? task.retryBackoff! : 2)
+
+  let lastError: string = ''
+  // Accumulate token usage across all attempts so billing/observability
+  // reflects the true cost of retries.
+  let totalUsage: TokenUsage = { input_tokens: 0, output_tokens: 0 }
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const result = await run()
+      totalUsage = {
+        input_tokens: totalUsage.input_tokens + result.tokenUsage.input_tokens,
+        output_tokens: totalUsage.output_tokens + result.tokenUsage.output_tokens,
+      }
+
+      if (result.success) {
+        return { ...result, tokenUsage: totalUsage }
+      }
+      lastError = result.output
+
+      // Failure — retry or give up
+      if (attempt < maxAttempts) {
+        const delay = computeRetryDelay(baseDelay, backoff, attempt)
+        onRetry?.({ attempt, maxAttempts, error: lastError, nextDelayMs: delay })
+        await delayFn(delay)
+        continue
+      }
+
+      return { ...result, tokenUsage: totalUsage }
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err)
+
+      if (attempt < maxAttempts) {
+        const delay = computeRetryDelay(baseDelay, backoff, attempt)
+        onRetry?.({ attempt, maxAttempts, error: lastError, nextDelayMs: delay })
+        await delayFn(delay)
+        continue
+      }
+
+      // All retries exhausted — return a failure result
+      return {
+        success: false,
+        output: lastError,
+        messages: [],
+        tokenUsage: totalUsage,
+        toolCalls: [],
+      }
+    }
+  }
+
+  // Should not be reached, but TypeScript needs a return
+  return {
+    success: false,
+    output: lastError,
+    messages: [],
+    tokenUsage: totalUsage,
+    toolCalls: [],
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Parsed task spec (result of coordinator decomposition)
 // ---------------------------------------------------------------------------
@@ -161,6 +262,8 @@ interface RunContext {
   readonly scheduler: Scheduler
   readonly agentResults: Map<string, AgentRunResult>
   readonly config: OrchestratorConfig
+  /** Trace run ID, present when `onTrace` is configured. */
+  readonly runId?: string
 }
 
 /**
@@ -180,6 +283,17 @@ async function executeQueue(
 ): Promise<void> {
   const { team, pool, scheduler, config } = ctx
 
+  // Relay queue-level skip events to the orchestrator's onProgress callback.
+  const unsubSkipped = config.onProgress
+    ? queue.on('task:skipped', (task) => {
+        config.onProgress!({
+          type: 'task_skipped',
+          task: task.id,
+          data: task,
+        } satisfies OrchestratorEvent)
+      })
+    : undefined
+
   while (true) {
     // Re-run auto-assignment each iteration so tasks that were unblocked since
     // the last round (and thus have no assignee yet) get assigned before dispatch.
@@ -191,6 +305,11 @@ async function executeQueue(
       break
     }
 
+    // Track tasks that complete successfully in this round for the approval gate.
+    // Safe to push from concurrent promises: JS is single-threaded, so
+    // Array.push calls from resolved microtasks never interleave.
+    const completedThisRound: Task[] = []
+
     // Dispatch all currently-pending tasks as a parallel batch.
     const dispatchPromises = pending.map(async (task): Promise<void> => {
       // Mark in-progress
@@ -239,56 +358,109 @@ async function executeQueue(
       // Build the prompt: inject shared memory context + task description
       const prompt = await buildTaskPrompt(task, team)
 
-      try {
-        const result = await pool.run(assignee, prompt)
-        ctx.agentResults.set(`${assignee}:${task.id}`, result)
+      // Build trace context for this task's agent run
+      const traceOptions: Partial<RunOptions> | undefined = config.onTrace
+        ? { onTrace: config.onTrace, runId: ctx.runId ?? '', taskId: task.id, traceAgent: assignee }
+        : undefined
 
-        if (result.success) {
-          // Persist result into shared memory so other agents can read it
-          const sharedMem = team.getSharedMemoryInstance()
-          if (sharedMem) {
-            await sharedMem.write(assignee, `task:${task.id}:result`, result.output)
-          }
-
-          queue.complete(task.id, result.output)
+      const taskStartMs = config.onTrace ? Date.now() : 0
+      let retryCount = 0
 
+      const result = await executeWithRetry(
+        () => pool.run(assignee, prompt, traceOptions),
+        task,
+        (retryData) => {
+          retryCount++
           config.onProgress?.({
-            type: 'task_complete',
+            type: 'task_retry',
             task: task.id,
             agent: assignee,
-            data: result,
+            data: retryData,
           } satisfies OrchestratorEvent)
+        },
+      )
 
-          config.onProgress?.({
-            type: 'agent_complete',
-            agent: assignee,
-            task: task.id,
-            data: result,
-          } satisfies OrchestratorEvent)
-        } else {
-          queue.fail(task.id, result.output)
-          config.onProgress?.({
-            type: 'error',
-            task: task.id,
-            agent: assignee,
-            data: result,
-          } satisfies OrchestratorEvent)
+      // Emit task trace
+      if (config.onTrace) {
+        const taskEndMs = Date.now()
+        emitTrace(config.onTrace, {
+          type: 'task',
+          runId: ctx.runId ?? '',
+          taskId: task.id,
+          taskTitle: task.title,
+          agent: assignee,
+          success: result.success,
+          retries: retryCount,
+          startMs: taskStartMs,
+          endMs: taskEndMs,
+          durationMs: taskEndMs - taskStartMs,
+        })
+      }
+
+      ctx.agentResults.set(`${assignee}:${task.id}`, result)
+
+      if (result.success) {
+        // Persist result into shared memory so other agents can read it
+        const sharedMem = team.getSharedMemoryInstance()
+        if (sharedMem) {
+          await sharedMem.write(assignee, `task:${task.id}:result`, result.output)
         }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err)
-        queue.fail(task.id, message)
+
+        const completedTask = queue.complete(task.id, result.output)
+        completedThisRound.push(completedTask)
+
+        config.onProgress?.({
+          type: 'task_complete',
+          task: task.id,
+          agent: assignee,
+          data: result,
+        } satisfies OrchestratorEvent)
+
+        config.onProgress?.({
+          type: 'agent_complete',
+          agent: assignee,
+          task: task.id,
+          data: result,
+        } satisfies OrchestratorEvent)
+      } else {
+        queue.fail(task.id, result.output)
         config.onProgress?.({
           type: 'error',
           task: task.id,
           agent: assignee,
-          data: err,
+          data: result,
         } satisfies OrchestratorEvent)
       }
     })
 
     // Wait for the entire parallel batch before checking for newly-unblocked tasks.
     await Promise.all(dispatchPromises)
+
+    // --- Approval gate ---
+    // After the batch completes, check if the caller wants to approve
+    // the next round before it starts.
+    if (config.onApproval && completedThisRound.length > 0) {
+      scheduler.autoAssign(queue, team.getAgents())
+      const nextPending = queue.getByStatus('pending')
+
+      if (nextPending.length > 0) {
+        let approved: boolean
+        try {
+          approved = await config.onApproval(completedThisRound, nextPending)
+        } catch (err) {
+          const reason = `Skipped: approval callback error — ${err instanceof Error ? err.message : String(err)}`
+          queue.skipRemaining(reason)
+          break
+        }
+        if (!approved) {
+          queue.skipRemaining('Skipped: approval rejected.')
+          break
+        }
+      }
+    }
   }
+
+  unsubSkipped?.()
 }
 
 /**
@@ -341,8 +513,8 @@ async function buildTaskPrompt(task: Task, team: Team): Promise<string> {
  */
 export class OpenMultiAgent {
   private readonly config: Required<
-    Omit<OrchestratorConfig, 'onProgress'>
-  > & Pick<OrchestratorConfig, 'onProgress'>
+    Omit<OrchestratorConfig, 'onApproval' | 'onProgress' | 'onTrace' | 'defaultBaseURL' | 'defaultApiKey'>
+  > & Pick<OrchestratorConfig, 'onApproval' | 'onProgress' | 'onTrace' | 'defaultBaseURL' | 'defaultApiKey'>
 
   private readonly teams: Map<string, Team> = new Map()
   private completedTaskCount = 0
@@ -360,7 +532,11 @@ export class OpenMultiAgent {
       maxConcurrency: config.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY,
       defaultModel: config.defaultModel ?? DEFAULT_MODEL,
       defaultProvider: config.defaultProvider ?? 'anthropic',
+      defaultBaseURL: config.defaultBaseURL,
+      defaultApiKey: config.defaultApiKey,
+      onApproval: config.onApproval,
       onProgress: config.onProgress,
+      onTrace: config.onTrace,
     }
   }
 
@@ -405,14 +581,24 @@ export class OpenMultiAgent {
    * @param prompt - The user prompt to send.
    */
   async runAgent(config: AgentConfig, prompt: string): Promise<AgentRunResult> {
-    const agent = buildAgent(config)
+    const effective: AgentConfig = {
+      ...config,
+      provider: config.provider ?? this.config.defaultProvider,
+      baseURL: config.baseURL ?? this.config.defaultBaseURL,
+      apiKey: config.apiKey ?? this.config.defaultApiKey,
+    }
+    const agent = buildAgent(effective)
     this.config.onProgress?.({
       type: 'agent_start',
       agent: config.name,
       data: { prompt },
     })
 
-    const result = await agent.run(prompt)
+    const traceOptions: Partial<RunOptions> | undefined = this.config.onTrace
+      ? { onTrace: this.config.onTrace, runId: generateRunId(), traceAgent: config.name }
+      : undefined
+
+    const result = await agent.run(prompt, traceOptions)
 
     this.config.onProgress?.({
       type: 'agent_complete',
@@ -462,12 +648,15 @@ export class OpenMultiAgent {
       name: 'coordinator',
       model: this.config.defaultModel,
       provider: this.config.defaultProvider,
+      baseURL: this.config.defaultBaseURL,
+      apiKey: this.config.defaultApiKey,
       systemPrompt: this.buildCoordinatorSystemPrompt(agentConfigs),
       maxTurns: 3,
     }
 
     const decompositionPrompt = this.buildDecompositionPrompt(goal, agentConfigs)
     const coordinatorAgent = buildAgent(coordinatorConfig)
+    const runId = this.config.onTrace ? generateRunId() : undefined
 
     this.config.onProgress?.({
       type: 'agent_start',
@@ -475,7 +664,10 @@ export class OpenMultiAgent {
       data: { phase: 'decomposition', goal },
     })
 
-    const decompositionResult = await coordinatorAgent.run(decompositionPrompt)
+    const decompTraceOptions: Partial<RunOptions> | undefined = this.config.onTrace
+      ? { onTrace: this.config.onTrace, runId: runId ?? '', traceAgent: 'coordinator' }
+      : undefined
+    const decompositionResult = await coordinatorAgent.run(decompositionPrompt, decompTraceOptions)
     const agentResults = new Map<string, AgentRunResult>()
     agentResults.set('coordinator:decompose', decompositionResult)
 
@@ -519,6 +711,7 @@ export class OpenMultiAgent {
       scheduler,
       agentResults,
       config: this.config,
+      runId,
     }
 
     await executeQueue(queue, ctx)
@@ -527,7 +720,10 @@ export class OpenMultiAgent {
     // Step 5: Coordinator synthesises final result
     // ------------------------------------------------------------------
     const synthesisPrompt = await this.buildSynthesisPrompt(goal, queue.list(), team)
-    const synthesisResult = await coordinatorAgent.run(synthesisPrompt)
+    const synthTraceOptions: Partial<RunOptions> | undefined = this.config.onTrace
+      ? { onTrace: this.config.onTrace, runId: runId ?? '', traceAgent: 'coordinator' }
+      : undefined
+    const synthesisResult = await coordinatorAgent.run(synthesisPrompt, synthTraceOptions)
     agentResults.set('coordinator', synthesisResult)
 
     this.config.onProgress?.({
@@ -564,6 +760,9 @@ export class OpenMultiAgent {
       description: string
       assignee?: string
       dependsOn?: string[]
+      maxRetries?: number
+      retryDelayMs?: number
+      retryBackoff?: number
     }>,
   ): Promise<TeamRunResult> {
     const agentConfigs = team.getAgents()
@@ -576,6 +775,9 @@ export class OpenMultiAgent {
         description: t.description,
         assignee: t.assignee,
         dependsOn: t.dependsOn,
+        maxRetries: t.maxRetries,
+        retryDelayMs: t.retryDelayMs,
+        retryBackoff: t.retryBackoff,
       })),
       agentConfigs,
       queue,
@@ -591,6 +793,7 @@ export class OpenMultiAgent {
       scheduler,
       agentResults,
       config: this.config,
+      runId: this.config.onTrace ? generateRunId() : undefined,
     }
 
     await executeQueue(queue, ctx)
@@ -694,6 +897,7 @@ export class OpenMultiAgent {
   ): Promise<string> {
     const completedTasks = tasks.filter((t) => t.status === 'completed')
     const failedTasks = tasks.filter((t) => t.status === 'failed')
+    const skippedTasks = tasks.filter((t) => t.status === 'skipped')
 
     const resultSections = completedTasks.map((t) => {
       const assignee = t.assignee ?? 'unknown'
@@ -704,6 +908,10 @@ export class OpenMultiAgent {
       (t) => `### ${t.title} (FAILED)\nError: ${t.result ?? 'unknown error'}`,
     )
 
+    const skippedSections = skippedTasks.map(
+      (t) => `### ${t.title} (SKIPPED)\nReason: ${t.result ?? 'approval rejected'}`,
+    )
+
     // Also include shared memory summary for additional context
     let memorySummary = ''
     const sharedMem = team.getSharedMemoryInstance()
@@ -718,11 +926,12 @@ export class OpenMultiAgent {
       `## Task Results`,
       ...resultSections,
       ...(failureSections.length > 0 ? ['', '## Failed Tasks', ...failureSections] : []),
+      ...(skippedSections.length > 0 ? ['', '## Skipped Tasks', ...skippedSections] : []),
       ...(memorySummary ? ['', memorySummary] : []),
       '',
       '## Your Task',
       'Synthesise the above results into a comprehensive final answer that addresses the original goal.',
-      'If some tasks failed, note any gaps in the result.',
+      'If some tasks failed or were skipped, note any gaps in the result.',
     ].join('\n')
   }
 
@@ -733,7 +942,11 @@ export class OpenMultiAgent {
    * then resolving them to real IDs before adding tasks to the queue.
    */
   private loadSpecsIntoQueue(
-    specs: ReadonlyArray<ParsedTaskSpec>,
+    specs: ReadonlyArray<ParsedTaskSpec & {
+      maxRetries?: number
+      retryDelayMs?: number
+      retryBackoff?: number
+    }>,
     agentConfigs: AgentConfig[],
     queue: TaskQueue,
   ): void {
@@ -750,6 +963,9 @@ export class OpenMultiAgent {
         assignee: spec.assignee && agentNames.has(spec.assignee)
           ? spec.assignee
           : undefined,
+        maxRetries: spec.maxRetries,
+        retryDelayMs: spec.retryDelayMs,
+        retryBackoff: spec.retryBackoff,
       })
       titleToId.set(spec.title.toLowerCase().trim(), task.id)
       createdTasks.push(task)
@@ -792,6 +1008,8 @@ export class OpenMultiAgent {
         ...config,
         model: config.model,
         provider: config.provider ?? this.config.defaultProvider,
+        baseURL: config.baseURL ?? this.config.defaultBaseURL,
+        apiKey: config.apiKey ?? this.config.defaultApiKey,
       }
       pool.add(buildAgent(effective))
     }
@@ -825,13 +1043,15 @@ export class OpenMultiAgent {
       if (!existing) {
         collapsed.set(agentName, result)
       } else {
-        // Merge multiple results for the same agent (multi-task case)
+        // Merge multiple results for the same agent (multi-task case).
+        // Keep the latest `structured` value (last completed task wins).
         collapsed.set(agentName, {
           success: existing.success && result.success,
           output: [existing.output, result.output].filter(Boolean).join('\n\n---\n\n'),
           messages: [...existing.messages, ...result.messages],
           tokenUsage: addUsage(existing.tokenUsage, result.tokenUsage),
           toolCalls: [...existing.toolCalls, ...result.toolCalls],
+          structured: result.structured !== undefined ? result.structured : existing.structured,
         })
       }
 

package/src/task/queue.ts

@@ -18,6 +18,7 @@ export type TaskQueueEvent =
   | 'task:ready'
   | 'task:complete'
   | 'task:failed'
+  | 'task:skipped'
   | 'all:complete'
 
 /** Handler for `'task:ready' | 'task:complete' | 'task:failed'` events. */
@@ -156,6 +157,51 @@ export class TaskQueue {
     return failed
   }
 
+  /**
+   * Marks `taskId` as `'skipped'` and records `reason` in the `result` field.
+   *
+   * Fires `'task:skipped'` for the skipped task and cascades to every
+   * downstream task that transitively depended on it — even if the dependent
+   * has other dependencies that are still pending or completed. A skipped
+   * upstream is treated as permanently unsatisfiable, mirroring `fail()`.
+   *
+   * @throws {Error} when `taskId` is not found.
+   */
+  skip(taskId: string, reason: string): Task {
+    const skipped = this.update(taskId, { status: 'skipped', result: reason })
+    this.emit('task:skipped', skipped)
+    this.cascadeSkip(taskId)
+    if (this.isComplete()) {
+      this.emitAllComplete()
+    }
+    return skipped
+  }
+
+  /**
+   * Marks all non-terminal tasks as `'skipped'`.
+   *
+   * Used when an approval gate rejects continuation — every pending, blocked,
+   * or in-progress task is skipped with the given reason.
+   *
+   * **Important:** Call only when no tasks are actively executing. The
+   * orchestrator invokes this after `await Promise.all()`, so no tasks are
+   * in-flight. Calling while agents are running may mark an in-progress task
+   * as skipped while its agent continues executing.
+   */
+  skipRemaining(reason = 'Skipped: approval rejected.'): void {
+    // Snapshot first — update() mutates the live map, which is unsafe to
+    // iterate over during modification.
+    const snapshot = Array.from(this.tasks.values())
+    for (const task of snapshot) {
+      if (task.status === 'completed' || task.status === 'failed' || task.status === 'skipped') continue
+      const skipped = this.update(task.id, { status: 'skipped', result: reason })
+      this.emit('task:skipped', skipped)
+    }
+    if (this.isComplete()) {
+      this.emitAllComplete()
+    }
+  }
+
   /**
    * Recursively marks all tasks that (transitively) depend on `failedTaskId`
    * as `'failed'` with an informative message, firing `'task:failed'` for each.
@@ -178,6 +224,24 @@ export class TaskQueue {
     }
   }
 
+  /**
+   * Recursively marks all tasks that (transitively) depend on `skippedTaskId`
+   * as `'skipped'`, firing `'task:skipped'` for each.
+   */
+  private cascadeSkip(skippedTaskId: string): void {
+    for (const task of this.tasks.values()) {
+      if (task.status !== 'blocked' && task.status !== 'pending') continue
+      if (!task.dependsOn?.includes(skippedTaskId)) continue
+
+      const cascaded = this.update(task.id, {
+        status: 'skipped',
+        result: `Skipped: dependency "${skippedTaskId}" was skipped.`,
+      })
+      this.emit('task:skipped', cascaded)
+      this.cascadeSkip(task.id)
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // Queries
   // ---------------------------------------------------------------------------
@@ -227,11 +291,11 @@ export class TaskQueue {
 
   /**
    * Returns `true` when every task in the queue has reached a terminal state
-   * (`'completed'` or `'failed'`), **or** the queue is empty.
+   * (`'completed'`, `'failed'`, or `'skipped'`), **or** the queue is empty.
    */
   isComplete(): boolean {
     for (const task of this.tasks.values()) {
-      if (task.status !== 'completed' && task.status !== 'failed') return false
+      if (task.status !== 'completed' && task.status !== 'failed' && task.status !== 'skipped') return false
     }
     return true
   }
@@ -249,12 +313,14 @@ export class TaskQueue {
     total: number
     completed: number
     failed: number
+    skipped: number
     inProgress: number
     pending: number
     blocked: number
   } {
     let completed = 0
     let failed = 0
+    let skipped = 0
     let inProgress = 0
     let pending = 0
     let blocked = 0
@@ -267,6 +333,9 @@ export class TaskQueue {
         case 'failed':
           failed++
           break
+        case 'skipped':
+          skipped++
+          break
         case 'in_progress':
           inProgress++
           break
@@ -283,6 +352,7 @@ export class TaskQueue {
       total: this.tasks.size,
       completed,
       failed,
+      skipped,
       inProgress,
       pending,
       blocked,
@@ -356,7 +426,7 @@ export class TaskQueue {
 
       // Re-check against the current state of the whole task set.
       // Pass the pre-built map to avoid rebuilding it for every candidate task.
-      if (isTaskReady(task, allTasks, taskById)) {
+      if (isTaskReady({ ...task, status: 'pending' }, allTasks, taskById)) {
         const unblocked: Task = {
           ...task,
           status: 'pending',
@@ -370,7 +440,7 @@ export class TaskQueue {
     }
   }
 
-  private emit(event: 'task:ready' | 'task:complete' | 'task:failed', task: Task): void {
+  private emit(event: 'task:ready' | 'task:complete' | 'task:failed' | 'task:skipped', task: Task): void {
     const map = this.listeners.get(event)
     if (!map) return
     for (const handler of map.values()) {

package/src/task/task.ts

@@ -6,6 +6,7 @@
  * Stateful orchestration belongs in {@link TaskQueue}.
  */
 
+import { randomUUID } from 'node:crypto'
 import type { Task, TaskStatus } from '../types.js'
 
 // ---------------------------------------------------------------------------
@@ -30,10 +31,13 @@ export function createTask(input: {
   description: string
   assignee?: string
   dependsOn?: string[]
+  maxRetries?: number
+  retryDelayMs?: number
+  retryBackoff?: number
 }): Task {
   const now = new Date()
   return {
-    id: crypto.randomUUID(),
+    id: randomUUID(),
     title: input.title,
     description: input.description,
     status: 'pending' as TaskStatus,
@@ -42,6 +46,9 @@ export function createTask(input: {
     result: undefined,
     createdAt: now,
     updatedAt: now,
+    maxRetries: input.maxRetries,
+    retryDelayMs: input.retryDelayMs,
+    retryBackoff: input.retryBackoff,
   }
 }
 

package/src/team/messaging.ts

@@ -6,6 +6,8 @@
  * for replay and audit; read-state is tracked per recipient.
  */
 
+import { randomUUID } from 'node:crypto'
+
 // ---------------------------------------------------------------------------
 // Message type
 // ---------------------------------------------------------------------------
@@ -93,7 +95,7 @@ export class MessageBus {
    */
   send(from: string, to: string, content: string): Message {
     const message: Message = {
-      id: crypto.randomUUID(),
+      id: randomUUID(),
       from,
       to,
       content,