@tagma/sdk 0.7.1 → 0.7.3

package/src/engine.ts

@@ -32,6 +32,7 @@ import {
   skipNonTerminalTasks,
 } from './core/scheduler';
 import { executeTask } from './core/task-executor';
+import { bunRuntime, type TagmaRuntime } from './runtime';
 export { TriggerBlockedError, TriggerTimeoutError } from './core/trigger-errors';
 
 function isPromptTaskConfig(
@@ -104,6 +105,11 @@ export interface RunPipelineOptions {
    * do not share handler state.
    */
   readonly registry: PluginRegistry;
+  /**
+   * Runtime implementation for command and driver process execution.
+   * Defaults to the SDK's Bun runtime.
+   */
+  readonly runtime?: TagmaRuntime;
 }
 
 // Poll interval when no tasks are in-flight but non-terminal tasks remain
@@ -123,6 +129,7 @@ export async function runPipeline(
   const approvalGateway = options.approvalGateway ?? new InMemoryApprovalGateway();
   const maxLogRuns = options.maxLogRuns ?? 20;
   const registry = options.registry;
+  const runtime = options.runtime ?? bunRuntime();
   if (!registry) {
     throw new Error(
       'runPipeline requires options.registry. Use createTagma().run(...) for the public SDK API.',
@@ -192,6 +199,7 @@ export async function runPipeline(
       workDir,
       pipelineInfo,
       onEvent: options.onEvent,
+      runtime,
     });
 
     // Pipeline start hook (gate). Runs BEFORE the engine emits run_start so

package/src/index.ts

@@ -1,5 +1,7 @@
 export { createTagma } from './tagma';
 export type { CreateTagmaOptions, Tagma, TagmaRunOptions } from './tagma';
+export { bunRuntime } from './runtime';
+export type { TagmaRuntime, RunOptions as RuntimeRunOptions } from './runtime';
 export { definePipeline } from './pipeline-definition';
 export { PluginRegistry } from './registry';
 export { TriggerBlockedError, TriggerTimeoutError } from './engine';
@@ -20,6 +22,9 @@ export type {
   TaskStatus,
   ApprovalRequest,
   PluginCategory,
+  PluginCapabilities,
+  PluginSetupContext,
+  TagmaPlugin,
   DriverPlugin,
   TriggerPlugin,
   CompletionPlugin,

package/src/plugin-registry.test.ts

@@ -3,9 +3,10 @@ import { PluginRegistry } from './registry';
 import { bootstrapBuiltins } from './bootstrap';
 import { runPipeline } from './engine';
 import type { DriverPlugin, TriggerPlugin, PipelineConfig } from './types';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import type { TagmaPlugin } from './types';
 
 function makeDriver(name: string, marker: string[]): DriverPlugin {
   return {
@@ -100,6 +101,130 @@ describe('PluginRegistry — instance isolation', () => {
   });
 });
 
+describe('PluginRegistry — capability plugins', () => {
+  test('registerTagmaPlugin registers multiple capabilities from one package', () => {
+    const reg = new PluginRegistry();
+    const driver = makeDriver('cap-driver', []);
+    const trigger = makeTrigger('cap-trigger', []);
+    const plugin: TagmaPlugin = {
+      name: 'tagma-plugin-multi',
+      capabilities: {
+        drivers: { cap_driver: driver },
+        triggers: { cap_trigger: trigger },
+      },
+    };
+
+    expect(reg.registerTagmaPlugin(plugin)).toEqual([
+      { category: 'drivers', type: 'cap_driver', result: 'registered' },
+      { category: 'triggers', type: 'cap_trigger', result: 'registered' },
+    ]);
+    expect(reg.getHandler<DriverPlugin>('drivers', 'cap_driver')).toBe(driver);
+    expect(reg.getHandler<TriggerPlugin>('triggers', 'cap_trigger')).toBe(trigger);
+  });
+
+  test('registerTagmaPlugin keeps replacement warnings from the registry path', () => {
+    const reg = new PluginRegistry();
+    const originalWarn = console.warn;
+    const warnings: string[] = [];
+    console.warn = (message?: unknown) => {
+      warnings.push(String(message));
+    };
+    try {
+      reg.registerPlugin('drivers', 'mock', makeDriver('first', []));
+      const result = reg.registerTagmaPlugin({
+        name: 'tagma-plugin-replacement',
+        capabilities: {
+          drivers: { mock: makeDriver('second', []) },
+        },
+      });
+
+      expect(result).toEqual([{ category: 'drivers', type: 'mock', result: 'replaced' }]);
+      expect(warnings).toContain(
+        '[tagma-sdk] registerPlugin: replaced existing drivers/mock - check for duplicate plugin packages claiming the same type.',
+      );
+    } finally {
+      console.warn = originalWarn;
+    }
+  });
+
+  test('loadPlugins accepts capability plugin default exports', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'tagma-capability-plugin-'));
+    const pluginDir = join(dir, 'node_modules', 'tagma-plugin-capability');
+    mkdirSync(pluginDir, { recursive: true });
+    writeFileSync(
+      join(pluginDir, 'package.json'),
+      JSON.stringify({ name: 'tagma-plugin-capability', version: '1.0.0', type: 'module', main: './index.js' }),
+      'utf-8',
+    );
+    writeFileSync(
+      join(pluginDir, 'index.js'),
+      [
+        'const driver = {',
+        "  name: 'cap-driver',",
+        '  capabilities: { sessionResume: false, systemPrompt: false, outputFormat: false },',
+        "  async buildCommand() { return { args: ['echo', 'cap'] }; },",
+        '};',
+        'const trigger = {',
+        "  name: 'cap-trigger',",
+        '  async watch() {}',
+        '};',
+        'export default {',
+        "  name: 'tagma-plugin-capability',",
+        '  capabilities: {',
+        '    drivers: { cap_driver: driver },',
+        '    triggers: { cap_trigger: trigger },',
+        '  },',
+        '};',
+        '',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    try {
+      const reg = new PluginRegistry();
+      await reg.loadPlugins(['tagma-plugin-capability'], dir);
+      expect(reg.hasHandler('drivers', 'cap_driver')).toBe(true);
+      expect(reg.hasHandler('triggers', 'cap_trigger')).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('loadPlugins rejects legacy plugin module exports', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'tagma-legacy-plugin-'));
+    const pluginDir = join(dir, 'node_modules', 'tagma-plugin-legacy');
+    mkdirSync(pluginDir, { recursive: true });
+    writeFileSync(
+      join(pluginDir, 'package.json'),
+      JSON.stringify({ name: 'tagma-plugin-legacy', version: '1.0.0', type: 'module', main: './index.js' }),
+      'utf-8',
+    );
+    writeFileSync(
+      join(pluginDir, 'index.js'),
+      [
+        "export const pluginCategory = 'drivers';",
+        "export const pluginType = 'legacy';",
+        'export default {',
+        "  name: 'legacy',",
+        '  capabilities: { sessionResume: false, systemPrompt: false, outputFormat: false },',
+        "  async buildCommand() { return { args: ['echo', 'legacy'] }; },",
+        '};',
+        '',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    try {
+      const reg = new PluginRegistry();
+      await expect(reg.loadPlugins(['tagma-plugin-legacy'], dir)).rejects.toThrow(
+        /must default-export a TagmaPlugin/,
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
 describe('PluginRegistry — validation', () => {
   test('rejects unknown category', () => {
     const reg = new PluginRegistry();
@@ -153,6 +278,18 @@ describe('PluginRegistry — validation', () => {
       /bun add @tagma\/middleware-audit/,
     );
   });
+
+  test('rejects middleware without enhanceDoc', () => {
+    const reg = new PluginRegistry();
+    expect(() =>
+      reg.registerPlugin('middlewares', 'old', {
+        name: 'old',
+        async enhance(prompt: string) {
+          return prompt;
+        },
+      } as never),
+    ).toThrow(/must export enhanceDoc/);
+  });
 });
 
 describe('runPipeline — options.registry isolation', () => {

package/src/plugins.ts

@@ -5,14 +5,17 @@ export {
   PLUGIN_NAME_RE,
   readPluginManifest,
 } from './registry';
-export type { RegisterResult } from './registry';
+export type { RegisteredCapability, RegisterResult } from './registry';
 export type {
+  CapabilityHandler,
   PluginCategory,
+  PluginCapabilities,
   PluginModule,
   PluginManifest,
+  PluginSetupContext,
+  TagmaPlugin,
   DriverPlugin,
   TriggerPlugin,
   CompletionPlugin,
   MiddlewarePlugin,
 } from './types';
-

package/src/registry.ts

@@ -1,24 +1,34 @@
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import type {
+  CapabilityHandler,
   PluginCategory,
   DriverPlugin,
   TriggerPlugin,
   CompletionPlugin,
   MiddlewarePlugin,
   PluginManifest,
+  TagmaPlugin,
 } from './types';
 
-type PluginType = DriverPlugin | TriggerPlugin | CompletionPlugin | MiddlewarePlugin;
+type PluginType = CapabilityHandler;
 
-const VALID_CATEGORIES: ReadonlySet<PluginCategory> = new Set([
+const CAPABILITY_CATEGORIES = [
   'drivers',
   'triggers',
   'completions',
   'middlewares',
-]);
+] as const satisfies readonly PluginCategory[];
+
+const VALID_CATEGORIES: ReadonlySet<PluginCategory> = new Set(CAPABILITY_CATEGORIES);
 const PLUGIN_TYPE_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
 
+export interface RegisteredCapability {
+  readonly category: PluginCategory;
+  readonly type: string;
+  readonly result: RegisterResult;
+}
+
 function singularCategory(category: PluginCategory): string {
   switch (category) {
     case 'drivers':
@@ -37,7 +47,7 @@ function singularCategory(category: PluginCategory): string {
  * registration time rather than crashing the engine mid-run.
  *
  * For drivers we materialize `capabilities` and assert each field is a
- * boolean �?otherwise a plugin author can write
+ * boolean —otherwise a plugin author can write
  *     get capabilities() { throw new Error('boom') }
  * and pass the basic typeof check, then crash preflight when the engine
  * touches `driver.capabilities.sessionResume`. (R8)
@@ -55,7 +65,7 @@ function validateContract(category: PluginCategory, handler: unknown): void {
       if (typeof h.buildCommand !== 'function') {
         throw new Error(`drivers plugin "${h.name}" must export buildCommand()`);
       }
-      // Materialize capabilities �?this triggers any throwing getter NOW
+      // Materialize capabilities —this triggers any throwing getter NOW
       // instead of during preflight.
       let caps: unknown;
       try {
@@ -96,22 +106,11 @@ function validateContract(category: PluginCategory, handler: unknown): void {
       }
       break;
     case 'middlewares':
-      // A middleware must provide at least one entry point. `enhanceDoc` is
-      // the structured PromptDocument API (preferred); `enhance` is the
-      // legacy string-in/string-out API the engine still supports for
-      // v0.x plugins. Requiring only `enhance` here rejects every built-in
-      // and every plugin written against the current types.
-      if (typeof h.enhanceDoc !== 'function' && typeof h.enhance !== 'function') {
+      if (typeof h.enhanceDoc !== 'function') {
         throw new Error(
-          `middlewares plugin "${h.name}" must export enhanceDoc() or enhance()`,
+          `middlewares plugin "${h.name}" must export enhanceDoc()`,
         );
       }
-      if (h.enhanceDoc !== undefined && typeof h.enhanceDoc !== 'function') {
-        throw new Error(`middlewares plugin "${h.name}".enhanceDoc must be a function or undefined`);
-      }
-      if (h.enhance !== undefined && typeof h.enhance !== 'function') {
-        throw new Error(`middlewares plugin "${h.name}".enhance must be a function or undefined`);
-      }
       break;
   }
 }
@@ -132,7 +131,7 @@ export function isValidPluginName(name: unknown): name is string {
  *
  * Returns the strongly-typed manifest if the field is present and
  * well-formed (`category` is one of the four known categories and `type`
- * is a non-empty string). Returns `null` if the field is absent �?that
+ * is a non-empty string). Returns `null` if the field is absent —that
  * is the host's signal that the package is a library, not a plugin.
  *
  * Throws if the field is present but malformed: that's a packaging bug
@@ -167,6 +166,33 @@ export function readPluginManifest(pkgJson: unknown): PluginManifest | null {
   return { category: category as PluginCategory, type };
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isTagmaPlugin(value: unknown): value is TagmaPlugin {
+  if (!isRecord(value)) return false;
+  if (typeof value.name !== 'string' || value.name.length === 0) return false;
+  if (value.capabilities !== undefined && !isRecord(value.capabilities)) return false;
+  if (value.setup !== undefined && typeof value.setup !== 'function') return false;
+  return true;
+}
+
+function hasSupportedCapabilityMap(plugin: TagmaPlugin): boolean {
+  if (!plugin.capabilities) return false;
+  const capabilities = plugin.capabilities as Record<string, unknown>;
+  return CAPABILITY_CATEGORIES.some((category) => capabilities[category] !== undefined);
+}
+
+function moduleDefaultPlugin(name: string, mod: unknown): TagmaPlugin {
+  if (!isRecord(mod) || !isTagmaPlugin(mod.default) || !hasSupportedCapabilityMap(mod.default)) {
+    throw new Error(
+      `Plugin "${name}" must default-export a TagmaPlugin with capabilities maps`,
+    );
+  }
+  return mod.default;
+}
+
 /**
  * Instance-scoped plugin registry. Each workspace in a multi-tenant sidecar
  * owns its own PluginRegistry, so installing/uninstalling a driver in one
@@ -214,22 +240,54 @@ export class PluginRegistry {
     if (wasReplaced) {
       // D18: surface silent shadowing. Hot-reload flows legitimately replace
       // handlers; installing two different plugin packages that both claim
-      // the same (category, type) does not �?the second wins and breaks the
+      // the same (category, type) does not —the second wins and breaks the
       // first's consumers with no audit trail. A console.warn is cheap,
       // respects existing callers that rely on 'replaced', and gives ops a
       // grep-able signal when registrations collide unexpectedly.
       console.warn(
-        `[tagma-sdk] registerPlugin: replaced existing ${category}/${type} �?` +
+        `[tagma-sdk] registerPlugin: replaced existing ${category}/${type} - ` +
           `check for duplicate plugin packages claiming the same type.`,
       );
     }
     return wasReplaced ? 'replaced' : 'registered';
   }
 
+  registerTagmaPlugin(plugin: TagmaPlugin): RegisteredCapability[] {
+    if (!isTagmaPlugin(plugin)) {
+      throw new Error('TagmaPlugin must be an object with a non-empty "name"');
+    }
+    if (!plugin.capabilities) {
+      throw new Error(`TagmaPlugin "${plugin.name}" must declare capabilities`);
+    }
+
+    const registered: RegisteredCapability[] = [];
+    const capabilities = plugin.capabilities as Record<string, unknown>;
+    for (const category of CAPABILITY_CATEGORIES) {
+      const handlers = capabilities[category];
+      if (handlers === undefined) continue;
+      if (!isRecord(handlers)) {
+        throw new Error(
+          `TagmaPlugin "${plugin.name}" capabilities.${category} must be an object map`,
+        );
+      }
+      for (const [type, handler] of Object.entries(handlers)) {
+        const result = this.registerPlugin(category, type, handler as PluginType);
+        registered.push({ category, type, result });
+      }
+    }
+
+    if (registered.length === 0) {
+      throw new Error(
+        `TagmaPlugin "${plugin.name}" must declare at least one supported capability`,
+      );
+    }
+    return registered;
+  }
+
   /**
    * Remove a plugin from the in-process registry. Returns true if a plugin
    * was actually removed. Note: ESM module caching is not affected, so
-   * re-importing the same file after unregister will yield the cached module �?   * callers wanting a fresh load must restart the host process.
+   * re-importing the same file after unregister will yield the cached module —   * callers wanting a fresh load must restart the host process.
    */
   unregisterPlugin(category: PluginCategory, type: string): boolean {
     if (!VALID_CATEGORIES.has(category)) return false;
@@ -289,10 +347,7 @@ export class PluginRegistry {
         moduleUrl = pathToFileURL(resolved).href;
       }
       const mod = await import(moduleUrl);
-      if (!mod.pluginCategory || !mod.pluginType || !mod.default) {
-        throw new Error(`Plugin "${name}" must export pluginCategory, pluginType, and default`);
-      }
-      this.registerPlugin(mod.pluginCategory, mod.pluginType, mod.default);
+      this.registerTagmaPlugin(moduleDefaultPlugin(name, mod));
     }
   }
 }

package/src/runtime.ts

@@ -0,0 +1,20 @@
+import type { DriverPlugin, SpawnSpec, TaskResult } from './types';
+import { runCommand, runSpawn, type RunOptions } from './runner';
+
+export type { RunOptions };
+
+export interface TagmaRuntime {
+  runSpawn(
+    spec: SpawnSpec,
+    driver: DriverPlugin | null,
+    options?: RunOptions,
+  ): Promise<TaskResult>;
+  runCommand(command: string, cwd: string, options?: RunOptions): Promise<TaskResult>;
+}
+
+export function bunRuntime(): TagmaRuntime {
+  return {
+    runSpawn,
+    runCommand,
+  };
+}

package/src/schema-ports.test.ts

@@ -83,6 +83,29 @@ describe('schema — unified bindings passthrough', () => {
     expect(back.tracks[0]!.tasks[0]!.outputs).toBeUndefined();
   });
 
+  test('legacy ports are not carried through resolve or deresolve', () => {
+    const raw: RawPipelineConfig = {
+      name: 'p',
+      tracks: [
+        {
+          id: 't',
+          name: 'T',
+          tasks: [
+            {
+              id: 'a',
+              command: 'echo ok',
+              ports: { outputs: [{ name: 'old', type: 'string' }] },
+            },
+          ],
+        },
+      ],
+    };
+    const resolved = resolveConfig(raw, WORK_DIR);
+    expect(resolved.tracks[0]!.tasks[0]!.ports).toBeUndefined();
+    const back = deresolvePipeline(resolved, WORK_DIR);
+    expect(back.tracks[0]!.tasks[0]!.ports).toBeUndefined();
+  });
+
   test('YAML round-trip preserves typed unified binding shape', () => {
     const raw: RawPipelineConfig = {
       name: 'p',

package/src/schema.ts

@@ -161,11 +161,10 @@ export function resolveConfig(raw: RawPipelineConfig, workDir: string): Pipeline
         completion: rawTask.completion,
         agent_profile: rawTask.agent_profile ?? rawTrack.agent_profile,
         cwd: rawTask.cwd ? validatePath(rawTask.cwd, workDir) : trackCwd,
-        // Lightweight bindings and ports: no inheritance — they describe
+        // Unified bindings have no inheritance; they describe
         // per-task data flow, not cross-task defaults.
         inputs: rawTask.inputs,
         outputs: rawTask.outputs,
-        ports: rawTask.ports,
       };
     });
 
@@ -313,11 +312,6 @@ export function deresolvePipeline(config: PipelineConfig, workDir: string): RawP
           : {}),
         ...(task.inputs && Object.keys(task.inputs).length > 0 ? { inputs: task.inputs } : {}),
         ...(task.outputs && Object.keys(task.outputs).length > 0 ? { outputs: task.outputs } : {}),
-        ...(task.ports &&
-        ((task.ports.inputs && task.ports.inputs.length > 0) ||
-          (task.ports.outputs && task.ports.outputs.length > 0))
-          ? { ports: task.ports }
-          : {}),
       };
     });
 

package/src/tagma.test.ts

@@ -3,7 +3,8 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createTagma } from './tagma';
-import type { DriverPlugin, PipelineConfig } from './types';
+import type { DriverPlugin, TagmaPlugin, TaskResult } from './types';
+import type { TagmaRuntime } from './runtime';
 
 function makeDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), prefix));
@@ -21,6 +22,76 @@ function makeDriver(name: string, marker: string[]): DriverPlugin {
 }
 
 describe('createTagma', () => {
+  test('runs command tasks through the configured runtime', async () => {
+    const calls: string[] = [];
+    const taskResult: TaskResult = {
+      exitCode: 0,
+      stdout: 'runtime-ok',
+      stderr: '',
+      stdoutPath: null,
+      stderrPath: null,
+      stdoutBytes: 10,
+      stderrBytes: 0,
+      durationMs: 1,
+      sessionId: null,
+      normalizedOutput: null,
+      failureKind: null,
+    };
+    const runtime: TagmaRuntime = {
+      async runCommand(command, cwd) {
+        calls.push(`${cwd}:${command}`);
+        return taskResult;
+      },
+      async runSpawn() {
+        throw new Error('runSpawn should not be called for command tasks');
+      },
+    };
+    const tagma = createTagma({ builtins: false, runtime });
+    const dir = makeDir('tagma-runtime-run-');
+    try {
+      const result = await tagma.run(
+        {
+          name: 'runtime-run',
+          tracks: [
+            {
+              id: 't',
+              name: 'T',
+              tasks: [{ id: 'cmd', name: 'cmd', command: 'fake-only-command' }],
+            },
+          ],
+        },
+        {
+          cwd: dir,
+          skipPluginLoading: true,
+        },
+      );
+
+      expect(result.success).toBe(true);
+      expect(calls).toEqual([`${dir}:fake-only-command`]);
+      expect(result.states.get('t.cmd')?.result?.stdout).toBe('runtime-ok');
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test('registers capability plugins passed to options', () => {
+    const seen: string[] = [];
+    const driver = makeDriver('driver-plugin', seen);
+    const plugin: TagmaPlugin = {
+      name: 'tagma-plugin-local',
+      capabilities: {
+        drivers: {
+          mock: driver,
+        },
+      },
+    };
+
+    const tagma = createTagma({ builtins: false, plugins: [plugin] });
+
+    expect(tagma.registry.getHandler<DriverPlugin>('drivers', 'mock')).toBe(driver);
+    expect(seen).toEqual([]);
+  });
+
   test('instances own isolated plugin registries', () => {
     const seenA: string[] = [];
     const seenB: string[] = [];

package/src/tagma.ts

@@ -2,7 +2,8 @@ import { runPipeline, type EngineResult, type RunPipelineOptions } from './engin
 import { bootstrapBuiltins } from './bootstrap';
 import { PluginRegistry } from './registry';
 import { validateConfig } from './schema';
-import type { PipelineConfig } from './types';
+import { bunRuntime, type TagmaRuntime } from './runtime';
+import type { PipelineConfig, TagmaPlugin } from './types';
 
 export interface CreateTagmaOptions {
   /**
@@ -14,6 +15,15 @@ export interface CreateTagmaOptions {
    * instance registry. Defaults to true.
    */
   readonly builtins?: boolean;
+  /**
+   * Package-level capability plugins to register into this SDK instance.
+   */
+  readonly plugins?: readonly TagmaPlugin[];
+  /**
+   * Runtime implementation used for command and driver process execution.
+   * Defaults to the SDK's Bun runtime.
+   */
+  readonly runtime?: TagmaRuntime;
 }
 
 export interface TagmaRunOptions extends Omit<RunPipelineOptions, 'registry'> {
@@ -28,9 +38,13 @@ export interface Tagma {
 
 export function createTagma(options: CreateTagmaOptions = {}): Tagma {
   const registry = options.registry ?? new PluginRegistry();
+  const runtime = options.runtime ?? bunRuntime();
   if (options.builtins !== false) {
     bootstrapBuiltins(registry);
   }
+  for (const plugin of options.plugins ?? []) {
+    registry.registerTagmaPlugin(plugin);
+  }
 
   return {
     registry,
@@ -38,6 +52,7 @@ export function createTagma(options: CreateTagmaOptions = {}): Tagma {
       return runPipeline(config, cwd, {
         ...runOptions,
         registry,
+        runtime,
       });
     },
     validate(config) {