@the-open-engine/zeroshot 6.39.2 → 6.41.0

package/cli/semantic-parser.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOpenedEvidence = parseOpenedEvidence;
+const crypto = require("crypto");
+const fs = require("fs");
+const export_stream_1 = require("./export-stream");
+const semantic_contract_1 = require("./semantic-contract");
+const semantic_events_1 = require("./semantic-events");
+const semantic_line_scanner_1 = require("./semantic-line-scanner");
+const semantic_provider_line_1 = require("./semantic-provider-line");
+const trace_output_1 = require("./trace-output");
+function readEvidence(fd, byteLength, scanner, digest) {
+    let bytes = 0;
+    while (bytes < byteLength) {
+        const remaining = byteLength - bytes;
+        const buffer = Buffer.allocUnsafe(Math.min(trace_output_1.TRACE_OUTPUT_CHUNK_BYTES, remaining));
+        const read = fs.readSync(fd, buffer, 0, buffer.length, bytes);
+        if (read === 0)
+            break;
+        const chunk = read === buffer.length ? buffer : buffer.subarray(0, read);
+        digest.update(chunk);
+        scanner.consume(chunk, bytes);
+        bytes += read;
+    }
+    scanner.finish(bytes);
+    return bytes;
+}
+function finishAdapter(adapter, state, context) {
+    try {
+        const final = adapter.finishParsing?.(state) ?? null;
+        for (const event of (0, semantic_events_1.emittedEvents)(final))
+            (0, semantic_events_1.emitEvent)(context, event, null, 'finish');
+    }
+    catch {
+        (0, semantic_contract_1.reportDiagnostic)(context, 'parser_finish_error', null);
+    }
+}
+function reportProjectionCompleteness(context) {
+    if (context.provider !== 'pi' && context.logFormat === null) {
+        if (!context.issueCodes.has('legacy_ambiguous_channels')) {
+            (0, semantic_contract_1.reportDiagnostic)(context, 'legacy_ambiguous_channels', null);
+        }
+    }
+    if (!context.terminalResultEmitted)
+        (0, semantic_contract_1.reportDiagnostic)(context, 'terminal_result_missing', null);
+}
+function sourceMatches(evidence, bytes, digest) {
+    const after = fs.fstatSync(evidence.fd, { bigint: true });
+    return (bytes === evidence.byteLength &&
+        digest.digest('hex') === evidence.sha256 &&
+        (0, export_stream_1.sameFileSnapshot)(evidence.before, after));
+}
+function parseOpenedEvidence(evidence, context, adapter) {
+    if (evidence.fd === null || evidence.before === null || evidence.byteLength === null)
+        return false;
+    const stableEvidence = {
+        fd: evidence.fd,
+        before: evidence.before,
+        byteLength: evidence.byteLength,
+        sha256: evidence.sha256,
+    };
+    const state = adapter.createParserState();
+    const digest = crypto.createHash('sha256');
+    const scanner = new semantic_line_scanner_1.BoundedLineScanner((line, source) => (0, semantic_provider_line_1.handleProviderLine)(context, state, line, source));
+    try {
+        const bytes = readEvidence(stableEvidence.fd, stableEvidence.byteLength, scanner, digest);
+        finishAdapter(adapter, state, context);
+        reportProjectionCompleteness(context);
+        const complete = sourceMatches(stableEvidence, bytes, digest);
+        if (!complete)
+            (0, semantic_contract_1.reportDiagnostic)(context, 'log_changed_during_parse', null);
+        return complete;
+    }
+    catch {
+        (0, semantic_contract_1.reportDiagnostic)(context, 'log_read_failed', null);
+        return false;
+    }
+}

package/cli/semantic-parser.ts

