@exaudeus/workrail 3.80.0 → 3.81.0

package/dist/cli/commands/worktrain-diagnose.js

@@ -0,0 +1,628 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDaemonEvents = parseDaemonEvents;
+exports.formatDiagnosticCard = formatDiagnosticCard;
+exports.formatDiagnosticJson = formatDiagnosticJson;
+const chalk_1 = __importDefault(require("chalk"));
+function parseDaemonEvents(sessionIdQuery, eventsDir, daysBack, readFile) {
+    const filePaths = buildFilePaths(eventsDir, daysBack);
+    const sessionEvents = new Map();
+    for (const filePath of filePaths) {
+        const content = readFile(filePath);
+        if (content === null)
+            continue;
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            const eventSessionId = extractSessionId(obj);
+            if (!eventSessionId)
+                continue;
+            if (!matchesQuery(eventSessionId, sessionIdQuery))
+                continue;
+            let acc = sessionEvents.get(eventSessionId);
+            if (!acc) {
+                acc = createAccumulator(eventSessionId);
+                sessionEvents.set(eventSessionId, acc);
+            }
+            accumulateEvent(acc, obj, trimmed);
+        }
+    }
+    if (sessionEvents.size === 0) {
+        return { kind: 'NOT_FOUND', sessionIdQuery, daysBack };
+    }
+    if (sessionEvents.size > 1) {
+        return {
+            kind: 'AMBIGUOUS',
+            sessionIdQuery,
+            candidates: Array.from(sessionEvents.keys()).sort(),
+        };
+    }
+    const acc = sessionEvents.values().next().value;
+    return classify(acc);
+}
+function classify(acc) {
+    const metrics = buildMetrics(acc);
+    const steps = buildSteps(acc);
+    const durationMs = acc.startedAt !== null && acc.lastTs !== null
+        ? acc.lastTs - acc.startedAt
+        : 0;
+    if (acc.completedEvent?.outcome === 'success') {
+        return {
+            kind: 'SUCCESS',
+            sessionId: acc.sessionId,
+            workflowId: acc.workflowId,
+            startedAt: acc.startedAt,
+            durationMs,
+            metrics,
+        };
+    }
+    const processState = determineProcessState(acc);
+    if (acc.abortedEvent !== null) {
+        const infraReason = acc.abortedEvent.reason === 'daemon_shutdown' ? 'daemon_shutdown'
+            : acc.abortedEvent.reason === 'daemon_killed' ? 'daemon_killed'
+                : 'unknown';
+        return {
+            kind: 'INFRA_ERROR',
+            sessionId: acc.sessionId,
+            workflowId: acc.workflowId,
+            startedAt: acc.startedAt,
+            durationMs,
+            infraReason,
+            detail: `Session interrupted: ${acc.abortedEvent.reason}`,
+            metrics,
+            steps,
+            processState,
+        };
+    }
+    if (acc.completedEvent === null) {
+        return {
+            kind: 'ORPHANED',
+            sessionId: acc.sessionId,
+            workflowId: acc.workflowId,
+            startedAt: acc.startedAt,
+            durationMs,
+            lastEventKind: acc.lastEventKind,
+            lastEventTs: acc.lastTs,
+            metrics,
+            steps,
+        };
+    }
+    const { outcome, detail, rawLine } = acc.completedEvent;
+    const detailTruncated = detail.length >= 198;
+    if (outcome === 'stuck') {
+        return {
+            kind: 'WORKFLOW_STUCK',
+            sessionId: acc.sessionId,
+            workflowId: acc.workflowId,
+            startedAt: acc.startedAt,
+            durationMs,
+            stuckReason: acc.stuckReason ?? 'no_progress',
+            stuckDetail: acc.stuckDetail ?? detail,
+            toolName: acc.stuckToolName ?? undefined,
+            argsSummary: acc.stuckArgsSummary ?? undefined,
+            metrics,
+            steps,
+            processState,
+        };
+    }
+    if (outcome === 'timeout') {
+        const timeoutReason = detail.includes('wall_clock') ? 'wall_clock'
+            : detail.includes('max_turns') ? 'max_turns'
+                : 'unknown';
+        return {
+            kind: 'WORKFLOW_TIMEOUT',
+            sessionId: acc.sessionId,
+            workflowId: acc.workflowId,
+            startedAt: acc.startedAt,
+            durationMs,
+            timeoutReason,
+            stepAdvances: acc.stepAdvances,
+            metrics,
+            steps,
+            processState,
+        };
+    }
+    if (outcome === 'error' && (/model identifier|invalid model|api.*key|authentication/i.test(detail) || /\b400\b.*model|\bmodel\b.*\b400\b/i.test(detail))) {
+        return {
+            kind: 'CONFIG_ERROR',
+            sessionId: acc.sessionId,
+            workflowId: acc.workflowId,
+            startedAt: acc.startedAt,
+            durationMs,
+            detail,
+            detailTruncated,
+            metrics,
+            steps,
+            processState,
+        };
+    }
+    if (outcome === 'error' && /aborted|SIGKILL|SIGTERM|network|ECONNRESET|ENOTFOUND/i.test(detail)) {
+        return {
+            kind: 'INFRA_ERROR',
+            sessionId: acc.sessionId,
+            workflowId: acc.workflowId,
+            startedAt: acc.startedAt,
+            durationMs,
+            infraReason: /aborted/i.test(detail) ? 'aborted' : 'network',
+            detail,
+            metrics,
+            steps,
+            processState,
+        };
+    }
+    return {
+        kind: 'DEFAULT',
+        sessionId: acc.sessionId,
+        workflowId: acc.workflowId,
+        startedAt: acc.startedAt,
+        durationMs,
+        outcome,
+        detail,
+        rawEventLine: rawLine,
+        metrics,
+        steps,
+        processState,
+    };
+}
+function accumulateEvent(acc, obj, rawLine) {
+    const kind = typeof obj['kind'] === 'string' ? obj['kind'] : null;
+    const ts = typeof obj['ts'] === 'number' ? obj['ts'] : null;
+    if (ts !== null) {
+        if (acc.startedAt === null || ts < acc.startedAt) {
+            acc.startedAt = ts;
+        }
+        if (acc.lastTs === null || ts > acc.lastTs) {
+            acc.lastTs = ts;
+        }
+    }
+    if (kind !== null)
+        acc.lastEventKind = kind;
+    if (!kind)
+        return;
+    switch (kind) {
+        case 'session_started': {
+            if (typeof obj['workflowId'] === 'string')
+                acc.workflowId = obj['workflowId'];
+            break;
+        }
+        case 'session_completed': {
+            const outcome = typeof obj['outcome'] === 'string' ? obj['outcome'] : 'unknown';
+            const detail = typeof obj['detail'] === 'string' ? obj['detail'] : '';
+            acc.completedEvent = { outcome, detail, rawLine };
+            break;
+        }
+        case 'session_aborted': {
+            const reason = typeof obj['reason'] === 'string' ? obj['reason'] : 'unknown';
+            acc.abortedEvent = { reason };
+            break;
+        }
+        case 'agent_stuck': {
+            const reason = typeof obj['reason'] === 'string' ? obj['reason'] : null;
+            if (reason === 'repeated_tool_call' || reason === 'no_progress' || reason === 'stall') {
+                acc.stuckReason = reason;
+            }
+            acc.stuckDetail = typeof obj['detail'] === 'string' ? obj['detail'] : null;
+            acc.stuckToolName = typeof obj['toolName'] === 'string' ? obj['toolName'] : null;
+            acc.stuckArgsSummary = typeof obj['argsSummary'] === 'string' ? obj['argsSummary'] : null;
+            break;
+        }
+        case 'llm_turn_completed': {
+            acc.llmTurns++;
+            const inputTokens = typeof obj['inputTokens'] === 'number' ? obj['inputTokens'] : 0;
+            const outputTokens = typeof obj['outputTokens'] === 'number' ? obj['outputTokens'] : 0;
+            acc.inputTokens += inputTokens;
+            acc.outputTokens += outputTokens;
+            break;
+        }
+        case 'step_advanced': {
+            const turnsForStep = acc.llmTurns - acc.turnsAtLastStep;
+            acc.stepTurnCounts.push(turnsForStep);
+            acc.turnsAtLastStep = acc.llmTurns;
+            acc.stepAdvances++;
+            break;
+        }
+        case 'tool_call_started': {
+            acc.toolCallsTotal++;
+            break;
+        }
+        case 'tool_call_failed': {
+            acc.toolCallsFailed++;
+            break;
+        }
+        case 'tool_called': {
+            break;
+        }
+    }
+}
+function buildFilePaths(eventsDir, daysBack) {
+    const paths = [];
+    const now = new Date();
+    for (let i = 0; i < daysBack; i++) {
+        const d = new Date(now);
+        d.setDate(d.getDate() - i);
+        const dateStr = d.toISOString().slice(0, 10);
+        paths.push(`${eventsDir}/${dateStr}.jsonl`);
+    }
+    return paths;
+}
+function extractSessionId(obj) {
+    const sid = typeof obj['sessionId'] === 'string' ? obj['sessionId'] : null;
+    const wrid = typeof obj['workrailSessionId'] === 'string' ? obj['workrailSessionId'] : null;
+    return sid ?? wrid;
+}
+function matchesQuery(sessionId, query) {
+    return sessionId === query || sessionId.startsWith(query);
+}
+function createAccumulator(sessionId) {
+    return {
+        sessionId,
+        workflowId: 'unknown',
+        startedAt: null,
+        lastTs: null,
+        llmTurns: 0,
+        stepAdvances: 0,
+        toolCallsTotal: 0,
+        toolCallsFailed: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        stuckReason: null,
+        stuckDetail: null,
+        stuckToolName: null,
+        stuckArgsSummary: null,
+        completedEvent: null,
+        abortedEvent: null,
+        lastEventKind: null,
+        turnsAtLastStep: 0,
+        stepTurnCounts: [],
+    };
+}
+function buildMetrics(acc) {
+    return {
+        llmTurns: acc.llmTurns,
+        stepAdvances: acc.stepAdvances,
+        toolCallsTotal: acc.toolCallsTotal,
+        toolCallsFailed: acc.toolCallsFailed,
+        inputTokens: acc.inputTokens,
+        outputTokens: acc.outputTokens,
+    };
+}
+function buildSteps(acc) {
+    const steps = [];
+    for (let i = 0; i < acc.stepTurnCounts.length; i++) {
+        steps.push({ index: i + 1, status: 'completed', turns: acc.stepTurnCounts[i] ?? 0 });
+    }
+    if (acc.stepAdvances > 0 || acc.llmTurns > 0) {
+        const turnsOnTerminalStep = acc.llmTurns - acc.turnsAtLastStep;
+        steps.push({
+            index: steps.length + 1,
+            status: acc.completedEvent?.outcome === 'success' ? 'completed' : 'terminal',
+            turns: turnsOnTerminalStep,
+        });
+    }
+    return steps;
+}
+function determineProcessState(acc) {
+    if (acc.completedEvent !== null || acc.abortedEvent !== null)
+        return 'STOPPED';
+    return 'UNKNOWN';
+}
+const GLYPHS = {
+    done: '✓',
+    terminal: '→',
+    pending: '·',
+};
+const ASCII_GLYPHS = {
+    done: '[ok]',
+    terminal: '[->]',
+    pending: '[ ]',
+};
+const ZONE3_CAP = 8;
+function getGlyph(key, opts) {
+    return opts.ascii ? ASCII_GLYPHS[key] : GLYPHS[key];
+}
+function applyChalk(text, fn, opts) {
+    return opts.noColor ? text : fn(text);
+}
+function formatDiagnosticCard(result, opts = {}) {
+    switch (result.kind) {
+        case 'NOT_FOUND':
+            return formatNotFound(result, opts);
+        case 'AMBIGUOUS':
+            return formatAmbiguous(result, opts);
+        case 'SUCCESS':
+            return formatSuccess(result, opts);
+        case 'CONFIG_ERROR':
+            return formatConfigError(result, opts);
+        case 'WORKFLOW_STUCK':
+            return formatWorkflowStuck(result, opts);
+        case 'WORKFLOW_TIMEOUT':
+            return formatWorkflowTimeout(result, opts);
+        case 'INFRA_ERROR':
+            return formatInfraError(result, opts);
+        case 'ORPHANED':
+            return formatOrphaned(result, opts);
+        case 'DEFAULT':
+            return formatDefault(result, opts);
+        default: {
+            const _exhaustive = result;
+            return `Unknown diagnostic kind: ${JSON.stringify(_exhaustive)}`;
+        }
+    }
+}
+function formatHeader(categoryBadge, sessionId, workflowId, startedAt, durationMs, processState) {
+    const startedStr = startedAt !== null
+        ? `Started: ${formatStartedAt(startedAt)}`
+        : '';
+    const durationStr = formatDuration(durationMs);
+    const stateStr = processState !== null ? `  [${processState}]` : '';
+    const parts = [categoryBadge, sessionId, workflowId, startedStr, durationStr].filter(Boolean);
+    return parts.join('  ') + stateStr;
+}
+function formatStartedAt(ts) {
+    const d = new Date(ts);
+    const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    const day = days[d.getDay()] ?? '';
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    return `${day} ${hh}:${mm}`;
+}
+function formatDuration(ms) {
+    const totalSec = Math.floor(ms / 1000);
+    const min = Math.floor(totalSec / 60);
+    const sec = totalSec % 60;
+    if (min > 0)
+        return `${min}m ${sec}s`;
+    return `${totalSec}s`;
+}
+function formatMetricsLine(m) {
+    const failRate = m.toolCallsTotal > 0
+        ? ` (${m.toolCallsFailed} failed, ${Math.round((m.toolCallsFailed / m.toolCallsTotal) * 100)}%)`
+        : '';
+    const tokensIn = m.inputTokens > 0 ? `${Math.round(m.inputTokens / 1000)}k in` : null;
+    const tokensOut = m.outputTokens > 0 ? `${Math.round(m.outputTokens / 1000)}k out` : null;
+    const tokensStr = [tokensIn, tokensOut].filter(Boolean).join(' / ');
+    const parts = [
+        `Turns: ${m.llmTurns}`,
+        `Steps: ${m.stepAdvances}`,
+        `Tool calls: ${m.toolCallsTotal}${failRate}`,
+        tokensStr ? `Tokens: ${tokensStr}` : null,
+    ].filter(Boolean);
+    return parts.join('  |  ');
+}
+function formatStepTimeline(steps, opts) {
+    if (steps.length === 0) {
+        return 'Step timeline:\n  (session terminated before first step)';
+    }
+    let displaySteps = steps;
+    let ellipsisLine = null;
+    if (steps.length > ZONE3_CAP) {
+        const firstTwo = steps.slice(0, 2);
+        const lastThree = steps.slice(-3);
+        const omitted = steps.length - 5;
+        ellipsisLine = `  ... (${omitted} steps omitted, use --verbose to see all) ...`;
+        displaySteps = [...firstTwo, ...lastThree];
+    }
+    const lines = ['Step timeline:'];
+    let ellipsisInserted = false;
+    for (const step of displaySteps) {
+        if (ellipsisLine && !ellipsisInserted && step === steps[steps.length - 3] && steps.length > ZONE3_CAP) {
+            lines.push(ellipsisLine);
+            ellipsisInserted = true;
+        }
+        const glyph = step.status === 'completed' ? getGlyph('done', opts)
+            : step.status === 'terminal' ? getGlyph('terminal', opts)
+                : getGlyph('pending', opts);
+        const turnsStr = step.turns > 0 ? `${step.turns} turns` : '';
+        const statusLabel = step.status === 'terminal' ? '  [STOPPED]' : '';
+        const stepLine = step.status === 'terminal'
+            ? `  ${applyChalk(glyph, chalk_1.default.bold, opts)}  step ${step.index}${turnsStr ? `  ${turnsStr}` : ''}${statusLabel}`
+            : `  ${glyph}  step ${step.index}${turnsStr ? `  ${turnsStr}` : ''}`;
+        lines.push(stepLine);
+    }
+    if (ellipsisLine && !ellipsisInserted) {
+        lines.push(ellipsisLine);
+    }
+    return lines.join('\n');
+}
+function formatNotFound(result, _opts) {
+    return [
+        `Session not found in the last ${result.daysBack} days.`,
+        `Query: "${result.sessionIdQuery}"`,
+        ``,
+        `Verify the session ID, or check execution-stats.jsonl for older sessions:`,
+        `  cat ~/.workrail/data/execution-stats.jsonl | grep "${result.sessionIdQuery.slice(0, 8)}"`,
+    ].join('\n');
+}
+function formatAmbiguous(result, _opts) {
+    return [
+        `Multiple sessions match "${result.sessionIdQuery}". Be more specific:`,
+        ...result.candidates.map(c => `  ${c}`),
+    ].join('\n');
+}
+function formatSuccess(result, opts) {
+    const badge = applyChalk('[SUCCESS]', chalk_1.default.green, opts);
+    const header = formatHeader(badge, result.sessionId, result.workflowId, result.startedAt, result.durationMs, null);
+    return [
+        header,
+        ``,
+        `DIAGNOSIS: SUCCESS -- session completed normally`,
+        ``,
+        `  No failure detected.`,
+        `  Run: worktrain logs --session ${result.sessionId} to see session activity.`,
+        ``,
+        formatMetricsLine(result.metrics),
+    ].join('\n');
+}
+function formatConfigError(result, opts) {
+    const badge = applyChalk('[CONFIG]', chalk_1.default.red, opts);
+    const header = formatHeader(badge, result.sessionId, result.workflowId, result.startedAt, result.durationMs, result.processState);
+    const truncNote = result.detailTruncated ? `\n  (truncated at 200 chars -- see conversation log for full text)` : '';
+    return [
+        header,
+        ``,
+        applyChalk(`DIAGNOSIS: CONFIG -- invalid model or API configuration`, chalk_1.default.red, opts),
+        ``,
+        `  Error: "${result.detail}"${truncNote}`,
+        `  Fix:   Check agentConfig.model in triggers.yml.`,
+        `         Use format: provider/model-id`,
+        `         e.g. amazon-bedrock/us.anthropic.claude-sonnet-4-6`,
+        ``,
+        formatMetricsLine(result.metrics),
+        ``,
+        formatStepTimeline(result.steps, opts),
+    ].join('\n');
+}
+function formatWorkflowStuck(result, opts) {
+    const badge = applyChalk('[STUCK]', chalk_1.default.red, opts);
+    const header = formatHeader(badge, result.sessionId, result.workflowId, result.startedAt, result.durationMs, result.processState);
+    const reasonLabel = result.stuckReason === 'repeated_tool_call' ? 'repeated tool call'
+        : result.stuckReason === 'no_progress' ? 'no step progress'
+            : 'stalled tool call';
+    const toolLine = result.toolName ? `  Tool:   ${result.toolName}` : null;
+    const argsLine = result.argsSummary ? `  Args:   "${result.argsSummary}"` : null;
+    let fixLine;
+    if (result.stuckReason === 'repeated_tool_call') {
+        fixLine = result.toolName
+            ? `  Fix:   ${result.toolName} called with identical args repeatedly. Review step prompt to clarify the observation loop.`
+            : `  Fix:   Agent called the same tool with identical args repeatedly. Review step prompt.`;
+    }
+    else if (result.stuckReason === 'no_progress') {
+        fixLine = `  Fix:   Agent used ${result.metrics.llmTurns} turns with 0 step advances. Step 1 prompt may be unclear or impossible with available tools.`;
+    }
+    else {
+        fixLine = `  Fix:   A tool call hung and never completed. Check network connectivity or file lock issues.`;
+    }
+    return [
+        header,
+        ``,
+        applyChalk(`DIAGNOSIS: STUCK -- ${reasonLabel}`, chalk_1.default.red, opts),
+        ``,
+        toolLine,
+        argsLine,
+        fixLine,
+        ``,
+        formatMetricsLine(result.metrics),
+        ``,
+        formatStepTimeline(result.steps, opts),
+    ].filter(line => line !== null).join('\n');
+}
+function formatWorkflowTimeout(result, opts) {
+    const badge = applyChalk('[TIMEOUT]', chalk_1.default.yellow, opts);
+    const header = formatHeader(badge, result.sessionId, result.workflowId, result.startedAt, result.durationMs, result.processState);
+    const reasonLabel = result.timeoutReason === 'wall_clock' ? 'wall clock limit reached'
+        : result.timeoutReason === 'max_turns' ? 'turn limit reached'
+            : 'limit reached';
+    let fixLine;
+    if (result.timeoutReason === 'wall_clock') {
+        fixLine = result.stepAdvances === 0
+            ? `  Fix:   Agent never advanced a step before timeout. The workflow prompt may be unclear.`
+            : `  Fix:   Increase maxSessionMinutes in triggers.yml agentConfig, or narrow the workflow scope.`;
+    }
+    else if (result.timeoutReason === 'max_turns') {
+        fixLine = `  Fix:   Increase maxTurns in triggers.yml agentConfig, or simplify the workflow.`;
+    }
+    else {
+        fixLine = `  Fix:   Increase maxSessionMinutes or maxTurns in triggers.yml agentConfig.`;
+    }
+    return [
+        header,
+        ``,
+        applyChalk(`DIAGNOSIS: TIMEOUT -- ${reasonLabel}`, chalk_1.default.yellow, opts),
+        ``,
+        `  Steps completed: ${result.stepAdvances}`,
+        fixLine,
+        ``,
+        formatMetricsLine(result.metrics),
+        ``,
+        formatStepTimeline(result.steps, opts),
+    ].join('\n');
+}
+function formatInfraError(result, opts) {
+    const badge = applyChalk('[INFRA]', chalk_1.default.yellow, opts);
+    const header = formatHeader(badge, result.sessionId, result.workflowId, result.startedAt, result.durationMs, result.processState);
+    const reasonLabel = result.infraReason === 'daemon_shutdown' ? 'daemon stopped mid-session'
+        : result.infraReason === 'daemon_killed' ? 'daemon killed mid-session'
+            : result.infraReason === 'network' ? 'network error'
+                : result.infraReason === 'aborted' ? 'session aborted'
+                    : 'infrastructure error';
+    const fixLine = (result.infraReason === 'daemon_shutdown' || result.infraReason === 'daemon_killed')
+        ? `  Fix:   Restart the daemon: worktrain daemon start\n         Re-queue the trigger or re-run the session manually.`
+        : `  Fix:   Check daemon logs: worktrain logs --session ${result.sessionId}`;
+    return [
+        header,
+        ``,
+        applyChalk(`DIAGNOSIS: INFRA -- ${reasonLabel}`, chalk_1.default.yellow, opts),
+        ``,
+        `  Detail: ${result.detail}`,
+        fixLine,
+        ``,
+        formatMetricsLine(result.metrics),
+        ``,
+        formatStepTimeline(result.steps, opts),
+    ].join('\n');
+}
+function formatOrphaned(result, opts) {
+    const badge = applyChalk('[ORPHANED]', chalk_1.default.gray ?? chalk_1.default.dim, opts);
+    const header = formatHeader(badge, result.sessionId, result.workflowId, result.startedAt, result.durationMs, null);
+    const lastEventStr = result.lastEventKind && result.lastEventTs !== null
+        ? `  Last event: ${result.lastEventKind} (${formatRelativeTime(result.lastEventTs)} ago)`
+        : `  Last event: unknown`;
+    return [
+        header,
+        ``,
+        applyChalk(`DIAGNOSIS: ORPHANED -- session ended without a completion event`, chalk_1.default.dim, opts),
+        ``,
+        lastEventStr,
+        `  Note: The daemon may have crashed or been killed mid-session.`,
+        `  Fix:   Check daemon process: worktrain daemon --status`,
+        `         If stopped, restart: worktrain daemon start`,
+        ``,
+        formatMetricsLine(result.metrics),
+        ``,
+        formatStepTimeline(result.steps, opts),
+    ].join('\n');
+}
+function formatDefault(result, opts) {
+    const badge = `[${result.outcome.toUpperCase()}]`;
+    const header = formatHeader(badge, result.sessionId, result.workflowId, result.startedAt, result.durationMs, result.processState);
+    return [
+        header,
+        ``,
+        `DIAGNOSIS: UNKNOWN -- unrecognized failure type`,
+        ``,
+        `  Outcome: ${result.outcome}`,
+        result.detail ? `  Detail:  ${result.detail}` : null,
+        `  Raw:     ${result.rawEventLine.slice(0, 200)}`,
+        ``,
+        `  No automated fix suggestion available for this failure type.`,
+        `  File an issue: https://github.com/EtienneBBeaulac/workrail/issues`,
+        ``,
+        formatMetricsLine(result.metrics),
+        ``,
+        formatStepTimeline(result.steps, opts),
+    ].filter(line => line !== null).join('\n');
+}
+function formatRelativeTime(ts) {
+    const elapsed = Date.now() - ts;
+    const min = Math.floor(elapsed / 60000);
+    if (min < 1)
+        return 'just now';
+    if (min < 60)
+        return `${min} minutes`;
+    const h = Math.floor(min / 60);
+    return `${h} hours`;
+}
+function formatDiagnosticJson(result) {
+    return JSON.stringify(result, null, 2);
+}