@tagma/sdk 0.4.19 → 0.5.1

package/src/drivers/opencode.ts

@@ -0,0 +1,204 @@
+import type {
+  DriverPlugin,
+  DriverCapabilities,
+  DriverResultMeta,
+  TaskConfig,
+  TrackConfig,
+  DriverContext,
+  SpawnSpec,
+} from '../types';
+
+const DEFAULT_MODEL = 'opencode/big-pickle';
+
+// NOTE on Windows multi-line prompts: `opencode` resolves to `opencode.cmd`,
+// an npm-generated batch wrapper. cmd.exe silently truncates argv elements
+// at the first newline, so a multi-line prompt reaches the model as only
+// its first line. The SDK's runner auto-unwraps npm .cmd shims into direct
+// `node <js-entry>` invocations so newlines survive, and this driver can
+// keep using the bare `opencode` name on every platform.
+
+// tagma uses a provider-neutral reasoning_effort vocabulary (low|medium|high)
+// but opencode's `--variant` is provider-specific (e.g. high|max|minimal).
+// Map the tagma values to the closest opencode variant:
+//   low    → minimal  (least thinking)
+//   medium → <no flag, provider default>
+//   high   → high     (most thinking)
+// Unknown values pass through unchanged so users who target a specific
+// opencode variant (e.g. "max") still work.
+const EFFORT_TO_VARIANT: Record<string, string | null> = {
+  low: 'minimal',
+  medium: null,
+  high: 'high',
+};
+
+export const OpenCodeDriver: DriverPlugin = {
+  name: 'opencode',
+
+  capabilities: {
+    sessionResume: true, // supports --session
+    systemPrompt: false, // no --system-prompt flag; prepend to prompt instead
+    outputFormat: true, // supports --format json
+  } satisfies DriverCapabilities,
+
+  resolveModel(): string {
+    return DEFAULT_MODEL;
+  },
+
+  async buildCommand(task: TaskConfig, track: TrackConfig, ctx: DriverContext): Promise<SpawnSpec> {
+    const model = task.model ?? track.model ?? DEFAULT_MODEL;
+    // Resolve reasoning_effort → opencode --variant. SDK schema layer already
+    // resolved task → track → pipeline inheritance, so we only need to read
+    // task.reasoning_effort here.
+    const rawEffort = task.reasoning_effort ?? track.reasoning_effort;
+    const variant = rawEffort
+      ? rawEffort in EFFORT_TO_VARIANT
+        ? EFFORT_TO_VARIANT[rawEffort]
+        : rawEffort
+      : null;
+
+    let prompt = task.prompt!;
+
+    // agent_profile has no dedicated flag; prepend to prompt
+    const profile = task.agent_profile ?? track.agent_profile;
+    if (profile) {
+      prompt = `[Role]\n${profile}\n\n[Task]\n${prompt}`;
+    }
+
+    // continue_from: prefer session resume, fall back to text injection
+    let sessionId: string | null = null;
+    if (task.continue_from) {
+      sessionId = ctx.sessionMap.get(task.continue_from) ?? null;
+      if (!sessionId) {
+        // no session — degrade to text context passthrough
+        let prev: string | null = null;
+        if (ctx.normalizedMap.has(task.continue_from)) {
+          prev = ctx.normalizedMap.get(task.continue_from)!;
+        }
+        if (prev !== null) {
+          prompt = `[Previous Output]\n${prev}\n\n[Current Task]\n${prompt}`;
+        }
+      }
+    }
+
+    // opencode run does not support stdin (no `-` placeholder like codex exec).
+    // Prompt is always a positional argument. Flags must be declared before `--`;
+    // the prompt follows after so that leading `--flag` content cannot be
+    // misread by opencode's argument parser (flag-injection mitigation).
+    // Shell-level injection is already prevented by Bun.spawn's direct argv array.
+    // Windows cmd.exe argv truncation on the `.cmd` wrapper is handled by the
+    // SDK runner's shim unwrapping — see note at the top of this file.
+    const args: string[] = [
+      'opencode',
+      'run',
+      '--model',
+      model,
+      '--format',
+      'json', // JSON output for parseResult
+    ];
+
+    // `--variant` must precede `--` like every other flag. opencode rejects
+    // unknown variant names with a clear error, so we don't pre-validate.
+    if (variant) {
+      args.push('--variant', variant);
+    }
+
+    // session resume (must appear before --)
+    if (sessionId) {
+      args.push('--session', sessionId);
+    }
+
+    // `--` (POSIX end-of-options) isolates prompt from flag parsing
+    args.push('--', prompt);
+
+    return { args, cwd: task.cwd ?? ctx.workDir };
+  },
+
+  parseResult(stdout: string): DriverResultMeta {
+    // opencode --format json emits NDJSON — one JSON object per line
+    // (step_start / text / step_finish / …). The previous single
+    // `JSON.parse(stdout)` always threw on this shape and fell through to
+    // the catch, returning sessionId:null and losing session resume.
+    // Walk line-by-line, pick up the first sessionID we see, concatenate
+    // any text-type parts into normalizedOutput, and bail early on error
+    // payloads.
+    const lines = stdout.split(/\r?\n/);
+    let sessionId: string | undefined;
+    const textParts: string[] = [];
+    let sawAnyJson = false;
+    let errorReason: string | null = null;
+
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (!line) continue;
+      let json: Record<string, unknown>;
+      try {
+        json = JSON.parse(line) as Record<string, unknown>;
+      } catch {
+        continue; // tolerate interleaved non-JSON noise
+      }
+      sawAnyJson = true;
+
+      // M12: opencode sometimes emits {type:"error", error:{...}} with
+      // exit 0 for transient API failures. Force-fail so downstream
+      // skip_downstream / stop_all kicks in.
+      if (json.type === 'error') {
+        const err = json.error as { message?: unknown } | string | undefined;
+        const msg =
+          typeof err === 'object' && err !== null && typeof err.message === 'string'
+            ? err.message
+            : typeof err === 'string'
+              ? err
+              : null;
+        errorReason = msg
+          ? `opencode reported error: ${msg}`
+          : 'opencode emitted an error JSON payload';
+        // D21: stop at the first error. Continuing meant subsequent text
+        // lines got accumulated into `textParts` only to be discarded by
+        // the error-return below, and a later `{type:"error"}` would
+        // silently overwrite the original cause — operators then debugged
+        // a downstream symptom while the root-cause line scrolled past.
+        break;
+      }
+
+      // Session id — opencode uses `sessionID` (camelCase with capital D).
+      // Keep `session_id` / `sessionId` as fallbacks for forward/backward
+      // compatibility with other shapes.
+      if (!sessionId) {
+        const sid =
+          (json.sessionID as string | undefined) ??
+          (json.session_id as string | undefined) ??
+          (json.sessionId as string | undefined) ??
+          null;
+        if (typeof sid === 'string' && sid.length > 0) sessionId = sid;
+      }
+
+      // Extract human-readable text from text-type parts.
+      if (json.type === 'text') {
+        const part = json.part as { text?: unknown } | undefined;
+        if (part && typeof part.text === 'string') {
+          textParts.push(part.text);
+        }
+      } else if (typeof json.result === 'string') {
+        textParts.push(json.result);
+      } else if (typeof json.content === 'string') {
+        textParts.push(json.content);
+      }
+    }
+
+    if (errorReason) {
+      return { forceFailure: true, forceFailureReason: errorReason };
+    }
+
+    // If nothing parsed as JSON, treat stdout as plain text.
+    const normalizedOutput = !sawAnyJson
+      ? stdout
+      : textParts.length > 0
+        ? textParts.join('\n')
+        : stdout;
+
+    return {
+      sessionId,
+      normalizedOutput,
+    };
+  },
+};