@@ -0,0 +1,95 @@
+import crypto = require('crypto');
+import fs = require('fs');
+import type { ProviderAdapter } from './agent-provider-boundary';
+import { sameFileSnapshot } from './export-stream';
+import { reportDiagnostic, type OpenedEvidence, type TaskProjection } from './semantic-contract';
+import { emitEvent, emittedEvents } from './semantic-events';
+import { BoundedLineScanner } from './semantic-line-scanner';
+import { handleProviderLine } from './semantic-provider-line';
+import { TRACE_OUTPUT_CHUNK_BYTES } from './trace-output';
+
+function readEvidence(
+  fd: number,
+  byteLength: number,
+  scanner: BoundedLineScanner,
+  digest: crypto.Hash
+): number {
+  let bytes = 0;
+  while (bytes < byteLength) {
+    const remaining = byteLength - bytes;
+    const buffer = Buffer.allocUnsafe(Math.min(TRACE_OUTPUT_CHUNK_BYTES, remaining));
+    const read = fs.readSync(fd, buffer, 0, buffer.length, bytes);
+    if (read === 0) break;
+    const chunk = read === buffer.length ? buffer : buffer.subarray(0, read);
+    digest.update(chunk);
+    scanner.consume(chunk, bytes);
+    bytes += read;
+  }
+  scanner.finish(bytes);
+  return bytes;
+}
+
+function finishAdapter(adapter: ProviderAdapter, state: object, context: TaskProjection): void {
+  try {
+    const final = adapter.finishParsing?.(state) ?? null;
+    for (const event of emittedEvents(final)) emitEvent(context, event, null, 'finish');
+  } catch {
+    reportDiagnostic(context, 'parser_finish_error', null);
+  }
+}
+
+function reportProjectionCompleteness(context: TaskProjection): void {
+  if (context.provider !== 'pi' && context.logFormat === null) {
+    if (!context.issueCodes.has('legacy_ambiguous_channels')) {
+      reportDiagnostic(context, 'legacy_ambiguous_channels', null);
+    }
+  }
+  if (!context.terminalResultEmitted) reportDiagnostic(context, 'terminal_result_missing', null);
+}
+
+interface StableEvidence {
+  fd: number;
+  before: fs.BigIntStats;
+  byteLength: number;
+  sha256: string | null;
+}
+
+function sourceMatches(evidence: StableEvidence, bytes: number, digest: crypto.Hash): boolean {
+  const after = fs.fstatSync(evidence.fd, { bigint: true });
+  return (
+    bytes === evidence.byteLength &&
+    digest.digest('hex') === evidence.sha256 &&
+    sameFileSnapshot(evidence.before, after)
+  );
+}
+
+export function parseOpenedEvidence(
+  evidence: OpenedEvidence,
+  context: TaskProjection,
+  adapter: ProviderAdapter
+): boolean {
+  if (evidence.fd === null || evidence.before === null || evidence.byteLength === null)
+    return false;
+  const stableEvidence: StableEvidence = {
+    fd: evidence.fd,
+    before: evidence.before,
+    byteLength: evidence.byteLength,
+    sha256: evidence.sha256,
+  };
+  const state = adapter.createParserState();
+  const digest = crypto.createHash('sha256');
+  const scanner = new BoundedLineScanner((line, source) =>
+    handleProviderLine(context, state, line, source)
+  );
+  try {
+    const bytes = readEvidence(stableEvidence.fd, stableEvidence.byteLength, scanner, digest);
+    finishAdapter(adapter, state, context);
+    reportProjectionCompleteness(context);
+    const complete = sourceMatches(stableEvidence, bytes, digest);
+    if (!complete) reportDiagnostic(context, 'log_changed_during_parse', null);
+    return complete;
+  } catch {
+    reportDiagnostic(context, 'log_read_failed', null);
+    return false;
+  }
+}

