@tagma/sdk 0.7.3 → 0.7.5

package/src/core/dataflow.ts

@@ -1,161 +0,0 @@
-import type {
-  PortDef,
-  TaskConfig,
-  TaskInputBindings,
-  TaskOutputBindings,
-  TaskPorts,
-  TaskResult,
-} from '../types';
-import {
-  extractTaskBindingOutputs,
-  extractTaskOutputs,
-  inferPromptPorts,
-} from '../ports';
-import type { RunContext } from './run-context';
-
-function isPromptTaskConfig(
-  task: TaskConfig,
-): task is TaskConfig & { readonly prompt: string; readonly command?: undefined } {
-  return task.prompt !== undefined && task.command === undefined;
-}
-
-function isCommandTaskConfig(
-  task: TaskConfig,
-): task is TaskConfig & { readonly command: string; readonly prompt?: undefined } {
-  return task.command !== undefined && task.prompt === undefined;
-}
-
-function inputBindingsToPorts(bindings: TaskInputBindings | undefined): PortDef[] | undefined {
-  if (!bindings || Object.keys(bindings).length === 0) return undefined;
-  return Object.entries(bindings).map(([name, binding]) => ({
-    name,
-    type: binding.type ?? 'json',
-    ...(binding.description ? { description: binding.description } : {}),
-    ...(binding.required !== undefined ? { required: binding.required } : {}),
-    ...(binding.default !== undefined ? { default: binding.default } : {}),
-    ...(binding.enum ? { enum: [...binding.enum] } : {}),
-    ...(binding.from ? { from: binding.from } : {}),
-  }));
-}
-
-function outputBindingsToPorts(bindings: TaskOutputBindings | undefined): PortDef[] | undefined {
-  if (!bindings || Object.keys(bindings).length === 0) return undefined;
-  return Object.entries(bindings).map(([name, binding]) => ({
-    name,
-    type: binding.type ?? 'json',
-    ...(binding.description ? { description: binding.description } : {}),
-    ...(binding.default !== undefined ? { default: binding.default } : {}),
-    ...(binding.enum ? { enum: [...binding.enum] } : {}),
-  }));
-}
-
-function taskBindingsAsPorts(task: TaskConfig): TaskPorts | undefined {
-  const inputs = inputBindingsToPorts(task.inputs);
-  const outputs = outputBindingsToPorts(task.outputs);
-  if (!inputs && !outputs) return undefined;
-  return {
-    ...(inputs ? { inputs } : {}),
-    ...(outputs ? { outputs } : {}),
-  };
-}
-
-export type EffectivePortsResult =
-  | {
-      readonly kind: 'ready';
-      readonly isPromptTask: boolean;
-      readonly effectivePorts: TaskPorts | undefined;
-    }
-  | {
-      readonly kind: 'blocked';
-      readonly reason: string;
-    };
-
-export function inferEffectivePorts(
-  ctx: RunContext,
-  taskId: string,
-): EffectivePortsResult {
-  const node = ctx.dag.nodes.get(taskId)!;
-  const task = node.task;
-  const isPromptTask = isPromptTaskConfig(task);
-
-  if (!isPromptTask) {
-    return { kind: 'ready', isPromptTask: false, effectivePorts: taskBindingsAsPorts(task) };
-  }
-
-  const inference = inferPromptPorts({
-    upstreams: node.dependsOn.map((upstreamId) => {
-      const upstream = ctx.dag.nodes.get(upstreamId);
-      const isUpstreamCommand = upstream ? isCommandTaskConfig(upstream.task) : false;
-      return {
-        taskId: upstreamId,
-        outputs: isUpstreamCommand ? outputBindingsToPorts(upstream?.task.outputs) : undefined,
-      };
-    }),
-    downstreams: (ctx.directDownstreams.get(taskId) ?? []).map((downstreamId) => {
-      const downstream = ctx.dag.nodes.get(downstreamId);
-      const isDownstreamCommand = downstream ? isCommandTaskConfig(downstream.task) : false;
-      return {
-        taskId: downstreamId,
-        inputs: isDownstreamCommand ? inputBindingsToPorts(downstream?.task.inputs) : undefined,
-      };
-    }),
-  });
-
-  if (inference.inputConflicts.length > 0 || inference.outputConflicts.length > 0) {
-    const lines: string[] = [];
-    for (const conflict of inference.inputConflicts) lines.push(conflict.reason);
-    for (const conflict of inference.outputConflicts) lines.push(conflict.reason);
-    return { kind: 'blocked', reason: lines.join('\n') };
-  }
-
-  return { kind: 'ready', isPromptTask: true, effectivePorts: inference.ports };
-}
-
-export interface ExtractSuccessfulOutputsOptions {
-  readonly task: TaskConfig;
-  readonly effectivePorts: TaskPorts | undefined;
-  readonly result: TaskResult;
-}
-
-export interface ExtractSuccessfulOutputsResult {
-  readonly outputs: Readonly<Record<string, unknown>> | null;
-  readonly bindingDiagnostic: string | null;
-  readonly portDiagnostic: string | null;
-}
-
-export function extractSuccessfulOutputs(
-  options: ExtractSuccessfulOutputsOptions,
-): ExtractSuccessfulOutputsResult {
-  const { task, effectivePorts, result } = options;
-  let extractedOutputs: Readonly<Record<string, unknown>> | null = null;
-
-  const bindingExtraction = extractTaskBindingOutputs(
-    task.outputs,
-    result.stdout,
-    result.stderr,
-    result.normalizedOutput,
-  );
-  if (task.outputs && Object.keys(task.outputs).length > 0) {
-    extractedOutputs = bindingExtraction.outputs;
-  }
-
-  if ((!task.outputs || Object.keys(task.outputs).length === 0) && effectivePorts?.outputs?.length) {
-    const portExtraction = extractTaskOutputs(
-      effectivePorts,
-      result.stdout,
-      result.normalizedOutput,
-    );
-    extractedOutputs = portExtraction.outputs;
-    return {
-      outputs: extractedOutputs,
-      bindingDiagnostic: bindingExtraction.diagnostic,
-      portDiagnostic: portExtraction.diagnostic,
-    };
-  }
-
-  return {
-    outputs: extractedOutputs,
-    bindingDiagnostic: bindingExtraction.diagnostic,
-    portDiagnostic: null,
-  };
-}

