@bbigbang/agent-node 0.1.0

package/dist/droidMissionRunner.js

@@ -0,0 +1,808 @@
+import { spawn } from 'node:child_process';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+const OUTPUT_LIMIT = 8_000;
+const TRANSCRIPT_LIMIT = 40_000;
+const ARTIFACT_POLL_MS = 1_000;
+const FOLLOWUP_MAILBOX_RELATIVE_PATH = path.join('.bigbang', 'mission-followups.jsonl');
+export function runDroidMission(msg, send) {
+    const workspaceRoot = resolveExistingDirectory(msg.workspaceRoot);
+    const missionDir = msg.interaction || msg.continueSession
+        ? resolveExistingMissionDir(workspaceRoot, msg.missionDir)
+        : resolveMissionDir(workspaceRoot, msg.missionDir);
+    if (msg.interaction) {
+        deliverMissionInteraction(msg, missionDir, send);
+        return;
+    }
+    const scaffold = msg.continueSession ? null : createDroidMissionScaffold(missionDir, {
+        title: msg.title,
+        prompt: msg.prompt,
+        runtimeContext: resolveMissionRuntimeContext(),
+    });
+    ensureMissionFollowupMailbox(missionDir);
+    const args = buildDroidArgs({ ...msg, missionDir });
+    const child = spawn('droid', args, {
+        cwd: missionDir,
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let ended = false;
+    const artifactTailer = new MissionArtifactTailer({
+        missionId: msg.missionId,
+        requestId: msg.requestId,
+        missionDir,
+        send,
+    });
+    let artifactInterval = null;
+    send({
+        type: 'mission.run.accepted',
+        requestId: msg.requestId,
+        missionId: msg.missionId,
+        missionDir,
+        pid: child.pid ?? null,
+    });
+    if (scaffold) {
+        send({
+            type: 'mission.run.event',
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            eventType: 'mission_scaffold_prepared',
+            source: 'agent_node',
+            eventTime: scaffold.preparedAt,
+            payload: scaffold,
+        });
+    }
+    artifactInterval = setInterval(() => {
+        artifactTailer.poll();
+    }, ARTIFACT_POLL_MS);
+    artifactTailer.poll();
+    child.stdout.on('data', (chunk) => {
+        sendOutputEvent(send, msg.requestId, msg.missionId, 'stdout', chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+        sendOutputEvent(send, msg.requestId, msg.missionId, 'stderr', chunk);
+    });
+    child.on('error', (error) => {
+        if (ended)
+            return;
+        ended = true;
+        if (artifactInterval)
+            clearInterval(artifactInterval);
+        artifactTailer.poll();
+        send({
+            type: 'mission.run.end',
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            missionDir,
+            ...findLatestFactoryArtifactContext(missionDir),
+            error: String(error.message ?? error),
+        });
+    });
+    child.on('close', (exitCode, signal) => {
+        if (ended)
+            return;
+        ended = true;
+        if (artifactInterval)
+            clearInterval(artifactInterval);
+        artifactTailer.poll();
+        send({
+            type: 'mission.run.end',
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            missionDir,
+            ...findLatestFactoryArtifactContext(missionDir),
+            exitCode,
+            signal,
+            ...(exitCode && exitCode !== 0 ? { error: `droid exited with code ${exitCode}` } : {}),
+        });
+    });
+}
+export function inspectDroidMissionContinuation(msg) {
+    try {
+        const workspaceRoot = resolveExistingDirectory(msg.workspaceRoot);
+        const missionDir = resolveExistingMissionDir(workspaceRoot, msg.missionDir);
+        const rootFactorySessionId = findLatestRootFactorySessionId(missionDir);
+        const context = findLatestFactoryArtifactContext(missionDir);
+        return {
+            type: 'mission.continuation.inspect.response',
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            missionDir,
+            rootFactorySessionId,
+            factorySessionId: context.factorySessionId ?? null,
+            factoryArtifactDir: context.factoryArtifactDir ?? null,
+            error: rootFactorySessionId ? null : 'No prior root Droid session found for this mission directory.',
+        };
+    }
+    catch (error) {
+        return {
+            type: 'mission.continuation.inspect.response',
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            missionDir: null,
+            rootFactorySessionId: null,
+            factorySessionId: null,
+            factoryArtifactDir: null,
+            error: String(error?.message ?? error),
+        };
+    }
+}
+function deliverMissionInteraction(msg, missionDir, send) {
+    const deliveredAt = Date.now();
+    try {
+        const mailboxPath = appendMissionFollowup(missionDir, {
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            prompt: msg.prompt,
+            deliveredAt,
+        });
+        send({
+            type: 'mission.run.accepted',
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            missionDir,
+            pid: null,
+        });
+        send({
+            type: 'mission.run.event',
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            eventType: 'mission_interaction_delivered',
+            source: 'agent_node',
+            eventTime: deliveredAt,
+            payload: {
+                mailboxPath,
+                deliveredAt,
+            },
+        });
+        send({
+            type: 'mission.run.end',
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            missionDir,
+            ...findLatestFactoryArtifactContext(missionDir),
+            exitCode: 0,
+            signal: null,
+        });
+    }
+    catch (error) {
+        send({
+            type: 'mission.run.end',
+            requestId: msg.requestId,
+            missionId: msg.missionId,
+            missionDir,
+            error: String(error?.message ?? error),
+        });
+    }
+}
+export class MissionArtifactTailer {
+    options;
+    files = new Map();
+    announcedArtifactDirs = new Set();
+    constructor(options) {
+        this.options = options;
+    }
+    poll() {
+        const dirs = [this.options.missionDir];
+        const context = findLatestFactoryArtifactContext(this.options.missionDir);
+        const sessionRoot = findFactorySessionRoot(this.options.missionDir);
+        if (sessionRoot) {
+            this.tailSessionJsonl(sessionRoot);
+        }
+        if (context.factoryArtifactDir) {
+            dirs.push(context.factoryArtifactDir);
+            if (!this.announcedArtifactDirs.has(context.factoryArtifactDir)) {
+                this.announcedArtifactDirs.add(context.factoryArtifactDir);
+                this.sendEvent('mission_artifact_discovered', 'droid_artifact', Date.now(), {
+                    factorySessionId: context.factorySessionId ?? null,
+                    factoryArtifactDir: context.factoryArtifactDir,
+                });
+            }
+        }
+        for (const dir of uniqueStrings(dirs)) {
+            this.tailJsonl(path.join(dir, 'progress_log.jsonl'), (record, lineNumber) => {
+                const payload = buildProgressPayload(dir, lineNumber, record);
+                this.sendEvent('mission_progress', 'droid_artifact', payload.eventTime, payload);
+            });
+            this.tailJsonl(path.join(dir, 'worker-transcripts.jsonl'), (record, lineNumber) => {
+                const payload = buildTranscriptPayload(dir, lineNumber, record);
+                this.sendEvent('mission_worker_transcript', 'droid_artifact', payload.eventTime, payload);
+            });
+        }
+    }
+    tailSessionJsonl(sessionRoot) {
+        let entries;
+        try {
+            entries = readdirSync(sessionRoot).filter((entry) => entry.endsWith('.jsonl'));
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const filePath = path.join(sessionRoot, entry);
+            const sessionId = entry.slice(0, -'.jsonl'.length);
+            this.tailJsonl(filePath, (record, lineNumber) => {
+                const payload = buildSessionPayload(sessionRoot, filePath, sessionId, lineNumber, record);
+                this.sendEvent('mission_session_event', 'droid_session', payload.eventTime, payload);
+            });
+        }
+    }
+    tailJsonl(filePath, onRecord) {
+        if (!existsSync(filePath))
+            return;
+        let stat;
+        try {
+            stat = statSync(filePath);
+        }
+        catch {
+            return;
+        }
+        const state = this.files.get(filePath) ?? { offset: 0, buffered: '', lineNumber: 0 };
+        if (stat.size < state.offset) {
+            state.offset = 0;
+            state.buffered = '';
+            state.lineNumber = 0;
+        }
+        if (stat.size === state.offset) {
+            this.files.set(filePath, state);
+            return;
+        }
+        let text;
+        try {
+            text = readFileSync(filePath).subarray(state.offset).toString('utf8');
+        }
+        catch {
+            this.files.set(filePath, state);
+            return;
+        }
+        state.offset = stat.size;
+        const combined = `${state.buffered}${text}`;
+        const lines = combined.split(/\r?\n/);
+        state.buffered = combined.endsWith('\n') || combined.endsWith('\r') ? '' : lines.pop() ?? '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            state.lineNumber += 1;
+            try {
+                const parsed = JSON.parse(line);
+                if (isRecord(parsed))
+                    onRecord(redactValue(parsed), state.lineNumber);
+            }
+            catch {
+                this.sendEvent('mission_artifact_parse_error', 'droid_artifact', Date.now(), {
+                    artifactPath: filePath,
+                    lineNumber: state.lineNumber,
+                    error: 'Invalid JSONL record',
+                });
+            }
+        }
+        this.files.set(filePath, state);
+    }
+    sendEvent(eventType, source, eventTime, payload) {
+        this.options.send({
+            type: 'mission.run.event',
+            requestId: this.options.requestId,
+            missionId: this.options.missionId,
+            eventType,
+            source,
+            eventTime,
+            payload,
+        });
+    }
+}
+export function buildDroidArgs(msg) {
+    const args = ['exec'];
+    if (msg.continueSession) {
+        const sessionId = findLatestRootFactorySessionId(msg.missionDir);
+        if (!sessionId) {
+            throw new Error('No prior root Droid session found for this mission directory.');
+        }
+        args.push('--auto', 'high');
+        args.push('--session-id', sessionId);
+        appendModelArg(args, '--model', msg.orchestratorModel);
+        args.push(withMissionRuntimeContextInstructions(msg.prompt, resolveMissionRuntimeContext()));
+        return args;
+    }
+    args.push('--mission', '--auto', 'high');
+    if (msg.modelMode === 'platform_override') {
+        appendModelArg(args, '--model', msg.orchestratorModel);
+        appendModelArg(args, '--worker-model', msg.workerModel);
+        appendModelArg(args, '--validator-model', msg.validatorModel);
+    }
+    args.push(withMissionFollowupInstructions(msg.prompt, msg.missionDir, resolveMissionRuntimeContext()));
+    return args;
+}
+export function missionFollowupMailboxPath(missionDir) {
+    return path.join(missionDir, FOLLOWUP_MAILBOX_RELATIVE_PATH);
+}
+export function ensureMissionFollowupMailbox(missionDir) {
+    const mailboxPath = missionFollowupMailboxPath(missionDir);
+    mkdirSync(path.dirname(mailboxPath), { recursive: true });
+    return mailboxPath;
+}
+export function createDroidMissionScaffold(missionDir, input) {
+    const created = [];
+    const existing = [];
+    const conflicts = [];
+    const writeMissing = (relativePath, content, options) => {
+        const filePath = path.join(missionDir, relativePath);
+        const parentPath = path.dirname(filePath);
+        const parentRelativePath = path.relative(missionDir, parentPath) || '.';
+        if (!ensureScaffoldDirectory(parentPath, parentRelativePath, conflicts))
+            return;
+        if (existsSync(filePath)) {
+            try {
+                if (!statSync(filePath).isFile()) {
+                    conflicts.push(relativePath);
+                    return;
+                }
+            }
+            catch {
+                conflicts.push(relativePath);
+                return;
+            }
+            existing.push(relativePath);
+            return;
+        }
+        writeFileSync(filePath, content, { encoding: 'utf8', mode: options?.executable ? 0o755 : 0o644 });
+        if (options?.executable)
+            chmodSync(filePath, 0o755);
+        created.push(relativePath);
+    };
+    const title = oneLine(input.title, 160) || 'Droid mission';
+    const promptPreview = truncateText(input.prompt, 2_000).text;
+    const runtimeContext = input.runtimeContext ?? resolveMissionRuntimeContext();
+    writeMissing('AGENTS.md', `# Mission Guidance
+
+Mission: ${title}
+
+Use this directory as the working directory for Droid mission artifacts. Preserve user files, write durable outputs as ordinary files, and keep final reports readable as Markdown when possible.
+
+## Bigbang Runtime Context
+
+Use these current platform endpoints for this Bigbang stack:
+
+- Web UI base URL: ${runtimeContext.webUrl ?? 'Not configured'}
+- Core API base URL: ${runtimeContext.coreUrl ?? 'Not configured'}
+
+Do not switch to another Bigbang deployment or tmux stack unless the mission prompt explicitly asks for it.
+
+Original request preview:
+
+${promptPreview}
+`);
+    writeMissing('features.json', `${JSON.stringify({
+        features: [],
+        note: 'Bigbang scaffold placeholder. Droid may replace or extend this file during mission execution.',
+    }, null, 2)}\n`);
+    writeMissing('validation-contract.md', `# Validation Contract
+
+Use this file to record validation expectations for the mission.
+
+- Confirm implemented changes satisfy the mission request.
+- Record smoke checks, commands, or manual verification steps.
+- Preserve failing assertions and follow-up work instead of deleting them.
+`);
+    writeMissing('services.yaml', `# Optional service declarations for this Droid mission.
+# Add project-specific services here if workers need them during execution.
+services: []
+`);
+    writeMissing('init.sh', `#!/usr/bin/env bash
+set -euo pipefail
+
+# Optional mission initialization hook.
+`, { executable: true });
+    writeMissing(path.join('skills', 'README.md'), `# Mission Skills
+
+Add mission-specific Droid skills in this directory when the task needs reusable worker instructions.
+`);
+    return {
+        preparedAt: Date.now(),
+        created,
+        existing,
+        conflicts,
+        missionDir,
+    };
+}
+function ensureScaffoldDirectory(dirPath, relativePath, conflicts) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+        return true;
+    }
+    try {
+        if (statSync(dirPath).isDirectory())
+            return true;
+    }
+    catch {
+        // Fall through and record a conflict.
+    }
+    conflicts.push(relativePath);
+    return false;
+}
+export function appendMissionFollowup(missionDir, input) {
+    const mailboxPath = ensureMissionFollowupMailbox(missionDir);
+    const runtimeContext = input.runtimeContext ?? resolveMissionRuntimeContext();
+    appendFileSync(mailboxPath, `${JSON.stringify({
+        type: 'platform_followup',
+        requestId: input.requestId,
+        missionId: input.missionId,
+        deliveredAt: input.deliveredAt,
+        prompt: withMissionRuntimeContextInstructions(input.prompt, runtimeContext),
+        runtimeContext,
+    })}\n`);
+    return mailboxPath;
+}
+export function withMissionFollowupInstructions(prompt, missionDir, runtimeContext = resolveMissionRuntimeContext()) {
+    return withMissionRuntimeInstructions(prompt, missionDir, runtimeContext);
+}
+export function withMissionRuntimeInstructions(prompt, missionDir, runtimeContext) {
+    const mailboxPath = missionFollowupMailboxPath(missionDir);
+    return `${withMissionRuntimeContextInstructions(prompt, runtimeContext)}
+
+---
+
+Bigbang live interaction mailbox:
+- During this mission, the platform may append user follow-up instructions to this JSONL file:
+  ${mailboxPath}
+- Check this file after each major phase, after any long wait, and immediately before your final report.
+- If it contains entries with prompts you have not handled, incorporate the latest follow-up into your next action or final report and explicitly mention that you handled it.
+- Reading this file is safe and expected. Do not modify or delete it.`;
+}
+export function withMissionRuntimeContextInstructions(prompt, runtimeContext) {
+    return `${prompt}
+
+---
+
+Bigbang runtime context:
+- Web UI base URL: ${runtimeContext.webUrl ?? 'Not configured'}
+- Core API base URL: ${runtimeContext.coreUrl ?? 'Not configured'}
+- Use these endpoints for this mission's UI/API checks. Do not switch to another Bigbang deployment or tmux stack unless the mission prompt explicitly asks for it.`;
+}
+export function resolveMissionRuntimeContext(env = process.env) {
+    return {
+        webUrl: normalizeRuntimeUrl(env.BIGBANG_MISSION_WEB_URL
+            ?? env.BIGBANG_WEB_URL
+            ?? env.BIGBANG_BASE_URL
+            ?? null),
+        coreUrl: normalizeRuntimeUrl(env.BIGBANG_MISSION_CORE_URL
+            ?? env.BIGBANG_CORE_URL
+            ?? env.CORE_HTTP_URL
+            ?? httpUrlFromWsUrl(env.CORE_URL)
+            ?? null),
+    };
+}
+function normalizeRuntimeUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const url = new URL(trimmed);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return null;
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        url.hash = '';
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        return null;
+    }
+}
+function httpUrlFromWsUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith('ws://'))
+        return `http://${trimmed.slice('ws://'.length)}`;
+    if (trimmed.startsWith('wss://'))
+        return `https://${trimmed.slice('wss://'.length)}`;
+    return trimmed.startsWith('http://') || trimmed.startsWith('https://') ? trimmed : null;
+}
+function appendModelArg(args, flag, value) {
+    if (typeof value === 'string' && value.trim()) {
+        args.push(flag, value.trim());
+    }
+}
+function sendOutputEvent(send, requestId, missionId, stream, chunk) {
+    const text = String(Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk);
+    send({
+        type: 'mission.run.event',
+        requestId,
+        missionId,
+        eventType: `mission_${stream}`,
+        source: 'droid_cli',
+        eventTime: Date.now(),
+        payload: {
+            stream,
+            text: text.length > OUTPUT_LIMIT ? `${text.slice(0, OUTPUT_LIMIT)}\n[truncated]` : text,
+        },
+    });
+}
+function resolveExistingDirectory(value) {
+    return realpathSync(path.resolve(value));
+}
+export function resolveMissionDir(workspaceRoot, missionDir) {
+    const resolved = path.isAbsolute(missionDir) ? path.resolve(missionDir) : path.resolve(workspaceRoot, missionDir);
+    const relative = path.relative(workspaceRoot, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error('Mission dir must be inside the workspace root.');
+    }
+    mkdirSync(resolved, { recursive: true });
+    const realWorkspaceRoot = realpathSync(workspaceRoot);
+    const realMissionDir = realpathSync(resolved);
+    const realRelative = path.relative(realWorkspaceRoot, realMissionDir);
+    if (realRelative.startsWith('..') || path.isAbsolute(realRelative)) {
+        throw new Error('Mission dir must stay inside the real workspace root.');
+    }
+    return realMissionDir;
+}
+export function resolveExistingMissionDir(workspaceRoot, missionDir) {
+    const resolved = path.isAbsolute(missionDir) ? path.resolve(missionDir) : path.resolve(workspaceRoot, missionDir);
+    const relative = path.relative(workspaceRoot, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error('Mission dir must be inside the workspace root.');
+    }
+    if (!existsSync(resolved)) {
+        throw new Error('Mission dir does not exist.');
+    }
+    const realWorkspaceRoot = realpathSync(workspaceRoot);
+    const realMissionDir = realpathSync(resolved);
+    const realRelative = path.relative(realWorkspaceRoot, realMissionDir);
+    if (realRelative.startsWith('..') || path.isAbsolute(realRelative)) {
+        throw new Error('Mission dir must stay inside the real workspace root.');
+    }
+    return realMissionDir;
+}
+export function findLatestFactorySessionId(missionDir) {
+    const sessionRoot = findFactorySessionRoot(missionDir);
+    if (!existsSync(sessionRoot))
+        return null;
+    const candidates = readdirSync(sessionRoot)
+        .filter((entry) => entry.endsWith('.jsonl'))
+        .map((entry) => {
+        const fullPath = path.join(sessionRoot, entry);
+        try {
+            return {
+                sessionId: entry.slice(0, -'.jsonl'.length),
+                mtimeMs: statSync(fullPath).mtimeMs,
+            };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((entry) => Boolean(entry));
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return candidates[0]?.sessionId ?? null;
+}
+export function findLatestRootFactorySessionId(missionDir) {
+    const sessionRoot = findFactorySessionRoot(missionDir);
+    if (!existsSync(sessionRoot))
+        return null;
+    const candidates = readdirSync(sessionRoot)
+        .filter((entry) => entry.endsWith('.jsonl'))
+        .map((entry) => {
+        const fullPath = path.join(sessionRoot, entry);
+        try {
+            const firstRecord = readFirstJsonlRecord(fullPath);
+            if (!firstRecord || stringValue(firstRecord.callingSessionId))
+                return null;
+            return {
+                sessionId: entry.slice(0, -'.jsonl'.length),
+                mtimeMs: statSync(fullPath).mtimeMs,
+            };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((entry) => Boolean(entry));
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return candidates[0]?.sessionId ?? null;
+}
+function findFactorySessionRoot(missionDir) {
+    return path.join(homedir(), '.factory', 'sessions', factorySessionDirName(missionDir));
+}
+function readFirstJsonlRecord(filePath) {
+    const text = readFileSync(filePath, 'utf8');
+    const line = text.split(/\r?\n/).find((entry) => entry.trim());
+    if (!line)
+        return null;
+    const parsed = JSON.parse(line);
+    return isRecord(parsed) ? parsed : null;
+}
+function factorySessionDirName(cwd) {
+    return path.resolve(cwd).replace(/[\\/]+/g, '-');
+}
+export function findLatestFactoryArtifactContext(missionDir) {
+    const factorySessionId = findLatestFactorySessionId(missionDir);
+    if (!factorySessionId)
+        return {};
+    const factoryArtifactDir = path.join(homedir(), '.factory', 'missions', factorySessionId);
+    return {
+        factorySessionId,
+        factoryArtifactDir: existsSync(factoryArtifactDir) ? factoryArtifactDir : null,
+    };
+}
+function buildProgressPayload(artifactDir, lineNumber, record) {
+    const type = stringValue(record.type) ?? stringValue(record.eventType) ?? 'progress';
+    const eventTime = timeValue(record.timestampMs ?? record.timestamp ?? record.time) ?? Date.now();
+    return {
+        artifactDir,
+        artifactPath: path.join(artifactDir, 'progress_log.jsonl'),
+        lineNumber,
+        role: classifyMissionRole(type, record),
+        type,
+        featureId: stringValue(record.featureId),
+        milestone: stringValue(record.milestone),
+        workerSessionId: stringValue(record.workerSessionId),
+        handoffFile: stringValue(record.handoffFile),
+        eventTime,
+        droidEvent: record,
+    };
+}
+function buildTranscriptPayload(artifactDir, lineNumber, record) {
+    const skeleton = stringValue(record.skeleton) ?? '';
+    const transcript = truncateText(skeleton, TRANSCRIPT_LIMIT);
+    const featureId = stringValue(record.featureId);
+    const eventTime = timeValue(record.timestampMs ?? record.timestamp ?? record.time) ?? Date.now();
+    return {
+        artifactDir,
+        artifactPath: path.join(artifactDir, 'worker-transcripts.jsonl'),
+        lineNumber,
+        role: classifyMissionRole('worker_transcript', record),
+        featureId,
+        milestone: stringValue(record.milestone),
+        workerSessionId: stringValue(record.workerSessionId),
+        eventTime,
+        transcriptPreview: firstMeaningfulLine(skeleton),
+        transcriptText: transcript.text,
+        transcriptTruncated: transcript.truncated,
+        droidEvent: {
+            ...record,
+            skeleton: transcript.text,
+            skeletonTruncated: transcript.truncated,
+        },
+    };
+}
+function buildSessionPayload(sessionRoot, artifactPath, sessionId, lineNumber, record) {
+    const type = stringValue(record.type) ?? 'session_event';
+    const eventTime = timeValue(record.timestampMs ?? record.timestamp ?? record.time) ?? Date.now();
+    const message = isRecord(record.message) ? record.message : {};
+    const messageRole = stringValue(message.role);
+    const textPreview = extractSessionTextPreview(record);
+    const sessionTitle = stringValue(record.sessionTitle) ?? stringValue(record.title);
+    return {
+        sessionRoot,
+        artifactPath,
+        sessionId,
+        lineNumber,
+        role: classifySessionRole(type, record),
+        type,
+        sessionTitle,
+        callingSessionId: stringValue(record.callingSessionId),
+        messageRole,
+        eventTime,
+        textPreview,
+        droidEvent: truncateSessionRecord(record),
+    };
+}
+function classifyMissionRole(type, record) {
+    const searchable = [
+        type,
+        stringValue(record.featureId),
+        stringValue(record.skillName),
+        stringValue(record.workerSessionId),
+    ].filter(Boolean).join(' ').toLowerCase();
+    if (searchable.includes('validat'))
+        return 'validator';
+    if (searchable.includes('worker') || type === 'worker_transcript')
+        return 'worker';
+    if (searchable.includes('orchestrator') || searchable.includes('milestone') || searchable.includes('handoff'))
+        return 'orchestrator';
+    return 'system';
+}
+function classifySessionRole(type, record) {
+    const sessionTitle = stringValue(record.sessionTitle) ?? stringValue(record.title);
+    const searchable = [
+        type,
+        sessionTitle,
+        stringValue(record.callingSessionId) ? 'worker' : 'orchestrator',
+    ].filter(Boolean).join(' ').toLowerCase();
+    if (searchable.includes('validat'))
+        return 'validator';
+    if (searchable.includes('worker') || stringValue(record.callingSessionId))
+        return 'worker';
+    if (searchable.includes('orchestrator') || type === 'session_start')
+        return 'orchestrator';
+    return 'system';
+}
+function extractSessionTextPreview(record) {
+    const message = isRecord(record.message) ? record.message : {};
+    const role = stringValue(message.role);
+    const content = Array.isArray(message.content) ? message.content : [];
+    const parts = [];
+    for (const item of content) {
+        if (!isRecord(item))
+            continue;
+        const type = stringValue(item.type);
+        const text = stringValue(item.text) ?? stringValue(item.thinking);
+        const toolName = stringValue(item.name);
+        if (text)
+            parts.push(text);
+        else if (toolName)
+            parts.push(`${type ?? 'tool'}: ${toolName}`);
+    }
+    if (parts.length > 0)
+        return truncateText(`${role ? `${role}: ` : ''}${parts.join('\n')}`, 500).text;
+    const title = stringValue(record.sessionTitle) ?? stringValue(record.title);
+    return title ? truncateText(title, 500).text : `${record.type ?? 'session_event'}`;
+}
+function truncateSessionRecord(record) {
+    const redacted = redactValue(record);
+    if (!isRecord(redacted))
+        return {};
+    const json = JSON.stringify(redacted);
+    if (json.length <= TRANSCRIPT_LIMIT)
+        return redacted;
+    return {
+        type: redacted.type,
+        id: redacted.id,
+        timestamp: redacted.timestamp,
+        sessionTitle: redacted.sessionTitle,
+        callingSessionId: redacted.callingSessionId,
+        truncatedJson: `${json.slice(0, TRANSCRIPT_LIMIT)}\n[truncated]`,
+    };
+}
+function firstMeaningfulLine(value) {
+    const line = value.split(/\r?\n/).map((entry) => entry.trim()).find((entry) => entry && !entry.startsWith('---'));
+    return line ? truncateText(line, 240).text : 'Transcript captured';
+}
+function oneLine(value, limit) {
+    return truncateText(value.replace(/\s+/g, ' ').trim(), limit).text;
+}
+function truncateText(value, limit) {
+    const redacted = redactString(value);
+    if (redacted.length <= limit)
+        return { text: redacted, truncated: false };
+    return { text: `${redacted.slice(0, limit)}\n[truncated]`, truncated: true };
+}
+function redactValue(value) {
+    if (typeof value === 'string')
+        return redactString(value);
+    if (Array.isArray(value))
+        return value.map(redactValue);
+    if (isRecord(value)) {
+        const result = {};
+        for (const [key, child] of Object.entries(value)) {
+            result[key] = redactValue(child);
+        }
+        return result;
+    }
+    return value;
+}
+function redactString(value) {
+    return value
+        .replace(/\bsk-[A-Za-z0-9_-]{8,}\b/g, '[redacted-secret]')
+        .replace(/\b(api[_-]?key|token|secret|password)\s*[:=]\s*["']?[^"'\s]+/gi, '$1=[redacted-secret]');
+}
+function timeValue(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}