package/src/engine.ts

@@ -14,6 +14,10 @@ import type {
   DriverContext,
   OnFailure,
   PromptDocument,
+  Permissions,
+  AbortReason,
+  RunEventPayload,
+  RunTaskState,
 } from './types';
 import { buildDag, type Dag } from './dag';
 import { getHandler, hasHandler, loadPlugins } from './registry';
@@ -30,7 +34,7 @@ import {
   type TrackInfo,
   type TaskInfo,
 } from './hooks';
-import { Logger, tailLines, clip, type LogLevel } from './logger';
+import { Logger, tailLines, clip } from './logger';
 import { InMemoryApprovalGateway, type ApprovalGateway } from './approval';
 
 // ═══ A7: Typed trigger errors ═══
@@ -61,7 +65,7 @@ function preflight(config: PipelineConfig, dag: Dag): void {
   for (const [, node] of dag.nodes) {
     const task = node.task;
     const track = node.track;
-    const driverName = task.driver ?? track.driver ?? config.driver ?? 'claude-code';
+    const driverName = task.driver ?? track.driver ?? config.driver ?? 'opencode';
 
     // Pure command tasks don't use a driver — skip driver registration check.
     const isCommandOnly = task.command && !task.prompt;
@@ -101,7 +105,7 @@ function preflight(config: PipelineConfig, dag: Dag): void {
             // 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';
+              upstream.task.driver ?? upstream.track.driver ?? config.driver ?? 'opencode';
             const upstreamDriver = hasHandler('drivers', upstreamDriverName)
               ? getHandler<DriverPlugin>('drivers', upstreamDriverName)
               : null;
@@ -144,37 +148,52 @@ export interface EngineResult {
 }
 
 // ═══ Pipeline Events ═══
+//
+// The engine emits RunEventPayload values (defined in @tagma/types) via
+// `onEvent`. Every payload carries `runId`; the editor server stamps a
+// per-run `seq` before broadcasting. There is one event vocabulary
+// end-to-end — no server-side translation layer.
 
-export type PipelineEvent =
-  | {
-      readonly type: 'task_status_change';
-      readonly taskId: string;
-      readonly status: TaskStatus;
-      readonly prevStatus: TaskStatus;
-      readonly runId: string;
-      readonly state: TaskState;
-    }
-  | {
-      readonly type: 'pipeline_start';
-      readonly runId: string;
-      readonly states: ReadonlyMap<string, TaskState>;
-    }
-  | { readonly type: 'pipeline_end'; readonly runId: string; readonly success: boolean }
-  /**
-   * Fine-grained log line emitted alongside every write to pipeline.log.
-   * Consumers use this to stream the full run process into UIs without
-   * tailing the log file. `taskId` is non-null for task-scoped lines and
-   * null for pipeline-wide messages (e.g. configuration dumps, DAG
-   * topology, pipeline start/end).
-   */
-  | {
-      readonly type: 'task_log';
-      readonly runId: string;
-      readonly taskId: string | null;
-      readonly level: LogLevel;
-      readonly timestamp: string;
-      readonly text: string;
-    };
+// Re-export so SDK consumers can import the event type without reaching
+// into @tagma/types directly.
+export type { RunEventPayload } from './types';
+
+// ═══ Helpers ═══
+
+/**
+ * Project the engine's internal TaskState onto the wire RunTaskState
+ * shape. `logs` / `totalLogCount` default to empty — they are populated
+ * on the server side from streamed `task_log` events, not from state.
+ */
+function toRunTaskState(
+  taskId: string,
+  trackId: string,
+  taskName: string,
+  state: TaskState,
+): RunTaskState {
+  const result = state.result;
+  const cfg = state.config;
+  return {
+    taskId,
+    trackId,
+    taskName,
+    status: state.status,
+    startedAt: state.startedAt,
+    finishedAt: state.finishedAt,
+    durationMs: result?.durationMs ?? null,
+    exitCode: result?.exitCode ?? null,
+    stdout: result?.stdout ?? '',
+    stderr: result?.stderr ?? '',
+    stderrPath: result?.stderrPath ?? null,
+    sessionId: result?.sessionId ?? null,
+    normalizedOutput: result?.normalizedOutput ?? null,
+    resolvedDriver: cfg.driver ?? null,
+    resolvedModel: cfg.model ?? null,
+    resolvedPermissions: (cfg.permissions as Permissions | undefined) ?? null,
+    logs: [],
+    totalLogCount: 0,
+  };
+}
 
 export interface RunPipelineOptions {
   readonly approvalGateway?: ApprovalGateway;
@@ -198,7 +217,7 @@ export interface RunPipelineOptions {
    * Called on every pipeline/task status transition.
    * Use for real-time UI updates (e.g. updating a visual workflow graph).
    */
-  readonly onEvent?: (event: PipelineEvent) => void;
+  readonly onEvent?: (event: RunEventPayload) => void;
   /**
    * Skip the engine's built-in `loadPlugins(config.plugins)` call.
    * Use this when the host has already pre-loaded plugins from a custom
@@ -260,7 +279,7 @@ export async function runPipeline(
     // File-only: dump the resolved pipeline shape + DAG topology for post-mortem.
     log.section('Pipeline configuration');
     log.quiet(`name:          ${config.name}`);
-    log.quiet(`driver:        ${config.driver ?? '(default: claude-code)'}`);
+    log.quiet(`driver:        ${config.driver ?? '(default: opencode)'}`);
     log.quiet(`timeout:       ${config.timeout ?? '(none)'}`);
     log.quiet(`tracks:        ${config.tracks.length}`);
     log.quiet(`tasks (total): ${dag.nodes.size}`);
@@ -290,7 +309,10 @@ export async function runPipeline(
       });
     }
 
-    // Pipeline start hook (gate)
+    // Pipeline start hook (gate). Runs BEFORE the engine emits run_start so
+    // a blocked pipeline produces zero wire events (the server treats the
+    // thrown error as run_error). Hosts get a rich error message; nothing
+    // is ever half-broadcast.
     const startHook = await executeHook(
       config.hooks,
       'pipeline_start',
@@ -305,7 +327,6 @@ export async function runPipeline(
         buildPipelineErrorContext(pipelineInfo, 'pipeline_blocked', 'pipeline_blocked'),
         workDir,
       );
-      // All tasks stay idle — pipeline never started
       return {
         success: false,
         runId,
@@ -322,41 +343,51 @@ export async function runPipeline(
       };
     }
 
-    // Pipeline approved — transition all tasks to waiting
+    // Pipeline approved — transition all tasks to waiting.
     for (const [, state] of states) {
       state.status = 'waiting';
     }
-    // Include a full states snapshot so listeners can initialize their mirrors without missing events
-    const statesSnapshot: ReadonlyMap<string, TaskState> = new Map(
-      [...states.entries()].map(([id, s]) => [id, { ...s }]),
-    );
-    options.onEvent?.({ type: 'pipeline_start', runId, states: statesSnapshot });
+    // Emit run_start with a wire-shape snapshot so SSE subscribers can
+    // initialize their task maps on the same event stream that carries
+    // updates. No separate "server pre-broadcasts run_start" ceremony —
+    // the engine owns the lifecycle boundary.
+    const runStartTasks: RunTaskState[] = [];
+    for (const [id, node] of dag.nodes) {
+      const s = states.get(id)!;
+      runStartTasks.push(toRunTaskState(id, node.track.id, node.task.name ?? id, s));
+    }
+    emit({ type: 'run_start', runId, tasks: runStartTasks });
 
     const sessionMap = new Map<string, string>();
     const normalizedMap = new Map<string, string>();
 
-    // Pipeline timeout
+    // Pipeline timeout + abort reason tracking.
+    //
+    // `abortReason` replaces the previous `pipelineAborted: boolean`: it
+    // carries the concrete cause (timeout / stop_all / external) through
+    // to run_end and the pipeline_error hook so downstream consumers can
+    // distinguish them without scraping message strings.
     const pipelineTimeoutMs = config.timeout ? parseDuration(config.timeout) : 0;
-    let pipelineAborted = false;
+    let abortReason: AbortReason | null = null;
     const abortController = new AbortController();
     let pipelineTimer: ReturnType<typeof setTimeout> | null = null;
 
     if (pipelineTimeoutMs > 0) {
       pipelineTimer = setTimeout(() => {
-        pipelineAborted = true;
+        if (abortReason === null) abortReason = 'timeout';
         abortController.abort();
       }, pipelineTimeoutMs);
     }
 
-    // When the pipeline is aborted (timeout, external shutdown), drain all
-    // pending approvals so waiting triggers unblock immediately.
+    // When the pipeline is aborted (timeout, stop_all, external), drain
+    // all pending approvals so waiting triggers unblock immediately.
     abortController.signal.addEventListener('abort', () => {
       approvalGateway.abortAll('pipeline aborted');
     });
 
     // Wire external cancel signal into the internal abort controller.
     const externalAbortHandler = () => {
-      pipelineAborted = true;
+      if (abortReason === null) abortReason = 'external';
       abortController.abort();
     };
     if (options.signal) {
@@ -367,9 +398,45 @@ export async function runPipeline(
       }
     }
 
+    // Bridge approval gateway events onto the wire stream so hosts (editor
+    // server, CLI adapters) see approvals on the same channel as task
+    // updates. The server no longer needs its own gateway subscription.
+    const unsubscribeApprovals = approvalGateway.subscribe((ev) => {
+      if (ev.type === 'requested') {
+        emit({
+          type: 'approval_request',
+          runId,
+          request: {
+            id: ev.request.id,
+            taskId: ev.request.taskId,
+            trackId: ev.request.trackId,
+            message: ev.request.message,
+            createdAt: ev.request.createdAt,
+            timeoutMs: ev.request.timeoutMs,
+            metadata: ev.request.metadata,
+          },
+        });
+        return;
+      }
+      if (ev.type === 'resolved' || ev.type === 'expired' || ev.type === 'aborted') {
+        const outcome =
+          ev.type === 'resolved'
+            ? ev.decision.outcome
+            : ev.type === 'expired'
+              ? 'timeout'
+              : 'aborted';
+        emit({
+          type: 'approval_resolved',
+          runId,
+          requestId: ev.request.id,
+          outcome,
+        });
+      }
+    });
+
     // ── Helpers ──
 
-    function emit(event: PipelineEvent): void {
+    function emit(event: RunEventPayload): void {
       options.onEvent?.(event);
     }
 
@@ -380,24 +447,26 @@ export async function runPipeline(
       // skipped and then having their in-flight processTask promise overwrite
       // that with success/failed, producing an invalid double transition.
       if (isTerminal(state.status)) return;
-      const prevStatus = state.status;
       state.status = newStatus;
-      // Snapshot state at emit time — result and finishedAt must be set before calling this for terminal statuses
-      const snapshot: TaskState = {
-        config: state.config,
-        trackConfig: state.trackConfig,
-        status: state.status,
-        result: state.result,
-        startedAt: state.startedAt,
-        finishedAt: state.finishedAt,
-      };
+      const result = state.result;
+      const cfg = state.config;
       emit({
-        type: 'task_status_change',
+        type: 'task_update',
+        runId,
         taskId,
         status: newStatus,
-        prevStatus,
-        runId,
-        state: snapshot,
+        startedAt: state.startedAt ?? undefined,
+        finishedAt: state.finishedAt ?? undefined,
+        durationMs: result?.durationMs,
+        exitCode: result?.exitCode,
+        stdout: result?.stdout,
+        stderr: result?.stderr,
+        stderrPath: result?.stderrPath ?? null,
+        sessionId: result?.sessionId ?? null,
+        normalizedOutput: result?.normalizedOutput ?? null,
+        resolvedDriver: cfg.driver ?? null,
+        resolvedModel: cfg.model ?? null,
+        resolvedPermissions: (cfg.permissions as Permissions | undefined) ?? null,
       });
     }
 
@@ -435,7 +504,7 @@ export async function runPipeline(
      * should a completed running task try to overwrite the skipped state.
      */
     function applyStopAll(_failedTrackId: string): void {
-      pipelineAborted = true;
+      if (abortReason === null) abortReason = 'stop_all';
       abortController.abort();
       for (const [id, state] of states) {
         if (state.status === 'waiting') {
@@ -559,7 +628,7 @@ export async function runPipeline(
           // If pipeline was aborted while we were still waiting for the trigger,
           // this task never entered running state → skipped, not timeout.
           state.finishedAt = nowISO();
-          if (pipelineAborted) {
+          if (abortReason !== null) {
             setTaskStatus(taskId, 'skipped');
           } else if (err instanceof TriggerBlockedError) {
             setTaskStatus(taskId, 'blocked'); // user/policy rejection
@@ -618,7 +687,7 @@ export async function runPipeline(
       }
 
       // 4. Mark running — set startedAt before emitting so subscribers see a
-      // complete snapshot (startedAt non-null) in the task_status_change event.
+      // complete task_update (startedAt non-null) on the status transition.
       state.startedAt = nowISO();
       setTaskStatus(taskId, 'running');
       log.info(
@@ -627,7 +696,7 @@ export async function runPipeline(
       );
 
       // File-only: resolved config for this task
-      const resolvedDriver = task.driver ?? track.driver ?? config.driver ?? 'claude-code';
+      const resolvedDriver = task.driver ?? track.driver ?? config.driver ?? 'opencode';
       const resolvedModel = task.model ?? track.model ?? config.model ?? '(default)';
       const resolvedPerms = task.permissions ?? track.permissions ?? '(default)';
       const resolvedCwd = task.cwd ?? track.cwd ?? workDir;
@@ -654,7 +723,7 @@ export async function runPipeline(
           result = await runCommand(task.command, task.cwd ?? workDir, runOpts);
         } else {
           // AI task: apply middleware chain against a structured PromptDocument.
-          const driverName = task.driver ?? track.driver ?? config.driver ?? 'claude-code';
+          const driverName = task.driver ?? track.driver ?? config.driver ?? 'opencode';
           const driver = getHandler<DriverPlugin>('drivers', driverName);
 
           const originalLen = task.prompt!.length;
@@ -936,7 +1005,7 @@ export async function runPipeline(
     const running = new Map<string, Promise<void>>();
 
     try {
-      while (!pipelineAborted) {
+      while (abortReason === null) {
         // Launch every task whose deps are all terminal and that isn't already in-flight
         for (const [id, state] of states) {
           if (state.status !== 'waiting' || running.has(id)) continue;
@@ -962,7 +1031,7 @@ export async function runPipeline(
         }
       }
 
-      if (pipelineAborted) {
+      if (abortReason !== null) {
         // Wait for in-flight tasks to honour the abort signal before marking states.
         if (running.size > 0) await Promise.allSettled(running.values());
         for (const [id, state] of states) {
@@ -986,6 +1055,9 @@ export async function runPipeline(
       if (approvalGateway.pending().length > 0) {
         approvalGateway.abortAll('pipeline finished');
       }
+      // Detach gateway → onEvent bridge so a long-lived gateway (host-supplied)
+      // doesn't keep firing into a dead run.
+      unsubscribeApprovals();
     }
 
     // ── Summary ──
@@ -1014,11 +1086,17 @@ export async function runPipeline(
     const finishedAt = nowISO();
     const durationMs = new Date(finishedAt).getTime() - new Date(startedAt).getTime();
 
-    if (pipelineAborted) {
+    if (abortReason !== null) {
+      const reasonText =
+        abortReason === 'timeout'
+          ? 'Pipeline timeout exceeded'
+          : abortReason === 'stop_all'
+            ? 'Pipeline stopped (on_failure: stop_all)'
+            : 'Pipeline aborted by host';
       await executeHook(
         config.hooks,
         'pipeline_error',
-        buildPipelineErrorContext(pipelineInfo, 'Pipeline timeout exceeded'),
+        buildPipelineErrorContext(pipelineInfo, reasonText, undefined, abortReason),
         workDir,
       );
     } else {
@@ -1034,10 +1112,15 @@ export async function runPipeline(
     }
 
     const allSuccess =
-      !pipelineAborted && summary.failed === 0 && summary.timeout === 0 && summary.blocked === 0;
+      abortReason === null &&
+      summary.failed === 0 &&
+      summary.timeout === 0 &&
+      summary.blocked === 0;
 
     log.section('Pipeline summary');
-    log.quiet(`status:   ${pipelineAborted ? 'aborted (timeout)' : 'completed'}`);
+    log.quiet(
+      `status:   ${abortReason !== null ? `aborted (${abortReason})` : 'completed'}`,
+    );
     log.quiet(`duration: ${(durationMs / 1000).toFixed(1)}s`);
     log.quiet(
       `counts:   total=${summary.total} success=${summary.success} ` +
@@ -1061,7 +1144,7 @@ export async function runPipeline(
     log.info('[pipeline]', `Duration: ${(durationMs / 1000).toFixed(1)}s`);
     log.info('[pipeline]', `Log: ${log.path}`);
 
-    emit({ type: 'pipeline_end', runId, success: allSuccess });
+    emit({ type: 'run_end', runId, success: allSuccess, abortReason });
     return { success: allSuccess, runId, logPath: log.path, summary, states: freezeStates(states) };
   } finally {
     // Close the persistent log file handle before pruning.

package/src/hooks.ts

@@ -1,4 +1,4 @@
-import type { HooksConfig, HookCommand } from './types';
+import type { HooksConfig, HookCommand, AbortReason } from './types';
 import { shellArgs } from './utils';
 
 type HookEvent =
@@ -182,6 +182,12 @@ export function buildPipelineErrorContext(
   pipeline: PipelineInfo,
   error: string,
   eventType?: string,
+  abortReason?: AbortReason,
 ) {
-  return { event: eventType ?? 'pipeline_error', pipeline, error };
+  return {
+    event: eventType ?? 'pipeline_error',
+    pipeline,
+    error,
+    ...(abortReason !== undefined ? { abort_reason: abortReason } : {}),
+  };
 }