@pellux/goodvibes-tui 0.18.10 → 0.18.12

package/src/automation/delivery-manager.ts

@@ -1,368 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import type { ArtifactReference, ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
-import { ChannelDeliveryRouter, RouteBindingManager } from '@pellux/goodvibes-sdk/platform/channels/index';
-import { ServiceRegistry } from '../config/service-registry.ts';
-import { createDomainDispatch } from '../runtime/store/index.ts';
-import type { DomainDispatch, RuntimeStore } from '../runtime/store/index.ts';
-import type { RuntimeEventBus } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
-import type { RouteSurfaceKind } from '@pellux/goodvibes-sdk/platform/runtime/events/routes';
-import {
-  emitDeliveryFailed,
-  emitDeliveryQueued,
-  emitDeliveryStarted,
-  emitDeliverySucceeded,
-} from '@pellux/goodvibes-sdk/platform/runtime/emitters/index';
-import type { AutomationDeliveryAttempt, AutomationDeliveryTarget } from '@pellux/goodvibes-sdk/platform/automation/delivery';
-import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
-import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
-import type { AutomationRun } from '@pellux/goodvibes-sdk/platform/automation/runs';
-import { classifyDeliveryError } from '@pellux/goodvibes-sdk/platform/integrations/delivery';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function calculateRetryDelay(baseDelayMs: number, attempt: number, strategy: 'fixed' | 'linear' | 'exponential', maxDelayMs?: number, jitterMs?: number): number {
-  const multiplier = strategy === 'fixed' ? 1 : strategy === 'linear' ? attempt : Math.pow(2, attempt - 1);
-  const base = baseDelayMs * multiplier;
-  const jitter = jitterMs ? Math.floor(Math.random() * jitterMs) : 0;
-  return Math.min(base + jitter, maxDelayMs ?? Number.MAX_SAFE_INTEGER);
-}
-
-function buildDeliveryMessage(job: AutomationJob, run: AutomationRun): string {
-  const lines = [
-    `Automation: ${job.name}`,
-    `Run: ${run.id}`,
-    `Status: ${run.status}`,
-  ];
-  if (run.error) lines.push(`Error: ${run.error}`);
-  if (job.delivery.includeSummary) {
-    const content = typeof run.result === 'string'
-      ? run.result
-      : run.result !== undefined
-        ? JSON.stringify(run.result, null, 2)
-        : '';
-    if (content) {
-      lines.push('');
-      lines.push(content.length > 3500 ? `${content.slice(0, 3500)}...` : content);
-    }
-  }
-  return lines.join('\n');
-}
-
-function toDeliveryKind(surfaceKind: string): 'notification' | 'reply' | 'action' | 'callback' {
-  return surfaceKind === 'webhook' ? 'callback' : 'notification';
-}
-
-function toDeliverySurfaceKind(surfaceKind: AutomationDeliveryTarget['surfaceKind']): RouteSurfaceKind {
-  return surfaceKind ?? 'webhook';
-}
-
-function extractArtifactReferences(result: unknown): ArtifactReference[] {
-  if (!result || typeof result !== 'object') return [];
-  const record = result as Record<string, unknown>;
-  const rawItems = [
-    ...(Array.isArray(record.artifacts) ? record.artifacts : []),
-    ...(Array.isArray(record.attachments) ? record.attachments : []),
-    ...(Array.isArray(record.artifactIds) ? record.artifactIds.map((artifactId) => ({ artifactId })) : []),
-  ];
-  const references: ArtifactReference[] = [];
-  for (const entry of rawItems) {
-    if (typeof entry === 'string' && entry.trim().length > 0) {
-      references.push({ artifactId: entry.trim() });
-      continue;
-    }
-    if (!entry || typeof entry !== 'object') continue;
-    const candidate = entry as Record<string, unknown>;
-    const artifactId = typeof candidate.artifactId === 'string'
-      ? candidate.artifactId
-      : typeof candidate.id === 'string'
-        ? candidate.id
-        : '';
-    if (!artifactId) continue;
-    references.push({
-      artifactId,
-      ...(typeof candidate.label === 'string' ? { label: candidate.label } : {}),
-      ...(typeof candidate.metadata === 'object' && candidate.metadata !== null
-        ? { metadata: candidate.metadata as Record<string, unknown> }
-        : {}),
-    });
-  }
-  return references.filter((entry, index, values) => values.findIndex((candidate) => candidate.artifactId === entry.artifactId) === index);
-}
-
-interface ResolvedDeliveryTarget {
-  readonly target: AutomationDeliveryTarget;
-  readonly binding?: AutomationRouteBinding;
-}
-
-export class AutomationDeliveryManager {
-  private readonly routeBindings: RouteBindingManager;
-  private readonly deliveryRouter: ChannelDeliveryRouter;
-  private runtimeDispatch: DomainDispatch | null = null;
-  private runtimeBus: RuntimeEventBus | null = null;
-
-  constructor(config: {
-    readonly serviceRegistry?: ServiceRegistry;
-    readonly configManager?: import('@pellux/goodvibes-sdk/platform/config/manager').ConfigManager;
-    readonly routeBindings: RouteBindingManager;
-    readonly deliveryRouter?: ChannelDeliveryRouter;
-    readonly artifactStore?: ArtifactStore;
-    readonly runtimeStore?: RuntimeStore;
-    readonly runtimeBus?: RuntimeEventBus;
-  }) {
-    this.routeBindings = config.routeBindings;
-    if (config.deliveryRouter) {
-      this.deliveryRouter = config.deliveryRouter;
-    } else {
-      if (!config.serviceRegistry || !config.configManager || !config.artifactStore) {
-        throw new Error(
-          'AutomationDeliveryManager requires serviceRegistry, configManager, and artifactStore when no deliveryRouter is provided.',
-        );
-      }
-      this.deliveryRouter = new ChannelDeliveryRouter({
-        configManager: config.configManager,
-        serviceRegistry: config.serviceRegistry,
-        artifactStore: config.artifactStore,
-      });
-    }
-    if (config.runtimeStore) this.runtimeDispatch = createDomainDispatch(config.runtimeStore);
-    this.runtimeBus = config.runtimeBus ?? null;
-  }
-
-  attachRuntime(config: {
-    readonly runtimeStore?: RuntimeStore | null;
-    readonly runtimeBus?: RuntimeEventBus | null;
-  }): void {
-    if (config.runtimeStore) {
-      this.runtimeDispatch = createDomainDispatch(config.runtimeStore);
-    }
-    if (config.runtimeBus) {
-      this.runtimeBus = config.runtimeBus;
-    }
-  }
-
-  getDeliveryRouter(): ChannelDeliveryRouter {
-    return this.deliveryRouter;
-  }
-
-  setControlPlaneGateway(gateway: import('../control-plane/gateway.ts').ControlPlaneGateway | null): void {
-    this.deliveryRouter.setControlPlaneGateway(gateway);
-  }
-
-  async deliverJobRun(job: AutomationJob, run: AutomationRun): Promise<readonly AutomationDeliveryAttempt[]> {
-    if (job.delivery.mode === 'none') return [];
-
-    await this.routeBindings.start();
-    const body = buildDeliveryMessage(job, run);
-    const primaryTargets = this.resolveTargets(job.delivery.targets.length > 0
-      ? [...job.delivery.targets]
-      : job.delivery.replyToRouteId
-        ? [{ kind: 'surface', routeId: job.delivery.replyToRouteId } satisfies AutomationDeliveryTarget]
-        : []);
-    const attempts = await this.deliverText(job, run, body, primaryTargets.map((entry) => entry.target));
-    const needsFallback = attempts.length === 0 || attempts.every((attempt) => attempt.status === 'failed' || attempt.status === 'dead_lettered');
-    if (!needsFallback || job.delivery.fallbackTargets.length === 0) {
-      return attempts;
-    }
-    const fallbackAttempts = await this.deliverText(job, run, body, job.delivery.fallbackTargets);
-    return [...attempts, ...fallbackAttempts];
-  }
-
-  async deliverText(
-    job: AutomationJob,
-    run: AutomationRun,
-    body: string,
-    targets: readonly AutomationDeliveryTarget[],
-  ): Promise<readonly AutomationDeliveryAttempt[]> {
-    await this.routeBindings.start();
-    const resolvedTargets = this.resolveTargets(targets);
-    if (resolvedTargets.length === 0) return [];
-
-    const attempts: AutomationDeliveryAttempt[] = [];
-    for (const resolved of resolvedTargets) {
-      const target = resolved.target;
-      const deliveryId = `delivery-${randomUUID().slice(0, 8)}`;
-      const startedAt = Date.now();
-      let attempt: AutomationDeliveryAttempt = {
-        id: deliveryId,
-        runId: run.id,
-        jobId: job.id,
-        target,
-        status: 'pending',
-      };
-      attempts.push(attempt);
-      this.syncAttempt(attempt, run, 'queued');
-
-      const retryPolicy = job.failure.retryPolicy;
-      let attemptIndex = 0;
-      let lastError = '';
-      while (attemptIndex < Math.max(1, retryPolicy.maxAttempts)) {
-        attemptIndex += 1;
-        attempt = {
-          ...attempt,
-          status: 'sending',
-          startedAt: Date.now(),
-          error: undefined,
-        };
-        this.syncAttempt(attempt, run, 'started');
-        try {
-          const responseId = await this.sendTarget(resolved, body, job, run);
-          if (resolved.binding?.id && responseId) {
-            await this.routeBindings.captureReplyTarget(resolved.binding.id, responseId, resolved.binding.threadId);
-          }
-          attempt = {
-            ...attempt,
-            status: 'sent',
-            endedAt: Date.now(),
-            responseId: responseId ?? target.address ?? target.routeId ?? target.label ?? target.surfaceKind ?? 'delivered',
-          };
-          attempts[attempts.length - 1] = attempt;
-          this.syncAttempt(attempt, run, 'succeeded');
-          lastError = '';
-          break;
-        } catch (error) {
-          lastError = summarizeError(error);
-          const retryable = classifyDeliveryError(error) === 'retryable';
-          const lastTry = attemptIndex >= Math.max(1, retryPolicy.maxAttempts);
-          if (!retryable || lastTry) {
-            attempt = {
-              ...attempt,
-              status: retryable ? 'dead_lettered' : 'failed',
-              endedAt: Date.now(),
-              error: lastError,
-            };
-            attempts[attempts.length - 1] = attempt;
-            this.syncAttempt(attempt, run, 'failed', lastError, retryable);
-            break;
-          }
-          const delayMs = calculateRetryDelay(
-            retryPolicy.delayMs,
-            attemptIndex,
-            retryPolicy.strategy,
-            retryPolicy.maxDelayMs,
-            retryPolicy.jitterMs,
-          );
-          await sleep(delayMs);
-        }
-      }
-
-      if (lastError && attempts[attempts.length - 1]?.status === 'sending') {
-        const failedAttempt: AutomationDeliveryAttempt = {
-          ...attempts[attempts.length - 1]!,
-          status: 'failed',
-          endedAt: Date.now(),
-          error: lastError,
-        };
-        attempts[attempts.length - 1] = failedAttempt;
-        this.syncAttempt(failedAttempt, run, 'failed', lastError, true);
-      }
-    }
-
-    return attempts;
-  }
-
-  private resolveTargets(targets: readonly AutomationDeliveryTarget[]): ResolvedDeliveryTarget[] {
-    return targets.map((target) => {
-      if (!target.routeId) return target;
-      const binding = this.routeBindings.getBinding(target.routeId);
-      if (!binding) return { target };
-      return {
-        target: {
-          ...target,
-          surfaceKind: target.surfaceKind ?? binding.surfaceKind,
-          address: target.address
-            ?? (typeof binding.metadata.responseUrl === 'string' ? binding.metadata.responseUrl
-              : typeof binding.metadata.callbackUrl === 'string' ? binding.metadata.callbackUrl
-                : binding.channelId ?? binding.externalId),
-          label: target.label ?? binding.title,
-        },
-        binding,
-      };
-    }).map((entry) => ('target' in entry ? entry : { target: entry }));
-  }
-
-  private async sendTarget(
-    resolved: ResolvedDeliveryTarget,
-    body: string,
-    job: AutomationJob,
-    run: AutomationRun,
-  ): Promise<string | undefined> {
-    return this.deliveryRouter.deliver({
-      target: resolved.target,
-      body,
-      title: job.name,
-      jobId: job.id,
-      runId: run.id,
-      status: run.status,
-      includeLinks: job.delivery.includeLinks,
-      ...(run.result !== undefined ? { attachments: extractArtifactReferences(run.result) } : {}),
-      ...(run.agentId ? { agentId: run.agentId } : {}),
-      ...(resolved.binding ? { binding: resolved.binding } : {}),
-    });
-  }
-
-  private syncAttempt(
-    attempt: AutomationDeliveryAttempt,
-    run: AutomationRun,
-    phase: 'queued' | 'started' | 'succeeded' | 'failed',
-    error?: string,
-    retryable = false,
-  ): void {
-    this.runtimeDispatch?.syncDeliveryAttempt(attempt, `deliveries.${phase}`);
-    if (!this.runtimeBus) return;
-    const surfaceKind = toDeliverySurfaceKind(attempt.target.surfaceKind);
-    const targetId = attempt.target.address ?? attempt.target.routeId ?? 'unknown';
-    const ctx = {
-      sessionId: run.target.sessionId ?? 'automation',
-      source: 'automation-delivery-manager',
-      traceId: attempt.id,
-    } as const;
-    if (phase === 'queued') {
-      emitDeliveryQueued(this.runtimeBus, ctx, {
-        deliveryId: attempt.id,
-        jobId: attempt.jobId,
-        runId: attempt.runId,
-        surfaceKind,
-        targetId,
-        deliveryKind: toDeliveryKind(surfaceKind),
-      });
-      return;
-    }
-    if (phase === 'started') {
-      emitDeliveryStarted(this.runtimeBus, ctx, {
-        deliveryId: attempt.id,
-        jobId: attempt.jobId,
-        runId: attempt.runId,
-        surfaceKind,
-        targetId,
-        startedAt: attempt.startedAt ?? Date.now(),
-      });
-      return;
-    }
-    if (phase === 'succeeded') {
-      emitDeliverySucceeded(this.runtimeBus, ctx, {
-        deliveryId: attempt.id,
-        jobId: attempt.jobId,
-        runId: attempt.runId,
-        surfaceKind,
-        targetId,
-        completedAt: attempt.endedAt ?? Date.now(),
-        durationMs: Math.max(0, (attempt.endedAt ?? Date.now()) - (attempt.startedAt ?? Date.now())),
-        statusCode: 200,
-      });
-      return;
-    }
-    emitDeliveryFailed(this.runtimeBus, ctx, {
-      deliveryId: attempt.id,
-      jobId: attempt.jobId,
-      runId: attempt.runId,
-      surfaceKind,
-      targetId,
-      failedAt: attempt.endedAt ?? Date.now(),
-      error: error ?? attempt.error ?? 'delivery failed',
-      retryable,
-    });
-  }
-}

package/src/automation/index.ts

@@ -1,72 +0,0 @@
-export type {
-  AutomationJobStatus,
-  AutomationRunStatus,
-  AutomationRunTrigger,
-  AutomationSurfaceKind,
-  AutomationRouteKind,
-  AutomationSourceKind,
-  AutomationExecutionKind,
-  AutomationDeliveryKind,
-  AutomationEntityBase,
-} from '@pellux/goodvibes-sdk/platform/automation/types';
-
-export type {
-  AutomationAtSchedule,
-  AutomationEverySchedule,
-  AutomationCronSchedule,
-  AutomationScheduleDefinition,
-  AutomationScheduleKind,
-} from '@pellux/goodvibes-sdk/platform/automation/schedules';
-export {
-  DEFAULT_TOP_OF_HOUR_STAGGER_MS,
-  parseEveryInterval,
-  formatEveryInterval,
-  validateSchedule,
-  isRecurringTopOfHourCronExpression,
-  normalizeCronStaggerMs,
-  resolveDefaultCronStaggerMs,
-  resolveAutomationCronStaggerMs,
-  resolveStableAutomationCronOffsetMs,
-  normalizeAtSchedule,
-  normalizeEverySchedule,
-  normalizeCronSchedule,
-  getNextAutomationOccurrence,
-  isAutomationDue,
-} from '@pellux/goodvibes-sdk/platform/automation/schedules';
-
-export type {
-  AutomationExecutionPolicy,
-  AutomationSessionTarget,
-  AutomationSessionTargetKind,
-  AutomationSandboxMode,
-  AutomationWakeMode,
-  AutomationExternalContentSource,
-  AutomationExternalContentSourceKind,
-} from '@pellux/goodvibes-sdk/platform/automation/session-targets';
-export type { AutomationDeliveryMode, AutomationDeliveryTarget, AutomationDeliveryPolicy, AutomationDeliveryAttempt } from '@pellux/goodvibes-sdk/platform/automation/delivery';
-export type { AutomationFailureAction, AutomationRetryStrategy, AutomationRetryPolicy, AutomationFailurePolicy, AutomationFailureRecord } from '@pellux/goodvibes-sdk/platform/automation/failures';
-export type { AutomationSourceRecord, AutomationSourceSnapshot } from '@pellux/goodvibes-sdk/platform/automation/sources';
-export type { AutomationRouteBinding, AutomationRouteResolution } from '@pellux/goodvibes-sdk/platform/automation/routes';
-export type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
-export type {
-  AutomationRun,
-  AutomationRunSummary,
-  AutomationRunTelemetry,
-  AutomationRunUsageSummary,
-} from '@pellux/goodvibes-sdk/platform/automation/runs';
-
-export type { LegacySchedulerSnapshot } from '@pellux/goodvibes-sdk/platform/automation/migration';
-export { migrateLegacySchedules } from '@pellux/goodvibes-sdk/platform/automation/migration';
-export { AutomationDeliveryManager } from '@pellux/goodvibes-sdk/platform/automation/delivery-manager';
-export { AutomationService } from '@pellux/goodvibes-sdk/platform/automation/service';
-export { AutomationJobStore } from '@pellux/goodvibes-sdk/platform/automation/store/jobs';
-export { AutomationRunStore } from '@pellux/goodvibes-sdk/platform/automation/store/runs';
-export { AutomationRouteStore } from '@pellux/goodvibes-sdk/platform/automation/store/routes';
-export { AutomationSourceStore } from '@pellux/goodvibes-sdk/platform/automation/store/sources';
-export type {
-  AutomationHeartbeatResult,
-  AutomationHeartbeatWake,
-  CreateAutomationJobInput,
-  UpdateAutomationJobInput,
-} from '@pellux/goodvibes-sdk/platform/automation/manager';
-export { AutomationManager } from '@pellux/goodvibes-sdk/platform/automation/manager';

package/src/automation/manager-runtime-delivery.ts

@@ -1,139 +0,0 @@
-import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
-import type { AutomationDeliveryManager } from '@pellux/goodvibes-sdk/platform/automation/delivery-manager';
-import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
-import type { AutomationRun } from '@pellux/goodvibes-sdk/platform/automation/runs';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-interface AutomationFailureFollowUpContext {
-  readonly jobs: Map<string, AutomationJob>;
-  readonly retryTimers: Map<string, ReturnType<typeof setTimeout>>;
-  readonly deliveryManager: AutomationDeliveryManager | null;
-  readonly activeRunCount: () => number;
-  readonly maxConcurrentRuns: () => number;
-  readonly executeJob: (job: AutomationJob, trigger: 'scheduled', dueRun: boolean, attempt?: number) => Promise<AutomationRun>;
-  readonly saveJobs: () => Promise<void>;
-  readonly scheduleJob: (job: AutomationJob) => void;
-}
-
-interface AutomationRunDeliveryContext {
-  readonly runs: Map<string, AutomationRun>;
-  readonly deliveryInFlight: Set<string>;
-  readonly deliveryManager: AutomationDeliveryManager | null;
-  readonly syncRunToRuntime: (run: AutomationRun, source: string) => void;
-  readonly saveRuns: () => Promise<void>;
-}
-
-export function scheduleAutomationFailureFollowUp(
-  context: AutomationFailureFollowUpContext,
-  maybeDeliverFailureNotice: (job: AutomationJob, run: AutomationRun) => void,
-  job: AutomationJob,
-  run: AutomationRun,
-): void {
-  maybeDeliverFailureNotice(job, run);
-  if (!job.enabled) return;
-
-  if (job.failure.action === 'cooldown') {
-    const cooled: AutomationJob = {
-      ...job,
-      nextRunAt: Date.now() + Math.max(1_000, job.failure.cooldownMs),
-      updatedAt: Date.now(),
-    };
-    context.jobs.set(job.id, cooled);
-    context.scheduleJob(cooled);
-    void context.saveJobs();
-    return;
-  }
-
-  const maxAttempts = Math.max(1, job.execution.maxAttempts ?? 1);
-  if (job.failure.action !== 'retry' || run.attempt >= maxAttempts) {
-    return;
-  }
-  const retryKey = `${job.id}:${run.id}`;
-  const existing = context.retryTimers.get(retryKey);
-  if (existing) {
-    clearTimeout(existing);
-  }
-  const timer = setTimeout(() => {
-    context.retryTimers.delete(retryKey);
-    const latestJob = context.jobs.get(job.id);
-    if (!latestJob?.enabled) return;
-    if (context.activeRunCount() >= context.maxConcurrentRuns()) {
-      scheduleAutomationFailureFollowUp(context, maybeDeliverFailureNotice, latestJob, run);
-      return;
-    }
-    void context.executeJob(latestJob, 'scheduled', false, run.attempt + 1).catch((error) => {
-      logger.warn('AutomationManager: retry execution failed', {
-        jobId: latestJob.id,
-        runId: run.id,
-        attempt: run.attempt + 1,
-        error: summarizeError(error),
-      });
-    });
-  }, Math.max(1_000, job.failure.cooldownMs));
-  context.retryTimers.set(retryKey, timer);
-}
-
-export function maybeDeliverAutomationFailureNotice(
-  deliveryManager: AutomationDeliveryManager | null,
-  job: AutomationJob,
-  run: AutomationRun,
-): void {
-  if (!deliveryManager) return;
-  const routeIds = [job.failure.notifyRouteId, job.failure.deadLetterRouteId].filter((value): value is string => typeof value === 'string' && value.length > 0);
-  if (routeIds.length === 0) return;
-  const targets = routeIds.map((routeId) => ({
-    kind: 'surface',
-    routeId,
-  } as const));
-  const message = [
-    `Automation failure: ${job.name}`,
-    `Run: ${run.id}`,
-    `Status: ${run.status}`,
-    run.error ? `Error: ${run.error}` : null,
-    run.cancelledReason ? `Cancelled: ${run.cancelledReason}` : null,
-  ].filter((value): value is string => typeof value === 'string' && value.length > 0).join('\n');
-  void deliveryManager.deliverText(job, run, message, targets).catch((error) => {
-    logger.warn('AutomationManager: failure notice delivery failed', {
-      jobId: job.id,
-      runId: run.id,
-      error: summarizeError(error),
-    });
-  });
-}
-
-export function maybeDeliverAutomationRun(
-  context: AutomationRunDeliveryContext,
-  job: AutomationJob,
-  run: AutomationRun,
-): void {
-  if (!context.deliveryManager) return;
-  if (job.delivery.mode === 'none') return;
-  if (context.deliveryInFlight.has(run.id)) return;
-  if (run.deliveryIds.length > 0) return;
-  context.deliveryInFlight.add(run.id);
-  void context.deliveryManager.deliverJobRun(job, run)
-    .then(async (deliveryAttempts) => {
-      if (deliveryAttempts.length === 0) return;
-      const latest = context.runs.get(run.id);
-      if (!latest) return;
-      const updated: AutomationRun = {
-        ...latest,
-        deliveryIds: deliveryAttempts.map((attempt) => attempt.id),
-        deliveryAttempts,
-        updatedAt: Date.now(),
-      };
-      context.runs.set(updated.id, updated);
-      context.syncRunToRuntime(updated, 'automation.delivery');
-      await context.saveRuns();
-    })
-    .catch((error) => {
-      logger.warn('AutomationManager: delivery failed', {
-        runId: run.id,
-        jobId: job.id,
-        error: summarizeError(error),
-      });
-    })
-    .finally(() => {
-      context.deliveryInFlight.delete(run.id);
-    });
-}