@tagma/sdk 0.7.1 → 0.7.4

package/src/engine.ts

@@ -1,450 +1,32 @@
-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';
-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;
+  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'> {
   /**
-   * 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.
+   * Runtime implementation for command and driver process execution.
+   * Defaults to the SDK's Bun runtime.
    */
-  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;
+  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;
-  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,
-    });
-
-    // 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,9 +1,9 @@
 export { createTagma } from './tagma';
 export type { CreateTagmaOptions, Tagma, TagmaRunOptions } from './tagma';
-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,
@@ -20,6 +20,9 @@ export type {
   TaskStatus,
   ApprovalRequest,
   PluginCategory,
+  PluginCapabilities,
+  PluginSetupContext,
+  TagmaPlugin,
   DriverPlugin,
   TriggerPlugin,
   CompletionPlugin,

package/src/logger.ts

@@ -1,182 +1,2 @@
-import { resolve, dirname } from 'node:path';
-import { mkdirSync, writeFileSync, openSync, writeSync, closeSync } from 'node:fs';
-
-/**
- * Structured record emitted for every log line. Consumers (e.g. the editor
- * server) use this to stream process-level detail into UIs alongside the
- * on-disk pipeline.log. `taskId` is extracted from a `[task:<id>]` prefix
- * when the call site passes one, or overridden explicitly via the optional
- * `taskId` argument on `section`/`quiet` (which carry no prefix).
- */
-export type LogLevel = 'info' | 'warn' | 'error' | 'debug' | 'section' | 'quiet';
-
-export interface LogRecord {
-  readonly level: LogLevel;
-  readonly taskId: string | null;
-  readonly timestamp: string;
-  readonly text: string;
-}
-
-export type LogListener = (record: LogRecord) => void;
-
-const TASK_PREFIX_RE = /\[task:([^\]]+)\]/;
-
-function taskIdFromPrefix(prefix: string): string | null {
-  const m = TASK_PREFIX_RE.exec(prefix);
-  return m ? m[1] : null;
-}
-
-/**
- * Dual-channel logger.
- *
- *   - `info/warn/error` → console AND file (brief, user-visible events)
- *   - `debug`           → file ONLY (verbose diagnostics)
- *   - `section`         → file ONLY (visual separators)
- *   - `quiet`           → file ONLY (bulk payload like full stdout dumps)
- *
- * Log file path: <workDir>/.tagma/logs/<runId>/pipeline.log (one file per pipeline run,
- * truncated on construction). Every line is also forwarded to the optional
- * `onLine` callback as a structured `LogRecord`, so callers that want to
- * stream the run process over IPC/SSE don't need to tail the file.
- */
-export class Logger {
-  private readonly filePath: string;
-  private readonly runDir: string;
-  private readonly onLine: LogListener | null;
-  /** Persistent file descriptor for append writes (avoids open/close per line). */
-  private fd: number | null;
-
-  constructor(workDir: string, runId: string, onLine?: LogListener) {
-    this.runDir = resolve(workDir, '.tagma', 'logs', runId);
-    this.filePath = resolve(this.runDir, 'pipeline.log');
-    this.onLine = onLine ?? null;
-    mkdirSync(dirname(this.filePath), { recursive: true });
-    const header =
-      `# Pipeline run ${runId} @ ${new Date().toISOString()}\n` +
-      `# Host: ${process.platform} ${process.arch}  Bun: ${process.versions.bun ?? 'n/a'}\n` +
-      `# Work dir: ${workDir}\n\n`;
-    writeFileSync(this.filePath, header);
-    // Open once for all subsequent appends (O_APPEND is implied by 'a' flag)
-    this.fd = openSync(this.filePath, 'a');
-  }
-
-  info(prefix: string, message: string): void {
-    const ts = timestamp();
-    const line = `${ts} ${prefix} ${message}`;
-    // eslint-disable-next-line no-console
-    console.log(line);
-    this.emit('info', ts, line, taskIdFromPrefix(prefix));
-    this.append(line);
-  }
-
-  warn(prefix: string, message: string): void {
-    const ts = timestamp();
-    const line = `${ts} ${prefix} WARN: ${message}`;
-    console.warn(line);
-    this.emit('warn', ts, line, taskIdFromPrefix(prefix));
-    this.append(line);
-  }
-
-  error(prefix: string, message: string): void {
-    const ts = timestamp();
-    const line = `${ts} ${prefix} ERROR: ${message}`;
-    console.error(line);
-    this.emit('error', ts, line, taskIdFromPrefix(prefix));
-    this.append(line);
-  }
-
-  /** File-only diagnostic log line. */
-  debug(prefix: string, message: string): void {
-    const ts = timestamp();
-    const line = `${ts} ${prefix} DEBUG: ${message}`;
-    this.emit('debug', ts, line, taskIdFromPrefix(prefix));
-    this.append(line);
-  }
-
-  /** File-only visual separator with title. */
-  section(title: string, taskId?: string | null): void {
-    const ts = timestamp();
-    const text = `\n━━━ ${title} ━━━`;
-    this.emit('section', ts, text, taskId ?? null);
-    this.append(text);
-  }
-
-  /** File-only bulk payload (e.g. full stdout / stderr dumps). */
-  quiet(message: string, taskId?: string | null): void {
-    const ts = timestamp();
-    this.emit('quiet', ts, message, taskId ?? null);
-    this.append(message);
-  }
-
-  private append(line: string): void {
-    if (this.fd === null) return;
-    try {
-      const data = line.endsWith('\n') ? line : line + '\n';
-      writeSync(this.fd, data);
-    } catch {
-      // Swallow log write failures; engine correctness shouldn't depend on logging.
-    }
-  }
-
-  /** Close the persistent file handle. Called by the engine at run completion. */
-  close(): void {
-    if (this.fd !== null) {
-      try {
-        closeSync(this.fd);
-      } catch {
-        /* already closed */
-      }
-      this.fd = null;
-    }
-  }
-
-  private emit(level: LogLevel, ts: string, text: string, taskId: string | null): void {
-    if (!this.onLine) return;
-    try {
-      this.onLine({ level, taskId, timestamp: ts, text });
-    } catch {
-      // Never let a listener error derail the pipeline.
-    }
-  }
-
-  get path(): string {
-    return this.filePath;
-  }
-
-  /** Directory that holds all artifacts for this run (pipeline.log, *.stderr, etc.). */
-  get dir(): string {
-    return this.runDir;
-  }
-}
-
-function timestamp(): string {
-  const d = new Date();
-  const hh = String(d.getHours()).padStart(2, '0');
-  const mm = String(d.getMinutes()).padStart(2, '0');
-  const ss = String(d.getSeconds()).padStart(2, '0');
-  const ms = String(d.getMilliseconds()).padStart(3, '0');
-  return `${hh}:${mm}:${ss}.${ms}`;
-}
-
-/** Return the last `n` non-empty lines of `text`, joined with newlines. */
-export function tailLines(text: string, n: number): string {
-  if (!text) return '';
-  const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
-  return lines.slice(-n).join('\n');
-}
-
-/**
- * Truncate a blob to at most `maxBytes` UTF-8 bytes for log embedding,
- * appending a marker when truncation occurred.
- * Uses TextEncoder so CJK and emoji (multi-byte) characters are counted correctly.
- */
-export function clip(text: string, maxBytes = 16 * 1024): string {
-  if (!text) return '';
-  const encoder = new TextEncoder();
-  const bytes = encoder.encode(text);
-  if (bytes.length <= maxBytes) return text;
-  const omittedBytes = bytes.length - maxBytes;
-  // TextDecoder handles partial code-point boundaries safely (replacement char insertion)
-  const truncated = new TextDecoder().decode(bytes.slice(0, maxBytes));
-  return truncated + `\n…[truncated ${omittedBytes} bytes]`;
-}
+export { clip, Logger, tailLines } from '@tagma/core';
+export type { LogLevel, LogListener, LogRecord } from '@tagma/core';