shortcutxl 0.2.0

package/dist/custom/cron/jobs.js

@@ -0,0 +1,226 @@
+/**
+ * Job CRUD and execution-result logic.
+ *
+ * Pure functions that operate on CronJob objects — no I/O.
+ */
+import crypto from 'node:crypto';
+import { computeNextRunAtMs } from './schedule.js';
+// -- Constants ---------------------------------------------------------------
+/** Clear runningAtMs markers older than this (stuck run detection). */
+export const STUCK_RUN_MS = 2 * 60 * 60 * 1000;
+/** Exponential backoff delays indexed by consecutive error count. */
+const BACKOFF_MS = [
+    30_000, // 1st → 30s
+    60_000, // 2nd → 1m
+    5 * 60_000, // 3rd → 5m
+    15 * 60_000, // 4th → 15m
+    60 * 60_000 // 5th+ → 60m
+];
+/** Minimum gap between consecutive fires to prevent spin-loops. */
+const MIN_REFIRE_GAP_MS = 2_000;
+/** Max consecutive schedule errors before auto-disabling. */
+const MAX_SCHEDULE_ERRORS = 3;
+/** Max transient retries for one-shot (at) jobs. */
+const MAX_TRANSIENT_RETRIES = 3;
+const TRANSIENT_PATTERNS = [
+    /rate[_ ]limit|too many requests|429/i,
+    /overloaded|529|high demand/i,
+    /network|econnreset|econnrefused|fetch failed|socket/i,
+    /timeout|etimedout/i,
+    /(?:status|http|code)[:\s]+5\d{2}\b/i
+];
+// -- Helpers -----------------------------------------------------------------
+function errorBackoffMs(consecutiveErrors) {
+    const idx = Math.min(consecutiveErrors - 1, BACKOFF_MS.length - 1);
+    return BACKOFF_MS[Math.max(0, idx)];
+}
+function isTransientError(error) {
+    if (!error)
+        return false;
+    return TRANSIENT_PATTERNS.some((re) => re.test(error));
+}
+// -- Create / Patch ----------------------------------------------------------
+export function createJob(input, nowMs) {
+    const id = crypto.randomUUID();
+    const schedule = input.schedule.kind === 'every' && input.schedule.anchorMs == null
+        ? { ...input.schedule, anchorMs: nowMs }
+        : input.schedule;
+    const deleteAfterRun = typeof input.deleteAfterRun === 'boolean'
+        ? input.deleteAfterRun
+        : schedule.kind === 'at'
+            ? true
+            : undefined;
+    const job = {
+        id,
+        name: input.name,
+        description: input.description,
+        enabled: input.enabled ?? true,
+        deleteAfterRun,
+        createdAtMs: nowMs,
+        updatedAtMs: nowMs,
+        schedule,
+        payload: input.payload,
+        state: { ...input.state }
+    };
+    job.state.nextRunAtMs = computeJobNextRun(job, nowMs);
+    return job;
+}
+export function applyJobPatch(job, patch, nowMs) {
+    if ('name' in patch && patch.name != null)
+        job.name = patch.name;
+    if ('description' in patch)
+        job.description = patch.description;
+    if (typeof patch.enabled === 'boolean')
+        job.enabled = patch.enabled;
+    if (typeof patch.deleteAfterRun === 'boolean')
+        job.deleteAfterRun = patch.deleteAfterRun;
+    if (patch.schedule)
+        job.schedule = patch.schedule;
+    if (patch.payload)
+        job.payload = { ...job.payload, ...patch.payload };
+    if (patch.state)
+        job.state = { ...job.state, ...patch.state };
+    job.updatedAtMs = nowMs;
+    // Recompute nextRunAtMs if schedule or enabled changed
+    if (patch.schedule != null || patch.enabled != null) {
+        job.state.nextRunAtMs = job.enabled ? computeJobNextRun(job, nowMs) : undefined;
+        if (!job.enabled)
+            job.state.runningAtMs = undefined;
+        if (patch.schedule != null)
+            job.state.scheduleErrorCount = 0;
+    }
+}
+// -- Schedule computation ----------------------------------------------------
+export function computeJobNextRun(job, nowMs) {
+    if (!job.enabled)
+        return undefined;
+    // For 'every' jobs, anchor to lastRunAtMs if available
+    if (job.schedule.kind === 'every') {
+        const lastRun = job.state.lastRunAtMs;
+        if (typeof lastRun === 'number' && Number.isFinite(lastRun)) {
+            const next = Math.floor(lastRun) + Math.max(1, Math.floor(job.schedule.everyMs));
+            if (next > nowMs)
+                return next;
+        }
+    }
+    // For 'at' jobs that already ran successfully, don't re-schedule
+    if (job.schedule.kind === 'at' && job.state.lastRunStatus === 'ok') {
+        return undefined;
+    }
+    return computeNextRunAtMs(job.schedule, nowMs);
+}
+// -- Job-due check -----------------------------------------------------------
+export function isJobDue(job, nowMs, forced = false) {
+    if (!job.enabled)
+        return false;
+    if (typeof job.state.runningAtMs === 'number')
+        return false;
+    if (forced)
+        return true;
+    return typeof job.state.nextRunAtMs === 'number' && nowMs >= job.state.nextRunAtMs;
+}
+/**
+ * Apply an execution result to a job's state.
+ * Returns true if the job should be deleted (one-shot success with deleteAfterRun).
+ */
+export function applyJobResult(job, result) {
+    job.state.runningAtMs = undefined;
+    job.state.lastRunAtMs = result.startedAt;
+    job.state.lastRunStatus = result.status;
+    job.state.lastDurationMs = Math.max(0, result.endedAt - result.startedAt);
+    job.state.lastError = result.error;
+    job.updatedAtMs = result.endedAt;
+    if (result.status === 'error') {
+        job.state.consecutiveErrors = (job.state.consecutiveErrors ?? 0) + 1;
+    }
+    else {
+        job.state.consecutiveErrors = 0;
+    }
+    const shouldDelete = job.schedule.kind === 'at' &&
+        job.deleteAfterRun === true &&
+        (result.status === 'ok' || result.status === 'skipped');
+    if (shouldDelete)
+        return true;
+    if (job.schedule.kind === 'at') {
+        if (result.status === 'ok' || result.status === 'skipped') {
+            job.enabled = false;
+            job.state.nextRunAtMs = undefined;
+        }
+        else {
+            // One-shot error: retry if transient
+            const consecutive = job.state.consecutiveErrors ?? 1;
+            if (isTransientError(result.error) && consecutive <= MAX_TRANSIENT_RETRIES) {
+                job.state.nextRunAtMs = result.endedAt + errorBackoffMs(consecutive);
+            }
+            else {
+                job.enabled = false;
+                job.state.nextRunAtMs = undefined;
+            }
+        }
+    }
+    else if (result.status === 'error' && job.enabled) {
+        // Recurring job error: apply backoff
+        const backoff = errorBackoffMs(job.state.consecutiveErrors ?? 1);
+        const normalNext = computeJobNextRun(job, result.endedAt);
+        const backoffNext = result.endedAt + backoff;
+        job.state.nextRunAtMs = normalNext != null ? Math.max(normalNext, backoffNext) : backoffNext;
+    }
+    else if (job.enabled) {
+        // Recurring job success — enforce minimum gap to prevent spin loops
+        const naturalNext = computeJobNextRun(job, result.endedAt);
+        const minNext = result.endedAt + MIN_REFIRE_GAP_MS;
+        job.state.nextRunAtMs = naturalNext != null ? Math.max(naturalNext, minNext) : minNext;
+    }
+    else {
+        job.state.nextRunAtMs = undefined;
+    }
+    return false;
+}
+// -- Maintenance -------------------------------------------------------------
+/**
+ * Normalize tick state: clear stuck runningAtMs, repair missing nextRunAtMs.
+ * Returns true if any field was changed.
+ */
+export function normalizeJobState(job, nowMs) {
+    let changed = false;
+    // Clear stuck runs
+    const runningAt = job.state.runningAtMs;
+    if (typeof runningAt === 'number' && nowMs - runningAt > STUCK_RUN_MS) {
+        job.state.runningAtMs = undefined;
+        changed = true;
+    }
+    // Disabled jobs should have no schedule
+    if (!job.enabled) {
+        if (job.state.nextRunAtMs != null) {
+            job.state.nextRunAtMs = undefined;
+            changed = true;
+        }
+        if (job.state.runningAtMs != null) {
+            job.state.runningAtMs = undefined;
+            changed = true;
+        }
+        return changed;
+    }
+    // Repair missing nextRunAtMs for enabled jobs
+    if (job.state.nextRunAtMs == null) {
+        const computed = computeJobNextRun(job, nowMs);
+        if (computed != null) {
+            job.state.nextRunAtMs = computed;
+            changed = true;
+        }
+    }
+    return changed;
+}
+/**
+ * Record a schedule computation error. Auto-disables after MAX_SCHEDULE_ERRORS.
+ */
+export function recordScheduleError(job, err) {
+    const count = (job.state.scheduleErrorCount ?? 0) + 1;
+    job.state.scheduleErrorCount = count;
+    job.state.nextRunAtMs = undefined;
+    job.state.lastError = `schedule error: ${String(err)}`;
+    if (count >= MAX_SCHEDULE_ERRORS) {
+        job.enabled = false;
+    }
+}
+//# sourceMappingURL=jobs.js.map

