@tagma/sdk 0.7.1 → 0.7.4

package/src/bootstrap.ts

@@ -1,4 +1,5 @@
-import type { PluginRegistry } from './registry';
+import type { PluginRegistry } from '@tagma/core';
+import type { TagmaPlugin } from './types';
 
 // Built-in Drivers
 // Only opencode is built in. Other drivers (codex, claude-code) ship as
@@ -19,6 +20,27 @@ import { OutputCheckCompletion } from './completions/output-check';
 // Built-in Middleware
 import { StaticContextMiddleware } from './middlewares/static-context';
 
+export const BuiltinTagmaPlugin = {
+  name: '@tagma/sdk/builtins',
+  capabilities: {
+    drivers: {
+      opencode: OpenCodeDriver,
+    },
+    triggers: {
+      file: FileTrigger,
+      manual: ManualTrigger,
+    },
+    completions: {
+      exit_code: ExitCodeCompletion,
+      file_exists: FileExistsCompletion,
+      output_check: OutputCheckCompletion,
+    },
+    middlewares: {
+      static_context: StaticContextMiddleware,
+    },
+  },
+} satisfies TagmaPlugin;
+
 /**
  * Register every built-in plugin into `target`. Hosts instantiate one
  * PluginRegistry per workspace or SDK instance and call this once per
@@ -29,18 +51,5 @@ import { StaticContextMiddleware } from './middlewares/static-context';
  * handler object into N registries is cheap and safe; no cloning is needed.
  */
 export function bootstrapBuiltins(target: PluginRegistry): void {
-  // Drivers
-  target.registerPlugin('drivers', 'opencode', OpenCodeDriver);
-
-  // Triggers
-  target.registerPlugin('triggers', 'file', FileTrigger);
-  target.registerPlugin('triggers', 'manual', ManualTrigger);
-
-  // Completions
-  target.registerPlugin('completions', 'exit_code', ExitCodeCompletion);
-  target.registerPlugin('completions', 'file_exists', FileExistsCompletion);
-  target.registerPlugin('completions', 'output_check', OutputCheckCompletion);
-
-  // Middlewares
-  target.registerPlugin('middlewares', 'static_context', StaticContextMiddleware);
+  target.registerTagmaPlugin(BuiltinTagmaPlugin);
 }

package/src/core/run-context.test.ts

@@ -3,6 +3,51 @@ import { RunContext } from './run-context';
 import { buildDag } from '../dag';
 import type { PipelineConfig, RunEventPayload } from '../types';
 import type { PipelineInfo } from '../hooks';
+import type { TagmaRuntime } from '../runtime';
+
+const fakeRuntime: TagmaRuntime = {
+  async runCommand() {
+    throw new Error('fakeRuntime.runCommand should not be called by RunContext tests');
+  },
+  async runSpawn() {
+    throw new Error('fakeRuntime.runSpawn should not be called by RunContext tests');
+  },
+  async ensureDir() {
+    /* no-op */
+  },
+  async fileExists() {
+    return false;
+  },
+  async *watch() {
+    /* no-op */
+  },
+  logStore: {
+    openRunLog() {
+      return {
+        path: 'mem://pipeline.log',
+        dir: 'mem://run',
+        append() {
+          /* no-op */
+        },
+        close() {
+          /* no-op */
+        },
+      };
+    },
+    taskOutputPath({ taskId, stream }) {
+      return `mem://${taskId}.${stream}`;
+    },
+    logsDir() {
+      return 'mem://logs';
+    },
+  },
+  now() {
+    return new Date('2026-04-26T00:00:00.000Z');
+  },
+  sleep() {
+    return Promise.resolve();
+  },
+};
 
 function makeContext(overrides: Partial<{
   config: PipelineConfig;
@@ -30,6 +75,7 @@ function makeContext(overrides: Partial<{
     workDir: '/tmp/wd',
     pipelineInfo: { name: config.name, run_id: 'run_test', started_at: '2026-04-26T00:00:00Z' } as PipelineInfo,
     onEvent,
+    runtime: fakeRuntime,
   });
   return { ctx, events };
 }
@@ -83,6 +129,7 @@ describe('RunContext.emit', () => {
       config,
       workDir: '/tmp/wd',
       pipelineInfo: { name: 'p', run_id: 'run_test', started_at: 'now' } as PipelineInfo,
+      runtime: fakeRuntime,
     });
     expect(() => ctx.emit({ type: 'run_end', runId: 'run_test', success: true, abortReason: null })).not.toThrow();
   });