package/src/core/log-prune.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdtempSync, mkdirSync, readdirSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { pruneLogDirs } from './log-prune';
-
-function fixture(): string {
-  return mkdtempSync(join(tmpdir(), 'tagma-prune-'));
-}
-
-describe('pruneLogDirs', () => {
-  test('returns silently when logsDir does not exist', async () => {
-    const root = fixture();
-    try {
-      await expect(
-        pruneLogDirs(join(root, 'nope'), 5, 'run_live'),
-      ).resolves.toBeUndefined();
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('keeps the live run plus (keep-1) most recent historical runs', async () => {
-    const root = fixture();
-    try {
-      for (const id of ['run_001', 'run_002', 'run_003', 'run_004', 'run_005']) {
-        mkdirSync(join(root, id));
-      }
-      await pruneLogDirs(root, 3, 'run_005'); // keep=3 → 1 live + 2 historical
-      expect(readdirSync(root).sort()).toEqual(['run_003', 'run_004', 'run_005']);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('never deletes the excluded live runId even if it would be pruned', async () => {
-    const root = fixture();
-    try {
-      for (const id of ['run_001', 'run_002', 'run_003']) mkdirSync(join(root, id));
-      await pruneLogDirs(root, 1, 'run_001');
-      expect(readdirSync(root).sort()).toEqual(['run_001']);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  test('ignores entries that do not look like run dirs', async () => {
-    const root = fixture();
-    try {
-      mkdirSync(join(root, 'run_001'));
-      mkdirSync(join(root, 'not_a_run'));
-      await pruneLogDirs(root, 1, 'run_001');
-      expect(readdirSync(root).sort()).toEqual(['not_a_run', 'run_001']);
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-});

package/src/core/log-prune.ts

@@ -1,43 +0,0 @@
-import { readdir, rm } from 'node:fs/promises';
-import { resolve } from 'node:path';
-
-/**
- * Delete the oldest subdirectories under `logsDir`, keeping only the
- * most recent `keep` total runs (including the currently-live run
- * identified by `excludeRunId`). Directories are sorted
- * lexicographically; because runIds are prefixed with a base-36
- * timestamp, lexicographic order equals chronological order.
- *
- * `excludeRunId` is always skipped from deletion even if it would
- * otherwise be pruned — this prevents a concurrent run from removing a
- * live log directory that is still in use.
- *
- * The live run occupies one slot out of `keep`, so the maximum number
- * of *historical* dirs to retain is `keep - 1`.
- */
-export async function pruneLogDirs(
-  logsDir: string,
-  keep: number,
-  excludeRunId: string,
-): Promise<void> {
-  let entries: string[];
-  try {
-    entries = await readdir(logsDir);
-  } catch {
-    return; // logsDir doesn't exist yet
-  }
-
-  const runDirs = entries
-    .filter((e) => e.startsWith('run_') && e !== excludeRunId)
-    .sort();
-  const historyKeep = Math.max(0, keep - 1);
-  const toDelete = runDirs.slice(0, Math.max(0, runDirs.length - historyKeep));
-
-  await Promise.all(
-    toDelete.map((dir) =>
-      rm(resolve(logsDir, dir), { recursive: true, force: true }).catch(() => {
-        // Ignore deletion errors — stale dirs are better than a crash
-      }),
-    ),
-  );
-}

package/src/core/preflight.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { preflight } from './preflight';
-import { buildDag } from '../dag';
-import { PluginRegistry } from '../registry';
-import { bootstrapBuiltins } from '../bootstrap';
-import type { PipelineConfig } from '../types';
-
-function emptyConfig(overrides: Partial<PipelineConfig> = {}): PipelineConfig {
-  return {
-    name: 'p',
-    tracks: [{ id: 't', name: 'T', tasks: [] }],
-    ...overrides,
-  };
-}
-
-describe('preflight', () => {
-  test('throws when a referenced driver is not registered', () => {
-    const reg = new PluginRegistry();
-    const cfg = emptyConfig({
-      tracks: [
-        { id: 't', name: 'T', tasks: [{ id: 'a', name: 'A', prompt: 'hi' }] },
-      ],
-    });
-    expect(() => preflight(cfg, buildDag(cfg), reg)).toThrow(
-      /driver "opencode" not registered/,
-    );
-  });
-
-  test('passes when all referenced plugins are registered', () => {
-    const reg = new PluginRegistry();
-    bootstrapBuiltins(reg);
-    const cfg = emptyConfig({
-      tracks: [
-        { id: 't', name: 'T', tasks: [{ id: 'a', name: 'A', prompt: 'hi' }] },
-      ],
-    });
-    expect(() => preflight(cfg, buildDag(cfg), reg)).not.toThrow();
-  });
-
-  test('skips driver check for command-only tasks', () => {
-    const reg = new PluginRegistry(); // no drivers registered
-    const cfg = emptyConfig({
-      tracks: [
-        { id: 't', name: 'T', tasks: [{ id: 'a', name: 'A', command: 'echo hi' }] },
-      ],
-    });
-    expect(() => preflight(cfg, buildDag(cfg), reg)).not.toThrow();
-  });
-});

package/src/core/preflight.ts

@@ -1,89 +0,0 @@
-import type { PipelineConfig, TaskConfig, DriverPlugin } from '../types';
-import type { Dag } from '../dag';
-import type { PluginRegistry } from '../registry';
-
-function isCommandOnly(
-  task: TaskConfig,
-): task is TaskConfig & { readonly command: string; readonly prompt?: undefined } {
-  return task.command !== undefined && task.prompt === undefined;
-}
-
-/**
- * Validate that every plugin referenced by the pipeline (drivers,
- * triggers, completions, middlewares) is registered, and that
- * `continue_from` is only used between drivers that can hand off via
- * sessionResume or text-injection. Throws with all errors aggregated
- * into one message so the caller sees every misconfiguration in a
- * single pass.
- */
-export function preflight(
-  config: PipelineConfig,
-  dag: Dag,
-  registry: PluginRegistry,
-): void {
-  const errors: string[] = [];
-
-  for (const [, node] of dag.nodes) {
-    const task = node.task;
-    const track = node.track;
-    const driverName = task.driver ?? track.driver ?? config.driver ?? 'opencode';
-
-    const isCommand = isCommandOnly(task);
-
-    if (!isCommand && !registry.hasHandler('drivers', driverName)) {
-      errors.push(`Task "${node.taskId}": driver "${driverName}" not registered`);
-    }
-
-    if (task.trigger && !registry.hasHandler('triggers', task.trigger.type)) {
-      errors.push(
-        `Task "${node.taskId}": trigger type "${task.trigger.type}" not registered`,
-      );
-    }
-
-    if (task.completion && !registry.hasHandler('completions', task.completion.type)) {
-      errors.push(
-        `Task "${node.taskId}": completion type "${task.completion.type}" not registered`,
-      );
-    }
-
-    const mws = task.middlewares ?? track.middlewares ?? [];
-    for (const mw of mws) {
-      if (!registry.hasHandler('middlewares', mw.type)) {
-        errors.push(
-          `Task "${node.taskId}": middleware type "${mw.type}" not registered`,
-        );
-      }
-    }
-
-    if (task.continue_from && registry.hasHandler('drivers', driverName)) {
-      const driver = registry.getHandler<DriverPlugin>('drivers', driverName);
-      if (!driver.capabilities.sessionResume) {
-        const upstreamId = node.resolvedContinueFrom;
-        if (upstreamId) {
-          const upstream = dag.nodes.get(upstreamId);
-          if (upstream) {
-            const upstreamDriverName =
-              upstream.task.driver ?? upstream.track.driver ?? config.driver ?? 'opencode';
-            const upstreamDriver = registry.hasHandler('drivers', upstreamDriverName)
-              ? registry.getHandler<DriverPlugin>('drivers', upstreamDriverName)
-              : null;
-            const canNormalize = typeof upstreamDriver?.parseResult === 'function';
-
-            if (!canNormalize) {
-              errors.push(
-                `Task "${node.taskId}" uses continue_from: "${task.continue_from}", ` +
-                  `but upstream task "${upstreamId}" its driver ` +
-                  `does not implement parseResult for text-injection handoff. ` +
-                  `Use a driver with parseResult, or remove continue_from.`,
-              );
-            }
-          }
-        }
-      }
-    }
-  }
-
-  if (errors.length > 0) {
-    throw new Error(`Preflight validation failed:\n  - ${errors.join('\n  - ')}`);
-  }
-}

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

@@ -1,256 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { RunContext } from './run-context';
-import { buildDag } from '../dag';
-import type { PipelineConfig, RunEventPayload } from '../types';
-import type { PipelineInfo } from '../hooks';
-import type { TagmaRuntime } from '../runtime';
-
-const fakeRuntime: TagmaRuntime = {
-  async runCommand() {
-    throw new Error('fakeRuntime.runCommand should not be called by RunContext tests');
-  },
-  async runSpawn() {
-    throw new Error('fakeRuntime.runSpawn should not be called by RunContext tests');
-  },
-};
-
-function makeContext(overrides: Partial<{
-  config: PipelineConfig;
-  onEvent: (e: RunEventPayload) => void;
-}> = {}): { ctx: RunContext; events: RunEventPayload[] } {
-  const config: PipelineConfig = overrides.config ?? {
-    name: 'p',
-    tracks: [
-      {
-        id: 't',
-        name: 'T',
-        tasks: [
-          { id: 'a', name: 'A', command: 'echo a' },
-          { id: 'b', name: 'B', command: 'echo b', depends_on: ['a'] },
-        ],
-      },
-    ],
-  };
-  const events: RunEventPayload[] = [];
-  const onEvent = overrides.onEvent ?? ((e: RunEventPayload) => { events.push(e); });
-  const ctx = new RunContext({
-    runId: 'run_test',
-    dag: buildDag(config),
-    config,
-    workDir: '/tmp/wd',
-    pipelineInfo: { name: config.name, run_id: 'run_test', started_at: '2026-04-26T00:00:00Z' } as PipelineInfo,
-    onEvent,
-    runtime: fakeRuntime,
-  });
-  return { ctx, events };
-}
-
-describe('RunContext constructor', () => {
-  test('initializes one idle state per dag node', () => {
-    const { ctx } = makeContext();
-    expect(ctx.states.size).toBe(2);
-    expect(ctx.states.get('t.a')!.status).toBe('idle');
-    expect(ctx.states.get('t.b')!.status).toBe('idle');
-  });
-
-  test('initializes all state maps as empty', () => {
-    const { ctx } = makeContext();
-    expect(ctx.sessionMap.size).toBe(0);
-    expect(ctx.normalizedMap.size).toBe(0);
-    expect(ctx.outputValuesMap.size).toBe(0);
-    expect(ctx.bindingDataMap.size).toBe(0);
-    expect(ctx.resolvedInputsMap.size).toBe(0);
-  });
-
-  test('computes directDownstreams reverse adjacency from dag', () => {
-    const { ctx } = makeContext();
-    expect([...ctx.directDownstreams.get('t.a')!]).toEqual(['t.b']);
-    expect([...ctx.directDownstreams.get('t.b')!]).toEqual([]);
-  });
-
-  test('starts with abortReason null and a fresh AbortController', () => {
-    const { ctx } = makeContext();
-    expect(ctx.abortReason).toBeNull();
-    expect(ctx.abortController.signal.aborted).toBe(false);
-  });
-});
-
-describe('RunContext.emit', () => {
-  test('forwards events to onEvent', () => {
-    const { ctx, events } = makeContext();
-    ctx.emit({ type: 'run_end', runId: 'run_test', success: true, abortReason: null });
-    expect(events).toHaveLength(1);
-    expect(events[0]).toEqual({ type: 'run_end', runId: 'run_test', success: true, abortReason: null });
-  });
-
-  test('is a no-op when onEvent is undefined', () => {
-    const config: PipelineConfig = {
-      name: 'p',
-      tracks: [{ id: 't', name: 'T', tasks: [{ id: 'a', name: 'A', command: 'echo a' }] }],
-    };
-    const ctx = new RunContext({
-      runId: 'run_test',
-      dag: buildDag(config),
-      config,
-      workDir: '/tmp/wd',
-      pipelineInfo: { name: 'p', run_id: 'run_test', started_at: 'now' } as PipelineInfo,
-      runtime: fakeRuntime,
-    });
-    expect(() => ctx.emit({ type: 'run_end', runId: 'run_test', success: true, abortReason: null })).not.toThrow();
-  });
-});
-
-describe('RunContext.setTaskStatus', () => {
-  test('transitions a non-terminal task and emits task_update', () => {
-    const { ctx, events } = makeContext();
-    ctx.setTaskStatus('t.a', 'waiting');
-    expect(ctx.states.get('t.a')!.status).toBe('waiting');
-    expect(events).toHaveLength(1);
-    expect(events[0].type).toBe('task_update');
-    if (events[0].type === 'task_update') {
-      expect(events[0].taskId).toBe('t.a');
-      expect(events[0].status).toBe('waiting');
-    }
-  });
-
-  test('refuses to re-transition a terminal task (terminal lock)', () => {
-    const { ctx, events } = makeContext();
-    ctx.setTaskStatus('t.a', 'success');
-    events.length = 0;
-    ctx.setTaskStatus('t.a', 'failed');
-    expect(ctx.states.get('t.a')!.status).toBe('success');
-    expect(events).toHaveLength(0);
-  });
-
-  test('echoes resolvedInputs and outputs from the maps in the emitted event', () => {
-    const { ctx, events } = makeContext();
-    ctx.resolvedInputsMap.set('t.a', { x: 1 });
-    ctx.outputValuesMap.set('t.a', { y: 2 });
-    ctx.setTaskStatus('t.a', 'running');
-    if (events[0].type === 'task_update') {
-      expect(events[0].inputs).toEqual({ x: 1 });
-      expect(events[0].outputs).toEqual({ y: 2 });
-    } else {
-      throw new Error('expected task_update');
-    }
-  });
-});
-
-describe('RunContext.getOnFailure', () => {
-  test('returns the track-level on_failure setting', () => {
-    const config: PipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          on_failure: 'stop_all',
-          tasks: [{ id: 'a', name: 'A', command: 'echo a' }],
-        },
-      ],
-    };
-    const { ctx } = makeContext({ config });
-    expect(ctx.getOnFailure('t.a')).toBe('stop_all');
-  });
-
-  test('defaults to skip_downstream when track does not specify', () => {
-    const { ctx } = makeContext();
-    expect(ctx.getOnFailure('t.a')).toBe('skip_downstream');
-  });
-});
-
-describe('RunContext.isDependencySatisfied', () => {
-  test('returns satisfied for success', () => {
-    const { ctx } = makeContext();
-    ctx.states.get('t.a')!.status = 'success';
-    expect(ctx.isDependencySatisfied('t.a')).toBe('satisfied');
-  });
-
-  test('returns skip for skipped', () => {
-    const { ctx } = makeContext();
-    ctx.states.get('t.a')!.status = 'skipped';
-    expect(ctx.isDependencySatisfied('t.a')).toBe('skip');
-  });
-
-  test('returns skip for failed under default policy, satisfied under ignore', () => {
-    const cfgSkip: PipelineConfig = {
-      name: 'p',
-      tracks: [{ id: 't', name: 'T', tasks: [{ id: 'a', name: 'A', command: 'echo a' }] }],
-    };
-    const cfgIgnore: PipelineConfig = {
-      name: 'p',
-      tracks: [
-        {
-          id: 't',
-          name: 'T',
-          on_failure: 'ignore',
-          tasks: [{ id: 'a', name: 'A', command: 'echo a' }],
-        },
-      ],
-    };
-    const a = makeContext({ config: cfgSkip }).ctx;
-    a.states.get('t.a')!.status = 'failed';
-    expect(a.isDependencySatisfied('t.a')).toBe('skip');
-
-    const b = makeContext({ config: cfgIgnore }).ctx;
-    b.states.get('t.a')!.status = 'failed';
-    expect(b.isDependencySatisfied('t.a')).toBe('satisfied');
-  });
-
-  test('returns unsatisfied for non-terminal statuses', () => {
-    const { ctx } = makeContext();
-    ctx.states.get('t.a')!.status = 'running';
-    expect(ctx.isDependencySatisfied('t.a')).toBe('unsatisfied');
-  });
-});
-
-describe('RunContext.applyStopAll', () => {
-  test('aborts the controller, sets abortReason, marks waiting tasks as skipped', () => {
-    const { ctx } = makeContext();
-    ctx.states.get('t.a')!.status = 'waiting';
-    ctx.states.get('t.b')!.status = 'waiting';
-    ctx.applyStopAll();
-    expect(ctx.abortReason).toBe('stop_all');
-    expect(ctx.abortController.signal.aborted).toBe(true);
-    expect(ctx.states.get('t.a')!.status).toBe('skipped');
-    expect(ctx.states.get('t.b')!.status).toBe('skipped');
-  });
-
-  test('does not overwrite an existing abortReason', () => {
-    const { ctx } = makeContext();
-    ctx.abortReason = 'timeout';
-    ctx.applyStopAll();
-    expect(ctx.abortReason).toBe('timeout');
-    expect(ctx.abortController.signal.aborted).toBe(true);
-  });
-
-  test('leaves running and terminal tasks alone', () => {
-    const { ctx } = makeContext();
-    ctx.states.get('t.a')!.status = 'running';
-    ctx.states.get('t.b')!.status = 'success';
-    ctx.applyStopAll();
-    expect(ctx.states.get('t.a')!.status).toBe('running');
-    expect(ctx.states.get('t.b')!.status).toBe('success');
-  });
-});
-
-describe('RunContext.buildTaskInfoObj / trackInfoOf', () => {
-  test('buildTaskInfoObj reports type=command for command tasks', () => {
-    const { ctx } = makeContext();
-    expect(ctx.buildTaskInfoObj('t.a').type).toBe('command');
-  });
-
-  test('buildTaskInfoObj reports type=ai for prompt tasks', () => {
-    const config: PipelineConfig = {
-      name: 'p',
-      tracks: [{ id: 't', name: 'T', tasks: [{ id: 'a', name: 'A', prompt: 'hi' }] }],
-    };
-    const { ctx } = makeContext({ config });
-    expect(ctx.buildTaskInfoObj('t.a').type).toBe('ai');
-  });
-
-  test('trackInfoOf returns the track id and name', () => {
-    const { ctx } = makeContext();
-    expect(ctx.trackInfoOf('t.a')).toEqual({ id: 't', name: 'T' });
-  });
-});