package/cli/semantic-provider-line.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProviderLine = handleProviderLine;
+const node_util_1 = require("node:util");
+const agent_provider_boundary_1 = require("./agent-provider-boundary");
+const semantic_contract_1 = require("./semantic-contract");
+const semantic_events_1 = require("./semantic-events");
+const task_log_line_1 = require("../src/task-log-line");
+function jsonLineIssue(content, providerId) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return null;
+    const candidate = providerId === 'pi' || trimmed.startsWith('{') || trimmed.startsWith('[');
+    if (!candidate)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        return 'malformed_json';
+    }
+    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? null
+        : 'invalid_json_shape';
+}
+function decodeLine(context, line, source) {
+    if (line === null) {
+        (0, semantic_contract_1.reportDiagnostic)(context, 'line_too_large', source);
+        return null;
+    }
+    try {
+        return new node_util_1.TextDecoder('utf-8', { fatal: true }).decode(line);
+    }
+    catch {
+        (0, semantic_contract_1.reportDiagnostic)(context, 'invalid_utf8', source);
+        return null;
+    }
+}
+function handleProviderLine(context, state, line, source) {
+    const rawLine = decodeLine(context, line, source);
+    if (rawLine === null)
+        return;
+    const timestamp = /^\[(\d{13})\]/.exec(rawLine);
+    source.timestamp_ms = timestamp ? Number(timestamp[1]) : null;
+    if (skipOwnedOrAmbiguous(context, rawLine, source))
+        return;
+    let content = (0, agent_provider_boundary_1.stripTimestampPrefix)(rawLine);
+    if (context.logFormat === 'channel-framed-v2') {
+        const decoded = (0, task_log_line_1.decodeTaskLogLine)(rawLine);
+        content = decoded.channel === 'provider_stdout' ? decoded.content : null;
+    }
+    if (content === null) {
+        (0, semantic_contract_1.reportDiagnostic)(context, 'unframed_log_line', source);
+        return;
+    }
+    parseProviderContent(context, state, content, source);
+}
+function skipOwnedOrAmbiguous(context, rawLine, source) {
+    const owned = (0, semantic_contract_1.classifyOwnedLogLine)(rawLine);
+    if (owned === 'format-v1') {
+        context.logFormat = 'stderr-tagged-v1';
+        return true;
+    }
+    if (owned === 'format-v2') {
+        context.logFormat = 'channel-framed-v2';
+        return true;
+    }
+    if (owned === 'owned')
+        return true;
+    if (context.provider !== 'pi' && context.logFormat === null) {
+        if (!context.issueCodes.has('legacy_ambiguous_channels')) {
+            (0, semantic_contract_1.reportDiagnostic)(context, 'legacy_ambiguous_channels', source);
+        }
+        return true;
+    }
+    return false;
+}
+function parseProviderContent(context, state, content, source) {
+    const lineIssue = jsonLineIssue(content, context.adapter?.id || '');
+    if (lineIssue)
+        (0, semantic_contract_1.reportDiagnostic)(context, lineIssue, source);
+    try {
+        const result = context.adapter?.parseEvent(content, state) ?? null;
+        for (const event of (0, semantic_events_1.emittedEvents)(result))
+            (0, semantic_events_1.emitEvent)(context, event, source, 'line');
+    }
+    catch {
+        (0, semantic_contract_1.reportDiagnostic)(context, 'parser_error', source);
+    }
+}

package/cli/semantic-provider-line.ts

