@tagma/sdk 0.7.3 → 0.7.5

package/src/engine-ports.test.ts

@@ -1,166 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync, writeFileSync } 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';
-
-const PERMS = { read: true, write: false, execute: false };
-
-function freshRegistry(): PluginRegistry {
-  const reg = new PluginRegistry();
-  bootstrapBuiltins(reg);
-  return reg;
-}
-
-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,
-    permissions: PERMS,
-    driver: 'opencode',
-    ...overrides,
-  };
-}
-
-function pipeline(tasks: TaskConfig[]): PipelineConfig {
-  return {
-    name: 'bindings-test',
-    tracks: [
-      {
-        id: 't',
-        name: 'T',
-        driver: 'opencode',
-        permissions: PERMS,
-        on_failure: 'skip_downstream',
-        tasks,
-      },
-    ],
-  };
-}
-
-async function run(config: PipelineConfig, workDir: string) {
-  const events: RunEventPayload[] = [];
-  const result = await runPipeline(config, workDir, {
-    registry: freshRegistry(),
-    skipPluginLoading: true,
-    onEvent: (e) => events.push(e),
-  });
-  return { events, success: result.success };
-}
-
-function finalUpdateFor(events: RunEventPayload[], qid: string): RunEventPayload | undefined {
-  let last: RunEventPayload | undefined;
-  for (const ev of events) {
-    if (ev.type === 'task_update' && ev.taskId === qid) last = ev;
-  }
-  return last;
-}
-
-function finalStatusFrom(events: RunEventPayload[], qid: string): TaskStatus | undefined {
-  const last = finalUpdateFor(events, qid);
-  return last && last.type === 'task_update' ? last.status : undefined;
-}
-
-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 config = pipeline([
-        task({
-          id: 'up',
-          command: `node "${emit}"`,
-          outputs: { id: { type: 'number' }, city: { type: 'string' } },
-        }),
-        task({
-          id: 'down',
-          depends_on: ['up'],
-          command: `node "${echo}" "{{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 },
-          },
-        }),
-      ]);
-
-      const { events, success } = await run(config, dir);
-      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 });
-      expect(finalUpdateFor(events, 't.down')?.stdout).toContain('Shanghai|42');
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  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 config = pipeline([
-        task({ id: 'up', command: `node "${emit}"`, outputs: { city: { type: 'string' } } }),
-        task({
-          id: 'down',
-          depends_on: ['up'],
-          command: `node "${echo}" "{{inputs.city}}"`,
-          inputs: { city: { from: 't.up.outputs.city', type: 'string', required: true } },
-        }),
-      ]);
-
-      const { events, success } = await run(config, dir);
-      expect(success).toBe(false);
-      expect(finalStatusFrom(events, 't.up')).toBe('success');
-      expect(finalStatusFrom(events, 't.down')).toBe('blocked');
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  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 config = pipeline([
-        task({ id: 'up', command: `node "${emit}"`, outputs: { id: { type: 'number' } } }),
-        task({
-          id: 'down',
-          depends_on: ['up'],
-          command: `node "${echo}" "{{inputs.id}}"`,
-          inputs: { id: { from: 't.up.outputs.id', type: 'number', required: true } },
-        }),
-      ]);
-
-      const { events, success } = await run(config, dir);
-      expect(success).toBe(false);
-      expect(finalStatusFrom(events, 't.up')).toBe('success');
-      expect(finalUpdateFor(events, 't.up')?.stderr).toContain('expected number');
-      expect(finalStatusFrom(events, 't.down')).toBe('blocked');
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/src/engine-task-type.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { runPipeline, type RunEventPayload } from './engine';
-import { PluginRegistry } from './registry';
-import type { PipelineConfig } from './types';
-
-function makeDir(): string {
-  return mkdtempSync(join(tmpdir(), 'tagma-task-type-'));
-}
-
-describe('engine task type detection', () => {
-  test('empty command is still a command task and does not require a driver', async () => {
-    const dir = makeDir();
-    const previousShell = process.env.PIPELINE_SHELL;
-    process.env.PIPELINE_SHELL = 'cmd';
-    try {
-      const events: RunEventPayload[] = [];
-      const config: PipelineConfig = {
-        name: 'empty-command',
-        tracks: [
-          {
-            id: 't',
-            name: 'T',
-            tasks: [{ id: 'cmd', name: 'cmd', command: '' }],
-          },
-        ],
-      };
-
-      const result = await runPipeline(config, dir, {
-        registry: new PluginRegistry(),
-        skipPluginLoading: true,
-        onEvent: (event) => events.push(event),
-      });
-
-      expect(result.success).toBe(true);
-      expect(events.some((event) => event.type === 'run_start')).toBe(true);
-      const final = events.findLast(
-        (event) => event.type === 'task_update' && event.taskId === 't.cmd',
-      );
-      expect(final?.type).toBe('task_update');
-      if (final?.type === 'task_update') {
-        expect(final.status).toBe('success');
-        expect(final.resolvedDriver).toBeNull();
-      }
-    } finally {
-      if (previousShell === undefined) {
-        delete process.env.PIPELINE_SHELL;
-      } else {
-        process.env.PIPELINE_SHELL = previousShell;
-      }
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/src/engine.ts

@@ -1,458 +0,0 @@
-import { resolve } from 'path';
-import type {
-  PipelineConfig,
-  TaskConfig,
-  TaskState,
-  RunEventPayload,
-  RunTaskState,
-} from './types';
-import { buildDag } from './dag';
-import type { PluginRegistry } from './registry';
-import { parseDuration, nowISO, generateRunId } from './utils';
-import {
-  executeHook,
-  buildPipelineStartContext,
-  buildPipelineCompleteContext,
-  buildPipelineErrorContext,
-  type PipelineInfo,
-} from './hooks';
-import { Logger } from './logger';
-import { InMemoryApprovalGateway, type ApprovalGateway } from './approval';
-import {
-  freezeStates,
-  summarizeStates,
-  toRunTaskState,
-} from './core/run-state';
-import { preflight } from './core/preflight';
-import { pruneLogDirs } from './core/log-prune';
-import { RunContext } from './core/run-context';
-import {
-  allTasksTerminal,
-  findLaunchableTasks,
-  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(
-  task: TaskConfig,
-): task is TaskConfig & { readonly prompt: string; readonly command?: undefined } {
-  return task.prompt !== undefined && task.command === undefined;
-}
-
-// ═══ Engine ═══
-
-export interface EngineResult {
-  readonly success: boolean;
-  readonly runId: string;
-  readonly logPath: string;
-  readonly summary: {
-    total: number;
-    success: number;
-    failed: number;
-    skipped: number;
-    timeout: number;
-    blocked: number;
-  };
-  readonly states: ReadonlyMap<string, TaskState>;
-}
-
-// ═══ 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.
-
-// Re-export so SDK consumers can import the event type without reaching
-// into @tagma/types directly.
-export type { RunEventPayload } from './types';
-
-export interface RunPipelineOptions {
-  readonly approvalGateway?: ApprovalGateway;
-  /**
-   * Maximum number of per-run log directories to retain under `<workDir>/.tagma/logs/`.
-   * Oldest directories are deleted after each run. Defaults to 20. Set to 0 to disable cleanup.
-   */
-  readonly maxLogRuns?: number;
-  /**
-   * Caller-supplied run ID. When provided the engine uses this instead of
-   * generating its own via `generateRunId()`, keeping the editor and SDK
-   * log directories aligned on the same ID.
-   */
-  readonly runId?: string;
-  /**
-   * External AbortSignal — aborting it cancels the pipeline immediately.
-   * Equivalent to the pipeline timeout firing, but caller-controlled.
-   */
-  readonly signal?: AbortSignal;
-  /**
-   * Called on every pipeline/task status transition.
-   * Use for real-time UI updates (e.g. updating a visual workflow graph).
-   */
-  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
-   * resolution path (e.g. a user workspace's node_modules) so the engine
-   * doesn't re-resolve them via Node's default cwd-based import.
-   */
-  readonly skipPluginLoading?: boolean;
-  /**
-   * Plugin registry to resolve drivers/triggers/completions/middlewares from.
-   * Callers pass a per-instance or per-workspace registry so concurrent runs
-   * 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
-// (e.g. tasks waiting on a file or manual trigger).
-const POLL_INTERVAL_MS = 50;
-
-// R15: cap on each normalized-output entry stored in normalizedMap so a
-// runaway parseResult can't accumulate hundreds of MB across tasks. 1 MB
-// is generous for any text-context handoff between AI tasks.
-const MAX_NORMALIZED_BYTES = 1_000_000;
-
-export async function runPipeline(
-  config: PipelineConfig,
-  workDir: string,
-  options: RunPipelineOptions,
-): Promise<EngineResult> {
-  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.',
-    );
-  }
-
-  // Load any plugins declared in the pipeline config before preflight so that
-  // drivers, completions, and middlewares referenced in YAML are registered.
-  // Hosts that pre-load plugins from a custom path (e.g. the editor loading
-  // from the user's workspace node_modules) pass skipPluginLoading: true so
-  // we don't re-resolve via Node's cwd-based default import.
-  if (!options.skipPluginLoading && config.plugins?.length) {
-    await registry.loadPlugins(config.plugins);
-  }
-
-  const dag = buildDag(config);
-  const runId = options.runId ?? generateRunId();
-  preflight(config, dag, registry);
-
-  const startedAt = nowISO();
-  const pipelineInfo: PipelineInfo = { name: config.name, run_id: runId, started_at: startedAt };
-  // Forward every structured log line to subscribers as task_log events.
-  // Reading options.onEvent inside the callback (vs. capturing it once) keeps
-  // the SDK behavior correct if callers pass a fresh onEvent on each run.
-  const log = new Logger(workDir, runId, (record) => {
-    options.onEvent?.({
-      type: 'task_log',
-      runId,
-      taskId: record.taskId,
-      level: record.level,
-      timestamp: record.timestamp,
-      text: record.text,
-    });
-  });
-
-  try {
-    log.info('[pipeline]', `start "${config.name}" run_id=${runId}`);
-
-    // 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: opencode)'}`);
-    log.quiet(`timeout:       ${config.timeout ?? '(none)'}`);
-    log.quiet(`tracks:        ${config.tracks.length}`);
-    log.quiet(`tasks (total): ${dag.nodes.size}`);
-    log.quiet(`plugins:       ${(config.plugins ?? []).join(', ') || '(none)'}`);
-    log.quiet(
-      `hooks:         ${config.hooks ? Object.keys(config.hooks).join(', ') || '(none)' : '(none)'}`,
-    );
-
-    log.section('DAG topology');
-    for (const [id, node] of dag.nodes) {
-      const deps = node.dependsOn.length ? node.dependsOn.join(', ') : '(root)';
-      const kind = isPromptTaskConfig(node.task) ? 'ai' : 'cmd';
-      log.quiet(`  • ${id}  [${kind}]  track=${node.track.id}  deps=[${deps}]`);
-    }
-    log.quiet('');
-
-    // Per-run state container. Constructed before the pipeline_start hook
-    // so the early-return path (blocked pipeline) can call freezeStates on
-    // the populated idle-state map. The constructor has no side effects —
-    // no listeners installed, no events emitted.
-    const ctx = new RunContext({
-      runId,
-      dag,
-      config,
-      workDir,
-      pipelineInfo,
-      onEvent: options.onEvent,
-      runtime,
-    });
-
-    // 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',
-      buildPipelineStartContext(pipelineInfo),
-      workDir,
-    );
-    if (!startHook.allowed) {
-      console.error(`Pipeline blocked by pipeline_start hook (exit code ${startHook.exitCode})`);
-      await executeHook(
-        config.hooks,
-        'pipeline_error',
-        buildPipelineErrorContext(pipelineInfo, 'pipeline_blocked', 'pipeline_blocked'),
-        workDir,
-      );
-      return {
-        success: false,
-        runId,
-        logPath: log.path,
-        summary: {
-          total: dag.nodes.size,
-          success: 0,
-          failed: 0,
-          skipped: 0,
-          timeout: 0,
-          blocked: 0,
-        },
-        states: freezeStates(ctx.states),
-      };
-    }
-
-    // Pipeline approved — transition all tasks to waiting.
-    for (const [, state] of ctx.states) {
-      state.status = 'waiting';
-    }
-    // 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 = ctx.states.get(id)!;
-      runStartTasks.push(toRunTaskState(id, node.track.id, node.task.name ?? id, s));
-    }
-    ctx.emit({ type: 'run_start', runId, tasks: runStartTasks });
-
-    // Pipeline timeout. `ctx.abortReason` 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 pipelineTimer: ReturnType<typeof setTimeout> | null = null;
-
-    if (pipelineTimeoutMs > 0) {
-      pipelineTimer = setTimeout(() => {
-        if (ctx.abortReason === null) ctx.abortReason = 'timeout';
-        ctx.abortController.abort();
-      }, pipelineTimeoutMs);
-    }
-
-    // When the pipeline is aborted (timeout, stop_all, external), drain
-    // all pending approvals so waiting triggers unblock immediately.
-    ctx.abortController.signal.addEventListener('abort', () => {
-      approvalGateway.abortAll('pipeline aborted');
-    });
-
-    // Wire external cancel signal into the internal abort controller.
-    const externalAbortHandler = () => {
-      if (ctx.abortReason === null) ctx.abortReason = 'external';
-      ctx.abortController.abort();
-    };
-    if (options.signal) {
-      if (options.signal.aborted) {
-        externalAbortHandler();
-      } else {
-        options.signal.addEventListener('abort', externalAbortHandler, { once: true });
-      }
-    }
-
-    // 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') {
-        ctx.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';
-        ctx.emit({
-          type: 'approval_resolved',
-          runId,
-          requestId: ev.request.id,
-          outcome,
-        });
-      }
-    });
-
-    // ── Process a single task ──
-    // ── Event loop ──
-    // Each task is launched as soon as ALL its deps reach a terminal state.
-    // We track in-flight tasks in `running` so a task completing mid-batch
-    // immediately unblocks its dependents without waiting for sibling tasks.
-    const running = new Map<string, Promise<void>>();
-
-    try {
-      while (ctx.abortReason === null) {
-        // Launch every task whose deps are all terminal and that isn't already in-flight
-        for (const id of findLaunchableTasks(ctx, new Set(running.keys()))) {
-          const p = executeTask({
-            taskId: id,
-            ctx,
-            registry,
-            log,
-            approvalGateway,
-          }).finally(() => running.delete(id));
-          running.set(id, p);
-        }
-
-        // All tasks terminal — done
-        if (allTasksTerminal(ctx)) break;
-
-        if (running.size === 0) {
-          // Nothing in-flight but non-terminal tasks exist (e.g. trigger-wait states
-          // that processTask hasn't been called for yet). Poll briefly.
-          await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-        } else {
-          // Wait for any one task to finish, then re-scan for new launchables.
-          await Promise.race(running.values());
-        }
-      }
-
-      if (ctx.abortReason !== null) {
-        // Wait for in-flight tasks to honour the abort signal before marking states.
-        if (running.size > 0) await Promise.allSettled(running.values());
-        // By the time allSettled resolves, processTask's try/finally has already
-        // set running tasks to success/failed/timeout. The only non-terminal
-        // statuses remaining here are waiting/idle tasks that were never started.
-        skipNonTerminalTasks(ctx);
-      }
-    } finally {
-      if (pipelineTimer) clearTimeout(pipelineTimer);
-      // Clean up the external abort signal listener to prevent dead references
-      // accumulating on long-lived shared AbortControllers.
-      if (options.signal) {
-        options.signal.removeEventListener('abort', externalAbortHandler);
-      }
-      // Safety net: drain any approvals still pending at shutdown (e.g. crash path).
-      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 ──
-    const summary = summarizeStates(ctx.states);
-
-    const finishedAt = nowISO();
-    const durationMs = new Date(finishedAt).getTime() - new Date(startedAt).getTime();
-
-    if (ctx.abortReason !== null) {
-      const reasonText =
-        ctx.abortReason === 'timeout'
-          ? 'Pipeline timeout exceeded'
-          : ctx.abortReason === 'stop_all'
-            ? 'Pipeline stopped (on_failure: stop_all)'
-            : 'Pipeline aborted by host';
-      await executeHook(
-        config.hooks,
-        'pipeline_error',
-        buildPipelineErrorContext(pipelineInfo, reasonText, undefined, ctx.abortReason),
-        workDir,
-      );
-    } else {
-      await executeHook(
-        config.hooks,
-        'pipeline_complete',
-        buildPipelineCompleteContext(
-          { ...pipelineInfo, finished_at: finishedAt, duration_ms: durationMs },
-          summary,
-        ),
-        workDir,
-      );
-    }
-
-    const allSuccess =
-      ctx.abortReason === null &&
-      summary.failed === 0 &&
-      summary.timeout === 0 &&
-      summary.blocked === 0;
-
-    log.section('Pipeline summary');
-    log.quiet(
-      `status:   ${ctx.abortReason !== null ? `aborted (${ctx.abortReason})` : 'completed'}`,
-    );
-    log.quiet(`duration: ${(durationMs / 1000).toFixed(1)}s`);
-    log.quiet(
-      `counts:   total=${summary.total} success=${summary.success} ` +
-        `failed=${summary.failed} skipped=${summary.skipped} ` +
-        `timeout=${summary.timeout} blocked=${summary.blocked}`,
-    );
-    log.quiet('');
-    log.quiet('per-task:');
-    for (const [id, state] of ctx.states) {
-      const dur =
-        state.result?.durationMs != null ? `${(state.result.durationMs / 1000).toFixed(1)}s` : '-';
-      const exit = state.result?.exitCode ?? '-';
-      log.quiet(`  ${state.status.padEnd(8)} ${id}  (exit=${exit}, ${dur})`);
-    }
-
-    log.info('[pipeline]', `completed "${config.name}"`);
-    log.info(
-      '[pipeline]',
-      `Total: ${summary.total} | Success: ${summary.success} | Failed: ${summary.failed} | Skipped: ${summary.skipped} | Timeout: ${summary.timeout} | Blocked: ${summary.blocked}`,
-    );
-    log.info('[pipeline]', `Duration: ${(durationMs / 1000).toFixed(1)}s`);
-    log.info('[pipeline]', `Log: ${log.path}`);
-
-    ctx.emit({ type: 'run_end', runId, success: allSuccess, abortReason: ctx.abortReason });
-    return { success: allSuccess, runId, logPath: log.path, summary, states: freezeStates(ctx.states) };
-  } finally {
-    // Close the persistent log file handle before pruning.
-    log.close();
-    // Prune old per-run log directories on every exit path (normal, blocked, or thrown).
-    // Exclude the current runId so a concurrent run cannot delete its own live directory.
-    if (maxLogRuns > 0) {
-      await pruneLogDirs(resolve(workDir, '.tagma', 'logs'), maxLogRuns, runId);
-    }
-  }
-}
-
-