package/dist/custom/cron/run-log.js

@@ -0,0 +1,51 @@
+/**
+ * Run log — append-only NDJSON log of cron job executions.
+ *
+ * Each job gets its own log file: cron/runs/<jobId>.ndjson
+ * One line per execution with timestamp, status, duration, and error.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { getCronDir } from './store.js';
+function getRunsDir() {
+    return path.join(getCronDir(), 'runs');
+}
+/** Max output stored per run (truncated beyond this). */
+const MAX_LOG_OUTPUT = 4096;
+/** Truncate output for storage. */
+export function truncateRunOutput(text) {
+    if (text.length <= MAX_LOG_OUTPUT)
+        return text;
+    return text.slice(0, MAX_LOG_OUTPUT) + '\n... (truncated)';
+}
+/** Append a run log entry for a completed job. */
+export async function appendRunLog(entry, runsDir = getRunsDir()) {
+    await fs.promises.mkdir(runsDir, { recursive: true, mode: 0o700 });
+    const logPath = path.join(runsDir, `${entry.jobId}.ndjson`);
+    const line = JSON.stringify(entry) + '\n';
+    await fs.promises.appendFile(logPath, line, { encoding: 'utf-8', mode: 0o600 });
+}
+/** Read recent run log entries for a job (newest first, up to limit). */
+export async function readRunLog(jobId, limit = 20, runsDir = getRunsDir()) {
+    const logPath = path.join(runsDir, `${jobId}.ndjson`);
+    let raw;
+    try {
+        raw = await fs.promises.readFile(logPath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const lines = raw.trim().split('\n').filter(Boolean);
+    const entries = [];
+    // Read from end for newest-first
+    for (let i = lines.length - 1; i >= 0 && entries.length < limit; i--) {
+        try {
+            entries.push(JSON.parse(lines[i]));
+        }
+        catch {
+            // Skip corrupt lines
+        }
+    }
+    return entries;
+}
+//# sourceMappingURL=run-log.js.map

package/dist/custom/cron/schedule.js

@@ -0,0 +1,72 @@
+/**
+ * Schedule computation — next-run-at logic for all three schedule kinds.
+ *
+ * Pure functions. No I/O. Caches parsed Cron instances for performance.
+ */
+import { Cron } from 'croner';
+// ---------------------------------------------------------------------------
+// Cron expression cache
+// ---------------------------------------------------------------------------
+const CACHE_MAX = 512;
+const cronCache = new Map();
+function getCron(expr, tz) {
+    const key = tz ? `${expr}|${tz}` : expr;
+    let cron = cronCache.get(key);
+    if (cron)
+        return cron;
+    // Evict oldest entry if cache is full (FIFO)
+    if (cronCache.size >= CACHE_MAX) {
+        const oldest = cronCache.keys().next().value;
+        if (oldest)
+            cronCache.delete(oldest);
+    }
+    cron = new Cron(expr, { timezone: tz });
+    cronCache.set(key, cron);
+    return cron;
+}
+// ---------------------------------------------------------------------------
+// Next-run computation
+// ---------------------------------------------------------------------------
+/**
+ * Compute the next run timestamp (epoch ms) for a schedule.
+ * Returns undefined if the schedule has no future runs (e.g. past "at" time).
+ */
+export function computeNextRunAtMs(schedule, nowMs) {
+    switch (schedule.kind) {
+        case 'at': {
+            const target = new Date(schedule.at).getTime();
+            if (!Number.isFinite(target)) {
+                throw new Error(`Invalid "at" timestamp: ${schedule.at}`);
+            }
+            return target > nowMs ? target : undefined;
+        }
+        case 'every': {
+            const everyMs = Math.max(1, Math.floor(schedule.everyMs));
+            const anchor = typeof schedule.anchorMs === 'number' && Number.isFinite(schedule.anchorMs)
+                ? schedule.anchorMs
+                : nowMs;
+            if (anchor > nowMs)
+                return anchor;
+            const elapsed = nowMs - anchor;
+            const steps = Math.max(1, Math.ceil(elapsed / everyMs));
+            return anchor + steps * everyMs;
+        }
+        case 'cron': {
+            const cron = getCron(schedule.expr, schedule.tz);
+            const now = new Date(nowMs);
+            let next = cron.nextRun(now);
+            // Workaround: croner can return a past time if the reference date
+            // is very close to (but just after) a fire time, especially with
+            // timezone offsets. Retry with a +1s bump.
+            if (next && next.getTime() <= nowMs) {
+                const bumped = new Date(nowMs + 1000);
+                const retry = cron.nextRun(bumped);
+                if (retry && retry.getTime() > nowMs) {
+                    next = retry;
+                }
+            }
+            return next ? next.getTime() : undefined;
+        }
+    }
+}
+//# sourceMappingURL=schedule.js.map

package/dist/custom/cron/status-line.js

@@ -0,0 +1,98 @@
+/**
+ * Cron status line — renders a one-line summary for the TUI footer.
+ *
+ * Reads jobs.json (cached) and PID file to build a status string like:
+ *   ⏰ 3 jobs · next: "Morning Report" in 2m · scheduler: running
+ *   ⏰ 0 jobs · scheduler: stopped
+ */
+import { getDaemonStatus } from './daemon-ipc.js';
+import { getCronStorePath, loadCronStore } from './store.js';
+const STATUS_KEY = 'cron';
+const POLL_INTERVAL_MS = 15_000;
+let timer = null;
+// ---------------------------------------------------------------------------
+// Time formatting
+// ---------------------------------------------------------------------------
+function formatDelta(ms) {
+    if (ms < 0)
+        return 'now';
+    const secs = Math.round(ms / 1000);
+    if (secs < 60)
+        return `${secs}s`;
+    const mins = Math.round(secs / 60);
+    if (mins < 60)
+        return `${mins}m`;
+    const hours = Math.floor(mins / 60);
+    const remainMins = mins % 60;
+    return remainMins > 0 ? `${hours}h ${remainMins}m` : `${hours}h`;
+}
+export async function computeCronStatus(storePath = getCronStorePath()) {
+    const daemon = getDaemonStatus();
+    let jobCount = 0;
+    let nextJobName;
+    let nextRunMs;
+    try {
+        const store = await loadCronStore(storePath);
+        const enabled = store.jobs.filter((j) => j.enabled);
+        jobCount = enabled.length;
+        // Find the next job to fire
+        let nearestMs = Infinity;
+        for (const job of enabled) {
+            const next = job.state.nextRunAtMs;
+            if (typeof next === 'number' && next < nearestMs) {
+                nearestMs = next;
+                nextJobName = job.name;
+                nextRunMs = next;
+            }
+        }
+    }
+    catch {
+        // Store doesn't exist or is corrupt — show minimal status
+    }
+    const parts = [];
+    // Job count
+    const jobLabel = jobCount === 1 ? '1 job' : `${jobCount} jobs`;
+    parts.push(jobLabel);
+    // Next fire
+    if (nextRunMs != null && nextJobName) {
+        const delta = nextRunMs - Date.now();
+        parts.push(`next: "${nextJobName}" in ${formatDelta(delta)}`);
+    }
+    // Scheduler status
+    parts.push(`scheduler: ${daemon.running ? 'running' : 'stopped'}`);
+    const text = `⏰ ${parts.join(' · ')}`;
+    return { text, jobCount, schedulerRunning: daemon.running };
+}
+/**
+ * Start polling cron status and updating the TUI footer.
+ * Call once from main.ts after InteractiveMode is ready.
+ */
+export function startCronStatusPolling(setStatus, storePath = getCronStorePath()) {
+    stopCronStatusPolling();
+    const update = async () => {
+        try {
+            const { text, jobCount, schedulerRunning } = await computeCronStatus(storePath);
+            // Only show status if there are jobs or the scheduler is running
+            if (jobCount > 0 || schedulerRunning) {
+                setStatus(STATUS_KEY, text);
+            }
+            else {
+                setStatus(STATUS_KEY, undefined);
+            }
+        }
+        catch {
+            // Silently ignore — don't crash the TUI
+        }
+    };
+    // Initial update
+    void update();
+    timer = setInterval(() => void update(), POLL_INTERVAL_MS);
+    timer.unref();
+}
+function stopCronStatusPolling() {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+}
+//# sourceMappingURL=status-line.js.map

package/dist/custom/cron/store.js

@@ -0,0 +1,87 @@
+/**
+ * Cron job store — persistent JSON file with atomic writes.
+ *
+ * Jobs live at ~/.shortcut/agent/cron/jobs.json.
+ * Writes use temp-file + rename for crash safety, with a .bak backup.
+ */
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getAgentDir } from '../../config.js';
+/** Lazy getter — avoids caching getAgentDir() at module load time. */
+export function getCronDir() {
+    return path.join(getAgentDir(), 'cron');
+}
+/** Lazy getter — avoids caching getAgentDir() at module load time. */
+export function getCronStorePath() {
+    return path.join(getCronDir(), 'jobs.json');
+}
+/** Cache to skip writes when content hasn't changed. */
+const serializedCache = new Map();
+export async function loadCronStore(storePath = getCronStorePath()) {
+    try {
+        const raw = await fs.promises.readFile(storePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version === 'number' && parsed.version !== 1) {
+            throw new Error(`Unsupported cron store version: ${parsed.version}`);
+        }
+        if ('jobs' in parsed && !Array.isArray(parsed.jobs)) {
+            throw new Error('Corrupt cron store: jobs is not an array');
+        }
+        const jobs = Array.isArray(parsed.jobs)
+            ? parsed.jobs.filter((j) => j != null &&
+                typeof j === 'object' &&
+                typeof j.id === 'string')
+            : [];
+        const store = { version: 1, jobs: jobs };
+        serializedCache.set(storePath, JSON.stringify(store, null, 2));
+        return store;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            serializedCache.delete(storePath);
+            return { version: 1, jobs: [] };
+        }
+        throw err;
+    }
+}
+export async function saveCronStore(storePath, store, opts) {
+    const json = JSON.stringify(store, null, 2);
+    if (serializedCache.get(storePath) === json)
+        return;
+    const dir = path.dirname(storePath);
+    await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 });
+    // Backup existing file
+    if (!opts?.skipBackup) {
+        try {
+            await fs.promises.copyFile(storePath, `${storePath}.bak`);
+        }
+        catch {
+            // best-effort — file may not exist yet
+        }
+    }
+    // Atomic write: temp file → rename
+    const tmp = `${storePath}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+    await fs.promises.writeFile(tmp, json, { encoding: 'utf-8', mode: 0o600 });
+    try {
+        await fs.promises.rename(tmp, storePath);
+    }
+    catch (err) {
+        // Windows fallback: rename can fail with EPERM/EEXIST when dest exists
+        const code = err.code;
+        if (code === 'EPERM' || code === 'EEXIST') {
+            await fs.promises.copyFile(tmp, storePath);
+            await fs.promises.unlink(tmp).catch(() => { });
+        }
+        else {
+            await fs.promises.unlink(tmp).catch(() => { });
+            throw err;
+        }
+    }
+    serializedCache.set(storePath, json);
+}
+/** Clear the serialization cache (for testing). */
+export function clearStoreCache() {
+    serializedCache.clear();
+}
+//# sourceMappingURL=store.js.map

package/dist/custom/cron/types.js

@@ -0,0 +1,8 @@
+/**
+ * Cron job types.
+ *
+ * Simplified from OpenClaw — no delivery channels, no gateway, no failure alerts.
+ * Every cron job spawns an isolated agent run with a prompt.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/custom/dev/index.js

@@ -0,0 +1,59 @@
+/**
+ * Centralized dev-mode hooks for SHORTCUT_DEV_MODE=1.
+ *
+ * All dev-only behaviors are registered here so they're easy to discover,
+ * audit, and extend. The composition root (main.ts) calls getDevHooks()
+ * once and wires the returned hooks into the session/mode options.
+ *
+ * To add a new dev-mode feature:
+ *   1. Create a file in custom/dev/ with the implementation
+ *   2. Wire it into DevHooks and getDevHooks() below
+ *   3. Consume the hook in main.ts
+ */
+import { exec } from 'child_process';
+import { ALL_DEV_SLASH_COMMANDS } from '../../core/slash-commands.js';
+import { exportDevTraces } from './trace-export.js';
+function openInBrowser(filePath) {
+    const cmd = process.platform === 'win32'
+        ? `start "" "${filePath}"`
+        : process.platform === 'darwin'
+            ? `open "${filePath}"`
+            : `xdg-open "${filePath}"`;
+    exec(cmd, () => { });
+}
+/**
+ * Build all dev-mode hooks for the given session.
+ * Returns undefined when dev mode is off — callers can use optional chaining.
+ */
+export function getDevHooks(session) {
+    // -- Trace export after each query --
+    let lastTracePaths = [];
+    const onAgentEnd = () => {
+        void exportDevTraces(session)
+            .then((paths) => {
+            lastTracePaths = paths;
+        })
+            .catch((err) => {
+            console.debug('[dev] trace export failed:', err);
+        });
+    };
+    // -- /trace command: open all traces in browser --
+    const onDevCommand = (command, showStatus) => {
+        if (command !== '/trace')
+            return false;
+        if (lastTracePaths.length === 0) {
+            showStatus('No traces exported yet');
+            return true;
+        }
+        for (const p of lastTracePaths)
+            openInBrowser(p);
+        showStatus(`Opened ${lastTracePaths.length} trace(s) in browser`);
+        return true;
+    };
+    return {
+        slashCommands: ALL_DEV_SLASH_COMMANDS,
+        onAgentEnd,
+        onDevCommand
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/custom/dev/trace-export.js

@@ -0,0 +1,58 @@
+/**
+ * Dev-mode HTML export of session traces after each query.
+ *
+ * When SHORTCUT_DEV_MODE=1, exports the main session JSONL and any subagent
+ * JSONLs to HTML after each agent_end event. File paths are shown in the
+ * footer via extension statuses (one line per trace).
+ */
+import { existsSync } from 'fs';
+import { basename, dirname, join } from 'path';
+import { exportFromFile } from '../../core/export-html/index.js';
+/**
+ * Export main + subagent session JSONLs to HTML.
+ * Returns all exported HTML paths, or empty array if nothing was exported.
+ */
+export async function exportDevTraces(session) {
+    const mainFile = session.sessionManager.getSessionFile();
+    if (!mainFile)
+        return [];
+    const outputDir = dirname(mainFile);
+    const paths = [];
+    // Export main session
+    try {
+        const mainBase = basename(mainFile, '.jsonl');
+        const mainHtml = join(outputDir, `${mainBase}.html`);
+        await exportFromFile(mainFile, { outputPath: mainHtml, title: 'Main Agent' });
+        paths.push(mainHtml);
+    }
+    catch {
+        // Silently skip — export may fail if session is empty
+    }
+    // Export subagent sessions from tool result details
+    const entries = session.sessionManager.getEntries();
+    let subIndex = 0;
+    for (const entry of entries) {
+        if (entry.type !== 'message')
+            continue;
+        const msg = entry.message;
+        if (msg?.role !== 'toolResult')
+            continue;
+        const subFile = msg?.details?.sessionFile;
+        if (typeof subFile === 'string' && existsSync(subFile)) {
+            try {
+                subIndex++;
+                const toolName = msg?.toolName;
+                const title = toolName ? `Subagent: ${toolName}` : `Subagent ${subIndex}`;
+                const subBase = basename(subFile, '.jsonl');
+                const subHtml = join(outputDir, `${subBase}.html`);
+                await exportFromFile(subFile, { outputPath: subHtml, title });
+                paths.push(subHtml);
+            }
+            catch {
+                // Skip failed subagent exports
+            }
+        }
+    }
+    return paths;
+}
+//# sourceMappingURL=trace-export.js.map