@@ -0,0 +1,106 @@
+import { TextDecoder } from 'node:util';
+import { stripTimestampPrefix, type ProviderAdapter } from './agent-provider-boundary';
+import {
+  classifyOwnedLogLine,
+  reportDiagnostic,
+  type SourceSpan,
+  type TaskProjection,
+} from './semantic-contract';
+import { emitEvent, emittedEvents } from './semantic-events';
+import { decodeTaskLogLine } from '../src/task-log-line';
+
+function jsonLineIssue(content: string, providerId: string): string | null {
+  const trimmed = content.trim();
+  if (!trimmed) return null;
+  const candidate = providerId === 'pi' || trimmed.startsWith('{') || trimmed.startsWith('[');
+  if (!candidate) return null;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return 'malformed_json';
+  }
+  return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+    ? null
+    : 'invalid_json_shape';
+}
+
+function decodeLine(
+  context: TaskProjection,
+  line: Buffer | null,
+  source: SourceSpan
+): string | null {
+  if (line === null) {
+    reportDiagnostic(context, 'line_too_large', source);
+    return null;
+  }
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(line);
+  } catch {
+    reportDiagnostic(context, 'invalid_utf8', source);
+    return null;
+  }
+}
+
+export function handleProviderLine(
+  context: TaskProjection,
+  state: ReturnType<ProviderAdapter['createParserState']>,
+  line: Buffer | null,
+  source: SourceSpan
+): void {
+  const rawLine = decodeLine(context, line, source);
+  if (rawLine === null) return;
+  const timestamp = /^\[(\d{13})\]/.exec(rawLine);
+  source.timestamp_ms = timestamp ? Number(timestamp[1]) : null;
+  if (skipOwnedOrAmbiguous(context, rawLine, source)) return;
+  let content: string | null = stripTimestampPrefix(rawLine);
+  if (context.logFormat === 'channel-framed-v2') {
+    const decoded = decodeTaskLogLine(rawLine);
+    content = decoded.channel === 'provider_stdout' ? decoded.content : null;
+  }
+  if (content === null) {
+    reportDiagnostic(context, 'unframed_log_line', source);
+    return;
+  }
+  parseProviderContent(context, state, content, source);
+}
+
+function skipOwnedOrAmbiguous(
+  context: TaskProjection,
+  rawLine: string,
+  source: SourceSpan
+): boolean {
+  const owned = classifyOwnedLogLine(rawLine);
+  if (owned === 'format-v1') {
+    context.logFormat = 'stderr-tagged-v1';
+    return true;
+  }
+  if (owned === 'format-v2') {
+    context.logFormat = 'channel-framed-v2';
+    return true;
+  }
+  if (owned === 'owned') return true;
+  if (context.provider !== 'pi' && context.logFormat === null) {
+    if (!context.issueCodes.has('legacy_ambiguous_channels')) {
+      reportDiagnostic(context, 'legacy_ambiguous_channels', source);
+    }
+    return true;
+  }
+  return false;
+}
+
+function parseProviderContent(
+  context: TaskProjection,
+  state: ReturnType<ProviderAdapter['createParserState']>,
+  content: string,
+  source: SourceSpan
+): void {
+  const lineIssue = jsonLineIssue(content, context.adapter?.id || '');
+  if (lineIssue) reportDiagnostic(context, lineIssue, source);
+  try {
+    const result = context.adapter?.parseEvent(content, state) ?? null;
+    for (const event of emittedEvents(result)) emitEvent(context, event, source, 'line');
+  } catch {
+    reportDiagnostic(context, 'parser_error', source);
+  }
+}

