@donkeylabs/server 2.0.35 → 2.1.0

package/src/core/events.ts

@@ -11,20 +11,33 @@ export interface Subscription {
   unsubscribe(): void;
 }
 
+export interface EventMetadata {
+  traceId?: string;
+  source?: string;
+  [key: string]: any;
+}
+
 export interface EventRecord {
   event: string;
   data: any;
   timestamp: Date;
+  metadata?: EventMetadata;
 }
 
 export interface EventAdapter {
-  publish(event: string, data: any): Promise<void>;
+  publish(event: string, data: any, metadata?: EventMetadata): Promise<void>;
   getHistory(event: string, limit?: number): Promise<EventRecord[]>;
+  /** Subscribe to events from other instances (for distributed adapters) */
+  subscribe?(callback: (event: string, data: any, metadata?: EventMetadata) => void): Promise<void>;
+  /** Stop the adapter and clean up resources */
+  stop?(): Promise<void>;
 }
 
 export interface EventsConfig {
   adapter?: EventAdapter;
   maxHistorySize?: number;
+  /** SSE service for auto-propagating distributed events to SSE clients */
+  sse?: import("./sse").SSE;
 }
 
 /**
@@ -41,11 +54,11 @@ export interface Events {
   /**
    * Emit a typed event (when EventRegistry is augmented)
    */
-  emit<K extends keyof EventRegistry>(event: K, data: EventRegistry[K]): Promise<void>;
+  emit<K extends keyof EventRegistry>(event: K, data: EventRegistry[K], metadata?: EventMetadata): Promise<void>;
   /**
    * Emit an untyped event (fallback for dynamic event names)
    */
-  emit<T = any>(event: string, data: T): Promise<void>;
+  emit<T = any>(event: string, data: T, metadata?: EventMetadata): Promise<void>;
 
   /**
    * Subscribe to a typed event (when EventRegistry is augmented)
@@ -67,6 +80,8 @@ export interface Events {
 
   off(event: string, handler?: EventHandler): void;
   getHistory(event: string, limit?: number): Promise<EventRecord[]>;
+  /** Stop the event bus and clean up resources */
+  stop(): Promise<void>;
 }
 
 // In-memory event adapter with history
@@ -78,11 +93,12 @@ export class MemoryEventAdapter implements EventAdapter {
     this.maxHistorySize = maxHistorySize;
   }
 
