@tagma/sdk 0.7.3 → 0.7.4

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');

package/src/engine.ts

@@ -1,110 +1,18 @@
-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;
+  runPipeline as runCorePipeline,
+  TriggerBlockedError,
+  TriggerTimeoutError,
+  type EngineResult,
+  type RunEventPayload,
+  type RunPipelineOptions as CoreRunPipelineOptions,
+} from '@tagma/core';
+import { bunRuntime } from '@tagma/runtime-bun';
+import type { PipelineConfig, TagmaRuntime } from './types';
+
+export { TriggerBlockedError, TriggerTimeoutError };
+export type { EngineResult, RunEventPayload };
+
+export interface RunPipelineOptions extends Omit<CoreRunPipelineOptions, 'runtime'> {
   /**
    * Runtime implementation for command and driver process execution.
    * Defaults to the SDK's Bun runtime.
@@ -112,347 +20,13 @@ export interface RunPipelineOptions {
   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(
+export 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,
-    });
+  return runCorePipeline(config, workDir, {
+    ...options,
+    runtime: options.runtime ?? bunRuntime(),
   });
-
-  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);
-    }
-  }
 }
-
-

package/src/index.ts

@@ -1,11 +1,9 @@
 export { createTagma } from './tagma';
 export type { CreateTagmaOptions, Tagma, TagmaRunOptions } from './tagma';
-export { bunRuntime } from './runtime';
-export type { TagmaRuntime, RunOptions as RuntimeRunOptions } from './runtime';
-export { definePipeline } from './pipeline-definition';
-export { PluginRegistry } from './registry';
-export { TriggerBlockedError, TriggerTimeoutError } from './engine';
-export type { EngineResult, RunEventPayload } from './engine';
+export { bunRuntime } from '@tagma/runtime-bun';
+export type { TagmaRuntime, RunOptions as RuntimeRunOptions } from '@tagma/core';
+export { definePipeline, PluginRegistry, TriggerBlockedError, TriggerTimeoutError } from '@tagma/core';
+export type { EngineResult, RunEventPayload } from '@tagma/core';
 export { RUN_PROTOCOL_VERSION, TASK_LOG_CAP } from './types';
 export type {
   PipelineConfig,