package/cli/trace-evidence.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasTerminalTaskStatus = hasTerminalTaskStatus;
+exports.forEachLedgerMessage = forEachLedgerMessage;
+exports.collectTaskCauses = collectTaskCauses;
+exports.logicalTaskRef = logicalTaskRef;
+exports.expectedLogPath = expectedLogPath;
+exports.readTraceTask = readTraceTask;
+const path = require("path");
+const export_stream_1 = require("./export-stream");
+const TASK_LIFECYCLE_EVENTS = new Set([
+    'TASK_ID_ASSIGNED',
+    'TASK_STARTED',
+    'TASK_COMPLETED',
+    'TASK_FAILED',
+]);
+const TERMINAL_TASK_STATUSES = new Set(['completed', 'failed', 'killed', 'stale', 'cancelled']);
+function hasTerminalTaskStatus(task) {
+    const status = (0, export_stream_1.nullableString)(task.status);
+    return status !== null && TERMINAL_TASK_STATUSES.has(status);
+}
+function forEachLedgerMessage(ledger, clusterId, consume) {
+    for (const message of ledger.iterateAll(clusterId))
+        consume(message);
+}
+function recordData(message) {
+    if (!(0, export_stream_1.isRecord)(message) || !(0, export_stream_1.isRecord)(message.content))
+        return null;
+    return (0, export_stream_1.isRecord)(message.content.data) ? message.content.data : null;
+}
+function messageSender(message, data) {
+    const declaredAgent = (0, export_stream_1.nullableString)(data.agent);
+    if (declaredAgent)
+        return declaredAgent;
+    if (!(0, export_stream_1.isRecord)(message))
+        return null;
+    return (0, export_stream_1.nullableString)(message.sender) || null;
+}
+function isTaskEvidenceMessage(message, data) {
+    if (!(0, export_stream_1.isRecord)(message))
+        return false;
+    if (message.topic === 'AGENT_OUTPUT')
+        return true;
+    return (message.topic === 'AGENT_LIFECYCLE' &&
+        TASK_LIFECYCLE_EVENTS.has((0, export_stream_1.nullableString)(data.event) || ''));
+}
+function collectTaskCauses(ledger, clusterId) {
+    const causes = new Map();
+    forEachLedgerMessage(ledger, clusterId, (message) => {
+        const data = recordData(message);
+        if (!data || !isTaskEvidenceMessage(message, data))
+            return;
+        const taskId = (0, export_stream_1.nullableString)(data.taskId);
+        if (!taskId)
+            return;
+        const cause = causes.get(taskId) || { agentIds: new Set() };
+        const sender = messageSender(message, data);
+        if (sender)
+            cause.agentIds.add(sender);
+        causes.set(taskId, cause);
+    });
+    return causes;
+}
+function logicalTaskRef(taskId, leaf) {
+    return `zeroshot-trace://task/${encodeURIComponent(taskId)}/${leaf}`;
+}
+function expectedLogPath(allowedLogRoot, taskId) {
+    const resolvedRoot = path.resolve(allowedLogRoot);
+    const expected = path.resolve(resolvedRoot, `${taskId}.log`);
+    return path.dirname(expected) === resolvedRoot ? expected : null;
+}
+function readTraceTask(taskId, readTask) {
+    let task;
+    try {
+        task = readTask(taskId);
+    }
+    catch {
+        return { task: null, issue: `task:${taskId}:task_row_unreadable` };
+    }
+    if (!task)
+        return { task: null, issue: `task:${taskId}:task_row_missing` };
+    if (task.id !== undefined && task.id !== taskId) {
+        return { task: null, issue: `task:${taskId}:task_row_identity_mismatch` };
+    }
+    return { task, issue: null };
+}

package/cli/trace-evidence.ts