-  async publish(event: string, data: any): Promise<void> {
+  async publish(event: string, data: any, metadata?: EventMetadata): Promise<void> {
     const record: EventRecord = {
       event,
       data,
       timestamp: new Date(),
+      metadata,
     };
 
     this.history.push(record);
@@ -103,16 +119,41 @@ export class MemoryEventAdapter implements EventAdapter {
 class EventsImpl implements Events {
   private handlers = new Map<string, Set<EventHandler>>();
   private adapter: EventAdapter;
+  private sse?: import("./sse").SSE;
+  private stopped = false;
 
   constructor(config: EventsConfig = {}) {
     this.adapter = config.adapter ?? new MemoryEventAdapter(config.maxHistorySize);
+    this.sse = config.sse;
+
+    // If adapter supports distributed subscriptions, set up the callback
+    if (this.adapter.subscribe) {
+      this.adapter.subscribe((event, data, metadata) => {
+        // Dispatch to local handlers without re-publishing to adapter
+        this.dispatchToLocalHandlers(event, data, metadata);
+        // Propagate to SSE clients so browser subscribers see distributed events
+        this.sse?.broadcastAll(event, data);
+      });
+    }
   }
 
-  async emit<T = any>(event: string, data: T): Promise<void> {
+  async emit<T = any>(event: string, data: T, metadata?: EventMetadata): Promise<void> {
+    if (this.stopped) return;
+
     // Store in adapter (for history/persistence)
-    await this.adapter.publish(event, data);
+    await this.adapter.publish(event, data, metadata);
+
+    // Dispatch to local handlers
+    await this.dispatchToLocalHandlers(event, data, metadata);
+  }
 
-    // Notify handlers
+  /**
+   * Dispatch an event to locally registered handlers.
+   * Separated from emit() so distributed adapters can deliver remote events
+   * without re-publishing to the adapter.
+   */
+  private async dispatchToLocalHandlers(event: string, data: any, _metadata?: EventMetadata): Promise<void> {
+    // Notify exact-match handlers
     const eventHandlers = this.handlers.get(event);
     if (eventHandlers) {
       const promises: Promise<void>[] = [];
@@ -185,6 +226,12 @@ class EventsImpl implements Events {
     return this.adapter.getHistory(event, limit);
   }
 
+  async stop(): Promise<void> {
+    this.stopped = true;
+    await this.adapter.stop?.();
+    this.handlers.clear();
+  }
+
   private matchPattern(event: string, pattern: string): boolean {
     // Convert glob pattern to regex (e.g., "user.*" -> /^user\..*$/)
     const regex = new RegExp(

package/src/core/health.ts

@@ -0,0 +1,165 @@
+// Core Health Check Service
+// Provides liveness and readiness probes for production deployments
+
+import type { Kysely } from "kysely";
+
+export type HealthStatus = "healthy" | "degraded" | "unhealthy";
+
+export interface HealthCheckResult {
+  status: HealthStatus;
+  message?: string;
+  latencyMs?: number;
+}
+
+export interface HealthCheck {
+  name: string;
+  check: () => Promise<HealthCheckResult> | HealthCheckResult;
+  /** Whether failure of this check marks the service as unhealthy (default: true) */
+  critical?: boolean;
+}
+
+export interface HealthResponse {
+  status: HealthStatus;
+  uptime: number;
+  timestamp: string;
+  checks: Record<string, HealthCheckResult>;
+}
+
+export interface HealthConfig {
+  checks?: HealthCheck[];
+  /** Path for liveness probe (default: "/_health") */
+  livenessPath?: string;
+  /** Path for readiness probe (default: "/_ready") */
+  readinessPath?: string;
+  /** Timeout per check in ms (default: 5000) */
+  checkTimeout?: number;
+  /** Whether to register a built-in database check (default: true) */
+  dbCheck?: boolean;
+}
+
+export interface Health {
+  /** Register a health check */
+  register(check: HealthCheck): void;
+  /** Run all readiness checks */
+  check(): Promise<HealthResponse>;
+  /** Fast liveness probe (no external checks) */
+  liveness(isShuttingDown: boolean): HealthResponse;
+}
+
+class HealthImpl implements Health {
+  private checks: HealthCheck[] = [];
+  private startTime = Date.now();
+  private checkTimeout: number;
+
+  constructor(config: HealthConfig = {}) {
+    this.checkTimeout = config.checkTimeout ?? 5000;
+
+    if (config.checks) {
+      for (const check of config.checks) {
+        this.checks.push(check);
+      }
+    }
+  }
+
+  register(check: HealthCheck): void {
+    this.checks.push(check);
+  }
+
+  async check(): Promise<HealthResponse> {
+    const results: Record<string, HealthCheckResult> = {};
+    let overallStatus: HealthStatus = "healthy";
+
+    await Promise.all(
+      this.checks.map(async (check) => {
+        const start = Date.now();
+        try {
+          const result = await Promise.race([
+            Promise.resolve(check.check()),
+            new Promise<HealthCheckResult>((_, reject) =>
+              setTimeout(() => reject(new Error("Health check timed out")), this.checkTimeout)
+            ),
+          ]);
+          results[check.name] = {
+            ...result,
+            latencyMs: result.latencyMs ?? Date.now() - start,
+          };
+
+          const isCritical = check.critical !== false;
+          if (result.status === "unhealthy" && isCritical) {
+            overallStatus = "unhealthy";
+          } else if (result.status === "degraded" && overallStatus !== "unhealthy") {
+            overallStatus = "degraded";
+          } else if (result.status === "unhealthy" && !isCritical && overallStatus !== "unhealthy") {
+            overallStatus = "degraded";
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          results[check.name] = {
+            status: "unhealthy",
+            message,
+            latencyMs: Date.now() - start,
+          };
+          const isCritical = check.critical !== false;
+          if (isCritical) {
+            overallStatus = "unhealthy";
+          } else if (overallStatus !== "unhealthy") {
+            overallStatus = "degraded";
+          }
+        }
+      })
+    );
+
+    return {
+      status: overallStatus,
+      uptime: Math.floor((Date.now() - this.startTime) / 1000),
+      timestamp: new Date().toISOString(),
+      checks: results,
+    };
+  }
+
+  liveness(isShuttingDown: boolean): HealthResponse {
+    return {
+      status: isShuttingDown ? "unhealthy" : "healthy",
+      uptime: Math.floor((Date.now() - this.startTime) / 1000),
+      timestamp: new Date().toISOString(),
+      checks: {},
+    };
+  }
+}
+
+/**
+ * Create a built-in database health check.
+ */
+export function createDbHealthCheck(db: Kysely<any>): HealthCheck {
+  return {
+    name: "database",
+    critical: true,
+    check: async () => {
+      const start = Date.now();
+      try {
+        await db.selectFrom(db.dynamic.ref("sqlite_master") as any)
+          .select(db.dynamic.ref("1") as any)
+          .execute()
+          .catch(async () => {
+            // Fallback for non-SQLite databases
+            const { sql } = await import("kysely");
+            await sql`SELECT 1`.execute(db);
+          });
+        return {
+          status: "healthy" as const,
+          latencyMs: Date.now() - start,
+        };
+      } catch (err) {
+        return {
+          status: "unhealthy" as const,
+          message: err instanceof Error ? err.message : String(err),
+          latencyMs: Date.now() - start,
+        };
+      }
+    },
+  };
+}
+
+export function createHealth(config?: HealthConfig): Health {
+  return new HealthImpl(config);
+}

package/src/core/index.ts

@@ -21,6 +21,7 @@ export {
 export {
   type Events,
   type EventHandler,
+  type EventMetadata,
   type Subscription,
   type EventRecord,
   type EventAdapter,
@@ -302,3 +303,14 @@ export {
   PersistentTransport,
   type PersistentTransportConfig,
 } from "./logs-transport";
+
+export {
+  type Health,
+  type HealthCheck,
+  type HealthCheckResult,
+  type HealthConfig,
+  type HealthResponse,
+  type HealthStatus,
+  createHealth,
+  createDbHealthCheck,
+} from "./health";

package/src/core/jobs.ts

@@ -56,6 +56,8 @@ export interface Job {
   lastHeartbeat?: Date;
   /** Current process state */
   processState?: ExternalJobProcessState;
+  /** Trace ID for distributed tracing */
+  traceId?: string;
 }
 
 export interface JobHandler<T = any, R = any> {
@@ -66,6 +68,8 @@ export interface JobHandlerContext {
   logger?: Logger;
   emit?: (event: string, data?: Record<string, any>) => Promise<void>;
   log?: (level: LogLevel, message: string, data?: Record<string, any>) => void;
+  /** Trace ID for distributed tracing */
+  traceId?: string;
 }
 
 /** Options for listing all jobs */
@@ -128,9 +132,9 @@ export interface Jobs {
   /** Register an external job (Python, Go, Shell, etc.) */
   registerExternal(name: string, config: ExternalJobConfig): void;
   /** Enqueue a job (works for both in-process and external jobs) */
-  enqueue<T = any>(name: string, data: T, options?: { maxAttempts?: number }): Promise<string>;
+  enqueue<T = any>(name: string, data: T, options?: { maxAttempts?: number; traceId?: string }): Promise<string>;
   /** Schedule a job to run at a specific time */
-  schedule<T = any>(name: string, data: T, runAt: Date, options?: { maxAttempts?: number }): Promise<string>;
+  schedule<T = any>(name: string, data: T, runAt: Date, options?: { maxAttempts?: number; traceId?: string }): Promise<string>;
   /** Get a job by ID */
   get(jobId: string): Promise<Job | null>;
   /** Cancel a pending job */
@@ -339,7 +343,7 @@ class JobsImpl implements Jobs {
     return this.externalConfigs.has(name);
   }
 
-  async enqueue<T = any>(name: string, data: T, options: { maxAttempts?: number } = {}): Promise<string> {
+  async enqueue<T = any>(name: string, data: T, options: { maxAttempts?: number; traceId?: string } = {}): Promise<string> {
     const isExternal = this.isExternalJob(name);
 
     if (!isExternal && !this.handlers.has(name)) {
@@ -355,6 +359,7 @@ class JobsImpl implements Jobs {
       maxAttempts: options.maxAttempts ?? this.defaultMaxAttempts,
       external: isExternal || undefined,
       processState: isExternal ? "spawning" : undefined,
+      traceId: options.traceId,
     });
 
     return job.id;
@@ -364,7 +369,7 @@ class JobsImpl implements Jobs {
     name: string,
     data: T,
     runAt: Date,
-    options: { maxAttempts?: number } = {}
+    options: { maxAttempts?: number; traceId?: string } = {}
   ): Promise<string> {
     const isExternal = this.isExternalJob(name);
 
@@ -382,6 +387,7 @@ class JobsImpl implements Jobs {
       maxAttempts: options.maxAttempts ?? this.defaultMaxAttempts,
       external: isExternal || undefined,
       processState: isExternal ? "spawning" : undefined,
+      traceId: options.traceId,
     });
 
     return job.id;
@@ -1147,6 +1153,7 @@ class JobsImpl implements Jobs {
         logger: scopedLogger,
         emit,
         log,
+        traceId: job.traceId,
       });
 
       await this.adapter.update(job.id, {

package/src/core/logs-adapter-kysely.ts

@@ -49,6 +49,8 @@ const LOG_LEVEL_VALUES: Record<LogLevel, number> = {
 export interface KyselyLogsAdapterConfig {
   /** Database file path (default: ".donkeylabs/logs.db") */
   dbPath?: string;
+  /** Use an existing Kysely instance */
+  db?: Kysely<Database>;
 }
 
 // ============================================
@@ -61,6 +63,11 @@ export class KyselyLogsAdapter implements LogsAdapter {
   private ensureTablePromise: Promise<void> | null = null;
 
   constructor(config: KyselyLogsAdapterConfig = {}) {
+    if (config.db) {
+      this.db = config.db;
+      return;
+    }
+
     const dbPath = config.dbPath ?? ".donkeylabs/logs.db";
 
     // Ensure directory exists

package/src/core/logs.ts

@@ -8,6 +8,7 @@
 
 import type { Events } from "./events";
 import type { LogLevel } from "./logger";
+import type { Kysely } from "kysely";
 
 // ============================================
 // Types
@@ -72,6 +73,8 @@ export interface LogsConfig {
   maxBufferSize?: number;
   /** Database path (default: ".donkeylabs/logs.db") */
   dbPath?: string;
+  /** Use an existing Kysely instance for logs storage */
+  db?: Kysely<any>;
 }
 
 // ============================================

package/src/core/migrations/workflows/002_add_metadata_column.ts

@@ -7,13 +7,8 @@
 import { sql, type Kysely } from "kysely";
 
 export async function up(db: Kysely<any>): Promise<void> {
-  // SQLite doesn't support IF NOT EXISTS for ALTER TABLE ADD COLUMN
-  // Check if column exists first
-  const tableInfo = await sql<{ name: string }>`
-    PRAGMA table_info(__donkeylabs_workflow_instances__)
-  `.execute(db);
-
-  const hasMetadataColumn = tableInfo.rows.some((row) => row.name === "metadata");
+  const dialect = getDialectName(db);
+  const hasMetadataColumn = await columnExists(db, dialect);
 
   if (!hasMetadataColumn) {
     await sql`
@@ -26,3 +21,42 @@ export async function down(db: Kysely<any>): Promise<void> {
   // SQLite doesn't support DROP COLUMN directly
   // In practice, we don't need to remove it - the column can stay
 }
+
+async function columnExists(db: Kysely<any>, dialect: string): Promise<boolean> {
+  if (dialect.includes("postgres")) {
+    const result = await sql<{ name: string }>`
+      SELECT column_name as name
+      FROM information_schema.columns
+      WHERE table_name = '__donkeylabs_workflow_instances__'
+        AND column_name = 'metadata'
+        AND table_schema = current_schema()
+    `.execute(db);
+    return result.rows.length > 0;
+  }
+
+  if (dialect.includes("mysql")) {
+    const result = await sql<{ name: string }>`
+      SELECT column_name as name
+      FROM information_schema.columns
+      WHERE table_name = '__donkeylabs_workflow_instances__'
+        AND column_name = 'metadata'
+        AND table_schema = database()
+    `.execute(db);
+    return result.rows.length > 0;
+  }
+
+  const tableInfo = await sql<{ name: string }>`
+    PRAGMA table_info(__donkeylabs_workflow_instances__)
+  `.execute(db);
+
+  return tableInfo.rows.some((row) => row.name === "metadata");
+}
+
+function getDialectName(db: Kysely<any>): string {
+  try {
+    const adapter = (db as any).getExecutor?.().adapter;
+    return adapter?.constructor?.name?.toLowerCase() ?? "";
+  } catch {
+    return "";
+  }
+}

package/src/core/processes.ts

@@ -170,8 +170,8 @@ export interface SpawnOptions {
 // ============================================
 
 export interface ProcessesConfig {
-  /** SQLite adapter configuration */
-  adapter?: SqliteProcessAdapterConfig;
+  /** Adapter instance or sqlite adapter configuration */
+  adapter?: ProcessAdapter | SqliteProcessAdapterConfig;
   /** Socket server configuration */
   socket?: ProcessSocketConfig;
   /** Events service for emitting process events */
@@ -278,7 +278,11 @@ export class ProcessesImpl implements Processes {
   private isShuttingDown = false;
 
   constructor(config: ProcessesConfig = {}) {
-    this.adapter = new SqliteProcessAdapter(config.adapter);
+    if (config.adapter && typeof (config.adapter as ProcessAdapter).get === "function") {
+      this.adapter = config.adapter as ProcessAdapter;
+    } else {
+      this.adapter = new SqliteProcessAdapter(config.adapter as SqliteProcessAdapterConfig | undefined);
+    }
     this.events = config.events;
     this.heartbeatCheckInterval = config.heartbeatCheckInterval ?? 10000;
     this.autoRecoverOrphans = config.autoRecoverOrphans ?? true;

package/src/core/subprocess-bootstrap.ts

@@ -20,6 +20,7 @@ import {
   KyselyWorkflowAdapter,
   MemoryAuditAdapter,
   MemoryLogsAdapter,
+  createHealth,
 } from "./index";
 import { PluginManager, type CoreServices, type ConfiguredPlugin } from "../core";
 
@@ -96,6 +97,7 @@ export async function bootstrapSubprocess(
   const audit = createAudit({ adapter: auditAdapter });
   const websocket = createWebSocket();
   const storage = createStorage();
+  const health = createHealth({ dbCheck: false });
 
   const core: CoreServices = {
     db,
@@ -114,6 +116,7 @@ export async function bootstrapSubprocess(
     websocket,
     storage,
     logs,
+    health,
   };
 
   workflows.setCore(core);

package/src/core/watchdog-executor.ts

@@ -1,10 +1,11 @@
-import { Kysely } from "kysely";
+import { Kysely, PostgresDialect, MysqlDialect } from "kysely";
 import { BunSqliteDialect } from "kysely-bun-sqlite";
 import Database from "bun:sqlite";
 import { ProcessClient } from "./process-client";
 import { KyselyWorkflowAdapter } from "./workflow-adapter-kysely";
 import { KyselyJobAdapter } from "./job-adapter-kysely";
 import { SqliteProcessAdapter } from "./process-adapter-sqlite";
+import { KyselyProcessAdapter } from "./process-adapter-kysely";
 import { WatchdogRunner, type WatchdogRunnerConfig } from "./watchdog-runner";
 
 interface WatchdogConfig extends WatchdogRunnerConfig {
@@ -17,6 +18,10 @@ interface WatchdogConfig extends WatchdogRunnerConfig {
     synchronous?: "OFF" | "NORMAL" | "FULL" | "EXTRA";
     journalMode?: "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY" | "WAL" | "OFF";
   };
+  database?: {
+    type: "sqlite" | "postgres" | "mysql";
+    connectionString: string;
+  };
 }
 
 const raw = process.env.DONKEYLABS_WATCHDOG_CONFIG;
@@ -27,19 +32,21 @@ if (!raw) {
 const config: WatchdogConfig = JSON.parse(raw);
 const client = await ProcessClient.connect();
 
-const workflowAdapter = config.workflows?.dbPath
-  ? new KyselyWorkflowAdapter(createDb(config.workflows.dbPath, config.sqlitePragmas), {
+const workflowAdapter = config.workflows?.dbPath || config.database
+  ? new KyselyWorkflowAdapter(await createDb(config.workflows?.dbPath, config), {
       cleanupDays: 0,
     })
   : undefined;
-const jobAdapter = config.jobs?.dbPath
-  ? new KyselyJobAdapter(createDb(config.jobs.dbPath, config.sqlitePragmas), {
+const jobAdapter = config.jobs?.dbPath || config.database
+  ? new KyselyJobAdapter(await createDb(config.jobs?.dbPath, config), {
       cleanupDays: 0,
     })
   : undefined;
 const processAdapter = config.processes?.dbPath
   ? new SqliteProcessAdapter({ path: config.processes.dbPath, cleanupDays: 0 })
-  : undefined;
+  : config.database
+    ? new KyselyProcessAdapter(await createDb(undefined, config))
+    : undefined;
 
 const runner = new WatchdogRunner(config, {
   workflowsAdapter: workflowAdapter,
@@ -60,21 +67,52 @@ process.on("SIGTERM", async () => {
   client.disconnect();
 });
 
-function createDb(
-  dbPath: string,
-  pragmas?: { busyTimeout?: number; synchronous?: string; journalMode?: string }
-): Kysely<any> {
-  const sqlite = new Database(dbPath);
-  const busyTimeout = pragmas?.busyTimeout ?? 5000;
-  sqlite.run(`PRAGMA busy_timeout = ${busyTimeout}`);
-  if (pragmas?.journalMode) {
-    sqlite.run(`PRAGMA journal_mode = ${pragmas.journalMode}`);
+async function createDb(
+  dbPath: string | undefined,
+  config: WatchdogConfig
+): Promise<Kysely<any>> {
+  const dbConfig = config.database;
+
+  if (!dbConfig || dbConfig.type === "sqlite") {
+    const sqlitePath = dbConfig?.connectionString ?? dbPath;
+    if (!sqlitePath) {
+      throw new Error("SQLite dbPath or connectionString is required for watchdog");
+    }
+    const sqlite = new Database(sqlitePath);
+    const pragmas = config.sqlitePragmas;
+    const busyTimeout = pragmas?.busyTimeout ?? 5000;
+    sqlite.run(`PRAGMA busy_timeout = ${busyTimeout}`);
+    if (pragmas?.journalMode) {
+      sqlite.run(`PRAGMA journal_mode = ${pragmas.journalMode}`);
+    }
+    if (pragmas?.synchronous) {
+      sqlite.run(`PRAGMA synchronous = ${pragmas.synchronous}`);
+    }
+
+    return new Kysely<any>({
+      dialect: new BunSqliteDialect({ database: sqlite }),
+    });
   }
-  if (pragmas?.synchronous) {
-    sqlite.run(`PRAGMA synchronous = ${pragmas.synchronous}`);
+
+  if (dbConfig.type === "postgres") {
+    // @ts-ignore optional dependency
+    const { Pool: PGPool } = await import("pg");
+    return new Kysely<any>({
+      dialect: new PostgresDialect({
+        pool: new PGPool({ connectionString: dbConfig.connectionString }),
+      }),
+    });
+  }
+
+  if (dbConfig.type === "mysql") {
+    // @ts-ignore optional dependency
+    const { createPool: createMySQLPool } = await import("mysql2");
+    return new Kysely<any>({
+      dialect: new MysqlDialect({
+        pool: createMySQLPool(dbConfig.connectionString),
+      }),
+    });
   }
 
-  return new Kysely<any>({
-    dialect: new BunSqliteDialect({ database: sqlite }),
-  });
+  throw new Error(`Unsupported database type: ${dbConfig.type}`);
 }

package/src/core/workflow-executor.ts

@@ -226,6 +226,7 @@ function createIpcEventBridge(socket: Socket, instanceId: string): StateMachineE
         type: "progress",
         instanceId: id,
         timestamp: Date.now(),
+        stepName: currentStep,
         progress,
         completedSteps: completed,
         totalSteps: total,

package/src/core/workflow-state-machine.ts

@@ -751,12 +751,13 @@ export class WorkflowStateMachine {
 
     this.events.onStepCompleted(instanceId, stepName, output, nextStep);
 
-    // Calculate progress
+    // Calculate progress — re-fetch after persist to get accurate count
+    const updated = await this.adapter.getInstance(instanceId);
     const totalSteps = definition.steps.size;
-    const completedSteps = Object.values(instance.stepResults).filter(
-      (r) => r.status === "completed",
-    ).length + 1; // +1 for current step
-    const progress = Math.round((completedSteps / totalSteps) * 100);
+    const completedSteps = updated
+      ? Object.values(updated.stepResults).filter((r) => r.status === "completed").length
+      : 1;
+    const progress = Math.min(100, Math.round((completedSteps / totalSteps) * 100));
 
     this.events.onProgress(instanceId, progress, stepName, completedSteps, totalSteps);
   }