@tagma/sdk 0.4.7 → 0.4.9

package/src/engine.ts

@@ -1,5 +1,5 @@
-import { resolve, dirname } from 'path';
-import { mkdir, readdir, rm } from 'fs/promises';
+import { resolve } from 'path';
+import { readdir, rm } from 'fs/promises';
 import type {
   PipelineConfig, TaskConfig, TrackConfig, TaskState, TaskStatus,
   TaskResult, DriverPlugin, TriggerPlugin, CompletionPlugin,
@@ -9,7 +9,7 @@ import type {
 import { buildDag, type Dag, type DagNode } from './dag';
 import { getHandler, hasHandler, loadPlugins } from './registry';
 import { runSpawn, runCommand } from './runner';
-import { parseDuration, nowISO, generateRunId, validatePath } from './utils';
+import { parseDuration, nowISO, generateRunId } from './utils';
 import {
   executeHook,
   buildPipelineStartContext, buildTaskContext,
@@ -79,7 +79,7 @@ function preflight(config: PipelineConfig, dag: Dag): void {
           const upstream = dag.nodes.get(upstreamId);
           if (upstream) {
             // A handoff is possible via session resume (already ruled out above),
-            // an output file, OR in-memory text injection through normalizedMap
+            // OR in-memory text injection through normalizedMap
             // (when the upstream driver implements parseResult and returns normalizedOutput).
             const upstreamDriverName = upstream.task.driver ?? upstream.track.driver
               ?? config.driver ?? 'claude-code';
@@ -88,12 +88,12 @@ function preflight(config: PipelineConfig, dag: Dag): void {
               : null;
             const canNormalize = typeof upstreamDriver?.parseResult === 'function';
 
-            if (!upstream.task.output && !canNormalize) {
+            if (!canNormalize) {
               errors.push(
                 `Task "${node.taskId}" uses continue_from: "${task.continue_from}", ` +
-                `but upstream task "${upstreamId}" has no "output" field and its driver ` +
+                `but upstream task "${upstreamId}" its driver ` +
                 `does not implement parseResult for text-injection handoff. ` +
-                `Add output to the upstream task, use a driver with parseResult, or remove continue_from.`
+                `Use a driver with parseResult, or remove continue_from.`
               );
             }
           }
@@ -297,7 +297,6 @@ export async function runPipeline(
   options.onEvent?.({ type: 'pipeline_start', runId, states: statesSnapshot });
 
   const sessionMap = new Map<string, string>();
-  const outputMap = new Map<string, string>();
   const normalizedMap = new Map<string, string>();
 
   // Pipeline timeout
@@ -407,7 +406,6 @@ export async function runPipeline(
       status: state.status,
       exit_code: state.result?.exitCode ?? null,
       duration_ms: state.result?.durationMs ?? null,
-      output_path: state.result?.outputPath ?? null,
       stderr_path: state.result?.stderrPath ?? null,
       session_id: state.result?.sessionId ?? null,
       started_at: state.startedAt,
@@ -585,7 +583,7 @@ export async function runPipeline(
           log.debug(`[task:${taskId}]`,
             `middleware chain: ${mws.map(m => m.type).join(' → ')}`);
           const mwCtx: MiddlewareContext = {
-            task, track, outputMap, workDir: task.cwd ?? workDir,
+            task, track, workDir: task.cwd ?? workDir,
           };
           for (const mwConfig of mws) {
             const before = prompt.length;
@@ -611,7 +609,7 @@ export async function runPipeline(
 
         // H1: hand the driver a continue_from that has already been
         // qualified by dag.ts. Without this, drivers like codex/opencode/
-        // claude-code do `outputMap.get(task.continue_from)` directly with
+        // claude-code look up maps directly with
         // the user's raw (possibly bare) string, which races whenever two
         // tracks share a task name. dag.ts has the only authoritative
         // resolver, so we use its precomputed answer here.
@@ -621,7 +619,7 @@ export async function runPipeline(
           continue_from: node.resolvedContinueFrom ?? task.continue_from,
         };
         const driverCtx: DriverContext = {
-          sessionMap, outputMap, normalizedMap, workDir: task.cwd ?? workDir,
+          sessionMap, normalizedMap, workDir: task.cwd ?? workDir,
         };
         const spec = await driver.buildCommand(enrichedTask, track, driverCtx);
         log.debug(`[task:${taskId}]`, `driver=${driverName}`);
@@ -635,27 +633,6 @@ export async function runPipeline(
         result = await runSpawn(spec, driver, runOpts);
       }
 
-      // 5. Write output file with RAW stdout (preserves driver output format).
-      // Done BEFORE the completion check so a `file_exists` completion pointing
-      // at `task.output` observes the AI-generated artefact. Writes happen
-      // regardless of exit code so failed/timed-out tasks still leave a
-      // debuggable artefact on disk.
-      if (task.output) {
-        // validatePath enforces no .. traversal and no absolute paths escaping workDir.
-        const outPath = validatePath(task.output, workDir);
-        await mkdir(dirname(outPath), { recursive: true });
-        await Bun.write(outPath, result.stdout);
-        result = { ...result, outputPath: outPath };
-        // H1: only write the fully-qualified taskId. The previous "also store
-        // bare id when not yet present" trick produced non-deterministic
-        // continue_from lookups when two tracks shared a task name —
-        // whichever finished first won the bare key. dag.ts now resolves
-        // continue_from to a qualified id (DagNode.resolvedContinueFrom),
-        // and the enrichedTask handed to drivers carries that qualified
-        // version, so bare keys are no longer needed.
-        outputMap.set(taskId, outPath);
-      }
-
       // 6. Determine terminal status (without emitting yet — result must be complete first)
       // H2: branch on failureKind so spawn errors no longer masquerade as
       // timeouts. Old runners that don't set failureKind still work — we
@@ -697,7 +674,6 @@ export async function runPipeline(
           ? result.normalizedOutput.slice(0, MAX_NORMALIZED_BYTES) +
             `\n[…clipped at ${MAX_NORMALIZED_BYTES} bytes]`
           : result.normalizedOutput;
-        // H1: qualified-only key (see comment near outputMap above).
         normalizedMap.set(taskId, clipped);
       }
 
@@ -708,7 +684,7 @@ export async function runPipeline(
       }
 
       if (result.sessionId) {
-        // H1: qualified-only key (see comment near outputMap above).
+        // H1: qualified-only key.
         sessionMap.set(taskId, result.sessionId);
       }
 
@@ -736,9 +712,6 @@ export async function runPipeline(
       if (result.sessionId) {
         log.debug(`[task:${taskId}]`, `sessionId: ${result.sessionId}`);
       }
-      if (result.outputPath) {
-        log.debug(`[task:${taskId}]`, `wrote output: ${result.outputPath}`);
-      }
       if (result.stderrPath) {
         log.debug(`[task:${taskId}]`, `wrote stderr: ${result.stderrPath}`);
       }
@@ -760,7 +733,7 @@ export async function runPipeline(
         exitCode: -1,
         stdout: '',
         stderr: errMsg,
-        outputPath: null, stderrPath: null, durationMs: 0,
+        stderrPath: null, durationMs: 0,
         sessionId: null, normalizedOutput: null,
         // H2: Engine-level pre-execution errors (driver throw, middleware
         // throw, getHandler 404) classify as spawn_error — the process never

package/src/hooks.ts

@@ -141,7 +141,6 @@ export interface TaskInfo {
   readonly status: string;
   readonly exit_code: number | null;
   readonly duration_ms: number | null;
-  readonly output_path: string | null;
   readonly stderr_path: string | null;
   readonly session_id: string | null;
   readonly started_at: string | null;

package/src/registry.ts

@@ -1,214 +1,214 @@
-import type {
-  PluginCategory, DriverPlugin, TriggerPlugin,
-  CompletionPlugin, MiddlewarePlugin, PluginManifest,
-} from './types';
-
-type PluginType = DriverPlugin | TriggerPlugin | CompletionPlugin | MiddlewarePlugin;
-
-const VALID_CATEGORIES: ReadonlySet<PluginCategory> = new Set([
-  'drivers', 'triggers', 'completions', 'middlewares',
-]);
-
-const registries = {
-  drivers:     new Map<string, DriverPlugin>(),
-  triggers:    new Map<string, TriggerPlugin>(),
-  completions: new Map<string, CompletionPlugin>(),
-  middlewares: new Map<string, MiddlewarePlugin>(),
-};
-
-/**
- * Minimal contract enforcement so a malformed plugin fails fast at
- * 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
- *     get capabilities() { throw new Error('boom') }
- * and pass the basic typeof check, then crash preflight when the engine
- * touches `driver.capabilities.sessionResume`. (R8)
- */
-function validateContract(category: PluginCategory, handler: unknown): void {
-  if (!handler || typeof handler !== 'object') {
-    throw new Error(`Plugin handler for category "${category}" must be an object`);
-  }
-  const h = handler as Record<string, unknown>;
-  if (typeof h.name !== 'string' || h.name.length === 0) {
-    throw new Error(`Plugin handler for category "${category}" must declare a non-empty "name"`);
-  }
-  switch (category) {
-    case 'drivers': {
-      if (typeof h.buildCommand !== 'function') {
-        throw new Error(`drivers plugin "${h.name}" must export buildCommand()`);
-      }
-      // Materialize capabilities — this triggers any throwing getter NOW
-      // instead of during preflight.
-      let caps: unknown;
-      try {
-        caps = h.capabilities;
-      } catch (err) {
-        throw new Error(
-          `drivers plugin "${h.name}" capabilities accessor threw: ` +
-          (err instanceof Error ? err.message : String(err))
-        );
-      }
-      if (!caps || typeof caps !== 'object') {
-        throw new Error(`drivers plugin "${h.name}" must declare capabilities object`);
-      }
-      const c = caps as Record<string, unknown>;
-      for (const field of ['sessionResume', 'systemPrompt', 'outputFormat'] as const) {
-        if (typeof c[field] !== 'boolean') {
-          throw new Error(
-            `drivers plugin "${h.name}".capabilities.${field} must be a boolean (got ${typeof c[field]})`
-          );
-        }
-      }
-      // Optional methods, but if present must be functions.
-      for (const opt of ['parseResult', 'resolveModel', 'resolveTools'] as const) {
-        if (h[opt] !== undefined && typeof h[opt] !== 'function') {
-          throw new Error(
-            `drivers plugin "${h.name}".${opt} must be a function or undefined`
-          );
-        }
-      }
-      break;
-    }
-    case 'triggers':
-      if (typeof h.watch !== 'function') {
-        throw new Error(`triggers plugin "${h.name}" must export watch()`);
-      }
-      break;
-    case 'completions':
-      if (typeof h.check !== 'function') {
-        throw new Error(`completions plugin "${h.name}" must export check()`);
-      }
-      break;
-    case 'middlewares':
-      if (typeof h.enhance !== 'function') {
-        throw new Error(`middlewares plugin "${h.name}" must export enhance()`);
-      }
-      break;
-  }
-}
-
-export type RegisterResult = 'registered' | 'replaced' | 'unchanged';
-
-/**
- * Register a plugin under (category, type). Returns:
- *   - 'registered' on first registration
- *   - 'replaced'   when an existing entry was overwritten with a different handler
- *   - 'unchanged'  when the same handler instance was already present
- *
- * Throws if `category` is unknown, `type` is empty, or `handler` violates the
- * minimum interface contract for the category.
- */
-export function registerPlugin<T extends PluginType>(
-  category: PluginCategory, type: string, handler: T,
-): RegisterResult {
-  if (!VALID_CATEGORIES.has(category)) {
-    throw new Error(`Unknown plugin category "${category}"`);
-  }
-  if (typeof type !== 'string' || type.length === 0) {
-    throw new Error(`Plugin type must be a non-empty string (category="${category}")`);
-  }
-  validateContract(category, handler);
-  const registry = registries[category] as Map<string, T>;
-  const existing = registry.get(type);
-  if (existing === handler) return 'unchanged';
-  const wasReplaced = existing !== undefined;
-  registry.set(type, handler);
-  return wasReplaced ? 'replaced' : '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.
- */
-export function unregisterPlugin(category: PluginCategory, type: string): boolean {
-  if (!VALID_CATEGORIES.has(category)) return false;
-  return registries[category].delete(type);
-}
-
-export function getHandler<T extends PluginType>(
-  category: PluginCategory, type: string,
-): T {
-  const handler = registries[category].get(type);
-  if (!handler) {
-    throw new Error(
-      `${category} type "${type}" not registered.\n` +
-      `Install the plugin: bun add @tagma/${category.replace(/s$/, '')}-${type}`
-    );
-  }
-  return handler as T;
-}
-
-export function hasHandler(category: PluginCategory, type: string): boolean {
-  return registries[category].has(type);
-}
-
-// Plugin name must be a scoped npm package or a tagma-prefixed package.
-// Reject absolute/relative paths and suspicious patterns to prevent
-// arbitrary code execution via crafted YAML configs.
-export const PLUGIN_NAME_RE = /^(@[a-z0-9-]+\/[a-z0-9._-]+|tagma-plugin-[a-z0-9._-]+)$/;
-
-export function isValidPluginName(name: unknown): name is string {
-  return typeof name === 'string' && PLUGIN_NAME_RE.test(name);
-}
-
-/**
- * Parse and validate the `tagmaPlugin` field of a `package.json` blob.
- *
- * 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 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
- * the plugin author should hear about loudly, not a silent skip.
- *
- * Hosts use this during auto-discovery to decide whether to load a
- * package as a plugin without having to dynamically `import()` it.
- */
-export function readPluginManifest(pkgJson: unknown): PluginManifest | null {
-  if (!pkgJson || typeof pkgJson !== 'object') return null;
-  const raw = (pkgJson as Record<string, unknown>).tagmaPlugin;
-  if (raw === undefined) return null;
-  if (!raw || typeof raw !== 'object') {
-    throw new Error('tagmaPlugin field must be an object with { category, type }');
-  }
-  const m = raw as Record<string, unknown>;
-  const category = m.category;
-  const type = m.type;
-  if (typeof category !== 'string' || !VALID_CATEGORIES.has(category as PluginCategory)) {
-    throw new Error(
-      `tagmaPlugin.category must be one of ${[...VALID_CATEGORIES].join(', ')}, got ${JSON.stringify(category)}`
-    );
-  }
-  if (typeof type !== 'string' || type.length === 0) {
-    throw new Error(`tagmaPlugin.type must be a non-empty string, got ${JSON.stringify(type)}`);
-  }
-  return { category: category as PluginCategory, type };
-}
-
-export async function loadPlugins(pluginNames: readonly string[]): Promise<void> {
-  for (const name of pluginNames) {
-    if (!isValidPluginName(name)) {
-      throw new Error(
-        `Plugin "${name}" rejected: plugin names must be scoped npm packages ` +
-        `(e.g. @tagma/trigger-xyz) or tagma-plugin-* packages. ` +
-        `Relative/absolute paths are not allowed.`
-      );
-    }
-    const mod = await import(name);
-    if (!mod.pluginCategory || !mod.pluginType || !mod.default) {
-      throw new Error(
-        `Plugin "${name}" must export pluginCategory, pluginType, and default`
-      );
-    }
-    registerPlugin(mod.pluginCategory, mod.pluginType, mod.default);
-  }
-}
-
-export function listRegistered(category: PluginCategory): string[] {
-  return [...registries[category].keys()];
-}
+import type {
+  PluginCategory, DriverPlugin, TriggerPlugin,
+  CompletionPlugin, MiddlewarePlugin, PluginManifest,
+} from './types';
+
+type PluginType = DriverPlugin | TriggerPlugin | CompletionPlugin | MiddlewarePlugin;
+
+const VALID_CATEGORIES: ReadonlySet<PluginCategory> = new Set([
+  'drivers', 'triggers', 'completions', 'middlewares',
+]);
+
+const registries = {
+  drivers:     new Map<string, DriverPlugin>(),
+  triggers:    new Map<string, TriggerPlugin>(),
+  completions: new Map<string, CompletionPlugin>(),
+  middlewares: new Map<string, MiddlewarePlugin>(),
+};
+
+/**
+ * Minimal contract enforcement so a malformed plugin fails fast at
+ * 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
+ *     get capabilities() { throw new Error('boom') }
+ * and pass the basic typeof check, then crash preflight when the engine
+ * touches `driver.capabilities.sessionResume`. (R8)
+ */
+function validateContract(category: PluginCategory, handler: unknown): void {
+  if (!handler || typeof handler !== 'object') {
+    throw new Error(`Plugin handler for category "${category}" must be an object`);
+  }
+  const h = handler as Record<string, unknown>;
+  if (typeof h.name !== 'string' || h.name.length === 0) {
+    throw new Error(`Plugin handler for category "${category}" must declare a non-empty "name"`);
+  }
+  switch (category) {
+    case 'drivers': {
+      if (typeof h.buildCommand !== 'function') {
+        throw new Error(`drivers plugin "${h.name}" must export buildCommand()`);
+      }
+      // Materialize capabilities — this triggers any throwing getter NOW
+      // instead of during preflight.
+      let caps: unknown;
+      try {
+        caps = h.capabilities;
+      } catch (err) {
+        throw new Error(
+          `drivers plugin "${h.name}" capabilities accessor threw: ` +
+          (err instanceof Error ? err.message : String(err))
+        );
+      }
+      if (!caps || typeof caps !== 'object') {
+        throw new Error(`drivers plugin "${h.name}" must declare capabilities object`);
+      }
+      const c = caps as Record<string, unknown>;
+      for (const field of ['sessionResume', 'systemPrompt', 'outputFormat'] as const) {
+        if (typeof c[field] !== 'boolean') {
+          throw new Error(
+            `drivers plugin "${h.name}".capabilities.${field} must be a boolean (got ${typeof c[field]})`
+          );
+        }
+      }
+      // Optional methods, but if present must be functions.
+      for (const opt of ['parseResult', 'resolveModel', 'resolveTools'] as const) {
+        if (h[opt] !== undefined && typeof h[opt] !== 'function') {
+          throw new Error(
+            `drivers plugin "${h.name}".${opt} must be a function or undefined`
+          );
+        }
+      }
+      break;
+    }
+    case 'triggers':
+      if (typeof h.watch !== 'function') {
+        throw new Error(`triggers plugin "${h.name}" must export watch()`);
+      }
+      break;
+    case 'completions':
+      if (typeof h.check !== 'function') {
+        throw new Error(`completions plugin "${h.name}" must export check()`);
+      }
+      break;
+    case 'middlewares':
+      if (typeof h.enhance !== 'function') {
+        throw new Error(`middlewares plugin "${h.name}" must export enhance()`);
+      }
+      break;
+  }
+}
+
+export type RegisterResult = 'registered' | 'replaced' | 'unchanged';
+
+/**
+ * Register a plugin under (category, type). Returns:
+ *   - 'registered' on first registration
+ *   - 'replaced'   when an existing entry was overwritten with a different handler
+ *   - 'unchanged'  when the same handler instance was already present
+ *
+ * Throws if `category` is unknown, `type` is empty, or `handler` violates the
+ * minimum interface contract for the category.
+ */
+export function registerPlugin<T extends PluginType>(
+  category: PluginCategory, type: string, handler: T,
+): RegisterResult {
+  if (!VALID_CATEGORIES.has(category)) {
+    throw new Error(`Unknown plugin category "${category}"`);
+  }
+  if (typeof type !== 'string' || type.length === 0) {
+    throw new Error(`Plugin type must be a non-empty string (category="${category}")`);
+  }
+  validateContract(category, handler);
+  const registry = registries[category] as Map<string, T>;
+  const existing = registry.get(type);
+  if (existing === handler) return 'unchanged';
+  const wasReplaced = existing !== undefined;
+  registry.set(type, handler);
+  return wasReplaced ? 'replaced' : '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.
+ */
+export function unregisterPlugin(category: PluginCategory, type: string): boolean {
+  if (!VALID_CATEGORIES.has(category)) return false;
+  return registries[category].delete(type);
+}
+
+export function getHandler<T extends PluginType>(
+  category: PluginCategory, type: string,
+): T {
+  const handler = registries[category].get(type);
+  if (!handler) {
+    throw new Error(
+      `${category} type "${type}" not registered.\n` +
+      `Install the plugin: bun add @tagma/${category.replace(/s$/, '')}-${type}`
+    );
+  }
+  return handler as T;
+}
+
+export function hasHandler(category: PluginCategory, type: string): boolean {
+  return registries[category].has(type);
+}
+
+// Plugin name must be a scoped npm package or a tagma-prefixed package.
+// Reject absolute/relative paths and suspicious patterns to prevent
+// arbitrary code execution via crafted YAML configs.
+export const PLUGIN_NAME_RE = /^(@[a-z0-9-]+\/[a-z0-9._-]+|tagma-plugin-[a-z0-9._-]+)$/;
+
+export function isValidPluginName(name: unknown): name is string {
+  return typeof name === 'string' && PLUGIN_NAME_RE.test(name);
+}
+
+/**
+ * Parse and validate the `tagmaPlugin` field of a `package.json` blob.
+ *
+ * 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 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
+ * the plugin author should hear about loudly, not a silent skip.
+ *
+ * Hosts use this during auto-discovery to decide whether to load a
+ * package as a plugin without having to dynamically `import()` it.
+ */
+export function readPluginManifest(pkgJson: unknown): PluginManifest | null {
+  if (!pkgJson || typeof pkgJson !== 'object') return null;
+  const raw = (pkgJson as Record<string, unknown>).tagmaPlugin;
+  if (raw === undefined) return null;
+  if (!raw || typeof raw !== 'object') {
+    throw new Error('tagmaPlugin field must be an object with { category, type }');
+  }
+  const m = raw as Record<string, unknown>;
+  const category = m.category;
+  const type = m.type;
+  if (typeof category !== 'string' || !VALID_CATEGORIES.has(category as PluginCategory)) {
+    throw new Error(
+      `tagmaPlugin.category must be one of ${[...VALID_CATEGORIES].join(', ')}, got ${JSON.stringify(category)}`
+    );
+  }
+  if (typeof type !== 'string' || type.length === 0) {
+    throw new Error(`tagmaPlugin.type must be a non-empty string, got ${JSON.stringify(type)}`);
+  }
+  return { category: category as PluginCategory, type };
+}
+
+export async function loadPlugins(pluginNames: readonly string[]): Promise<void> {
+  for (const name of pluginNames) {
+    if (!isValidPluginName(name)) {
+      throw new Error(
+        `Plugin "${name}" rejected: plugin names must be scoped npm packages ` +
+        `(e.g. @tagma/trigger-xyz) or tagma-plugin-* packages. ` +
+        `Relative/absolute paths are not allowed.`
+      );
+    }
+    const mod = await import(name);
+    if (!mod.pluginCategory || !mod.pluginType || !mod.default) {
+      throw new Error(
+        `Plugin "${name}" must export pluginCategory, pluginType, and default`
+      );
+    }
+    registerPlugin(mod.pluginCategory, mod.pluginType, mod.default);
+  }
+}
+
+export function listRegistered(category: PluginCategory): string[] {
+  return [...registries[category].keys()];
+}

package/src/runner.ts

@@ -111,7 +111,6 @@ function failResult(stderr: string, durationMs: number): TaskResult {
     exitCode: -1,
     stdout: '',
     stderr,
-    outputPath: null,
     stderrPath: null,
     durationMs,
     sessionId: null,
@@ -289,7 +288,6 @@ export async function runSpawn(
       exitCode: -1,
       stdout,
       stderr,
-      outputPath: null,
       stderrPath: null,
       durationMs,
       sessionId: null,
@@ -339,7 +337,6 @@ export async function runSpawn(
         exitCode,
         stdout,
         stderr: stderr + note,
-        outputPath: null,
         stderrPath: null,
         durationMs,
         sessionId: null,
@@ -362,7 +359,6 @@ export async function runSpawn(
       exitCode: exitCode === 0 ? 1 : exitCode,
       stdout,
       stderr: stderr + (stderr.endsWith('\n') ? '' : '\n') + `[driver] ${forcedFailureMessage}`,
-      outputPath: null,
       stderrPath: null,
       durationMs,
       sessionId,
@@ -374,7 +370,6 @@ export async function runSpawn(
     exitCode,
     stdout,
     stderr,
-    outputPath: null,
     stderrPath: null,
     durationMs,
     sessionId,