@kb-labs/workflow-engine 1.1.0

package/dist/index.js

@@ -0,0 +1,3077 @@
+import { readFile, mkdir, writeFile, readdir } from 'fs/promises';
+import { resolve, join, basename } from 'path';
+import { parse, stringify } from 'yaml';
+import { WorkflowSpecSchema } from '@kb-labs/workflow-contracts';
+import { randomUUID } from 'crypto';
+import { WORKFLOW_REDIS_CHANNEL, EVENT_NAMES, IDEMPOTENCY_TTL_ENV, CONCURRENCY_TTL_ENV } from '@kb-labs/workflow-constants';
+import { createFileSystemArtifactClient } from '@kb-labs/workflow-artifacts';
+import { existsSync } from 'fs';
+import { nanoid } from 'nanoid';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var WorkflowLoader = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  async fromFile(filePath, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const absolutePath = resolve(cwd, filePath);
+    this.logger.debug(`Loading workflow spec from file`, {
+      path: absolutePath
+    });
+    const raw = await readFile(absolutePath, "utf8");
+    const parsed = this.parse(raw, absolutePath);
+    return this.validate(parsed, absolutePath);
+  }
+  fromInline(spec, source = "inline") {
+    let candidate = spec;
+    if (typeof spec === "string") {
+      candidate = this.parse(spec, source);
+    }
+    return this.validate(candidate, source);
+  }
+  parse(raw, source) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      throw new Error(`Workflow spec ${source} is empty`);
+    }
+    if (source.endsWith(".json") || trimmed.startsWith("{")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Failed to parse JSON workflow spec from ${source}`, error instanceof Error ? error : void 0, {
+          errorMessage: message
+        });
+        throw new Error(`Failed to parse workflow spec JSON: ${message}`);
+      }
+    }
+    try {
+      return parse(trimmed);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to parse YAML workflow spec from ${source}`, error instanceof Error ? error : void 0, {
+        errorMessage: message
+      });
+      throw new Error(`Failed to parse workflow spec YAML: ${message}`);
+    }
+  }
+  validate(candidate, source) {
+    const parsed = WorkflowSpecSchema.safeParse(candidate);
+    if (!parsed.success) {
+      const issues = parsed.error.issues.map(
+        (issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`
+      ).join("\n");
+      this.logger.warn(`Workflow spec validation failed`, { source, issues });
+      throw new Error(`Workflow spec validation failed:
+${issues}`);
+    }
+    const spec = parsed.data;
+    return { spec, source };
+  }
+};
+
+// src/state-store.ts
+var StateStore = class {
+  constructor(cache, logger) {
+    this.logger = logger;
+    this.cache = cache;
+  }
+  cache;
+  async saveRun(run) {
+    const key = `kb:run:${run.id}`;
+    this.logger.debug("Persisting workflow run", { runId: run.id, key });
+    await this.cache.set(key, JSON.stringify(run));
+    const timestamp = new Date(run.createdAt).getTime();
+    await this.cache.zadd("workflow:runs:index", timestamp, run.id);
+  }
+  async getRun(runId) {
+    const key = `kb:run:${runId}`;
+    const payload = await this.cache.get(key);
+    if (!payload) {
+      return null;
+    }
+    try {
+      return JSON.parse(payload);
+    } catch (error) {
+      this.logger.error("Failed to parse stored workflow run", error instanceof Error ? error : void 0, {
+        runId
+      });
+      return null;
+    }
+  }
+  async deleteRun(runId) {
+    const key = `kb:run:${runId}`;
+    await this.cache.delete(key);
+    await this.cache.zrem("workflow:runs:index", runId);
+  }
+  async getAllRunIds() {
+    const runIds = await this.cache.zrangebyscore("workflow:runs:index", -Infinity, Infinity);
+    return runIds ?? [];
+  }
+  async updateRun(runId, mutator) {
+    const run = await this.getRun(runId);
+    if (!run) {
+      return null;
+    }
+    const draft = clone(run);
+    const result = mutator(draft);
+    const next = result ?? draft;
+    await this.saveRun(next);
+    return next;
+  }
+  async updateJob(runId, jobId, mutator) {
+    let updatedJob = null;
+    await this.updateRun(runId, (run) => {
+      const index = run.jobs.findIndex((job) => job.id === jobId);
+      if (index === -1) {
+        return;
+      }
+      const existingJob = run.jobs[index];
+      if (!existingJob) {
+        return;
+      }
+      const jobDraft = clone(existingJob);
+      const result = mutator(jobDraft);
+      const nextJob = result ?? jobDraft;
+      run.jobs[index] = nextJob;
+      updatedJob = nextJob;
+    });
+    return updatedJob;
+  }
+  async updateStep(runId, jobId, stepId, mutator) {
+    let updatedStep = null;
+    await this.updateRun(runId, (run) => {
+      const jobIndex = run.jobs.findIndex((job2) => job2.id === jobId);
+      if (jobIndex === -1) {
+        return;
+      }
+      const job = run.jobs[jobIndex];
+      if (!job) {
+        return;
+      }
+      const stepIndex = job.steps.findIndex(
+        (step) => step.id === stepId
+      );
+      if (stepIndex === -1) {
+        return;
+      }
+      const existingStep = job.steps[stepIndex];
+      if (!existingStep) {
+        return;
+      }
+      const draft = clone(existingStep);
+      const result = mutator(draft);
+      const nextStep = result ?? draft;
+      job.steps[stepIndex] = nextStep;
+      updatedStep = nextStep;
+    });
+    return updatedStep;
+  }
+  async releaseBlockedJobs(runId, completedJobName) {
+    const released = [];
+    await this.updateRun(runId, (run) => {
+      for (const job of run.jobs) {
+        if (job.status !== "queued" || !job.blocked) {
+          continue;
+        }
+        if (!job.pendingDependencies || job.pendingDependencies.length === 0) {
+          continue;
+        }
+        if (!job.needs?.includes(completedJobName)) {
+          continue;
+        }
+        const remaining = job.pendingDependencies.filter(
+          (dependency) => dependency !== completedJobName
+        );
+        if (remaining.length === job.pendingDependencies.length) {
+          continue;
+        }
+        job.pendingDependencies = remaining;
+        if (remaining.length === 0) {
+          job.blocked = false;
+          released.push(clone(job));
+        }
+      }
+    });
+    return released;
+  }
+};
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+var DEFAULT_IDEMPOTENCY_TTL_MS = 1e3 * 60 * 60 * 24;
+function resolveIdempotencyTtlMs(explicit) {
+  if (typeof explicit === "number" && explicit > 0) {
+    return explicit;
+  }
+  const envValue = process.env[IDEMPOTENCY_TTL_ENV];
+  const parsed = envValue ? Number(envValue) : void 0;
+  if (parsed && Number.isFinite(parsed) && parsed > 0) {
+    return parsed;
+  }
+  return DEFAULT_IDEMPOTENCY_TTL_MS;
+}
+var RunCoordinator = class {
+  constructor(cache, stateStore, concurrencyManager, logger, options = {}) {
+    this.stateStore = stateStore;
+    this.concurrencyManager = concurrencyManager;
+    this.logger = logger;
+    this.cache = cache;
+    this.idempotencyTtlMs = resolveIdempotencyTtlMs(options.idempotencyTtlMs);
+  }
+  cache;
+  idempotencyTtlMs;
+  async ensureRun(input) {
+    if (input.idempotencyKey) {
+      const existing = await this.loadByIdempotencyKey(input.idempotencyKey);
+      if (existing) {
+        this.logger.info("Idempotent workflow run reused", {
+          runId: existing.id,
+          idempotencyKey: input.idempotencyKey
+        });
+        return existing;
+      }
+    }
+    const runId = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (input.concurrencyGroup) {
+      const acquired = await this.concurrencyManager.acquire(
+        input.concurrencyGroup,
+        runId
+      );
+      if (!acquired) {
+        const active = await this.concurrencyManager.getActiveRun(
+          input.concurrencyGroup
+        );
+        const message = active ? `Concurrency group ${input.concurrencyGroup} already locked by run ${active}` : `Failed to acquire concurrency lock for ${input.concurrencyGroup}`;
+        this.logger.warn(message, {
+          concurrencyGroup: input.concurrencyGroup,
+          activeRunId: active
+        });
+        throw new Error(message);
+      }
+    }
+    const run = this.buildInitialRun(input, runId, now);
+    await this.stateStore.saveRun(run);
+    if (input.idempotencyKey) {
+      await this.registerIdempotencyKey(input.idempotencyKey, run.id);
+    }
+    this.logger.info("Workflow run created", {
+      runId: run.id,
+      name: run.name,
+      version: run.version
+    });
+    return run;
+  }
+  buildInitialRun(input, runId, timestamp) {
+    const jobs = [];
+    for (const [jobName, jobSpec] of Object.entries(
+      input.spec.jobs
+    )) {
+      const jobId = `${runId}:${jobName}`;
+      const needs = Array.isArray(jobSpec.needs) ? [...jobSpec.needs] : [];
+      const priority = jobSpec.priority ?? "normal";
+      const effectiveTarget = jobSpec.target ?? input.spec.target;
+      const effectiveIsolation = jobSpec.isolation ?? input.spec.isolation;
+      const stepRuns = jobSpec.steps.map((step, index) => ({
+        id: `${jobId}:${index}`,
+        runId,
+        jobId,
+        name: step.name,
+        index,
+        status: "queued",
+        queuedAt: timestamp,
+        attempt: 0,
+        timeoutMs: step.timeoutMs,
+        continueOnError: step.continueOnError,
+        spec: step
+      }));
+      jobs.push({
+        id: jobId,
+        runId,
+        jobName,
+        status: "queued",
+        runsOn: jobSpec.runsOn,
+        queuedAt: timestamp,
+        attempt: 0,
+        steps: stepRuns,
+        concurrency: jobSpec.concurrency,
+        retries: jobSpec.retries,
+        timeoutMs: jobSpec.timeoutMs,
+        target: effectiveTarget,
+        isolation: effectiveIsolation,
+        artifacts: jobSpec.artifacts,
+        env: jobSpec.env,
+        secrets: jobSpec.secrets,
+        needs,
+        pendingDependencies: [...needs],
+        blocked: needs.length > 0,
+        priority
+      });
+    }
+    const workflowRun = {
+      id: runId,
+      name: input.spec.name,
+      version: input.spec.version,
+      status: "queued",
+      createdAt: timestamp,
+      queuedAt: timestamp,
+      trigger: input.trigger,
+      env: input.spec.env,
+      secrets: input.spec.secrets,
+      jobs,
+      metadata: {
+        idempotencyKey: input.idempotencyKey,
+        concurrencyGroup: input.concurrencyGroup,
+        target: input.spec.target,
+        isolation: input.spec.isolation
+      },
+      artifacts: []
+    };
+    return workflowRun;
+  }
+  async registerIdempotencyKey(key, runId) {
+    const cacheKey = `kb:idempotency:${key}`;
+    const registered = await this.cache.setIfNotExists(
+      cacheKey,
+      runId,
+      this.idempotencyTtlMs
+    );
+    if (!registered) {
+      const existingRunId = await this.cache.get(cacheKey);
+      if (existingRunId) {
+        const existing = await this.stateStore.getRun(existingRunId);
+        if (existing) {
+          throw new Error(
+            `Idempotency key ${key} already associated with run ${existingRunId}`
+          );
+        }
+      }
+      throw new Error(`Failed to register idempotency key ${key}`);
+    }
+  }
+  async loadByIdempotencyKey(key) {
+    const cacheKey = `kb:idempotency:${key}`;
+    const existingRunId = await this.cache.get(cacheKey);
+    if (!existingRunId) {
+      return null;
+    }
+    return this.stateStore.getRun(existingRunId);
+  }
+  async releaseConcurrency(run) {
+    const group = run.metadata?.concurrencyGroup;
+    if (!group) {
+      return;
+    }
+    await this.concurrencyManager.release(group, run.id);
+    this.logger.debug("Released concurrency group", {
+      runId: run.id,
+      group
+    });
+  }
+};
+var DEFAULT_TTL_MS = 1e3 * 60 * 30;
+function resolveTtlMs(explicit) {
+  if (typeof explicit === "number" && explicit > 0) {
+    return explicit;
+  }
+  const envValue = process.env[CONCURRENCY_TTL_ENV];
+  const parsed = envValue ? Number(envValue) : void 0;
+  if (parsed && Number.isFinite(parsed) && parsed > 0) {
+    return parsed;
+  }
+  return DEFAULT_TTL_MS;
+}
+var ConcurrencyManager = class {
+  constructor(cache, logger, options = {}) {
+    this.logger = logger;
+    this.cache = cache;
+    this.ttlMs = resolveTtlMs(options.ttlMs);
+  }
+  cache;
+  ttlMs;
+  async acquire(group, runId, options = {}) {
+    const ttl = resolveTtlMs(options.ttlMs ?? this.ttlMs);
+    const key = `kb:concurrency:${group}`;
+    const acquired = await this.cache.setIfNotExists(key, runId, ttl);
+    this.logger.debug("Concurrency acquire attempt", {
+      group,
+      runId,
+      acquired
+    });
+    return acquired;
+  }
+  async release(group, runId) {
+    const key = `kb:concurrency:${group}`;
+    const current = await this.cache.get(key);
+    if (current === runId) {
+      await this.cache.delete(key);
+      this.logger.debug("Concurrency lock released", { group, runId });
+    }
+  }
+  async getActiveRun(group) {
+    const key = `kb:concurrency:${group}`;
+    return this.cache.get(key);
+  }
+};
+
+// src/scheduler.ts
+var Scheduler = class {
+  constructor(cache, logger, options = {}) {
+    this.logger = logger;
+    this.cache = cache;
+    this.defaultPriority = options.defaultPriority ?? "normal";
+    this.lookAheadMs = options.lookAheadMs ?? 1e3;
+  }
+  cache;
+  defaultPriority;
+  lookAheadMs;
+  priorityOrder = ["high", "normal", "low"];
+  async scheduleRun(run) {
+    const readyJobs = run.jobs.filter((job) => {
+      if (job.blocked) {
+        this.logger.debug("Job blocked by dependencies; deferring enqueue", {
+          runId: run.id,
+          jobId: job.id,
+          needs: job.needs
+        });
+        return false;
+      }
+      return true;
+    });
+    await Promise.all(
+      readyJobs.map((job) => {
+        const priority = job.priority ?? this.defaultPriority;
+        return this.enqueueJob(run.id, job, priority);
+      })
+    );
+  }
+  async enqueueJob(runId, job, priority = this.defaultPriority) {
+    if (job.blocked) {
+      this.logger.debug("Skipping enqueue for blocked job", {
+        runId,
+        jobId: job.id,
+        needs: job.pendingDependencies
+      });
+      return;
+    }
+    const now = Date.now();
+    const entryId = `${runId}:${job.id}:${now}:${Math.random().toString(36).slice(2, 10)}`;
+    const entry = {
+      id: entryId,
+      runId,
+      jobId: job.id,
+      jobName: job.jobName,
+      priority,
+      enqueuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      availableAt: now
+    };
+    await this.cache.zadd(
+      `kb:jobqueue:${priority}`,
+      entry.availableAt,
+      JSON.stringify(entry)
+    );
+    this.logger.debug("Job enqueued", { runId, jobId: job.id, priority });
+  }
+  async dequeueJob() {
+    for (const priority of this.priorityOrder) {
+      const entry = await this.dequeueFromPriority(priority);
+      if (entry) {
+        return entry;
+      }
+    }
+    return null;
+  }
+  async reschedule(entry, delayMs) {
+    const availableAt = Date.now() + delayMs;
+    const next = {
+      ...entry,
+      availableAt,
+      enqueuedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.cache.zadd(
+      `kb:jobqueue:${entry.priority}`,
+      availableAt,
+      JSON.stringify(next)
+    );
+    this.logger.debug("Job rescheduled", {
+      runId: entry.runId,
+      jobId: entry.jobId,
+      delayMs,
+      priority: entry.priority
+    });
+  }
+  async dequeueFromPriority(priority) {
+    const now = Date.now();
+    const key = `kb:jobqueue:${priority}`;
+    const results = await this.cache.zrangebyscore(
+      key,
+      0,
+      now + this.lookAheadMs
+    );
+    if (results.length === 0) {
+      return null;
+    }
+    const raw = results[0];
+    if (typeof raw !== "string") {
+      return null;
+    }
+    try {
+      const entry = JSON.parse(raw);
+      await this.cache.zrem(key, raw);
+      return entry;
+    } catch (error) {
+      this.logger.error("Failed to parse job queue entry", error instanceof Error ? error : void 0);
+      return null;
+    }
+  }
+  getDefaultPriority() {
+    return this.defaultPriority;
+  }
+};
+
+// src/secrets.ts
+var EnvSecretProvider = class {
+  prefix;
+  allowPlain;
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "KB_SECRET_";
+    this.allowPlain = options.allowPlain ?? true;
+  }
+  async resolve(names) {
+    const resolved = {};
+    for (const name of names) {
+      if (!name) {
+        continue;
+      }
+      const prefixed = `${this.prefix}${name}`;
+      const candidates = this.allowPlain ? [process.env[name], process.env[prefixed]] : [process.env[prefixed]];
+      const value = candidates.find((candidate) => typeof candidate === "string");
+      if (typeof value === "string") {
+        resolved[name] = value;
+      }
+    }
+    return resolved;
+  }
+};
+function createDefaultSecretProvider() {
+  return new EnvSecretProvider();
+}
+var EventBusBridge = class {
+  constructor(events, logger) {
+    this.logger = logger;
+    this.events = events;
+  }
+  events;
+  channel = WORKFLOW_REDIS_CHANNEL;
+  async publish(event) {
+    const payload = {
+      ...event,
+      timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.events.publish(this.channel, payload);
+    this.logger.debug("Workflow event published", {
+      channel: this.channel,
+      type: event.type,
+      runId: event.runId
+    });
+  }
+};
+
+// src/retry.ts
+var DEFAULT_INITIAL_INTERVAL_MS = 1e3;
+function calculateBackoff(attempt, policy) {
+  if (!policy) {
+    return 0;
+  }
+  const base = policy.initialIntervalMs ?? DEFAULT_INITIAL_INTERVAL_MS;
+  const backoff = policy.backoff === "lin" ? base * (attempt + 1) : base * Math.pow(2, attempt);
+  if (policy.maxIntervalMs) {
+    return Math.min(backoff, policy.maxIntervalMs);
+  }
+  return backoff;
+}
+function shouldRetry(attempt, policy) {
+  if (!policy) {
+    return { shouldRetry: false };
+  }
+  if (attempt >= policy.max) {
+    return { shouldRetry: false };
+  }
+  return {
+    shouldRetry: true,
+    nextDelayMs: calculateBackoff(attempt, policy)
+  };
+}
+
+// src/run-snapshot.ts
+var SNAPSHOT_VERSION = "1.0.0";
+var RunSnapshotStorage = class {
+  constructor(cache, logger) {
+    this.cache = cache;
+    this.logger = logger;
+  }
+  getSnapshotKey(runId) {
+    return `workflow:snapshot:${runId}`;
+  }
+  async createSnapshot(run, stepOutputs, env, refs) {
+    const snapshot = {
+      runId: run.id,
+      run,
+      stepOutputs,
+      env,
+      refs,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: SNAPSHOT_VERSION
+    };
+    const key = this.getSnapshotKey(run.id);
+    await this.cache.set(
+      key,
+      JSON.stringify(snapshot),
+      7 * 24 * 60 * 60 * 1e3
+      // 7 days in ms
+    );
+    this.logger.info("Snapshot created", { runId: run.id });
+    return snapshot;
+  }
+  async getSnapshot(runId) {
+    const key = this.getSnapshotKey(runId);
+    const stored = await this.cache.get(key);
+    if (!stored) {
+      return null;
+    }
+    try {
+      const snapshot = JSON.parse(stored);
+      if (snapshot.version !== SNAPSHOT_VERSION) {
+        this.logger.warn("Snapshot version mismatch", {
+          runId,
+          expected: SNAPSHOT_VERSION,
+          actual: snapshot.version
+        });
+      }
+      return snapshot;
+    } catch (error) {
+      this.logger.error("Failed to parse snapshot", error instanceof Error ? error : void 0, {
+        runId
+      });
+      return null;
+    }
+  }
+  async deleteSnapshot(runId) {
+    const key = this.getSnapshotKey(runId);
+    await this.cache.delete(key);
+    this.logger.debug("Snapshot deleted", { runId });
+  }
+};
+
+// src/engine.ts
+var WorkflowEngine = class {
+  constructor(options) {
+    this.options = options;
+    this.logger = options.logger;
+    this.analytics = options.analytics;
+    this.stateStore = new StateStore(options.cache, this.logger);
+    this.concurrency = new ConcurrencyManager(
+      options.cache,
+      this.logger,
+      options.concurrency
+    );
+    this.runCoordinator = new RunCoordinator(
+      options.cache,
+      this.stateStore,
+      this.concurrency,
+      this.logger,
+      options.runCoordinator
+    );
+    this.scheduler = new Scheduler(options.cache, this.logger, options.scheduler);
+    this.events = new EventBusBridge(options.events, this.logger);
+    this.loader = new WorkflowLoader(this.logger);
+    this.maxWorkflowDepth = options.maxWorkflowDepth ?? 2;
+    this.snapshotStorage = new RunSnapshotStorage(options.cache, this.logger);
+  }
+  loader;
+  maxWorkflowDepth;
+  logger;
+  analytics;
+  stateStore;
+  concurrency;
+  runCoordinator;
+  scheduler;
+  events;
+  snapshotStorage;
+  async dispose() {
+  }
+  /**
+   * Subscribe to real-time events for a specific workflow run.
+   * Events are filtered by runId from the shared event bus channel.
+   */
+  subscribeToRunEvents(runId, handler) {
+    return this.options.events.subscribe(WORKFLOW_REDIS_CHANNEL, async (raw) => {
+      const event = raw;
+      if (event.runId === runId) handler(event);
+    });
+  }
+  async createRun(input) {
+    const run = await this.runCoordinator.ensureRun(input);
+    this.analytics?.track("workflow.run.created", {
+      runId: run.id,
+      name: run.name,
+      version: run.version,
+      jobCount: run.jobs.length,
+      trigger: input.trigger?.type
+    }).catch(() => {
+    });
+    await this.events.publish({
+      type: EVENT_NAMES.run.created,
+      runId: run.id,
+      payload: {
+        status: run.status,
+        name: run.name,
+        version: run.version
+      }
+    });
+    await this.scheduler.scheduleRun(run);
+    return run;
+  }
+  async runFromSpec(spec, input) {
+    return this.createRun({
+      ...input,
+      spec
+    });
+  }
+  async runFromFile(filePath, input) {
+    const result = await this.loader.fromFile(filePath);
+    return this.runFromSpec(result.spec, input);
+  }
+  async runFromInline(spec, input) {
+    const result = this.loader.fromInline(spec);
+    return this.runFromSpec(result.spec, input);
+  }
+  async getRun(runId) {
+    return this.stateStore.getRun(runId);
+  }
+  async cancelRun(runId) {
+    const run = await this.getRun(runId);
+    await this.stateStore.updateRun(runId, (draft) => {
+      draft.status = "cancelled";
+      draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return draft;
+    });
+    this.analytics?.track("workflow.run.cancelled", {
+      runId,
+      name: run?.name,
+      reason: "cancelled by parent workflow"
+    }).catch(() => {
+    });
+    await this.events.publish({
+      type: EVENT_NAMES.run.cancelled,
+      runId,
+      payload: { reason: "cancelled by parent workflow" }
+    });
+  }
+  /**
+   * Mark job as failed and optionally schedule retry.
+   * Implements exponential/linear backoff retry logic.
+   */
+  async markJobFailed(runId, jobId, error, shouldRetry2 = true) {
+    const run = await this.stateStore.getRun(runId);
+    if (!run) {
+      this.logger.warn("Cannot mark job as failed: run not found", { runId, jobId });
+      return;
+    }
+    const job = run.jobs.find((j) => j.id === jobId);
+    if (!job) {
+      this.logger.warn("Cannot mark job as failed: job not found", { runId, jobId });
+      return;
+    }
+    await this.stateStore.updateJob(runId, jobId, (draft) => {
+      draft.status = "failed";
+      draft.error = {
+        message: error.message,
+        stack: error.stack,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      draft.attempt = (draft.attempt || 0) + 1;
+    });
+    this.logger.error("Job failed", error, {
+      runId,
+      jobId,
+      attempt: (job.attempt || 0) + 1
+    });
+    this.analytics?.track("workflow.job.failed", {
+      runId,
+      jobId,
+      jobName: job.jobName,
+      attempt: (job.attempt || 0) + 1,
+      errorMessage: error.message,
+      willRetry: shouldRetry2 && this.shouldRetryJob(job)
+    }).catch(() => {
+    });
+    await this.events.publish({
+      type: EVENT_NAMES.job.failed,
+      runId,
+      jobId,
+      payload: { jobName: job.jobName, error: error.message, attempt: (job.attempt || 0) + 1 }
+    });
+    if (shouldRetry2 && this.shouldRetryJob(job)) {
+      const backoffMs = this.calculateBackoff(job.attempt || 0, job.retries);
+      this.logger.info("Scheduling job retry", {
+        runId,
+        jobId,
+        attempt: (job.attempt || 0) + 1,
+        backoffMs
+      });
+      setTimeout(async () => {
+        await this.stateStore.updateJob(runId, jobId, (draft) => {
+          draft.status = "queued";
+          draft.error = void 0;
+          draft.startedAt = void 0;
+          draft.finishedAt = void 0;
+        });
+        const updatedRun = await this.stateStore.getRun(runId);
+        const updatedJob = updatedRun?.jobs.find((j) => j.id === jobId);
+        if (updatedJob) {
+          await this.scheduler.enqueueJob(runId, updatedJob, updatedJob.priority ?? "normal");
+        }
+        this.logger.info("Job re-queued for retry", { runId, jobId });
+      }, backoffMs);
+    } else {
+      await this.moveToDLQ(runId, jobId, error);
+    }
+  }
+  /**
+   * Mark job as interrupted (e.g., during graceful shutdown).
+   * Interrupted jobs will be retried on next daemon startup.
+   */
+  async markJobInterrupted(runId, jobId) {
+    await this.stateStore.updateJob(runId, jobId, (draft) => {
+      draft.status = "interrupted";
+      draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    });
+    this.logger.warn("Job interrupted", { runId, jobId });
+  }
+  /**
+   * Mark job as started (running).
+   */
+  async markJobStarted(runId, jobId) {
+    await this.stateStore.updateJob(runId, jobId, (draft) => {
+      draft.status = "running";
+      draft.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    });
+    this.logger.debug("Job started", { runId, jobId });
+    const run = await this.getRun(runId);
+    const job = run?.jobs.find((j) => j.id === jobId);
+    this.analytics?.track("workflow.job.started", {
+      runId,
+      jobId,
+      jobName: job?.jobName,
+      stepCount: job?.steps.length ?? 0
+    }).catch(() => {
+    });
+    await this.events.publish({
+      type: EVENT_NAMES.job.started,
+      runId,
+      jobId,
+      payload: { jobName: job?.jobName }
+    });
+  }
+  /**
+   * Mark job as completed successfully.
+   */
+  async markJobCompleted(runId, jobId) {
+    const run = await this.getRun(runId);
+    const job = run?.jobs.find((j) => j.id === jobId);
+    const startTime = job?.startedAt ? new Date(job.startedAt).getTime() : Date.now();
+    const duration = Date.now() - startTime;
+    await this.stateStore.updateJob(runId, jobId, (draft) => {
+      draft.status = "success";
+      draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    });
+    this.logger.info("Job completed successfully", { runId, jobId });
+    this.analytics?.track("workflow.job.completed", {
+      runId,
+      jobId,
+      jobName: job?.jobName,
+      durationMs: duration,
+      stepCount: job?.steps.length ?? 0
+    }).catch(() => {
+    });
+    await this.events.publish({
+      type: EVENT_NAMES.job.succeeded,
+      runId,
+      jobId,
+      payload: { jobName: job?.jobName, durationMs: duration }
+    });
+    await this.checkRunCompletion(runId);
+  }
+  /**
+   * Check if all jobs in a run are completed and update run status accordingly.
+   */
+  async checkRunCompletion(runId) {
+    const run = await this.getRun(runId);
+    if (!run) {
+      return;
+    }
+    const allSuccess = run.jobs.every((j) => j.status === "success");
+    const anyFailed = run.jobs.some((j) => j.status === "failed");
+    const anyRunning = run.jobs.some((j) => j.status === "running" || j.status === "queued");
+    if (anyRunning) {
+      return;
+    }
+    if (allSuccess) {
+      await this.stateStore.updateRun(runId, (draft) => {
+        draft.status = "success";
+        draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return draft;
+      });
+      this.logger.info("Workflow run completed successfully", { runId });
+      this.analytics?.track("workflow.run.completed", {
+        runId,
+        name: run.name,
+        jobCount: run.jobs.length,
+        status: "success"
+      }).catch(() => {
+      });
+      await this.events.publish({
+        type: EVENT_NAMES.run.finished,
+        runId,
+        payload: { status: "success", name: run.name }
+      });
+    } else if (anyFailed) {
+      await this.stateStore.updateRun(runId, (draft) => {
+        draft.status = "failed";
+        draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+        return draft;
+      });
+      this.logger.info("Workflow run failed", { runId });
+      this.analytics?.track("workflow.run.completed", {
+        runId,
+        name: run.name,
+        jobCount: run.jobs.length,
+        status: "failed"
+      }).catch(() => {
+      });
+      await this.events.publish({
+        type: EVENT_NAMES.run.failed,
+        runId,
+        payload: { status: "failed", name: run.name }
+      });
+    }
+  }
+  /**
+   * Mark step as started (running).
+   */
+  async markStepStarted(runId, jobId, stepId) {
+    await this.stateStore.updateStep(runId, jobId, stepId, (draft) => {
+      draft.status = "running";
+      draft.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    });
+    this.logger.debug("Step started", { runId, jobId, stepId });
+    await this.events.publish({
+      type: EVENT_NAMES.step.started,
+      runId,
+      jobId,
+      stepId
+    });
+  }
+  /**
+   * Mark step as completed successfully with output.
+   */
+  async markStepCompleted(runId, jobId, stepId, output) {
+    await this.stateStore.updateStep(runId, jobId, stepId, (draft) => {
+      draft.status = "success";
+      draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (output !== void 0) {
+        draft.outputs = output;
+      }
+    });
+    this.logger.debug("Step completed", { runId, jobId, stepId });
+    await this.events.publish({
+      type: EVENT_NAMES.step.succeeded,
+      runId,
+      jobId,
+      stepId,
+      payload: output !== void 0 ? { outputs: output } : void 0
+    });
+  }
+  /**
+   * Mark step as failed with error.
+   */
+  async markStepFailed(runId, jobId, stepId, error, outputs) {
+    await this.stateStore.updateStep(runId, jobId, stepId, (draft) => {
+      draft.status = "failed";
+      draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      draft.error = {
+        message: error.message,
+        stack: error.stack
+      };
+      if (outputs) draft.outputs = outputs;
+    });
+    this.logger.debug("Step failed", { runId, jobId, stepId, error: error.message });
+    await this.events.publish({
+      type: EVENT_NAMES.step.failed,
+      runId,
+      jobId,
+      stepId,
+      payload: { error: error.message }
+    });
+  }
+  /**
+   * Mark step as waiting for human approval.
+   */
+  async markStepWaitingApproval(runId, jobId, stepId) {
+    await this.stateStore.updateStep(runId, jobId, stepId, (draft) => {
+      draft.status = "waiting_approval";
+      draft.startedAt = draft.startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    });
+    await this.events.publish({
+      type: EVENT_NAMES.step.waitingApproval,
+      runId,
+      payload: { jobId, stepId }
+    });
+    this.logger.info("Step waiting for approval", { runId, jobId, stepId });
+  }
+  /**
+   * Resolve a pending approval — approve or reject.
+   * On approve: marks step as success with approval outputs.
+   * On reject: marks step as failed with rejection error.
+   */
+  async resolveApproval(runId, jobId, stepId, action, data, comment) {
+    if (action === "approve") {
+      await this.stateStore.updateStep(runId, jobId, stepId, (draft) => {
+        draft.status = "success";
+        draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+        draft.outputs = {
+          approved: true,
+          action,
+          ...comment ? { comment } : {},
+          ...data ?? {}
+        };
+      });
+      this.logger.info("Approval granted", { runId, jobId, stepId, comment });
+    } else {
+      await this.stateStore.updateStep(runId, jobId, stepId, (draft) => {
+        draft.status = "failed";
+        draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+        draft.error = {
+          message: comment || "Approval rejected",
+          code: "APPROVAL_REJECTED"
+        };
+        draft.outputs = {
+          approved: false,
+          action,
+          ...comment ? { comment } : {},
+          ...data ?? {}
+        };
+      });
+      this.logger.info("Approval rejected", { runId, jobId, stepId, comment });
+    }
+    await this.events.publish({
+      type: EVENT_NAMES.step.updated,
+      runId,
+      payload: { jobId, stepId, action }
+    });
+  }
+  /**
+   * Get the state store for direct access (used by worker for gate restart-from).
+   */
+  getStateStore() {
+    return this.stateStore;
+  }
+  /**
+   * Get the scheduler for direct access (used by worker for gate re-enqueue).
+   */
+  getScheduler() {
+    return this.scheduler;
+  }
+  /**
+   * Mark stale running/queued runs as failed on daemon startup.
+   * Runs that were in-flight when the daemon crashed are unrecoverable —
+   * their executor process is gone, so we mark them failed immediately.
+   */
+  async cleanupStaleRuns() {
+    const runIds = await this.stateStore.getAllRunIds();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let count = 0;
+    await Promise.all(
+      runIds.map(async (runId) => {
+        const run = await this.stateStore.getRun(runId);
+        if (!run) {
+          return;
+        }
+        if (run.status !== "running" && run.status !== "queued") {
+          return;
+        }
+        await this.stateStore.updateRun(runId, (draft) => {
+          draft.status = "failed";
+          draft.finishedAt = now;
+          if (draft.startedAt) {
+            draft.durationMs = new Date(now).getTime() - new Date(draft.startedAt).getTime();
+          }
+          for (const job of draft.jobs) {
+            if (job.status === "running" || job.status === "queued") {
+              job.status = "failed";
+              job.error = { message: "Daemon restarted \u2014 run was abandoned" };
+              job.finishedAt = now;
+            }
+          }
+          return draft;
+        });
+        count++;
+      })
+    );
+    if (count > 0) {
+      this.logger.warn("Cleaned up stale runs from previous daemon process", { count });
+    }
+  }
+  /**
+   * Resume interrupted jobs on daemon startup.
+   * Re-queues jobs that were interrupted during previous shutdown.
+   */
+  async resumeInterruptedJobs() {
+    const runIds = await this.stateStore.getAllRunIds();
+    const results = await Promise.all(
+      runIds.map(async (runId) => {
+        const run = await this.stateStore.getRun(runId);
+        if (!run) {
+          return 0;
+        }
+        const interruptedJobs = run.jobs.filter((job) => job.status === "interrupted");
+        await Promise.all(
+          interruptedJobs.map(async (job) => {
+            this.logger.info("Resuming interrupted job", { runId, jobId: job.id });
+            await this.stateStore.updateJob(runId, job.id, (draft) => {
+              draft.status = "queued";
+              draft.startedAt = void 0;
+              draft.finishedAt = void 0;
+            });
+            const queuedJob = { ...job, status: "queued" };
+            await this.scheduler.enqueueJob(runId, queuedJob, queuedJob.priority ?? "normal");
+          })
+        );
+        return interruptedJobs.length;
+      })
+    );
+    const resumedCount = results.reduce((sum, count) => sum + count, 0);
+    if (resumedCount > 0) {
+      this.logger.info("Resumed interrupted jobs", { count: resumedCount });
+    }
+  }
+  /**
+   * Determine if job should be retried based on retry policy.
+   */
+  shouldRetryJob(job) {
+    const retryPolicy = job.retries || { max: 3};
+    const attempt = job.attempt || 0;
+    return attempt < retryPolicy.max;
+  }
+  /**
+   * Calculate backoff delay using exponential or linear strategy.
+   */
+  calculateBackoff(attempt, policy) {
+    const config = {
+      backoff: policy?.backoff || "exp",
+      initialIntervalMs: policy?.initialIntervalMs || 1e3,
+      maxIntervalMs: policy?.maxIntervalMs || 6e4
+    };
+    let backoffMs;
+    if (config.backoff === "exp") {
+      backoffMs = config.initialIntervalMs * Math.pow(2, attempt);
+    } else {
+      backoffMs = config.initialIntervalMs * (attempt + 1);
+    }
+    return Math.min(backoffMs, config.maxIntervalMs);
+  }
+  /**
+   * Move permanently failed job to Dead Letter Queue.
+   */
+  async moveToDLQ(runId, jobId, error) {
+    this.logger.warn("Job moved to DLQ after max retries", { runId, jobId });
+    await this.stateStore.updateRun(runId, (draft) => {
+      draft.status = "dlq";
+      draft.result = {
+        status: "dlq",
+        summary: `Job ${jobId} failed after max retries`,
+        error: {
+          message: error.message,
+          details: {
+            stack: error.stack
+          }
+        }
+      };
+      draft.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    });
+    const dlqKey = `workflow:dlq:${runId}:${jobId}`;
+    const run = await this.stateStore.getRun(runId);
+    const job = run?.jobs.find((j) => j.id === jobId);
+    await this.options.cache.set(
+      dlqKey,
+      JSON.stringify({
+        runId,
+        jobId,
+        jobName: job?.jobName,
+        error: {
+          message: error.message,
+          stack: error.stack
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        attempts: job?.attempt || 0
+      }),
+      7 * 24 * 60 * 60 * 1e3
+      // TTL 7 days
+    );
+    const updatedRun = await this.stateStore.getRun(runId);
+    if (updatedRun) {
+      await this.publishRunEvent(EVENT_NAMES.run.failed, updatedRun);
+    }
+  }
+  async updateRun(runId, mutator) {
+    const updated = await this.stateStore.updateRun(runId, mutator);
+    if (updated) {
+      await this.publishRunEvent(EVENT_NAMES.run.updated, updated);
+    }
+    return updated;
+  }
+  async finalizeRun(runId, status, context = {}) {
+    const updated = await this.stateStore.updateRun(runId, (run) => {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      run.status = status;
+      run.finishedAt = now;
+      run.durationMs = computeDurationMs(run.startedAt ?? run.queuedAt, now);
+      if (context.jobs) {
+        run.jobs = context.jobs;
+      }
+      if (context.steps) ;
+      return run;
+    });
+    if (updated) {
+      await this.runCoordinator.releaseConcurrency(updated);
+      await this.publishRunEvent(
+        status === "failed" ? EVENT_NAMES.run.failed : status === "cancelled" ? EVENT_NAMES.run.cancelled : EVENT_NAMES.run.finished,
+        updated
+      );
+    }
+    return updated;
+  }
+  async nextJob() {
+    return this.scheduler.dequeueJob();
+  }
+  async rescheduleJob(entry, delayMs) {
+    await this.scheduler.reschedule(entry, delayMs);
+  }
+  async publishRunEvent(type, run) {
+    await this.events.publish({
+      type,
+      runId: run.id,
+      payload: {
+        status: run.status,
+        name: run.name,
+        version: run.version
+      }
+    });
+  }
+  /**
+   * Publish a log entry for real-time streaming to Studio UI.
+   */
+  async publishLog(runId, jobId, stepId, entry) {
+    await this.events.publish({
+      type: EVENT_NAMES.log.appended,
+      runId,
+      jobId,
+      stepId,
+      payload: entry
+    });
+  }
+  /**
+   * Create a snapshot of the current run state
+   */
+  async createSnapshot(runId, stepOutputs, env, refs) {
+    const run = await this.getRun(runId);
+    if (!run) {
+      this.logger.warn("Cannot create snapshot: run not found", { runId });
+      return null;
+    }
+    return this.snapshotStorage.createSnapshot(run, stepOutputs, env, refs);
+  }
+  /**
+   * Get a snapshot for a run
+   */
+  async getSnapshot(runId) {
+    return this.snapshotStorage.getSnapshot(runId);
+  }
+  /**
+   * Replay a run from a snapshot, optionally starting from a specific step
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity -- Replay orchestration: handles snapshot loading, step state transitions (before/at/after fromStep), env merging, job traversal, and conditional status reset logic
+  async replayRun(runId, options = {}) {
+    const snapshot = await this.snapshotStorage.getSnapshot(runId);
+    if (!snapshot) {
+      this.logger.warn("Cannot replay: snapshot not found", { runId });
+      return null;
+    }
+    if (snapshot.refs?.workspaceSnapshotId || snapshot.refs?.environmentSnapshotId) {
+      if (!this.options.snapshotManager) {
+        throw new Error("SnapshotManager is required for replay with infra snapshot references");
+      }
+      if (snapshot.refs.workspaceSnapshotId) {
+        await this.options.snapshotManager.restoreSnapshot({
+          snapshotId: snapshot.refs.workspaceSnapshotId,
+          metadata: { source: "workflow.replay", runId }
+        });
+      }
+      if (snapshot.refs.environmentSnapshotId) {
+        await this.options.snapshotManager.restoreSnapshot({
+          snapshotId: snapshot.refs.environmentSnapshotId,
+          metadata: { source: "workflow.replay", runId }
+        });
+      }
+    }
+    const restoredRun = snapshot.run;
+    if (options.env) {
+      restoredRun.env = { ...snapshot.env, ...options.env };
+    } else {
+      restoredRun.env = snapshot.env;
+    }
+    if (options.fromStepId) {
+      for (const job of restoredRun.jobs) {
+        let foundStep = false;
+        for (const step of job.steps) {
+          if (step.id === options.fromStepId) {
+            foundStep = true;
+            if (step.status !== "queued") {
+              step.status = "queued";
+              step.startedAt = void 0;
+              step.finishedAt = void 0;
+            }
+            continue;
+          }
+          if (!foundStep) {
+            if (step.status === "running" || step.status === "queued") {
+              step.status = "success";
+              step.finishedAt = step.finishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+            }
+          } else {
+            step.status = "queued";
+            step.startedAt = void 0;
+            step.finishedAt = void 0;
+          }
+        }
+      }
+    } else {
+      for (const job of restoredRun.jobs) {
+        for (const step of job.steps) {
+          step.status = "queued";
+          step.startedAt = void 0;
+          step.finishedAt = void 0;
+        }
+      }
+    }
+    restoredRun.status = "running";
+    restoredRun.startedAt = restoredRun.startedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    restoredRun.finishedAt = void 0;
+    await this.stateStore.saveRun(restoredRun);
+    await this.scheduler.scheduleRun(restoredRun);
+    this.logger.info("Run replayed from snapshot", {
+      runId,
+      fromStepId: options.fromStepId
+    });
+    return restoredRun;
+  }
+  /**
+   * Delete a snapshot
+   */
+  async deleteSnapshot(runId) {
+    await this.snapshotStorage.deleteSnapshot(runId);
+  }
+  /**
+   * Get all active workflow executions (running or queued).
+   * Returns array of WorkflowRun objects with status 'running' or 'queued'.
+   */
+  async getActiveExecutions() {
+    const runIds = await this.stateStore.getAllRunIds();
+    const runs = await Promise.all(runIds.map((id) => this.stateStore.getRun(id)));
+    return runs.filter(
+      (run) => run !== null && (run.status === "running" || run.status === "queued")
+    );
+  }
+  /**
+   * Get all workflow runs (all statuses).
+   * Returns array of all WorkflowRun objects ordered by creation time.
+   */
+  async getAllRuns() {
+    const runIds = await this.stateStore.getAllRunIds();
+    const runs = await Promise.all(runIds.map((id) => this.stateStore.getRun(id)));
+    return runs.filter((run) => run !== null);
+  }
+  /**
+   * List all workflow runs.
+   * Returns array of all runs in the system.
+   * Alias for getAllRuns() - maintained for backward compatibility.
+   */
+  async listRuns() {
+    return this.getAllRuns();
+  }
+  /**
+   * Get workflow engine metrics.
+   * Returns statistics about runs, jobs, and system health.
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity -- Metrics aggregation: iterates all runs and jobs, counts by status (6 run statuses + 4 job statuses), handles nulls
+  async getMetrics() {
+    const runIds = await this.stateStore.getAllRunIds();
+    const metrics = {
+      runs: {
+        total: 0,
+        queued: 0,
+        running: 0,
+        completed: 0,
+        failed: 0,
+        cancelled: 0,
+        dlq: 0
+      },
+      jobs: {
+        total: 0,
+        queued: 0,
+        running: 0,
+        completed: 0,
+        failed: 0
+      }
+    };
+    const runs = await Promise.all(runIds.map((id) => this.stateStore.getRun(id)));
+    for (const run of runs) {
+      if (!run) {
+        continue;
+      }
+      metrics.runs.total++;
+      if (run.status === "queued") {
+        metrics.runs.queued++;
+      } else if (run.status === "running") {
+        metrics.runs.running++;
+      } else if (run.status === "success") {
+        metrics.runs.completed++;
+      } else if (run.status === "failed") {
+        metrics.runs.failed++;
+      } else if (run.status === "cancelled") {
+        metrics.runs.cancelled++;
+      } else if (run.status === "dlq") {
+        metrics.runs.dlq++;
+      }
+      for (const job of run.jobs) {
+        metrics.jobs.total++;
+        if (job.status === "queued") {
+          metrics.jobs.queued++;
+        } else if (job.status === "running") {
+          metrics.jobs.running++;
+        } else if (job.status === "success") {
+          metrics.jobs.completed++;
+        } else if (job.status === "failed") {
+          metrics.jobs.failed++;
+        }
+      }
+    }
+    return metrics;
+  }
+};
+function computeDurationMs(startedAt, finishedAt) {
+  if (!startedAt) {
+    return void 0;
+  }
+  const start = Date.parse(startedAt);
+  const end = Date.parse(finishedAt);
+  if (Number.isNaN(start) || Number.isNaN(end)) {
+    return void 0;
+  }
+  return Math.max(0, end - start);
+}
+var ArtifactMerger = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async mergeArtifacts(config, targetArtifacts, currentRunId) {
+    const { strategy, from } = config;
+    this.options.logger.debug("Starting artifact merge", {
+      strategy,
+      sources: from.length,
+      currentRunId
+    });
+    const results = await Promise.allSettled(
+      from.map(
+        (source) => this.loadArtifactsFromRun(source.runId, source.jobId).then(
+          (artifacts) => ({ source, artifacts, success: true }),
+          (error) => ({ source, error, success: false })
+        )
+      )
+    );
+    const sourceArtifacts = [];
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value.success) {
+        sourceArtifacts.push(...result.value.artifacts);
+      } else if (result.status === "fulfilled" && !result.value.success) {
+        this.options.logger.warn("Failed to load artifacts from source", {
+          runId: result.value.source.runId,
+          jobId: result.value.source.jobId,
+          error: result.value.error instanceof Error ? result.value.error.message : String(result.value.error)
+        });
+      }
+    }
+    if (sourceArtifacts.length === 0) {
+      this.options.logger.warn("No artifacts found to merge", {
+        sources: from.length
+      });
+      return;
+    }
+    await this.applyMergeStrategy(strategy, sourceArtifacts, targetArtifacts);
+    this.options.logger.info("Artifact merge completed", {
+      strategy,
+      mergedCount: sourceArtifacts.length
+    });
+  }
+  async loadArtifactsFromRun(runId, jobId) {
+    const run = await this.options.stateStore.getRun(runId);
+    if (!run) {
+      throw new Error(`Run ${runId} not found`);
+    }
+    const job = jobId ? run.jobs.find((j) => j.id === jobId) : run.jobs[0];
+    if (!job) {
+      throw new Error(`Job ${jobId ?? "first"} not found in run ${runId}`);
+    }
+    const artifactPaths = job.artifacts?.produce ?? [];
+    if (artifactPaths.length === 0) {
+      return [];
+    }
+    const sourceArtifacts = createFileSystemArtifactClient(join(
+      this.options.artifactsRoot,
+      runId,
+      job.jobName
+    ));
+    const results = await Promise.allSettled(
+      artifactPaths.map((artifactPath) => {
+        return this.loadArtifactContent(sourceArtifacts, artifactPath).then(
+          (content) => ({ artifactPath, content, success: true }),
+          (error) => ({ artifactPath, error, success: false })
+        );
+      })
+    );
+    const artifacts = [];
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value.success) {
+        artifacts.push({ path: result.value.artifactPath, content: result.value.content });
+      } else if (result.status === "fulfilled" && !result.value.success) {
+        this.options.logger.warn("Failed to load artifact", {
+          runId,
+          jobId: job.id,
+          artifactPath: result.value.artifactPath,
+          error: result.value.error instanceof Error ? result.value.error.message : String(result.value.error)
+        });
+      }
+    }
+    return artifacts;
+  }
+  async loadArtifactContent(artifacts, artifactPath) {
+    try {
+      const content = (await artifacts.consume(artifactPath)).toString("utf8");
+      try {
+        return JSON.parse(content);
+      } catch {
+        return content;
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to read artifact '${artifactPath}': ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async applyMergeStrategy(strategy, sourceArtifacts, targetArtifacts) {
+    const artifactsByPath = /* @__PURE__ */ new Map();
+    for (const artifact of sourceArtifacts) {
+      if (!artifactsByPath.has(artifact.path)) {
+        artifactsByPath.set(artifact.path, []);
+      }
+      artifactsByPath.get(artifact.path).push(artifact.content);
+    }
+    await Promise.all(
+      Array.from(artifactsByPath.entries()).map(async ([path, contents]) => {
+        let merged;
+        switch (strategy) {
+          case "append": {
+            merged = this.mergeAppend(contents);
+            break;
+          }
+          case "overwrite": {
+            merged = contents[contents.length - 1];
+            break;
+          }
+          case "json-merge": {
+            merged = this.mergeJson(contents);
+            break;
+          }
+          default: {
+            this.options.logger.warn("Unknown merge strategy, using overwrite", {
+              strategy,
+              path
+            });
+            merged = contents[contents.length - 1];
+          }
+        }
+        await this.saveMergedArtifact(targetArtifacts, path, merged);
+      })
+    );
+  }
+  mergeAppend(contents) {
+    if (contents.every((c) => Array.isArray(c))) {
+      return contents.flat();
+    }
+    if (contents.every((c) => typeof c === "string")) {
+      return contents.join("\n");
+    }
+    return contents;
+  }
+  mergeJson(contents) {
+    let merged = {};
+    for (const content of contents) {
+      if (typeof content === "object" && content !== null && !Array.isArray(content)) {
+        merged = this.deepMerge(merged, content);
+      } else {
+        merged = content;
+      }
+    }
+    return merged;
+  }
+  deepMerge(target, source) {
+    const result = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+      if (key in result && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key]) && typeof value === "object" && value !== null && !Array.isArray(value)) {
+        result[key] = this.deepMerge(
+          result[key],
+          value
+        );
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  async saveMergedArtifact(artifacts, path, content) {
+    const contentString = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+    await artifacts.produce(path, contentString);
+    this.options.logger.debug("Saved merged artifact", { path });
+  }
+};
+
+// src/manifest-scanner.ts
+var ManifestScanner = class {
+  cliApi;
+  platform;
+  cacheTtlMs;
+  constructor(options) {
+    this.cliApi = options.cliApi;
+    this.platform = options.platform;
+    this.cacheTtlMs = options.cacheTtlMs ?? 6e4;
+  }
+  /**
+   * Scan all installed plugins for workflows and jobs.
+   *
+   * Returns unified WorkflowRuntime representations.
+   */
+  async scanPlugins() {
+    const cacheKey = "manifest-scanner:workflows";
+    if (this.platform.cache) {
+      const cached = await this.platform.cache.get(cacheKey);
+      if (cached) {
+        this.platform.logger?.debug("ManifestScanner: Using cached workflows", { count: cached.length });
+        return cached;
+      }
+    }
+    this.platform.logger?.debug("ManifestScanner: Querying entity registry");
+    const workflows = [];
+    const workflowEntities = this.cliApi.queryEntities({ kind: "workflow" });
+    const jobEntities = this.cliApi.queryEntities({ kind: "job" });
+    const cronEntities = this.cliApi.queryEntities({ kind: "cron" });
+    const pluginRoots = /* @__PURE__ */ new Map();
+    for (const plugin of this.cliApi.listPlugins()) {
+      pluginRoots.set(plugin.id, plugin.source.path);
+    }
+    const allEntities = [
+      ...workflowEntities.map((e) => ({ entity: e, converter: "workflow" })),
+      ...jobEntities.map((e) => ({ entity: e, converter: "job" })),
+      ...cronEntities.map((e) => ({ entity: e, converter: "cron" }))
+    ];
+    for (const { entity, converter } of allEntities) {
+      const root = pluginRoots.get(entity.ref.pluginId);
+      if (!root) {
+        this.platform.logger?.warn("ManifestScanner: Plugin root not found, skipping entity", {
+          pluginId: entity.ref.pluginId,
+          entityId: entity.ref.entityId,
+          kind: entity.ref.kind
+        });
+        continue;
+      }
+      try {
+        if (converter === "workflow") {
+          workflows.push(this.convertWorkflowHandler(entity.ref.pluginId, entity.declaration, root));
+        } else if (converter === "job") {
+          workflows.push(this.convertJobHandler(entity.ref.pluginId, entity.declaration, root));
+        } else {
+          workflows.push(this.convertCronSchedule(entity.ref.pluginId, entity.declaration, root));
+        }
+      } catch (err) {
+        this.platform.logger?.warn("ManifestScanner: Failed to convert entity", {
+          pluginId: entity.ref.pluginId,
+          entityId: entity.ref.entityId,
+          kind: entity.ref.kind,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    this.platform.logger?.info("ManifestScanner: Discovered workflows via registry", {
+      count: workflows.length,
+      workflows: workflowEntities.length,
+      jobs: jobEntities.length,
+      crons: cronEntities.length
+    });
+    if (this.platform.cache) {
+      await this.platform.cache.set(cacheKey, workflows, this.cacheTtlMs);
+    }
+    return workflows;
+  }
+  /**
+   * Convert workflow handler declaration to WorkflowRuntime.
+   */
+  convertWorkflowHandler(pluginId, handler, pluginRoot) {
+    const id = `${pluginId}/${handler.id}`;
+    return {
+      id,
+      source: "manifest",
+      pluginId,
+      manifestPath: pluginRoot,
+      name: handler.describe ?? handler.id,
+      description: handler.describe,
+      tags: ["plugin", pluginId],
+      triggers: [
+        { type: "manual" }
+        // Workflow handlers can always be triggered manually
+      ],
+      handler: handler.handler,
+      status: "active",
+      permissions: handler.permissions,
+      input: handler.input,
+      output: handler.output
+    };
+  }
+  /**
+   * Convert job handler declaration to WorkflowRuntime.
+   */
+  convertJobHandler(pluginId, handler, pluginRoot) {
+    const id = `${pluginId}:job:${handler.id}`;
+    return {
+      id,
+      source: "manifest",
+      pluginId,
+      manifestPath: pluginRoot,
+      name: handler.describe ?? handler.id,
+      description: handler.describe,
+      tags: ["plugin", "job", pluginId],
+      triggers: [
+        { type: "manual" }
+        // Job handlers are invoked on-demand via ctx.api.jobs.submit()
+      ],
+      handler: handler.handler,
+      status: "active",
+      permissions: handler.permissions,
+      input: handler.input,
+      output: handler.output
+    };
+  }
+  /**
+   * Convert cron schedule declaration to WorkflowRuntime.
+   */
+  convertCronSchedule(pluginId, cronDecl, pluginRoot) {
+    const id = `${pluginId}:cron:${cronDecl.id}`;
+    const schedule = {
+      cron: cronDecl.schedule,
+      enabled: cronDecl.enabled ?? true
+    };
+    return {
+      id,
+      source: "manifest",
+      pluginId,
+      manifestPath: pluginRoot,
+      name: cronDecl.describe ?? cronDecl.id,
+      description: cronDecl.describe,
+      tags: ["plugin", "cron", pluginId],
+      triggers: [
+        {
+          type: "schedule",
+          config: { cron: cronDecl.schedule, timezone: cronDecl.timezone }
+        }
+      ],
+      // Note: Cron schedules reference a job type to execute
+      // The actual handler path comes from the job declaration
+      handler: void 0,
+      // Will be resolved at execution time via job type
+      schedule,
+      status: cronDecl.enabled ?? true ? "active" : "disabled",
+      permissions: cronDecl.permissions
+    };
+  }
+  // Legacy convertLegacyJob method removed - use cron schedules instead
+  /**
+   * Scan all installed plugins for job handlers only.
+   *
+   * Returns information needed to register handlers in JobManager.
+   */
+  async scanJobHandlers() {
+    const snapshot = this.cliApi.snapshot();
+    const jobHandlers = [];
+    for (const entry of snapshot.manifests ?? []) {
+      const handlers = entry.manifest.jobs?.handlers ?? [];
+      for (const handler of handlers) {
+        jobHandlers.push({
+          pluginId: entry.pluginId,
+          pluginVersion: entry.manifest.version,
+          pluginRoot: entry.pluginRoot,
+          handler
+        });
+      }
+    }
+    this.platform.logger?.debug("ManifestScanner: Discovered job handlers", {
+      count: jobHandlers.length
+    });
+    return jobHandlers;
+  }
+  /**
+   * Clear cache (useful for testing or force refresh).
+   */
+  async clearCache() {
+    if (this.platform.cache) {
+      await this.platform.cache.delete("manifest-scanner:workflows");
+      this.platform.logger?.debug("ManifestScanner: Cache cleared");
+    }
+  }
+  /**
+   * Watch for plugin changes and invalidate cache.
+   *
+   * @param callback Optional callback when workflows change
+   * @returns Unsubscribe function
+   */
+  watchPlugins(callback) {
+    return this.cliApi.onChange(async () => {
+      await this.clearCache();
+      if (callback) {
+        const workflows = await this.scanPlugins();
+        callback(workflows);
+      }
+    });
+  }
+};
+var WorkflowRepository = class {
+  platform;
+  storageDir;
+  workspaceRoot;
+  absoluteStorageDir;
+  constructor(options) {
+    this.platform = options.platform;
+    this.storageDir = options.storageDir ?? ".kb/workflows";
+    this.workspaceRoot = options.workspaceRoot ?? process.cwd();
+    this.absoluteStorageDir = resolve(this.workspaceRoot, this.storageDir);
+  }
+  /**
+   * Create a new standalone workflow.
+   */
+  async create(spec) {
+    const validated = WorkflowSpecSchema.parse(spec);
+    const id = `wf-${randomUUID().slice(0, 8)}`;
+    const stored = {
+      id,
+      spec: validated,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "active"
+    };
+    await this.saveWorkflow(id, stored);
+    this.platform.logger?.info("WorkflowRepository: Created workflow", {
+      id,
+      name: spec.name
+    });
+    return this.toRuntime(stored);
+  }
+  /**
+   * Get workflow by ID.
+   */
+  async get(id) {
+    const stored = await this.loadWorkflow(id);
+    return stored ? this.toRuntime(stored) : null;
+  }
+  /**
+   * List all workflows with optional filtering.
+   */
+  async list(options) {
+    const allFiles = await this.listWorkflowFiles();
+    const allWorkflows = await Promise.all(
+      allFiles.map(async (filename) => {
+        const id = filename.replace(/\.(yaml|yml)$/, "");
+        const stored = await this.loadWorkflow(id);
+        return stored ? this.toRuntime(stored) : null;
+      })
+    );
+    const workflows = allWorkflows.filter((workflow) => {
+      if (!workflow) {
+        return false;
+      }
+      if (options?.status && workflow.status !== options.status) {
+        return false;
+      }
+      return true;
+    });
+    if (options?.offset !== void 0 || options?.limit !== void 0) {
+      const start = options.offset ?? 0;
+      const end = options.limit ? start + options.limit : void 0;
+      return workflows.slice(start, end);
+    }
+    return workflows;
+  }
+  /**
+   * Update existing workflow.
+   */
+  async update(id, spec) {
+    const stored = await this.loadWorkflow(id);
+    if (!stored) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    const updatedSpec = { ...stored.spec, ...spec };
+    const validated = WorkflowSpecSchema.parse(updatedSpec);
+    const updated = {
+      ...stored,
+      spec: validated,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.saveWorkflow(id, updated);
+    this.platform.logger?.info("WorkflowRepository: Updated workflow", {
+      id,
+      name: validated.name
+    });
+    return this.toRuntime(updated);
+  }
+  /**
+   * Delete workflow.
+   */
+  async delete(id) {
+    const path = this.getWorkflowPath(id);
+    try {
+      await this.platform.storage.delete(path);
+      this.platform.logger?.info("WorkflowRepository: Deleted workflow", { id });
+    } catch (error) {
+      this.platform.logger?.error(
+        "WorkflowRepository: Delete failed",
+        error instanceof Error ? error : void 0,
+        { id }
+      );
+      throw error;
+    }
+  }
+  /**
+   * Enable workflow (set status to active).
+   */
+  async enable(id) {
+    await this.updateStatus(id, "active");
+  }
+  /**
+   * Disable workflow.
+   */
+  async disable(id) {
+    await this.updateStatus(id, "disabled");
+  }
+  /**
+   * Pause workflow.
+   */
+  async pause(id) {
+    await this.updateStatus(id, "paused");
+  }
+  /**
+   * Resume workflow (unpause).
+   */
+  async resume(id) {
+    await this.updateStatus(id, "active");
+  }
+  /**
+   * Update workflow statistics.
+   */
+  async updateStats(id, stats) {
+    const stored = await this.loadWorkflow(id);
+    if (!stored) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    const updated = {
+      ...stored,
+      stats: { ...stored.stats, ...stats },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.saveWorkflow(id, updated);
+  }
+  // ============================================================================
+  // Private helpers
+  // ============================================================================
+  async updateStatus(id, status) {
+    const stored = await this.loadWorkflow(id);
+    if (!stored) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    const updated = {
+      ...stored,
+      status,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.saveWorkflow(id, updated);
+    this.platform.logger?.info("WorkflowRepository: Updated workflow status", {
+      id,
+      status
+    });
+  }
+  getWorkflowPath(id) {
+    const ymlPath = join(this.absoluteStorageDir, `${id}.yml`);
+    const yamlPath = join(this.absoluteStorageDir, `${id}.yaml`);
+    if (existsSync(ymlPath)) {
+      return ymlPath;
+    }
+    return yamlPath;
+  }
+  async saveWorkflow(id, workflow) {
+    const path = this.getWorkflowPath(id);
+    const yaml = stringify(workflow, { indent: 2 });
+    try {
+      if (!existsSync(this.absoluteStorageDir)) {
+        await mkdir(this.absoluteStorageDir, { recursive: true });
+      }
+      await writeFile(path, yaml, "utf-8");
+    } catch (error) {
+      this.platform.logger?.error(
+        "WorkflowRepository: Save failed",
+        error instanceof Error ? error : void 0,
+        { path }
+      );
+      throw error;
+    }
+  }
+  async loadWorkflow(id) {
+    const path = this.getWorkflowPath(id);
+    try {
+      if (!existsSync(path)) {
+        return null;
+      }
+      const content = await readFile(path, "utf-8");
+      const parsed = parse(content);
+      if (parsed.id && parsed.spec && parsed.createdAt) {
+        return parsed;
+      }
+      const spec = {
+        name: parsed.name,
+        version: parsed.version || "1.0.0",
+        description: parsed.description,
+        on: parsed.on || { manual: true },
+        isolation: parsed.isolation,
+        inputs: parsed.inputs,
+        jobs: parsed.jobs,
+        env: parsed.env,
+        secrets: parsed.secrets
+      };
+      const stored = {
+        id: parsed.id || id,
+        spec,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "active"
+      };
+      return stored;
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return null;
+      }
+      this.platform.logger?.error(
+        "WorkflowRepository: Load failed",
+        error instanceof Error ? error : void 0,
+        { path }
+      );
+      return null;
+    }
+  }
+  async listWorkflowFiles() {
+    try {
+      if (!existsSync(this.absoluteStorageDir)) {
+        return [];
+      }
+      const files = await readdir(this.absoluteStorageDir);
+      return files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return [];
+      }
+      this.platform.logger?.error(
+        "WorkflowRepository: List failed",
+        error instanceof Error ? error : void 0
+      );
+      return [];
+    }
+  }
+  /**
+   * Convert stored workflow to WorkflowRuntime format.
+   */
+  toRuntime(stored) {
+    const { id, spec, status, stats } = stored;
+    const triggers = [];
+    if (spec.on.manual) {
+      triggers.push({ type: "manual" });
+    }
+    if (spec.on.push) {
+      triggers.push({ type: "push" });
+    }
+    if (spec.on.webhook) {
+      triggers.push({
+        type: "webhook",
+        config: typeof spec.on.webhook === "object" ? spec.on.webhook : void 0
+      });
+    }
+    let schedule;
+    if (spec.on.schedule) {
+      triggers.push({
+        type: "schedule",
+        config: spec.on.schedule
+      });
+      schedule = {
+        cron: spec.on.schedule.cron,
+        enabled: status === "active"
+      };
+    }
+    const tags = ["standalone"];
+    if (spec.description) {
+      const hashtagMatches = spec.description.match(/#\w+/g);
+      if (hashtagMatches) {
+        tags.push(...hashtagMatches.map((t) => t.slice(1)));
+      }
+    }
+    return {
+      id,
+      source: "standalone",
+      name: spec.name,
+      description: spec.description,
+      tags,
+      triggers,
+      schedule,
+      status,
+      stats,
+      // Store full spec for execution
+      input: spec,
+      // Expose declared input schema for REST API / Studio UI
+      inputSchema: spec.inputs
+    };
+  }
+};
+var WorkflowService = class {
+  scanner;
+  repository;
+  platform;
+  constructor(options) {
+    this.platform = options.platform;
+    this.scanner = new ManifestScanner({
+      cliApi: options.cliApi,
+      platform: options.platform,
+      cacheTtlMs: options.manifestCacheTtlMs
+    });
+    this.repository = new WorkflowRepository({
+      platform: options.platform,
+      storageDir: options.workflowStorageDir,
+      workspaceRoot: options.workspaceRoot
+    });
+  }
+  /**
+   * List all workflows (manifest + standalone).
+   */
+  async listAll(options) {
+    const workflows = [];
+    if (!options?.source || options.source === "manifest") {
+      const manifestWorkflows = await this.scanner.scanPlugins();
+      workflows.push(...manifestWorkflows);
+    }
+    if (!options?.source || options.source === "standalone") {
+      const standaloneWorkflows = await this.repository.list(options);
+      workflows.push(...standaloneWorkflows);
+    }
+    let filtered = workflows;
+    if (options?.status) {
+      filtered = filtered.filter((w) => w.status === options.status);
+    }
+    if (options?.tags && options.tags.length > 0) {
+      filtered = filtered.filter(
+        (w) => options.tags.some((tag) => w.tags?.includes(tag))
+      );
+    }
+    filtered.sort((a, b) => a.name.localeCompare(b.name));
+    this.platform.logger?.debug("WorkflowService: Listed workflows", {
+      total: filtered.length,
+      manifest: filtered.filter((w) => w.source === "manifest").length,
+      standalone: filtered.filter((w) => w.source === "standalone").length
+    });
+    return filtered;
+  }
+  /**
+   * Get workflow by ID (from either source).
+   */
+  async get(id) {
+    const standalone = await this.repository.get(id);
+    if (standalone) {
+      return standalone;
+    }
+    const manifestWorkflows = await this.scanner.scanPlugins();
+    const manifest = manifestWorkflows.find((w) => w.id === id);
+    return manifest ?? null;
+  }
+  /**
+   * Create standalone workflow.
+   */
+  async create(spec) {
+    this.platform.logger?.info("WorkflowService: Creating workflow", {
+      name: spec.name
+    });
+    return this.repository.create(spec);
+  }
+  /**
+   * Update standalone workflow.
+   */
+  async update(id, spec) {
+    const workflow = await this.get(id);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    if (workflow.source !== "standalone") {
+      throw new Error(`Cannot update manifest-based workflow: ${id}`);
+    }
+    this.platform.logger?.info("WorkflowService: Updating workflow", { id });
+    return this.repository.update(id, spec);
+  }
+  /**
+   * Delete standalone workflow.
+   */
+  async delete(id) {
+    const workflow = await this.get(id);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    if (workflow.source !== "standalone") {
+      throw new Error(`Cannot delete manifest-based workflow: ${id}`);
+    }
+    this.platform.logger?.info("WorkflowService: Deleting workflow", { id });
+    await this.repository.delete(id);
+  }
+  /**
+   * Enable workflow (set status to active).
+   */
+  async enable(id) {
+    const workflow = await this.get(id);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    if (workflow.source !== "standalone") {
+      throw new Error(`Cannot enable manifest-based workflow: ${id}`);
+    }
+    await this.repository.enable(id);
+  }
+  /**
+   * Disable workflow.
+   */
+  async disable(id) {
+    const workflow = await this.get(id);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    if (workflow.source !== "standalone") {
+      throw new Error(`Cannot disable manifest-based workflow: ${id}`);
+    }
+    await this.repository.disable(id);
+  }
+  /**
+   * Pause workflow.
+   */
+  async pause(id) {
+    const workflow = await this.get(id);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    if (workflow.source !== "standalone") {
+      throw new Error(`Cannot pause manifest-based workflow: ${id}`);
+    }
+    await this.repository.pause(id);
+  }
+  /**
+   * Resume workflow (unpause).
+   */
+  async resume(id) {
+    const workflow = await this.get(id);
+    if (!workflow) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    if (workflow.source !== "standalone") {
+      throw new Error(`Cannot resume manifest-based workflow: ${id}`);
+    }
+    await this.repository.resume(id);
+  }
+  /**
+   * Get available workflow handlers (for UI autocomplete).
+   *
+   * Returns manifest-based handlers that can be used in standalone workflows
+   * (via `uses: "plugin:id/handler"`).
+   */
+  async getAvailableHandlers() {
+    const manifestWorkflows = await this.scanner.scanPlugins();
+    const handlers = manifestWorkflows.filter((w) => w.source === "manifest" && w.handler).map((w) => ({
+      id: w.id,
+      pluginId: w.pluginId,
+      name: w.name,
+      description: w.description,
+      inputSchema: w.input,
+      outputSchema: w.output
+    }));
+    this.platform.logger?.debug("WorkflowService: Listed handlers", {
+      count: handlers.length
+    });
+    return handlers;
+  }
+  /**
+   * Validate workflow spec.
+   */
+  validate(spec) {
+    try {
+      WorkflowSpecSchema.parse(spec);
+      return { valid: true };
+    } catch (error) {
+      if (error && typeof error === "object" && "errors" in error) {
+        const zodError = error;
+        return {
+          valid: false,
+          errors: zodError.errors.map((e) => ({
+            path: e.path.join("."),
+            message: e.message
+          }))
+        };
+      }
+      return {
+        valid: false,
+        errors: [{ path: "", message: "Validation failed" }]
+      };
+    }
+  }
+  /**
+   * Refresh manifest scanner cache (force re-scan).
+   */
+  async refreshManifests() {
+    await this.scanner.clearCache();
+    this.platform.logger?.info("WorkflowService: Manifest cache cleared");
+  }
+};
+
+// src/workflow-schedule-manager.ts
+var WorkflowScheduleManager = class {
+  cronManager;
+  workflowService;
+  executor;
+  platform;
+  constructor(options) {
+    this.cronManager = options.cronManager;
+    this.workflowService = options.workflowService;
+    this.executor = options.executor;
+    this.platform = options.platform;
+  }
+  /**
+   * Register all scheduled workflows with CronManager.
+   *
+   * Scans both manifest-based jobs and standalone workflows with schedules.
+   */
+  async registerAll() {
+    const workflows = await this.workflowService.listAll();
+    const scheduled = workflows.filter(
+      (w) => w.schedule && w.schedule.enabled && w.status === "active"
+    );
+    this.platform.logger?.info("WorkflowScheduleManager: Registering scheduled workflows", {
+      total: workflows.length,
+      scheduled: scheduled.length
+    });
+    await Promise.all(scheduled.map((workflow) => this.register(workflow)));
+  }
+  /**
+   * Register single workflow schedule.
+   */
+  async register(workflow) {
+    if (!workflow.schedule || !workflow.schedule.enabled) {
+      this.platform.logger?.warn("WorkflowScheduleManager: Cannot register workflow without schedule", {
+        id: workflow.id
+      });
+      return;
+    }
+    const cronId = this.getCronId(workflow.id);
+    const schedule = workflow.schedule.cron;
+    this.cronManager.register(cronId, schedule, async (context) => {
+      this.platform.logger?.info("WorkflowScheduleManager: Executing scheduled workflow", {
+        workflowId: workflow.id,
+        workflowName: workflow.name,
+        runCount: context.runCount
+      });
+      try {
+        const result = await this.executor.execute({
+          workflowId: workflow.id,
+          trigger: "schedule",
+          input: {}
+        });
+        this.platform.logger?.info("WorkflowScheduleManager: Workflow execution started", {
+          workflowId: workflow.id,
+          runId: result.runId
+        });
+      } catch (error) {
+        this.platform.logger?.error(
+          "WorkflowScheduleManager: Workflow execution failed",
+          error instanceof Error ? error : void 0,
+          {
+            workflowId: workflow.id,
+            workflowName: workflow.name
+          }
+        );
+      }
+    });
+    this.platform.logger?.debug("WorkflowScheduleManager: Registered workflow", {
+      workflowId: workflow.id,
+      schedule
+    });
+  }
+  /**
+   * Unregister workflow schedule.
+   */
+  async unregister(workflowId) {
+    const cronId = this.getCronId(workflowId);
+    this.cronManager.unregister(cronId);
+    this.platform.logger?.debug("WorkflowScheduleManager: Unregistered workflow", {
+      workflowId
+    });
+  }
+  /**
+   * Re-register all schedules (refresh).
+   *
+   * Useful after workflow changes or service restart.
+   */
+  async refresh() {
+    const allJobs = this.cronManager.list();
+    for (const job of allJobs) {
+      if (job.id.startsWith("workflow:")) {
+        this.cronManager.unregister(job.id);
+      }
+    }
+    await this.registerAll();
+    this.platform.logger?.info("WorkflowScheduleManager: Refreshed all schedules");
+  }
+  /**
+   * Get next run time for scheduled workflow.
+   */
+  getNextRun(workflowId) {
+    const cronId = this.getCronId(workflowId);
+    const job = this.cronManager.list().find((j) => j.id === cronId);
+    return job?.nextRun ?? null;
+  }
+  /**
+   * Get last run time for scheduled workflow.
+   */
+  getLastRun(workflowId) {
+    const cronId = this.getCronId(workflowId);
+    const job = this.cronManager.list().find((j) => j.id === cronId);
+    return job?.lastRun ?? null;
+  }
+  /**
+   * Pause scheduled workflow.
+   */
+  pause(workflowId) {
+    const cronId = this.getCronId(workflowId);
+    this.cronManager.pause(cronId);
+    this.platform.logger?.info("WorkflowScheduleManager: Paused workflow schedule", {
+      workflowId
+    });
+  }
+  /**
+   * Resume paused workflow schedule.
+   */
+  resume(workflowId) {
+    const cronId = this.getCronId(workflowId);
+    this.cronManager.resume(cronId);
+    this.platform.logger?.info("WorkflowScheduleManager: Resumed workflow schedule", {
+      workflowId
+    });
+  }
+  /**
+   * List all scheduled workflows.
+   */
+  listScheduled() {
+    return this.cronManager.list().filter((job) => job.id.startsWith("workflow:")).map((job) => ({
+      workflowId: this.getWorkflowId(job.id),
+      schedule: job.schedule,
+      status: job.status,
+      lastRun: job.lastRun,
+      nextRun: job.nextRun,
+      runCount: job.runCount
+    }));
+  }
+  // ============================================================================
+  // Private helpers
+  // ============================================================================
+  getCronId(workflowId) {
+    return `workflow:${workflowId}`;
+  }
+  getWorkflowId(cronId) {
+    return cronId.replace("workflow:", "");
+  }
+};
+var WorkflowRegistry = class {
+  constructor(options) {
+    this.options = options;
+    this.loader = new WorkflowLoader(options.logger);
+  }
+  entries = /* @__PURE__ */ new Map();
+  loader;
+  /**
+   * Scan configured directories and index all workflow files
+   */
+  async scan() {
+    this.entries.clear();
+    const cwd = this.options.cwd ?? process.cwd();
+    this.options.logger.info("Starting workflow discovery", {
+      scanDirs: this.options.scanDirs,
+      cwd
+    });
+    for (const dir of this.options.scanDirs) {
+      const absoluteDir = resolve(cwd, dir);
+      if (!existsSync(absoluteDir)) {
+        this.options.logger.debug(`Directory not found, skipping`, { dir: absoluteDir });
+        continue;
+      }
+      try {
+        const files = await readdir(absoluteDir);
+        const yamlFiles = files.filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+        this.options.logger.debug(`Found workflow files`, {
+          dir: absoluteDir,
+          count: yamlFiles.length
+        });
+        await Promise.all(
+          // eslint-disable-line no-await-in-loop
+          yamlFiles.map((file) => {
+            const filePath = join(absoluteDir, file);
+            return this.indexFile(filePath);
+          })
+        );
+      } catch (error) {
+        this.options.logger.warn(`Failed to scan directory`, {
+          dir: absoluteDir,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    this.options.logger.info("Workflow discovery complete", {
+      totalWorkflows: this.entries.size,
+      ids: Array.from(this.entries.keys())
+    });
+  }
+  /**
+   * Index a single workflow file
+   */
+  async indexFile(filePath) {
+    try {
+      const raw = await readFile(filePath, "utf8");
+      const parsed = this.parseWorkflowFile(raw);
+      const id = parsed.id || basename(filePath, ".yml").replace(".yaml", "");
+      const spec = {
+        name: parsed.name,
+        version: "1.0.0",
+        description: parsed.description,
+        on: parsed.on || { manual: true },
+        // Default to manual trigger if not specified
+        isolation: parsed.isolation,
+        jobs: parsed.jobs,
+        env: parsed.env,
+        secrets: parsed.secrets
+      };
+      const entry = {
+        id,
+        name: parsed.name,
+        description: parsed.description,
+        filePath,
+        spec,
+        metadata: parsed.metadata
+      };
+      this.entries.set(id, entry);
+      this.options.logger.debug(`Indexed workflow`, {
+        id,
+        name: parsed.name,
+        filePath
+      });
+    } catch (error) {
+      this.options.logger.warn(`Failed to index workflow file`, {
+        filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Parse workflow file (YAML format with additional fields)
+   */
+  parseWorkflowFile(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      throw new Error("Workflow file is empty");
+    }
+    const { parse } = __require("yaml");
+    return parse(trimmed);
+  }
+  /**
+   * Get workflow by ID
+   */
+  get(id) {
+    return this.entries.get(id);
+  }
+  /**
+   * List all registered workflows
+   */
+  list() {
+    return Array.from(this.entries.values());
+  }
+  /**
+   * Check if workflow exists
+   */
+  has(id) {
+    return this.entries.has(id);
+  }
+  /**
+   * Get workflow spec by ID
+   */
+  getSpec(id) {
+    const entry = this.entries.get(id);
+    return entry?.spec;
+  }
+  /**
+   * Clear all indexed workflows
+   */
+  clear() {
+    this.entries.clear();
+  }
+};
+var JobManager = class {
+  constructor(cache, events, logger, config = {}) {
+    this.cache = cache;
+    this.events = events;
+    this.logger = logger;
+    this.config = config;
+    this.defaultTimeout = config.defaultTimeout ?? 3e5;
+    this.defaultMaxRetries = config.defaultMaxRetries ?? 3;
+    this.defaultPriority = config.defaultPriority ?? 50;
+    this.workspaceRoot = config.workspaceRoot ?? process.cwd();
+  }
+  handlerRegistry = /* @__PURE__ */ new Map();
+  defaultTimeout;
+  defaultMaxRetries;
+  defaultPriority;
+  workspaceRoot;
+  /**
+   * Register job handler from plugin manifest.
+   *
+   * Called by plugin-runtime during plugin initialization.
+   *
+   * @param pluginId - Plugin identifier
+   * @param pluginVersion - Plugin version
+   * @param pluginRoot - Plugin root directory
+   * @param handlerDecl - Job handler declaration from manifest
+   */
+  registerJobHandler(pluginId, pluginVersion, pluginRoot, handlerDecl) {
+    const jobType = `${pluginId}:${handlerDecl.id}`;
+    if (this.handlerRegistry.has(jobType)) {
+      this.logger.warn("Job handler already registered, overwriting", {
+        jobType,
+        pluginId,
+        jobId: handlerDecl.id
+      });
+    }
+    this.handlerRegistry.set(jobType, {
+      pluginId,
+      jobId: handlerDecl.id,
+      handlerPath: handlerDecl.handler,
+      config: handlerDecl,
+      pluginRoot,
+      pluginVersion
+    });
+    this.logger.info("Registered job handler", {
+      jobType,
+      handler: handlerDecl.handler
+    });
+  }
+  /**
+   * Submit a job for immediate execution.
+   */
+  async submit(job) {
+    const handlerEntry = this.handlerRegistry.get(job.type);
+    if (!handlerEntry) {
+      throw new Error(`Job handler not found: ${job.type}`);
+    }
+    if (job.idempotencyKey) {
+      const existing = await this.findByIdempotencyKey(job.idempotencyKey);
+      if (existing) {
+        this.logger.info("Job already submitted (idempotent)", {
+          idempotencyKey: job.idempotencyKey,
+          existingJobId: existing.id
+        });
+        return this.jobRecordToHandle(existing);
+      }
+    }
+    const jobId = nanoid();
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      id: jobId,
+      type: job.type,
+      payload: job.payload,
+      tenantId: job.tenantId ?? "default",
+      status: "pending",
+      priority: job.priority ?? this.defaultPriority,
+      maxRetries: job.maxRetries ?? handlerEntry.config.maxRetries ?? this.defaultMaxRetries,
+      timeout: job.timeout ?? handlerEntry.config.timeout ?? this.defaultTimeout,
+      attempt: 0,
+      progress: 0,
+      createdAt: now.toISOString(),
+      runAt: job.runAt?.toISOString(),
+      idempotencyKey: job.idempotencyKey
+    };
+    await this.saveJobRecord(record);
+    const availableAt = job.runAt ? job.runAt.getTime() : Date.now();
+    await this.enqueueJob(jobId, record.priority, availableAt);
+    this.logger.info("Job submitted", {
+      jobId,
+      type: job.type,
+      tenantId: record.tenantId,
+      priority: record.priority
+    });
+    await this.events.publish("job.submitted", {
+      jobId,
+      type: job.type,
+      tenantId: record.tenantId
+    });
+    return this.jobRecordToHandle(record);
+  }
+  /**
+   * Schedule a job for future/recurring execution.
+   */
+  async schedule(job, schedule) {
+    if (schedule instanceof Date) {
+      return this.submit({ ...job, runAt: schedule });
+    }
+    throw new Error("Cron scheduling not yet implemented");
+  }
+  /**
+   * Cancel a pending/running job.
+   */
+  async cancel(jobId) {
+    const record = await this.getJobRecord(jobId);
+    if (!record) {
+      return false;
+    }
+    if (record.status === "completed" || record.status === "failed" || record.status === "cancelled") {
+      this.logger.warn("Cannot cancel job in terminal state", {
+        jobId,
+        status: record.status
+      });
+      return false;
+    }
+    record.status = "cancelled";
+    record.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.saveJobRecord(record);
+    await this.removeFromQueue(jobId);
+    this.logger.info("Job cancelled", { jobId });
+    await this.events.publish("job.cancelled", {
+      jobId,
+      type: record.type,
+      tenantId: record.tenantId
+    });
+    return true;
+  }
+  /**
+   * Get job status.
+   */
+  async getStatus(jobId) {
+    const record = await this.getJobRecord(jobId);
+    if (!record) {
+      return null;
+    }
+    return this.jobRecordToHandle(record);
+  }
+  /**
+   * List jobs.
+   */
+  async list(filter = {}) {
+    const pattern = "kb:job:*";
+    const keys = await this.getAllJobKeys(pattern);
+    const allRecords = await Promise.all(keys.map((key) => this.cache.get(key)));
+    const records = allRecords.filter((data) => {
+      if (!data) {
+        return false;
+      }
+      if (filter.type && data.type !== filter.type) {
+        return false;
+      }
+      if (filter.tenantId && data.tenantId !== filter.tenantId) {
+        return false;
+      }
+      if (filter.status && data.status !== filter.status) {
+        return false;
+      }
+      return true;
+    });
+    records.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const offset = filter.offset ?? 0;
+    const limit = filter.limit ?? 100;
+    const page = records.slice(offset, offset + limit);
+    return page.map((r) => this.jobRecordToHandle(r));
+  }
+  /**
+   * Execute a job (called by worker).
+   *
+   * @internal
+   */
+  async executeJob(jobId) {
+    const record = await this.getJobRecord(jobId);
+    if (!record) {
+      this.logger.error("Job not found for execution", void 0, { jobId });
+      return;
+    }
+    const handlerEntry = this.handlerRegistry.get(record.type);
+    if (!handlerEntry) {
+      this.logger.error("Job handler not found", void 0, { jobId, type: record.type });
+      await this.markJobFailed(record, "Handler not found");
+      return;
+    }
+    if (!this.config.executionBackend) {
+      this.logger.error("ExecutionBackend not configured", void 0, { jobId });
+      await this.markJobFailed(record, "ExecutionBackend not configured");
+      return;
+    }
+    record.status = "running";
+    record.attempt += 1;
+    record.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.saveJobRecord(record);
+    await this.events.publish("job.started", {
+      jobId,
+      type: record.type,
+      tenantId: record.tenantId,
+      attempt: record.attempt
+    });
+    try {
+      const executionId = `job-${jobId}-${record.attempt}`;
+      const traceId = executionId;
+      const spanId = executionId;
+      const invocationId = executionId;
+      const descriptor = {
+        hostType: "cron",
+        hostContext: {
+          host: "cron",
+          cronId: record.type,
+          schedule: "",
+          // Not available in job context
+          scheduledAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        permissions: handlerEntry.config.permissions ?? {},
+        pluginId: handlerEntry.pluginId,
+        pluginVersion: "0.0.0",
+        // TODO: Get from manifest
+        requestId: executionId,
+        tenantId: record.tenantId
+      };
+      Object.assign(descriptor, {
+        traceId,
+        spanId,
+        invocationId,
+        executionId
+      });
+      const request = {
+        executionId,
+        descriptor,
+        pluginRoot: handlerEntry.pluginRoot,
+        handlerRef: handlerEntry.handlerPath,
+        input: {
+          jobId,
+          type: record.type,
+          input: record.payload,
+          tenantId: record.tenantId,
+          attempt: record.attempt
+        },
+        timeoutMs: record.timeout
+      };
+      this.logger.debug("Executing job handler", {
+        jobId,
+        handler: handlerEntry.handlerPath,
+        attempt: record.attempt
+      });
+      const result = await this.config.executionBackend.execute(request, {
+        signal: void 0
+        // TODO: Support cancellation
+      });
+      if (result.ok) {
+        record.status = "completed";
+        record.result = result.data;
+        record.progress = 100;
+        record.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await this.saveJobRecord(record);
+        this.logger.info("Job completed", {
+          jobId,
+          type: record.type,
+          duration: result.executionTimeMs
+        });
+        await this.events.publish("job.completed", {
+          jobId,
+          type: record.type,
+          tenantId: record.tenantId,
+          result: result.data
+        });
+      } else {
+        const errorMsg = result.error?.message ?? "Unknown error";
+        await this.handleJobFailure(record, errorMsg);
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.logger.error("Job execution failed", void 0, { jobId, error: errorMsg });
+      await this.handleJobFailure(record, errorMsg);
+    }
+  }
+  /**
+   * Update job progress.
+   *
+   * Called by job handler via ctx.updateProgress()
+   */
+  async updateProgress(jobId, percent, message) {
+    const record = await this.getJobRecord(jobId);
+    if (!record) {
+      this.logger.warn("Cannot update progress: job not found", { jobId });
+      return;
+    }
+    record.progress = Math.max(0, Math.min(100, percent));
+    await this.saveJobRecord(record);
+    await this.events.publish("job.progress", {
+      jobId,
+      type: record.type,
+      tenantId: record.tenantId,
+      progress: record.progress,
+      message
+    });
+  }
+  // ============================================================================
+  // Private helpers
+  // ============================================================================
+  async handleJobFailure(record, errorMsg) {
+    if (record.attempt < record.maxRetries) {
+      const backoffMs = this.calculateBackoff(record.attempt, record.type);
+      const availableAt = Date.now() + backoffMs;
+      record.status = "pending";
+      await this.saveJobRecord(record);
+      await this.enqueueJob(record.id, record.priority, availableAt);
+      this.logger.info("Job retry scheduled", {
+        jobId: record.id,
+        attempt: record.attempt,
+        maxRetries: record.maxRetries,
+        backoffMs
+      });
+      await this.events.publish("job.retry", {
+        jobId: record.id,
+        type: record.type,
+        tenantId: record.tenantId,
+        attempt: record.attempt,
+        backoffMs
+      });
+    } else {
+      await this.markJobFailed(record, errorMsg);
+    }
+  }
+  async markJobFailed(record, errorMsg) {
+    record.status = "failed";
+    record.error = errorMsg;
+    record.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.saveJobRecord(record);
+    this.logger.error("Job failed", void 0, {
+      jobId: record.id,
+      type: record.type,
+      error: errorMsg,
+      attempt: record.attempt
+    });
+    await this.events.publish("job.failed", {
+      jobId: record.id,
+      type: record.type,
+      tenantId: record.tenantId,
+      error: errorMsg
+    });
+  }
+  calculateBackoff(attempt, jobType) {
+    const handlerEntry = this.handlerRegistry.get(jobType);
+    const strategy = handlerEntry?.config.retryBackoff ?? "exp";
+    if (strategy === "exp") {
+      return Math.min(1e3 * Math.pow(2, attempt), 6e4);
+    } else {
+      return Math.min(5e3 * (attempt + 1), 6e4);
+    }
+  }
+  async saveJobRecord(record) {
+    const key = `kb:job:${record.id}`;
+    await this.cache.set(key, record, 7 * 24 * 60 * 60 * 1e3);
+  }
+  async getJobRecord(jobId) {
+    const key = `kb:job:${jobId}`;
+    return this.cache.get(key);
+  }
+  async enqueueJob(jobId, priority, availableAt) {
+    const entry = {
+      jobId,
+      priority,
+      availableAt
+    };
+    await this.cache.zadd("kb:jobqueue", availableAt, JSON.stringify(entry));
+  }
+  async removeFromQueue(jobId) {
+    const results = await this.cache.zrangebyscore("kb:jobqueue", 0, Date.now() + 1e6);
+    for (const raw of results) {
+      try {
+        const entry = JSON.parse(raw);
+        if (entry.jobId === jobId) {
+          await this.cache.zrem("kb:jobqueue", raw);
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  async findByIdempotencyKey(key) {
+    const pattern = "kb:job:*";
+    const keys = await this.getAllJobKeys(pattern);
+    const records = await Promise.all(keys.map((k) => this.cache.get(k)));
+    return records.find((record) => record?.idempotencyKey === key) ?? null;
+  }
+  async getAllJobKeys(_pattern) {
+    return [];
+  }
+  jobRecordToHandle(record) {
+    return {
+      id: record.id,
+      type: record.type,
+      tenantId: record.tenantId,
+      status: record.status,
+      progress: record.progress,
+      result: record.result,
+      error: record.error,
+      createdAt: new Date(record.createdAt),
+      startedAt: record.startedAt ? new Date(record.startedAt) : void 0,
+      completedAt: record.completedAt ? new Date(record.completedAt) : void 0
+    };
+  }
+};
+
+export { ArtifactMerger, ConcurrencyManager, EnvSecretProvider, EventBusBridge, JobManager, ManifestScanner, RunCoordinator, RunSnapshotStorage, Scheduler, StateStore, WorkflowEngine, WorkflowLoader, WorkflowRegistry, WorkflowRepository, WorkflowScheduleManager, WorkflowService, calculateBackoff, createDefaultSecretProvider, shouldRetry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map