@kb-labs/workflow-runtime 1.1.0

package/dist/index.js

@@ -0,0 +1,873 @@
+import { resolve, dirname, join, relative } from 'path';
+import { access, readFile, mkdir, writeFile } from 'fs/promises';
+import { execaCommand } from 'execa';
+import { randomUUID } from 'crypto';
+import { getHandlerPermissions } from '@kb-labs/plugin-contracts';
+import { z } from 'zod';
+import fg from 'fast-glob';
+import { parse } from 'yaml';
+import { WorkflowSpecSchema } from '@kb-labs/workflow-contracts';
+export { FileSystemArtifactClient, createFileSystemArtifactClient } from '@kb-labs/workflow-artifacts';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/registry/plugin-workflows.ts
+var plugin_workflows_exports = {};
+__export(plugin_workflows_exports, {
+  extractWorkflows: () => extractWorkflows,
+  findWorkflow: () => findWorkflow
+});
+function extractSnapshotManifests(snapshot) {
+  return (snapshot.manifests || []).map((entry) => ({
+    pluginId: entry.pluginId,
+    manifest: entry.manifest,
+    pluginRoot: entry.pluginRoot
+  }));
+}
+async function extractWorkflows(snapshot) {
+  const manifests = extractSnapshotManifests(snapshot);
+  const workflows = [];
+  for (const entry of manifests) {
+    const { manifest, pluginRoot } = entry;
+    const workflowHandlers = manifest.workflows?.handlers ?? [];
+    if (workflowHandlers.length === 0) {
+      continue;
+    }
+    let packageRoot = pluginRoot;
+    let currentDir = resolve(pluginRoot);
+    while (currentDir !== dirname(currentDir)) {
+      try {
+        const pkgPath = join(currentDir, "package.json");
+        await access(pkgPath);
+        packageRoot = currentDir;
+        break;
+      } catch {
+        currentDir = dirname(currentDir);
+      }
+    }
+    for (const wfHandler of workflowHandlers) {
+      const id = `plugin:${entry.pluginId}/${wfHandler.id}`;
+      const filePath = resolve(packageRoot, wfHandler.handler);
+      workflows.push({
+        id,
+        source: "plugin",
+        filePath,
+        description: wfHandler.describe,
+        tags: void 0,
+        // V3 doesn't have tags on workflow handlers
+        metadata: {
+          pluginId: entry.pluginId,
+          pluginVersion: manifest.version
+        }
+      });
+    }
+  }
+  return workflows;
+}
+async function findWorkflow(snapshot, id) {
+  const cleanId = id.startsWith("plugin:") ? id.slice("plugin:".length) : id;
+  const workflows = await extractWorkflows(snapshot);
+  return workflows.find((w) => w.id === id || w.id.endsWith(":" + cleanId)) ?? null;
+}
+var init_plugin_workflows = __esm({
+  "src/registry/plugin-workflows.ts"() {
+  }
+});
+
+// src/context.ts
+function createStepContext(input) {
+  return {
+    runId: input.runId,
+    jobId: input.jobId,
+    stepId: input.stepId,
+    attempt: input.attempt ?? 0,
+    env: { ...process.env, ...input.env ?? {} },
+    secrets: input.secrets ?? {},
+    artifacts: input.artifacts,
+    events: input.events,
+    logger: input.logger,
+    // Use provided logger (platform.logger)
+    trace: input.trace
+  };
+}
+function resolveCommand(step) {
+  const withBlock = step.with ?? {};
+  const commandField = withBlock.command ?? withBlock.run ?? withBlock.script;
+  return typeof commandField === "string" ? commandField : null;
+}
+var LocalRunner = class {
+  shell;
+  constructor(options = {}) {
+    this.shell = options.shell ?? process.env.SHELL ?? "bash";
+  }
+  async execute(request) {
+    const { spec, context } = request;
+    const command = resolveCommand(spec);
+    if (spec.uses && spec.uses !== "builtin:shell") {
+      context.logger.error(`LocalRunner cannot execute ${spec.uses}`, {
+        stepId: context.stepId
+      });
+      return {
+        status: "failed",
+        error: {
+          message: `Local runner cannot execute step with uses="${spec.uses}"`,
+          code: "UNSUPPORTED_STEP"
+        }
+      };
+    }
+    if (!command) {
+      context.logger.error("LocalRunner missing command", {
+        stepId: context.stepId
+      });
+      return {
+        status: "failed",
+        error: {
+          message: 'Local runner requires "with.command" (or with.run/with.script) to be specified',
+          code: "INVALID_STEP"
+        }
+      };
+    }
+    const cwd = request.workspace ?? process.cwd();
+    const env = {
+      ...process.env,
+      ...context.env,
+      ...context.secrets
+    };
+    if (request.signal?.aborted) {
+      return buildCancelledResult(request.signal);
+    }
+    context.logger.info("Executing builtin shell step", {
+      command,
+      cwd,
+      stepId: context.stepId
+    });
+    try {
+      const result = await execaCommand(command, {
+        cwd,
+        shell: this.shell,
+        env,
+        stdio: "pipe",
+        signal: request.signal
+      });
+      context.logger.info("Shell step completed", {
+        stepId: context.stepId,
+        exitCode: result.exitCode
+      });
+      return {
+        status: "success",
+        outputs: {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: result.exitCode
+        }
+      };
+    } catch (error) {
+      if (request.signal?.aborted) {
+        return buildCancelledResult(request.signal, error);
+      }
+      const message = error instanceof Error ? error.message : "Shell step failed";
+      const exitCode = typeof error?.exitCode === "number" ? error.exitCode : void 0;
+      context.logger.error("Shell step failed", {
+        stepId: context.stepId,
+        error: message,
+        exitCode
+      });
+      return {
+        status: "failed",
+        error: {
+          message,
+          code: "STEP_EXECUTION_FAILED",
+          details: {
+            exitCode
+          }
+        }
+      };
+    }
+  }
+};
+function buildCancelledResult(signal, error) {
+  const reason = error instanceof Error ? error.message : signalReason(signal) ?? "Step execution cancelled";
+  return {
+    status: "cancelled",
+    error: {
+      message: reason,
+      code: "STEP_CANCELLED"
+    }
+  };
+}
+function signalReason(signal) {
+  if (!signal.aborted) {
+    return void 0;
+  }
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    return reason.message;
+  }
+  if (typeof reason === "string") {
+    return reason;
+  }
+  return void 0;
+}
+
+// src/runners/output-normalizer.ts
+function isCommandResult(value) {
+  return typeof value === "object" && value !== null && "exitCode" in value && "result" in value && typeof value.exitCode === "number";
+}
+function toWorkflowOutputs(data) {
+  if (isCommandResult(data)) {
+    const inner = data.result;
+    if (typeof inner === "object" && inner !== null) {
+      return inner;
+    }
+    return inner !== void 0 && inner !== null ? { result: inner } : {};
+  }
+  if (typeof data === "object" && data !== null) {
+    return data;
+  }
+  if (data !== void 0 && data !== null) {
+    return { result: data };
+  }
+  return {};
+}
+
+// src/runners/sandbox-runner.ts
+var SandboxRunner = class {
+  backend;
+  cliApi;
+  workspaceRoot;
+  defaultTimeout;
+  analytics;
+  logger;
+  constructor(options) {
+    this.backend = options.backend;
+    this.cliApi = options.cliApi;
+    this.workspaceRoot = options.workspaceRoot ?? process.cwd();
+    this.defaultTimeout = options.defaultTimeout ?? 12e4;
+    this.analytics = options.analytics;
+  }
+  async execute(request) {
+    const { spec, context, signal } = request;
+    const startTime = Date.now();
+    if (signal?.aborted) {
+      return buildCancelledResult2(signal);
+    }
+    if (!spec.uses) {
+      return this.buildValidationError(context, 'Sandbox runner requires "uses" field to specify plugin handler');
+    }
+    const resolution = await this.tryResolveCommand(spec, request, context);
+    if (!resolution.ok) {
+      return resolution.error;
+    }
+    const executionRequest = this.buildExecutionRequest(resolution.value, request, context);
+    context.logger.info("Executing plugin handler", {
+      stepId: context.stepId,
+      pluginId: resolution.value.pluginId,
+      handler: resolution.value.handler,
+      executionId: executionRequest.executionId
+    });
+    this.analytics?.track("workflow.sandbox.execution.started", {
+      stepId: context.stepId,
+      pluginId: resolution.value.pluginId,
+      handler: resolution.value.handler,
+      uses: spec.uses
+    }).catch(() => {
+    });
+    const result = await this.backend.execute(executionRequest, { signal, onLog: context.onLog });
+    const duration = Date.now() - startTime;
+    if (result.ok) {
+      this.analytics?.track("workflow.sandbox.execution.completed", {
+        stepId: context.stepId,
+        pluginId: resolution.value.pluginId,
+        handler: resolution.value.handler,
+        durationMs: duration
+      }).catch(() => {
+      });
+    } else {
+      this.analytics?.track("workflow.sandbox.execution.failed", {
+        stepId: context.stepId,
+        pluginId: resolution.value.pluginId,
+        handler: resolution.value.handler,
+        errorCode: result.error?.code,
+        errorMessage: result.error?.message,
+        durationMs: duration
+      }).catch(() => {
+      });
+    }
+    return this.mapExecutionResult(result, executionRequest.executionId, context, signal);
+  }
+  /**
+   * Validate step spec and build error result if invalid
+   */
+  buildValidationError(context, message) {
+    context.logger.error("SandboxRunner validation failed", { stepId: context.stepId, message });
+    return {
+      status: "failed",
+      error: { message, code: "INVALID_STEP" }
+    };
+  }
+  /**
+   * Try to resolve command, returning result wrapper
+   */
+  async tryResolveCommand(spec, request, context) {
+    try {
+      const resolution = await this.resolveCommand(spec, request);
+      return { ok: true, value: resolution };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to resolve plugin command";
+      context.logger.error("Plugin command resolution failed", {
+        stepId: context.stepId,
+        uses: spec.uses,
+        error: message
+      });
+      return {
+        ok: false,
+        error: {
+          status: "failed",
+          error: { message, code: "COMMAND_RESOLUTION_FAILED" }
+        }
+      };
+    }
+  }
+  /**
+   * Build ExecutionRequest from resolved command
+   */
+  buildExecutionRequest(resolution, request, context) {
+    const requestId = context.trace?.traceId ?? randomUUID();
+    const traceId = context.trace?.traceId ?? requestId;
+    const executionId = `exec_${context.stepId}_${Date.now()}_${randomUUID().slice(0, 8)}`;
+    const spanId = executionId;
+    const invocationId = executionId;
+    const hostContext = {
+      host: "workflow",
+      workflowId: context.runId,
+      runId: context.runId,
+      jobId: context.jobId,
+      stepId: context.stepId,
+      attempt: context.attempt,
+      input: resolution.input
+    };
+    const descriptor = {
+      hostType: "workflow",
+      pluginId: resolution.pluginId,
+      pluginVersion: resolution.pluginVersion,
+      requestId,
+      permissions: resolution.permissions,
+      hostContext,
+      configSection: resolution.configSection
+      // For useConfig() auto-detection
+    };
+    Object.assign(descriptor, {
+      traceId,
+      spanId,
+      invocationId,
+      executionId
+    });
+    return {
+      executionId,
+      descriptor,
+      pluginRoot: resolution.pluginRoot,
+      handlerRef: resolution.handler,
+      input: resolution.input,
+      workspace: request.workspace ? {
+        type: "local",
+        cwd: request.workspace
+      } : void 0,
+      timeoutMs: resolution.permissions.quotas?.timeoutMs ?? this.defaultTimeout,
+      target: request.target
+    };
+  }
+  /**
+   * Map ExecutionResult to StepExecutionResult
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity -- Result mapping logic: handles success/failure/cancelled states, conditional stdout/stderr logging, debug metadata extraction, and error code translation
+  mapExecutionResult(result, executionId, context, signal) {
+    if (result.ok) {
+      const data = result.data;
+      context.logger.debug("mapExecutionResult received data", {
+        stepId: context.stepId,
+        executionId,
+        dataType: typeof data,
+        dataKeys: data && typeof data === "object" ? Object.keys(data) : [],
+        hasStdout: !!(data && typeof data === "object" && data.stdout),
+        hasStderr: !!(data && typeof data === "object" && data.stderr)
+      });
+      const logMeta = {
+        stepId: context.stepId,
+        executionId,
+        executionTimeMs: result.executionTimeMs
+      };
+      if (data && typeof data === "object") {
+        if (data.stdout) {
+          logMeta.stdout = data.stdout;
+        }
+        if (data.stderr) {
+          logMeta.stderr = data.stderr;
+        }
+        if (data.exitCode !== void 0) {
+          logMeta.exitCode = data.exitCode;
+        }
+      }
+      context.logger.info("Plugin handler completed", logMeta);
+      if (data && typeof data === "object" && data.ok === false) {
+        const message = data.stderr ? String(data.stderr).slice(0, 500) : `Step handler reported failure (exitCode: ${data.exitCode ?? "unknown"})`;
+        context.logger.error("Plugin handler reported failure via ok:false", {
+          stepId: context.stepId,
+          exitCode: data.exitCode,
+          stderr: data.stderr
+        });
+        return {
+          status: "failed",
+          error: {
+            message,
+            code: "HANDLER_REPORTED_FAILURE"
+          }
+        };
+      }
+      return {
+        status: "success",
+        outputs: toWorkflowOutputs(result.data)
+      };
+    }
+    if (signal?.aborted || result.error?.code === "ABORTED") {
+      return buildCancelledResult2(signal, result.error);
+    }
+    context.logger.error("Plugin handler failed", {
+      stepId: context.stepId,
+      executionId,
+      error: result.error?.message,
+      code: result.error?.code
+    });
+    return {
+      status: "failed",
+      error: {
+        message: result.error?.message ?? "Plugin execution failed",
+        code: result.error?.code ?? "UNKNOWN_ERROR",
+        stack: result.error?.stack,
+        details: result.error?.details
+      }
+    };
+  }
+  /**
+   * Resolve command reference to plugin handler.
+   *
+   * Supports three formats:
+   * - `plugin:id/handler` - workflow handler (native)
+   * - `command:name` - CLI command (via adapter)
+   * - `builtin:shell` - built-in shell execution
+   */
+  async resolveCommand(spec, request) {
+    const uses = spec.uses;
+    const input = spec.with ?? {};
+    if (uses.startsWith("plugin:")) {
+      return this.resolvePluginHandler(uses, input);
+    }
+    if (uses.startsWith("command:")) {
+      return this.resolveCLICommand(uses, input, request);
+    }
+    if (uses === "builtin:shell") {
+      return this.resolveBuiltinShell(spec);
+    }
+    if (uses === "builtin:approval" || uses === "builtin:gate") {
+      throw new Error(`${uses} is handled by the workflow worker, not the sandbox runner`);
+    }
+    throw new Error(`Unsupported uses format: ${uses}. Expected "plugin:...", "command:...", or "builtin:shell"`);
+  }
+  /**
+   * Resolve plugin handler reference.
+   * Format: `plugin:id/handler` or `plugin:id/path/to/handler`
+   */
+  async resolvePluginHandler(uses, input) {
+    const pluginRef = uses.slice("plugin:".length);
+    const [pluginId, ...handlerParts] = pluginRef.split("/");
+    if (!pluginId || handlerParts.length === 0) {
+      throw new Error(`Invalid plugin reference: ${uses}. Expected "plugin:id/handler"`);
+    }
+    const handlerName = handlerParts.join("/");
+    const snapshot = this.cliApi.snapshot();
+    const entry = snapshot.manifests?.find(
+      (m) => m.pluginId === pluginId || m.pluginId.endsWith(`/${pluginId}`)
+    );
+    if (!entry) {
+      throw new Error(`Plugin not found: ${pluginId}`);
+    }
+    const workflowHandlers = entry.manifest.workflows?.handlers ?? [];
+    const handler = workflowHandlers.find((h) => h.id === handlerName);
+    if (!handler) {
+      throw new Error(`Workflow handler not found: ${handlerName} in plugin ${pluginId}`);
+    }
+    return {
+      pluginId,
+      pluginVersion: entry.manifest.version,
+      pluginRoot: entry.pluginRoot,
+      handler: handler.handler,
+      // File path from manifest
+      input,
+      permissions: getHandlerPermissions(entry.manifest, "workflow", handlerName)
+    };
+  }
+  /**
+   * Resolve CLI command to plugin handler (with adapter).
+   *
+   * Format: `command:name` (e.g., `command:mind:rag-index`)
+   *
+   * This uses the CLI Adapter pattern to make CLI commands work in workflow context:
+   * - Searches for CLI command in plugin manifests
+   * - Wraps workflow input in CLI-compatible format { argv, flags, cwd }
+   * - Allows reusing existing CLI commands without writing workflow handlers
+   */
+  async resolveCLICommand(uses, input, request) {
+    const commandName = uses.slice("command:".length);
+    const snapshot = this.cliApi.snapshot();
+    for (const entry of snapshot.manifests ?? []) {
+      const commands = entry.manifest.cli?.commands ?? [];
+      const command = commands.find((c) => c.id === commandName);
+      if (command) {
+        return {
+          pluginId: entry.pluginId,
+          pluginVersion: entry.manifest.version,
+          pluginRoot: entry.pluginRoot,
+          handler: command.handler,
+          input: this.adaptToCLIFormat(input, request),
+          // CLI Adapter
+          permissions: getHandlerPermissions(entry.manifest, "cli", commandName),
+          configSection: entry.manifest.configSection
+          // For useConfig() auto-detection
+        };
+      }
+    }
+    throw new Error(`CLI command not found: ${commandName}`);
+  }
+  /**
+   * CLI Adapter: Convert workflow input to CLI-compatible format.
+   *
+   * Transforms:
+   *   { scope: "default", incremental: true }
+   * Into:
+   *   { argv: [], flags: { scope: "default", incremental: true }, cwd: "/workspace" }
+   *
+   * This allows CLI commands to work in workflow context without modification.
+   */
+  adaptToCLIFormat(input, request) {
+    if (input && typeof input === "object" && ("argv" in input || "flags" in input)) {
+      return input;
+    }
+    return {
+      argv: [],
+      flags: input || {},
+      cwd: request.workspace || this.workspaceRoot
+    };
+  }
+  /**
+   * Resolve builtin:shell to built-in shell handler.
+   *
+   * Returns a resolution pointing to the builtin-handlers/shell.js file
+   * that will be executed through ExecutionBackend.
+   */
+  async resolveBuiltinShell(spec) {
+    const builtinsUrl = await import.meta.resolve("@kb-labs/workflow-builtins");
+    const builtinsPath = builtinsUrl.replace("file://", "").replace("/dist/index.js", "");
+    const withBlock = spec.with ?? {};
+    const command = withBlock.command ?? withBlock.run ?? withBlock.script;
+    if (typeof command !== "string") {
+      throw new Error(
+        'builtin:shell requires "with.command" (or with.run/with.script) to be a string'
+      );
+    }
+    const shellInput = {
+      command,
+      env: typeof withBlock.env === "object" ? withBlock.env : void 0,
+      timeout: typeof withBlock.timeout === "number" ? withBlock.timeout : void 0,
+      throwOnError: typeof withBlock.throwOnError === "boolean" ? withBlock.throwOnError : false
+    };
+    return {
+      pluginId: "@kb-labs/workflow-builtins",
+      pluginVersion: "0.1.0",
+      pluginRoot: builtinsPath,
+      handler: "dist/shell.js",
+      // Relative path from pluginRoot
+      input: shellInput,
+      permissions: {
+        shell: { allow: ["*"] }
+        // builtin:shell needs shell access by definition
+      }
+    };
+  }
+};
+function buildCancelledResult2(signal, error) {
+  const reason = error?.message ?? signalReason2(signal) ?? "Step execution cancelled";
+  return {
+    status: "cancelled",
+    error: {
+      message: reason,
+      code: "STEP_CANCELLED"
+    }
+  };
+}
+function signalReason2(signal) {
+  if (!signal?.aborted) {
+    return void 0;
+  }
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    return reason.message;
+  }
+  if (typeof reason === "string") {
+    return reason;
+  }
+  return void 0;
+}
+var RemoteMarketplaceSourceSchema = z.object({
+  name: z.string().min(1),
+  url: z.string().url(),
+  ref: z.string().optional(),
+  // branch/tag, default: 'main'
+  path: z.string().optional()
+  // subdirectory in repo, default: '/'
+});
+var BudgetConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  limit: z.number().positive().optional(),
+  // Total budget limit (in cost units)
+  period: z.enum(["run", "day", "week", "month"]).default("run"),
+  action: z.enum(["warn", "fail", "cancel"]).default("warn"),
+  // Extension point: custom cost calculator plugin
+  costCalculator: z.string().optional()
+});
+var WorkflowConfigSchema = z.object({
+  workspaces: z.array(z.string()).default([".kb/workflows/**/*.yml"]),
+  plugins: z.boolean().default(true),
+  remotes: z.array(RemoteMarketplaceSourceSchema).optional(),
+  maxDepth: z.number().int().positive().default(2),
+  budget: BudgetConfigSchema.optional(),
+  defaults: z.object({
+    mode: z.enum(["wait", "fire-and-forget"]).default("wait"),
+    inheritEnv: z.boolean().default(true)
+  }).optional()
+});
+async function loadWorkflowConfig(workspaceRoot) {
+  const configPath = join(workspaceRoot, "kb.config.json");
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    if (!config.workflow) {
+      return WorkflowConfigSchema.parse({});
+    }
+    return WorkflowConfigSchema.parse(config.workflow);
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("ENOENT") || error.message.includes("Unexpected token"))) {
+      return WorkflowConfigSchema.parse({});
+    }
+    throw error;
+  }
+}
+async function saveWorkflowConfig(workspaceRoot, updates) {
+  const configPath = join(workspaceRoot, "kb.config.json");
+  let existingConfig = {};
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    existingConfig = JSON.parse(raw);
+  } catch {
+    existingConfig = {};
+  }
+  const currentWorkflow = existingConfig.workflow ?? {};
+  const updatedWorkflow = {
+    ...currentWorkflow,
+    ...updates,
+    // Deep merge for arrays (remotes)
+    remotes: updates.remotes ?? currentWorkflow.remotes
+  };
+  const updatedConfig = {
+    ...existingConfig,
+    workflow: updatedWorkflow
+  };
+  await mkdir(dirname(configPath), { recursive: true });
+  await writeFile(
+    configPath,
+    JSON.stringify(updatedConfig, null, 2) + "\n",
+    "utf-8"
+  );
+}
+var WorkspaceWorkflowRegistry = class {
+  constructor(config) {
+    this.config = config;
+  }
+  cache = null;
+  async list() {
+    if (this.cache) {
+      return this.cache;
+    }
+    const workflows = [];
+    const files = await fg(this.config.patterns, {
+      cwd: this.config.workspaceRoot,
+      absolute: true,
+      onlyFiles: true,
+      ignore: ["node_modules/**", "dist/**", ".git/**"]
+    });
+    const results = await Promise.allSettled(
+      files.map(async (file) => {
+        const spec = await this.loadWorkflowSpec(file);
+        if (!spec) {
+          return null;
+        }
+        const relativePath = relative(this.config.workspaceRoot, file);
+        const id = this.generateId(relativePath);
+        return {
+          id,
+          source: "workspace",
+          filePath: file,
+          description: spec.description
+          // tags: spec.tags, // TODO: Add tags to WorkflowSpec if needed
+        };
+      })
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value !== null) {
+        workflows.push(result.value);
+      } else if (result.status === "rejected") {
+        console.warn(
+          "[WorkspaceWorkflowRegistry] Failed to load workflow:",
+          result.reason instanceof Error ? result.reason.message : String(result.reason)
+        );
+      }
+    }
+    this.cache = workflows;
+    return workflows;
+  }
+  async resolve(id) {
+    const cleanId = id.startsWith("workspace:") ? id.slice("workspace:".length) : id;
+    const all = await this.list();
+    return all.find((w) => w.id === id || w.id.endsWith(":" + cleanId)) ?? null;
+  }
+  async refresh() {
+    this.cache = null;
+  }
+  async dispose() {
+  }
+  async loadWorkflowSpec(filePath) {
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      const parsed = filePath.endsWith(".json") ? JSON.parse(raw) : parse(raw);
+      const result = WorkflowSpecSchema.safeParse(parsed);
+      if (!result.success) {
+        return null;
+      }
+      return result.data;
+    } catch {
+      return null;
+    }
+  }
+  generateId(relativePath) {
+    const withoutExt = relativePath.replace(/\.(yml|yaml|json)$/, "");
+    const normalized = withoutExt.replace(/\\/g, "/");
+    return `workspace:${normalized}`;
+  }
+};
+
+// src/registry/composite-registry.ts
+init_plugin_workflows();
+
+// src/registry/errors.ts
+var WorkflowRegistryError = class extends Error {
+  constructor(message, workflowId) {
+    super(message);
+    this.workflowId = workflowId;
+    this.name = "WorkflowRegistryError";
+  }
+};
+
+// src/registry/composite-registry.ts
+var CompositeWorkflowRegistry = class {
+  constructor(workspace, cliApi, remote) {
+    this.workspace = workspace;
+    this.cliApi = cliApi;
+    this.remote = remote;
+  }
+  cache = null;
+  async list() {
+    if (this.cache) {
+      return this.cache;
+    }
+    const registries = [
+      this.workspace.list()
+    ];
+    if (this.cliApi) {
+      const snapshot = this.cliApi.snapshot();
+      registries.push(extractWorkflows(snapshot));
+    }
+    if (this.remote) {
+      registries.push(this.remote.list());
+    }
+    const results = await Promise.all(registries);
+    const allWorkflows = results.flat();
+    const ids = /* @__PURE__ */ new Set();
+    const conflicts = [];
+    for (const wf of allWorkflows) {
+      if (ids.has(wf.id)) {
+        conflicts.push(wf.id);
+      }
+      ids.add(wf.id);
+    }
+    if (conflicts.length > 0) {
+      throw new WorkflowRegistryError(
+        `Workflow ID conflicts detected: ${conflicts.join(", ")}. Use explicit prefixes (workspace:, plugin:, or remote:) to disambiguate.`
+      );
+    }
+    this.cache = allWorkflows;
+    return this.cache;
+  }
+  async resolve(id) {
+    if (id.startsWith("workspace:")) {
+      return this.workspace.resolve(id);
+    }
+    if (id.startsWith("plugin:") && this.cliApi) {
+      const snapshot = this.cliApi.snapshot();
+      const { findWorkflow: findWorkflow2 } = await Promise.resolve().then(() => (init_plugin_workflows(), plugin_workflows_exports));
+      return findWorkflow2(snapshot, id);
+    }
+    if (id.startsWith("remote:") && this.remote) {
+      return this.remote.resolve(id);
+    }
+    const all = await this.list();
+    const matches = all.filter(
+      (w) => w.id === id || w.id.endsWith(":" + id)
+    );
+    if (matches.length > 1) {
+      throw new WorkflowRegistryError(
+        `Ambiguous workflow ID "${id}". Multiple matches: ${matches.map((m) => m.id).join(", ")}. Use explicit prefix (workspace:, plugin:, or remote:).`,
+        id
+      );
+    }
+    return matches[0] ?? null;
+  }
+  async refresh() {
+    this.cache = null;
+    const refreshTasks = [
+      this.workspace.refresh()
+    ];
+    if (this.remote) {
+      refreshTasks.push(this.remote.refresh());
+    }
+    await Promise.all(refreshTasks);
+  }
+  async dispose() {
+    await Promise.all([
+      this.workspace.dispose?.() ?? Promise.resolve(),
+      this.remote?.dispose?.() ?? Promise.resolve()
+    ]);
+  }
+};
+
+// src/registry/index.ts
+init_plugin_workflows();
+
+export { BudgetConfigSchema, CompositeWorkflowRegistry, LocalRunner, RemoteMarketplaceSourceSchema, SandboxRunner, WorkflowConfigSchema, WorkflowRegistryError, WorkspaceWorkflowRegistry, createStepContext, extractWorkflows, findWorkflow, loadWorkflowConfig, saveWorkflowConfig };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map