package/src/core/run-context.ts

@@ -17,6 +17,7 @@ import {
   type TaskInfo,
   type TrackInfo,
 } from '../hooks';
+import type { TagmaRuntime } from '../runtime';
 import { isTerminal } from './run-state';
 import { nowISO } from '../utils';
 
@@ -33,6 +34,7 @@ export interface RunContextOptions {
   readonly workDir: string;
   readonly pipelineInfo: PipelineInfo;
   readonly onEvent?: (event: RunEventPayload) => void;
+  readonly runtime: TagmaRuntime;
 }
 
 /**
@@ -49,6 +51,7 @@ export class RunContext {
   readonly workDir: string;
   readonly pipelineInfo: PipelineInfo;
   readonly onEvent?: (event: RunEventPayload) => void;
+  readonly runtime: TagmaRuntime;
 
   readonly states = new Map<string, TaskState>();
   readonly sessionMap = new Map<string, string>();
@@ -67,6 +70,7 @@ export class RunContext {
     this.workDir = options.workDir;
     this.pipelineInfo = options.pipelineInfo;
     this.onEvent = options.onEvent;
+    this.runtime = options.runtime;
 
     for (const [id, node] of this.dag.nodes) {
       this.states.set(id, {

package/src/core/task-executor.ts

@@ -1,4 +1,3 @@
-import { resolve } from 'path';
 import type {
   CompletionPlugin,
   DriverContext,
@@ -12,7 +11,6 @@ import type {
   TriggerPlugin,
 } from '../types';
 import type { PluginRegistry } from '../registry';
-import { runCommand, runSpawn } from '../runner';
 import { parseDuration, nowISO } from '../utils';
 import {
   promptDocumentFromString,
@@ -137,6 +135,7 @@ export async function executeTask(options: ExecuteTaskOptions): Promise<void> {
             workDir: task.cwd ?? workDir,
             signal: ctx.abortController.signal,
             approvalGateway,
+            runtime: ctx.runtime,
           })
           .then(
             (v) => {
@@ -396,9 +395,18 @@ export async function executeTask(options: ExecuteTaskOptions): Promise<void> {
     // and keep only a bounded tail in the returned TaskResult. Filenames
     // mirror the existing `.stderr` naming — dots in task ids are replaced
     // so hierarchical ids (e.g. `track1.task2`) map cleanly to a flat dir.
-    const fsSafeTaskId = taskId.replace(/\./g, '_');
-    const stdoutPath = resolve(log.dir, `${fsSafeTaskId}.stdout`);
-    const stderrPath = resolve(log.dir, `${fsSafeTaskId}.stderr`);
+    const stdoutPath = ctx.runtime.logStore.taskOutputPath({
+      workDir,
+      runId: ctx.runId,
+      taskId,
+      stream: 'stdout',
+    });
+    const stderrPath = ctx.runtime.logStore.taskOutputPath({
+      workDir,
+      runId: ctx.runId,
+      taskId,
+      stream: 'stderr',
+    });
     const runOpts = {
       timeoutMs,
       signal: ctx.abortController.signal,
@@ -422,7 +430,7 @@ export async function executeTask(options: ExecuteTaskOptions): Promise<void> {
         );
       }
       log.debug(`[task:${taskId}]`, `command: ${expandedCommand}`);
-      result = await runCommand(expandedCommand, task.cwd ?? workDir, runOpts);
+      result = await ctx.runtime.runCommand(expandedCommand, task.cwd ?? workDir, runOpts);
     } else {
       // AI task: apply middleware chain against a structured PromptDocument.
       const driverName = task.driver ?? track.driver ?? config.driver ?? 'opencode';
@@ -466,48 +474,23 @@ export async function executeTask(options: ExecuteTaskOptions): Promise<void> {
           const beforeBlocks = doc.contexts.length;
           const beforeLen = serializePromptDocument(doc).length;
 
-          // Prefer the structured API. Fall back to the legacy
-          // `enhance(string) → string` path so v0.x plugins keep
-          // working — that fallback loses context structure (the
-          // middleware's output becomes the new task body) but never
-          // silently drops content.
-          if (typeof mwPlugin.enhanceDoc === 'function') {
-            const next = await mwPlugin.enhanceDoc(doc, mwConfig as Record<string, unknown>, mwCtx);
-            if (
-              !next ||
-              typeof next !== 'object' ||
-              !Array.isArray((next as PromptDocument).contexts) ||
-              typeof (next as PromptDocument).task !== 'string'
-            ) {
-              throw new Error(
-                `middleware "${mwConfig.type}".enhanceDoc() returned a malformed PromptDocument`,
-              );
-            }
-            doc = next as PromptDocument;
-          } else if (typeof mwPlugin.enhance === 'function') {
-            const asString = serializePromptDocument(doc);
-            const next = await mwPlugin.enhance(
-              asString,
-              mwConfig as Record<string, unknown>,
-              mwCtx,
+          if (typeof mwPlugin.enhanceDoc !== 'function') {
+            throw new Error(
+              `middleware "${mwConfig.type}" must provide enhanceDoc`,
             );
-            // R3: a middleware that returns undefined / null / a non-string
-            // would silently corrupt the prompt. Fail loud.
-            if (typeof next !== 'string') {
-              throw new Error(
-                `middleware "${mwConfig.type}".enhance() returned ${next === null ? 'null' : typeof next}, expected string`,
-              );
-            }
-            // Legacy fallback: collapse the returned string into a
-            // fresh doc. Earlier structure is folded into the string
-            // (serializePromptDocument just ran), so bytes the driver
-            // sees match the old string pipeline.
-            doc = { contexts: [], task: next };
-          } else {
+          }
+          const next = await mwPlugin.enhanceDoc(doc, mwConfig as Record<string, unknown>, mwCtx);
+          if (
+            !next ||
+            typeof next !== 'object' ||
+            !Array.isArray((next as PromptDocument).contexts) ||
+            typeof (next as PromptDocument).task !== 'string'
+          ) {
             throw new Error(
-              `middleware "${mwConfig.type}" provides neither enhanceDoc nor enhance`,
+              `middleware "${mwConfig.type}".enhanceDoc() returned a malformed PromptDocument`,
             );
           }
+          doc = next as PromptDocument;
           const afterLen = serializePromptDocument(doc).length;
           const addedBlocks = doc.contexts.length - beforeBlocks;
           log.debug(
@@ -567,7 +550,7 @@ export async function executeTask(options: ExecuteTaskOptions): Promise<void> {
       if (spec.env)
         log.debug(`[task:${taskId}]`, `spawn env overrides: ${Object.keys(spec.env).join(', ')}`);
       if (spec.stdin) log.debug(`[task:${taskId}]`, `spawn stdin: ${spec.stdin.length} chars`);
-      result = await runSpawn(spec, driver, runOpts);
+      result = await ctx.runtime.runSpawn(spec, driver, runOpts);
     }
 
     // 6. Determine terminal status (without emitting yet — result must be complete first)

package/src/engine-ports-mixed.test.ts

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import { bootstrapBuiltins } from './bootstrap';
 import { runPipeline, type RunEventPayload } from './engine';
 import { PluginRegistry } from './registry';
-import type { DriverPlugin, PipelineConfig, TaskConfig } from './types';
+import type { DriverPlugin, PipelineConfig, TagmaRuntime, TaskConfig, TaskResult } from './types';
 
 const PERMS = { read: true, write: false, execute: false };
 
@@ -13,40 +13,7 @@ function makeDir(): string {
   return mkdtempSync(join(tmpdir(), 'tagma-bindings-mixed-'));
 }
 
-function writeEmitScript(dir: string, name: string, payload: Record<string, unknown>): string {
-  const path = join(dir, `${name}.js`);
-  writeFileSync(
-    path,
-    `process.stdout.write(${JSON.stringify(JSON.stringify(payload))});\nprocess.stdout.write('\\n');\n`,
-  );
-  return path;
-}
-
-function writeEchoArgsScript(dir: string): string {
-  const path = join(dir, 'echo.js');
-  writeFileSync(path, `process.stdout.write(process.argv.slice(2).join('|'));\n`);
-  return path;
-}
-
-function writeMockDriverScript(dir: string): string {
-  const path = join(dir, 'mock-driver.js');
-  writeFileSync(
-    path,
-    [
-      `const fs = require('fs');`,
-      `let buf = '';`,
-      `process.stdin.setEncoding('utf8');`,
-      `process.stdin.on('data', (c) => { buf += c; });`,
-      `process.stdin.on('end', () => {`,
-      `  fs.writeFileSync(process.env.MOCK_RECORD_PATH, buf);`,
-      `  process.stdout.write(process.env.MOCK_RESPONSE + '\\n');`,
-      `});`,
-    ].join('\n'),
-  );
-  return path;
-}
-
-function registry(script: string, responses: Record<string, Record<string, unknown>>, records: Record<string, string>) {
+function registry(responses: Record<string, Record<string, unknown>>, records: Record<string, string>) {
   const reg = new PluginRegistry();
   bootstrapBuiltins(reg);
   const driver: DriverPlugin = {
@@ -54,7 +21,7 @@ function registry(script: string, responses: Record<string, Record<string, unkno
     capabilities: { sessionResume: false, systemPrompt: true, outputFormat: true },
     async buildCommand(task) {
       return {
-        args: ['node', script],
+        args: ['mock-driver', task.id],
         stdin: task.prompt ?? '',
         env: {
           MOCK_RESPONSE: JSON.stringify(responses[task.id] ?? {}),
@@ -85,12 +52,75 @@ async function run(config: PipelineConfig, workDir: string, reg: PluginRegistry)
   const events: RunEventPayload[] = [];
   const result = await runPipeline(config, workDir, {
     registry: reg,
+    runtime: fakeRuntime(),
     skipPluginLoading: true,
     onEvent: (e) => events.push(e),
   });
   return { events, success: result.success };
 }
 
+function taskResult(stdout: string, normalizedOutput: string | null = null): TaskResult {
+  return {
+    exitCode: 0,
+    stdout,
+    stderr: '',
+    stdoutPath: null,
+    stderrPath: null,
+    stdoutBytes: stdout.length,
+    stderrBytes: 0,
+    durationMs: 1,
+    sessionId: null,
+    normalizedOutput,
+    failureKind: null,
+  };
+}
+
+function fakeRuntime(): TagmaRuntime {
+  return {
+    async runCommand(command) {
+      if (command.startsWith('emit-city')) return taskResult('{"city":"Berlin"}\n');
+      return taskResult('ok\n');
+    },
+    async runSpawn(spec) {
+      const response = spec.env?.['MOCK_RESPONSE'] ?? '{}';
+      const recordPath = spec.env?.['MOCK_RECORD_PATH'];
+      if (recordPath) writeFileSync(recordPath, spec.stdin ?? '');
+      return taskResult(response + '\n', response);
+    },
+    async ensureDir() {
+      /* no-op */
+    },
+    async fileExists() {
+      return false;
+    },
+    async *watch() {
+      /* no-op */
+    },
+    logStore: {
+      openRunLog({ runId }) {
+        return {
+          path: `mem://${runId}/pipeline.log`,
+          dir: `mem://${runId}`,
+          append() {
+            /* memory sink */
+          },
+          close() {
+            /* memory sink */
+          },
+        };
+      },
+      taskOutputPath({ runId, taskId, stream }) {
+        return `mem://${runId}/${taskId}.${stream}`;
+      },
+      logsDir() {
+        return 'mem://logs';
+      },
+    },
+    now: () => new Date('2026-04-26T00:00:00.000Z'),
+    sleep: () => Promise.resolve(),
+  };
+}
+
 function finalUpdateFor(events: RunEventPayload[], qid: string): RunEventPayload | undefined {
   let last: RunEventPayload | undefined;
   for (const ev of events) {
@@ -103,17 +133,15 @@ describe('engine — mixed prompt/command unified bindings', () => {
   test('prompt outputs are inferred from downstream command inputs', async () => {
     const dir = makeDir();
     try {
-      const driverScript = writeMockDriverScript(dir);
-      const echo = writeEchoArgsScript(dir);
       const record = join(dir, 'prompt.txt');
-      const reg = registry(driverScript, { plan: { city: 'Paris' } }, { plan: record });
+      const reg = registry({ plan: { city: 'Paris' } }, { plan: record });
       const config = pipeline([
         task({ id: 'plan', prompt: 'Pick a city' }),
         task({
           id: 'fetch',
           driver: 'opencode',
           depends_on: ['plan'],
-          command: `node "${echo}" "{{inputs.city}}"`,
+          command: 'echo-city "{{inputs.city}}"',
           inputs: { city: { from: 't.plan.outputs.city', type: 'string', required: true } },
         }),
       ]);
@@ -131,15 +159,13 @@ describe('engine — mixed prompt/command unified bindings', () => {
   test('prompt inputs are inferred from upstream command outputs', async () => {
     const dir = makeDir();
     try {
-      const emit = writeEmitScript(dir, 'emit', { city: 'Berlin' });
-      const driverScript = writeMockDriverScript(dir);
       const record = join(dir, 'prompt.txt');
-      const reg = registry(driverScript, { summarize: {} }, { summarize: record });
+      const reg = registry({ summarize: {} }, { summarize: record });
       const config = pipeline([
         task({
           id: 'up',
           driver: 'opencode',
-          command: `node "${emit}"`,
+          command: 'emit-city',
           outputs: { city: { type: 'string' } },
         }),
         task({ id: 'summarize', depends_on: ['up'], prompt: 'City is {{inputs.city}}' }),

package/src/engine-ports.test.ts

@@ -1,11 +1,11 @@
 import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { bootstrapBuiltins } from './bootstrap';
 import { runPipeline, type RunEventPayload } from './engine';
 import { PluginRegistry } from './registry';
-import type { PipelineConfig, TaskConfig, TaskStatus } from './types';
+import type { PipelineConfig, TaskConfig, TagmaRuntime, TaskResult, TaskStatus } from './types';
 
 const PERMS = { read: true, write: false, execute: false };
 
@@ -19,21 +19,6 @@ function makeDir(): string {
   return mkdtempSync(join(tmpdir(), 'tagma-bindings-'));
 }
 
-function writeEmitScript(dir: string, name: string, payload: Record<string, unknown>): string {
-  const path = join(dir, `${name}.js`);
-  writeFileSync(
-    path,
-    `process.stdout.write(${JSON.stringify(JSON.stringify(payload))});\nprocess.stdout.write('\\n');\n`,
-  );
-  return path;
-}
-
-function writeEchoArgsScript(dir: string, name: string): string {
-  const path = join(dir, `${name}.js`);
-  writeFileSync(path, `process.stdout.write(process.argv.slice(2).join('|'));\n`);
-  return path;
-}
-
 function task(overrides: Partial<TaskConfig> & { id: string }): TaskConfig {
   return {
     name: overrides.id,
@@ -59,10 +44,72 @@ function pipeline(tasks: TaskConfig[]): PipelineConfig {
   };
 }
 
-async function run(config: PipelineConfig, workDir: string) {
+function taskResult(stdout: string): TaskResult {
+  return {
+    exitCode: 0,
+    stdout,
+    stderr: '',
+    stdoutPath: null,
+    stderrPath: null,
+    stdoutBytes: stdout.length,
+    stderrBytes: 0,
+    durationMs: 1,
+    sessionId: null,
+    normalizedOutput: null,
+    failureKind: null,
+  };
+}
+
+function fakeRuntime(commandStdout: Record<string, string>): TagmaRuntime {
+  return {
+    async runCommand(command) {
+      for (const [prefix, stdout] of Object.entries(commandStdout)) {
+        if (command.startsWith(prefix)) return taskResult(stdout);
+      }
+      return taskResult('Shanghai|42\n');
+    },
+    async runSpawn() {
+      throw new Error('runSpawn should not be called');
+    },
+    async ensureDir() {
+      /* no-op */
+    },
+    async fileExists() {
+      return false;
+    },
+    async *watch() {
+      /* no-op */
+    },
+    logStore: {
+      openRunLog({ runId }) {
+        return {
+          path: `mem://${runId}/pipeline.log`,
+          dir: `mem://${runId}`,
+          append() {
+            /* memory sink */
+          },
+          close() {
+            /* memory sink */
+          },
+        };
+      },
+      taskOutputPath({ runId, taskId, stream }) {
+        return `mem://${runId}/${taskId}.${stream}`;
+      },
+      logsDir() {
+        return 'mem://logs';
+      },
+    },
+    now: () => new Date('2026-04-26T00:00:00.000Z'),
+    sleep: () => Promise.resolve(),
+  };
+}
+
+async function run(config: PipelineConfig, workDir: string, runtime: TagmaRuntime) {
   const events: RunEventPayload[] = [];
   const result = await runPipeline(config, workDir, {
     registry: freshRegistry(),
+    runtime,
     skipPluginLoading: true,
     onEvent: (e) => events.push(e),
   });
@@ -86,18 +133,17 @@ describe('engine — unified inputs and outputs', () => {
   test('typed outputs feed typed inputs and command placeholders', async () => {
     const dir = makeDir();
     try {
-      const emit = writeEmitScript(dir, 'emit', { id: '42', city: 'Shanghai' });
-      const echo = writeEchoArgsScript(dir, 'echo');
+      const runtime = fakeRuntime({ 'emit-valid': '{"id":"42","city":"Shanghai"}\n' });
       const config = pipeline([
         task({
           id: 'up',
-          command: `node "${emit}"`,
+          command: 'emit-valid',
           outputs: { id: { type: 'number' }, city: { type: 'string' } },
         }),
         task({
           id: 'down',
           depends_on: ['up'],
-          command: `node "${echo}" "{{inputs.city}}" "{{inputs.id}}"`,
+          command: 'echo-down "{{inputs.city}}" "{{inputs.id}}"',
           inputs: {
             city: { from: 't.up.outputs.city', type: 'string', required: true },
             id: { from: 't.up.outputs.id', type: 'number', required: true },
@@ -105,7 +151,7 @@ describe('engine — unified inputs and outputs', () => {
         }),
       ]);
 
-      const { events, success } = await run(config, dir);
+      const { events, success } = await run(config, dir, runtime);
       expect(success).toBe(true);
       expect(finalUpdateFor(events, 't.up')?.outputs).toEqual({ id: 42, city: 'Shanghai' });
       expect(finalUpdateFor(events, 't.down')?.inputs).toEqual({ city: 'Shanghai', id: 42 });
@@ -118,19 +164,18 @@ describe('engine — unified inputs and outputs', () => {
   test('missing required unified input blocks without spawning downstream', async () => {
     const dir = makeDir();
     try {
-      const emit = writeEmitScript(dir, 'emit', { other: 'x' });
-      const echo = writeEchoArgsScript(dir, 'echo');
+      const runtime = fakeRuntime({ 'emit-missing': '{"other":"x"}\n' });
       const config = pipeline([
-        task({ id: 'up', command: `node "${emit}"`, outputs: { city: { type: 'string' } } }),
+        task({ id: 'up', command: 'emit-missing', outputs: { city: { type: 'string' } } }),
         task({
           id: 'down',
           depends_on: ['up'],
-          command: `node "${echo}" "{{inputs.city}}"`,
+          command: 'echo-down "{{inputs.city}}"',
           inputs: { city: { from: 't.up.outputs.city', type: 'string', required: true } },
         }),
       ]);
 
-      const { events, success } = await run(config, dir);
+      const { events, success } = await run(config, dir, runtime);
       expect(success).toBe(false);
       expect(finalStatusFrom(events, 't.up')).toBe('success');
       expect(finalStatusFrom(events, 't.down')).toBe('blocked');
@@ -142,19 +187,18 @@ describe('engine — unified inputs and outputs', () => {
   test('typed output coercion diagnostics leave missing downstream input', async () => {
     const dir = makeDir();
     try {
-      const emit = writeEmitScript(dir, 'emit', { id: 'not-a-number' });
-      const echo = writeEchoArgsScript(dir, 'echo');
+      const runtime = fakeRuntime({ 'emit-bad': '{"id":"not-a-number"}\n' });
       const config = pipeline([
-        task({ id: 'up', command: `node "${emit}"`, outputs: { id: { type: 'number' } } }),
+        task({ id: 'up', command: 'emit-bad', outputs: { id: { type: 'number' } } }),
         task({
           id: 'down',
           depends_on: ['up'],
-          command: `node "${echo}" "{{inputs.id}}"`,
+          command: 'echo-down "{{inputs.id}}"',
           inputs: { id: { from: 't.up.outputs.id', type: 'number', required: true } },
         }),
       ]);
 
-      const { events, success } = await run(config, dir);
+      const { events, success } = await run(config, dir, runtime);
       expect(success).toBe(false);
       expect(finalStatusFrom(events, 't.up')).toBe('success');
       expect(finalUpdateFor(events, 't.up')?.stderr).toContain('expected number');