@@ -0,0 +1,115 @@
+import path = require('path');
+import { isRecord, nullableString } from './export-stream';
+
+const TASK_LIFECYCLE_EVENTS = new Set([
+  'TASK_ID_ASSIGNED',
+  'TASK_STARTED',
+  'TASK_COMPLETED',
+  'TASK_FAILED',
+]);
+const TERMINAL_TASK_STATUSES = new Set(['completed', 'failed', 'killed', 'stale', 'cancelled']);
+
+export interface ClusterLedger {
+  iterateAll(clusterId: string): Iterable<unknown>;
+}
+
+export interface TraceTask {
+  id?: unknown;
+  fullPrompt?: unknown;
+  prompt?: unknown;
+  status?: unknown;
+  createdAt?: unknown;
+  updatedAt?: unknown;
+  exitCode?: unknown;
+  provider?: unknown;
+  model?: unknown;
+  logFile?: unknown;
+}
+
+export interface TaskCause {
+  agentIds: Set<string>;
+}
+
+export interface TraceTaskRead {
+  issue: string | null;
+  task: TraceTask | null;
+}
+
+export function hasTerminalTaskStatus(task: TraceTask): boolean {
+  const status = nullableString(task.status);
+  return status !== null && TERMINAL_TASK_STATUSES.has(status);
+}
+
+export function forEachLedgerMessage(
+  ledger: ClusterLedger,
+  clusterId: string,
+  consume: (message: unknown) => void
+): void {
+  for (const message of ledger.iterateAll(clusterId)) consume(message);
+}
+
+function recordData(message: unknown): Record<string, unknown> | null {
+  if (!isRecord(message) || !isRecord(message.content)) return null;
+  return isRecord(message.content.data) ? message.content.data : null;
+}
+
+function messageSender(message: unknown, data: Record<string, unknown>): string | null {
+  const declaredAgent = nullableString(data.agent);
+  if (declaredAgent) return declaredAgent;
+  if (!isRecord(message)) return null;
+  return nullableString(message.sender) || null;
+}
+
+function isTaskEvidenceMessage(message: unknown, data: Record<string, unknown>): boolean {
+  if (!isRecord(message)) return false;
+  if (message.topic === 'AGENT_OUTPUT') return true;
+  return (
+    message.topic === 'AGENT_LIFECYCLE' &&
+    TASK_LIFECYCLE_EVENTS.has(nullableString(data.event) || '')
+  );
+}
+
+export function collectTaskCauses(
+  ledger: ClusterLedger,
+  clusterId: string
+): Map<string, TaskCause> {
+  const causes = new Map<string, TaskCause>();
+  forEachLedgerMessage(ledger, clusterId, (message) => {
+    const data = recordData(message);
+    if (!data || !isTaskEvidenceMessage(message, data)) return;
+    const taskId = nullableString(data.taskId);
+    if (!taskId) return;
+    const cause = causes.get(taskId) || { agentIds: new Set<string>() };
+    const sender = messageSender(message, data);
+    if (sender) cause.agentIds.add(sender);
+    causes.set(taskId, cause);
+  });
+  return causes;
+}
+
+export function logicalTaskRef(taskId: string, leaf: 'prompt' | 'output'): string {
+  return `zeroshot-trace://task/${encodeURIComponent(taskId)}/${leaf}`;
+}
+
+export function expectedLogPath(allowedLogRoot: string, taskId: string): string | null {
+  const resolvedRoot = path.resolve(allowedLogRoot);
+  const expected = path.resolve(resolvedRoot, `${taskId}.log`);
+  return path.dirname(expected) === resolvedRoot ? expected : null;
+}
+
+export function readTraceTask(
+  taskId: string,
+  readTask: (taskId: string) => TraceTask | null
+): TraceTaskRead {
+  let task: TraceTask | null;
+  try {
+    task = readTask(taskId);
+  } catch {
+    return { task: null, issue: `task:${taskId}:task_row_unreadable` };
+  }
+  if (!task) return { task: null, issue: `task:${taskId}:task_row_missing` };
+  if (task.id !== undefined && task.id !== taskId) {
+    return { task: null, issue: `task:${taskId}:task_row_identity_mismatch` };
+  }
+  return { task, issue: null };
+}

package/cli/trace-export.js

@@ -0,0 +1,120 @@
+"use strict";
+const path = require("path");
+const export_stream_1 = require("./export-stream");
+const trace_evidence_1 = require("./trace-evidence");
+const trace_output_1 = require("./trace-output");
+const TRACE_SCHEMA_VERSION = 'zeroshot.trace.v1';
+const TRACE_MEDIA_TYPE = 'application/x-zeroshot-trace+jsonl';
+function nullableInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) ? value : null;
+}
+function assertOutputDoesNotReplaceTaskLog(outputPath, allowedLogRoot, taskIds) {
+    if (!outputPath)
+        return;
+    const resolvedOutput = path.resolve(outputPath);
+    for (const taskId of taskIds) {
+        if ((0, trace_evidence_1.expectedLogPath)(allowedLogRoot, taskId) === resolvedOutput) {
+            throw new Error('Trace export output cannot replace a source task log');
+        }
+    }
+}
+function taskPrompt(task) {
+    return (0, export_stream_1.nullableString)(task.fullPrompt) ?? (0, export_stream_1.nullableString)(task.prompt);
+}
+function streamTask(options) {
+    const { writer, taskId, cause, readTask, allowedLogRoot, issues } = options;
+    const agentIds = [...cause.agentIds].sort(export_stream_1.compareText);
+    if (agentIds.length > 1)
+        issues.push(`task:${taskId}:ambiguous_agent`);
+    const taskRead = (0, trace_evidence_1.readTraceTask)(taskId, readTask);
+    const task = taskRead.task;
+    if (taskRead.issue)
+        issues.push(taskRead.issue);
+    const taskTerminal = task !== null && (0, trace_evidence_1.hasTerminalTaskStatus)(task);
+    if (task && !taskTerminal)
+        issues.push(`task:${taskId}:task_not_terminal`);
+    const promptRef = (0, trace_evidence_1.logicalTaskRef)(taskId, 'prompt');
+    const rawOutputRef = (0, trace_evidence_1.logicalTaskRef)(taskId, 'output');
+    writer.write({
+        record_type: 'task',
+        task_id: taskId,
+        agent_id: agentIds.length === 1 ? agentIds[0] : null,
+        provider: (0, export_stream_1.nullableString)(task?.provider),
+        model: (0, export_stream_1.nullableString)(task?.model),
+        status: (0, export_stream_1.nullableString)(task?.status),
+        created_at: (0, export_stream_1.nullableString)(task?.createdAt),
+        updated_at: (0, export_stream_1.nullableString)(task?.updatedAt),
+        exit_code: nullableInteger(task?.exitCode),
+        prompt_ref: promptRef,
+        prompt: task ? taskPrompt(task) : null,
+        raw_output_ref: rawOutputRef,
+    });
+    if (!task) {
+        (0, trace_output_1.writeUnavailableOutput)(writer, taskId, rawOutputRef);
+        return { bytes: 0 };
+    }
+    return (0, trace_output_1.streamTaskOutput)({
+        writer,
+        taskId,
+        task,
+        allowedLogRoot,
+        rawOutputRef,
+        taskTerminal,
+        issues,
+    });
+}
+function streamClusterTraceExport(options) {
+    const { ledger, clusterId, readTask, allowedLogRoot, outputPath = null } = options;
+    const causes = (0, trace_evidence_1.collectTaskCauses)(ledger, clusterId);
+    assertOutputDoesNotReplaceTaskLog(outputPath, allowedLogRoot, causes.keys());
+    const destination = (0, export_stream_1.createExclusiveDestination)(outputPath, options.stdout ?? process.stdout, 'Trace');
+    const writer = (0, export_stream_1.createRecordWriter)(destination);
+    let ledgerMessages = 0;
+    let taskOutputBytes = 0;
+    const issues = [];
+    try {
+        writer.write({
+            record_type: 'header',
+            schema_version: TRACE_SCHEMA_VERSION,
+            media_type: TRACE_MEDIA_TYPE,
+            cluster_id: clusterId,
+            chunk_bytes: trace_output_1.TRACE_OUTPUT_CHUNK_BYTES,
+        });
+        (0, trace_evidence_1.forEachLedgerMessage)(ledger, clusterId, (message) => {
+            writer.write({ record_type: 'ledger_message', message });
+            ledgerMessages += 1;
+        });
+        const ordered = [...causes.entries()].sort(([left], [right]) => (0, export_stream_1.compareText)(left, right));
+        for (const [taskId, cause] of ordered) {
+            taskOutputBytes += streamTask({
+                writer,
+                taskId,
+                cause,
+                readTask,
+                allowedLogRoot,
+                issues,
+            }).bytes;
+        }
+        issues.sort(export_stream_1.compareText);
+        writer.finish({
+            record_type: 'footer',
+            complete: issues.length === 0,
+            ledger_messages: ledgerMessages,
+            tasks: causes.size,
+            task_output_bytes: taskOutputBytes,
+            issues,
+        });
+    }
+    finally {
+        destination.close();
+    }
+}
+module.exports = {
+    TRACE_OUTPUT_CHUNK_BYTES: trace_output_1.TRACE_OUTPUT_CHUNK_BYTES,
+    collectTaskCauses: trace_evidence_1.collectTaskCauses,
+    expectedLogPath: trace_evidence_1.expectedLogPath,
+    hasTerminalTaskStatus: trace_evidence_1.hasTerminalTaskStatus,
+    logicalTaskRef: trace_evidence_1.logicalTaskRef,
+    readTraceTask: trace_evidence_1.readTraceTask,
+    streamClusterTraceExport,
+};