@orkestrel/scaffold 0.0.76 → 0.0.78

package/dist/host/agents/skills/orkestrel-dispatch/scripts/helpers.ts

@@ -0,0 +1,239 @@
+// What the skill scripts share: argument reading, tree walking, JSON line reading, and the npm
+// command. This module runs nothing. Import it from a sibling or another skill's script with the
+// `.ts` extension, for example `import { readOption } from '../../orkestrel-dispatch/scripts/helpers.ts'`.
+import type { SpawnSyncReturns } from 'node:child_process'
+import { spawnSync } from 'node:child_process'
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+/** Names the directories every tree walk in a skill script skips. */
+export const SKIPPED_DIRECTORIES: ReadonlySet<string> = new Set([
+	'node_modules',
+	'.git',
+	'dist',
+	'tmp',
+	'.orkestrel',
+	'.idea',
+])
+
+/** Describes one file a tree walk found, with the modification time the sweep reads. */
+export interface WalkedFile {
+	readonly path: string
+	readonly modified: number
+}
+
+/** Describes how to spawn npm on this host without a shell where the CLI entry is present. */
+export interface NpmCommand {
+	readonly file: string
+	readonly prefix: readonly string[]
+	readonly shell: boolean
+}
+
+/**
+ * Reads the value that follows a flag.
+ *
+ * @remarks
+ * Every skill script reads `--flag value` pairs: the first occurrence of a flag wins, a following
+ * value that opens with `--` is a missing value, and the `--flag=value` form is not read.
+ *
+ * @param argv - The arguments after the script path.
+ * @param name - The flag, such as `--journal`.
+ * @returns The value after the flag, or undefined when the flag is absent, last, or followed by
+ * another flag.
+ */
+export function readOption(argv: readonly string[], name: string): string | undefined {
+	const index = argv.indexOf(name)
+	const value = index === -1 ? undefined : argv[index + 1]
+	return value === undefined || value.startsWith('--') ? undefined : value
+}
+
+/**
+ * Names the value flags a caller gave with no value.
+ *
+ * @param argv - The arguments after the script path.
+ * @param names - The flags that take a value.
+ * @returns Each named flag that appears last or is followed by another flag, in argument order.
+ */
+export function readMissingFlags(
+	argv: readonly string[],
+	names: readonly string[],
+): readonly string[] {
+	return names.filter((name) => argv.includes(name) && readOption(argv, name) === undefined)
+}
+
+/**
+ * Reads every value that follows a repeatable flag.
+ *
+ * @param argv - The arguments after the script path.
+ * @param name - The flag, such as `--range`.
+ * @returns The values in order, empty when the flag never appears.
+ */
+export function readOptions(argv: readonly string[], name: string): readonly string[] {
+	const values: string[] = []
+	argv.forEach((argument, index) => {
+		const value = argv[index + 1]
+		if (argument === name && value !== undefined && !value.startsWith('--')) values.push(value)
+	})
+	return values
+}
+
+/**
+ * Reads the values that follow a flag up to the next flag.
+ *
+ * @param argv - The arguments after the script path.
+ * @param name - The flag, such as `--tree`.
+ * @returns The values between the flag and the next `--` argument, empty when the flag is absent.
+ */
+export function readList(argv: readonly string[], name: string): readonly string[] {
+	const index = argv.indexOf(name)
+	if (index === -1) return []
+	const values: string[] = []
+	for (const argument of argv.slice(index + 1)) {
+		if (argument.startsWith('--')) break
+		values.push(argument)
+	}
+	return values
+}
+
+/**
+ * Normalizes a host path to forward slashes.
+ *
+ * @param path - A host path.
+ * @returns The same path with every backslash replaced by a slash.
+ */
+export function normalizeSlashes(path: string): string {
+	return path.split('\\').join('/')
+}
+
+/**
+ * Lists every regular file beneath a directory, skipping the directories skill scripts never read.
+ *
+ * @remarks
+ * A skipped name matches a directory at any depth, exactly and case-sensitively, so a
+ * `src/dist/` directory is skipped with the build output and a `Node_Modules/` directory is not.
+ *
+ * @param directory - The directory to walk.
+ * @param skipped - The directory names to skip. Default: {@link SKIPPED_DIRECTORIES}.
+ * @returns Each file's forward-slash path and modification time, in walk order.
+ * @throws Thrown when `directory` does not exist or cannot be read; check `existsSync` first.
+ */
+export function listFiles(
+	directory: string,
+	skipped: ReadonlySet<string> = SKIPPED_DIRECTORIES,
+): readonly WalkedFile[] {
+	const files: WalkedFile[] = []
+	const pending = [directory]
+	while (pending.length > 0) {
+		const current = pending.pop()
+		if (current === undefined) break
+		for (const entry of readdirSync(current, { withFileTypes: true })) {
+			if (skipped.has(entry.name)) continue
+			const path = join(current, entry.name)
+			if (entry.isDirectory()) pending.push(path)
+			else if (entry.isFile()) {
+				files.push({ path: normalizeSlashes(path), modified: statSync(path).mtimeMs })
+			}
+		}
+	}
+	return files
+}
+
+/**
+ * Reads the last non-empty line of a text as a JSON object.
+ *
+ * @param text - Text whose last line a script printed as JSON.
+ * @returns The parsed object, or undefined when the last line is not a JSON object.
+ */
+export function readJsonObject(text: string): Record<string, unknown> | undefined {
+	const line = text
+		.split(/\r\n|\n/)
+		.filter((candidate) => candidate.trim() !== '')
+		.at(-1)
+	if (line === undefined) return undefined
+	try {
+		const parsed: unknown = JSON.parse(line)
+		if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+			return Object.fromEntries(Object.entries(parsed))
+		}
+	} catch {}
+	return undefined
+}
+
+/**
+ * Parses a whole text as one JSON object.
+ *
+ * @param text - A JSON document, formatted or not, such as a manifest or `npm view --json` output.
+ * @returns The parsed object, or undefined when the text is not a JSON object.
+ */
+export function parseJsonRecord(text: string): Record<string, unknown> | undefined {
+	try {
+		const parsed: unknown = JSON.parse(text)
+		if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+			return Object.fromEntries(Object.entries(parsed))
+		}
+	} catch {}
+	return undefined
+}
+
+/**
+ * Reads a string member of a record.
+ *
+ * @param record - The record, or undefined.
+ * @param key - The member name.
+ * @returns The string, or undefined when the member is absent or not a string.
+ */
+export function readString(
+	record: Record<string, unknown> | undefined,
+	key: string,
+): string | undefined {
+	const value = record?.[key]
+	return typeof value === 'string' ? value : undefined
+}
+
+/**
+ * Reads a finite number member of a record.
+ *
+ * @param record - The record, or undefined.
+ * @param key - The member name.
+ * @returns The number, or undefined when the member is absent, not a number, or not finite.
+ */
+export function readNumber(
+	record: Record<string, unknown> | undefined,
+	key: string,
+): number | undefined {
+	const value = record?.[key]
+	return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+/**
+ * Resolves the npm command for this host.
+ *
+ * @remarks
+ * The `npm-cli.js` entry beside the running Node binary spawns without a shell on every host; the
+ * `npm` shim on Windows is a `.cmd` file that needs one, so that path is the fallback alone.
+ *
+ * @returns The file to spawn, the arguments that precede npm's own, and whether a shell is needed.
+ */
+export function resolveNpm(): NpmCommand {
+	const cli = join(dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js')
+	if (existsSync(cli)) return { file: process.execPath, prefix: [cli], shell: false }
+	return { file: 'npm', prefix: [], shell: process.platform === 'win32' }
+}
+
+/**
+ * Runs npm with the given arguments and returns the finished child.
+ *
+ * @param args - The npm arguments, such as `['view', '@orkestrel/scaffold', 'version']`.
+ * @param cwd - The working directory. Default: the current directory.
+ * @returns The spawn result with `utf8` stdout and stderr.
+ */
+export function runNpm(args: readonly string[], cwd?: string): SpawnSyncReturns<string> {
+	const npm = resolveNpm()
+	return spawnSync(npm.file, [...npm.prefix, ...args], {
+		encoding: 'utf8',
+		windowsHide: true,
+		shell: npm.shell,
+		maxBuffer: 64 * 1024 * 1024,
+		...(cwd === undefined ? {} : { cwd }),
+	})
+}

package/dist/host/agents/skills/orkestrel-dispatch/scripts/launch.ts

@@ -0,0 +1,124 @@
+// Journaled launch of a bench exec or any command that outlives a turn. Run from the checkout root:
+//   node .agents/skills/orkestrel-dispatch/scripts/launch.ts --journal tmp/codex/UNIT.jsonl --errors tmp/codex/UNIT.err --cap 1500 [--status] -- codex exec --json ...
+// The command's stdout goes to --journal and its stderr to --errors; stdin is closed. Arguments after
+// `--` pass to the command verbatim, so no shell quoting is involved. --cap is in seconds: when it
+// expires the process tree is killed and the errors file records `capped=true`. --status records
+// `git status --porcelain` before and after beside the journal, which is how a read-only lane's
+// containment is checked. Stdout carries up to two JSON lines. The spawn line
+// `{"pid","journal","errors"}` prints as soon as the command starts, and the pid, as decimal digits
+// and a newline, goes to `<journal>.pid`. A pid file an earlier run left on the same journal is
+// removed before the spawn, so neither appears when the command cannot start. The summary line
+// prints last, after the command exits, and the errors file ends with `exit=<code>`. At the cap,
+// Windows kills the process tree; any other host kills the command alone, not its descendants.
+// The launcher's own flags are read before `--` alone. Exit: the command's code; 124 when capped;
+// 127 when the command could not start (the errors file names why); 64 on usage, including a
+// journal and errors path that are the same file and a cap that is not a number of seconds.
+import { spawn, spawnSync } from 'node:child_process'
+import { appendFileSync, closeSync, mkdirSync, openSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { readMissingFlags, readOption } from './helpers.ts'
+
+function readStatus(): string {
+	const result = spawnSync('git', ['status', '--porcelain'], { encoding: 'utf8' })
+	return result.status === 0 ? result.stdout : `git status failed: ${result.stderr}`
+}
+
+function killTree(pid: number): void {
+	if (process.platform === 'win32') {
+		spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], { stdio: 'ignore' })
+		return
+	}
+	try {
+		process.kill(pid, 'SIGKILL')
+	} catch {}
+}
+
+interface Exit {
+	readonly code: number | null
+	readonly signal: NodeJS.Signals | null
+	readonly error: string | undefined
+}
+
+function waitForExit(child: ReturnType<typeof spawn>): Promise<Exit> {
+	return new Promise((resolve) => {
+		child.on('error', (error) => resolve({ code: null, signal: null, error: error.message }))
+		child.on('close', (code, signal) => resolve({ code, signal, error: undefined }))
+	})
+}
+
+async function main(argv: readonly string[]): Promise<number> {
+	const separator = argv.indexOf('--')
+	// The launcher's own flags end at the separator; everything after it belongs to the command.
+	const own = separator === -1 ? argv : argv.slice(0, separator)
+	const journal = readOption(own, '--journal')
+	const errors = readOption(own, '--errors')
+	const cap =
+		readMissingFlags(own, ['--cap']).length > 0
+			? Number.NaN
+			: Number(readOption(own, '--cap') ?? '0')
+	const [command, ...args] = separator === -1 ? [] : argv.slice(separator + 1)
+	if (
+		separator === -1 ||
+		journal === undefined ||
+		errors === undefined ||
+		journal === errors ||
+		!Number.isFinite(cap) ||
+		cap < 0 ||
+		command === undefined ||
+		command === ''
+	) {
+		console.error(
+			'usage: launch.ts --journal PATH --errors PATH --cap SECONDS [--status] -- COMMAND [ARGS...]; the journal and the errors file differ, and the cap is a number of seconds (0 for none)',
+		)
+		return 64
+	}
+	const status = own.includes('--status')
+	mkdirSync(dirname(journal), { recursive: true })
+	mkdirSync(dirname(errors), { recursive: true })
+	if (status) writeFileSync(`${journal}.status-before.txt`, readStatus())
+	const journalFd = openSync(journal, 'w')
+	const errorsFd = openSync(errors, 'w')
+	rmSync(`${journal}.pid`, { force: true })
+	const started = Date.now()
+	const child = spawn(command, args, { stdio: ['ignore', journalFd, errorsFd], windowsHide: true })
+	if (child.pid !== undefined) {
+		writeFileSync(`${journal}.pid`, `${child.pid}\n`)
+		console.log(JSON.stringify({ pid: child.pid, journal, errors }))
+	}
+	let capped = false
+	const timer =
+		cap > 0
+			? setTimeout(() => {
+					capped = true
+					if (child.pid !== undefined) killTree(child.pid)
+				}, cap * 1000)
+			: undefined
+	const exit = await waitForExit(child)
+	if (timer !== undefined) clearTimeout(timer)
+	closeSync(journalFd)
+	closeSync(errorsFd)
+	const durationMs = Date.now() - started
+	appendFileSync(
+		errors,
+		`${exit.error === undefined ? '' : `launch: the command could not start: ${exit.error}\n`}\nexit=${exit.error === undefined ? (exit.code ?? 'null') : '127'} signal=${exit.signal ?? 'none'} capped=${capped} duration_ms=${durationMs}\n`,
+	)
+	if (status) writeFileSync(`${journal}.status-after.txt`, readStatus())
+	console.log(
+		JSON.stringify({
+			pid: child.pid,
+			exit: exit.error === undefined ? exit.code : 127,
+			signal: exit.signal,
+			capped,
+			durationMs,
+			journal,
+			errors,
+			error: exit.error,
+		}),
+	)
+	if (exit.error !== undefined) return 127
+	return capped ? 124 : (exit.code ?? 1)
+}
+
+main(process.argv.slice(2)).then((code) => {
+	process.exitCode = code
+})

package/dist/host/agents/skills/orkestrel-dispatch/scripts/login.ts

@@ -0,0 +1,123 @@
+// Recover a bench login. Run from the checkout root:
+//   node .agents/skills/orkestrel-dispatch/scripts/login.ts --codex [--cap SECONDS]
+//   node .agents/skills/orkestrel-dispatch/scripts/login.ts --claude
+// --codex reads `codex login status`; when it reports no login, the script runs
+// `codex login --device-auth` with its output journaled to tmp/codex/login.log, prints the
+// verification URL and the one-time code the moment the journal carries them, polls
+// `codex login status` every 5 seconds until it answers or the cap (default 600 seconds) ends, then
+// kills the login by its pid. --claude reads `claude auth status` and prints it. The JSON summary
+// carries `live`; exit 0 when the bench is logged in, 3 when it is not, 64 on usage.
+import { spawn, spawnSync } from 'node:child_process'
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync } from 'node:fs'
+import { readMissingFlags, readOption } from './helpers.ts'
+
+const JOURNAL = 'tmp/codex/login.log'
+const POLL_MS = 5_000
+const URL_PATTERN = /https?:\/\/[^\s"'<>]+/u
+const CODE_PATTERN = /\b([A-Z0-9]{4,5}-[A-Z0-9]{4,5})\b/u
+
+interface Status {
+	readonly live: boolean
+	readonly text: string
+}
+
+function readStatus(command: string, args: readonly string[]): Status {
+	const result = spawnSync(command, args, { encoding: 'utf8', windowsHide: true })
+	if (result.error !== undefined)
+		return { live: false, text: `${command} could not start: ${result.error.message}` }
+	return { live: result.status === 0, text: `${result.stdout ?? ''}${result.stderr ?? ''}`.trim() }
+}
+
+function killTree(pid: number): void {
+	if (process.platform === 'win32') {
+		spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], { stdio: 'ignore' })
+		return
+	}
+	try {
+		process.kill(pid, 'SIGTERM')
+	} catch {}
+}
+
+function waitFor(ms: number): Promise<void> {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms)
+	})
+}
+
+async function loginCodex(capSeconds: number): Promise<number> {
+	const before = readStatus('codex', ['login', 'status'])
+	if (before.live) {
+		console.log(JSON.stringify({ bench: 'codex', live: true, status: before.text }))
+		return 0
+	}
+	mkdirSync('tmp/codex', { recursive: true })
+	const journal = openSync(JOURNAL, 'w')
+	const started = Date.now()
+	const child = spawn('codex', ['login', '--device-auth'], {
+		stdio: ['ignore', journal, journal],
+		windowsHide: true,
+	})
+	let url: string | undefined
+	let code: string | undefined
+	let live = false
+	while (Date.now() - started < capSeconds * 1000) {
+		await waitFor(POLL_MS)
+		const text = existsSync(JOURNAL) ? readFileSync(JOURNAL, 'utf8') : ''
+		if (url === undefined) {
+			url = text.match(URL_PATTERN)?.[0]
+			if (url !== undefined) console.error(`login: open ${url}`)
+		}
+		if (code === undefined) {
+			code = text.match(CODE_PATTERN)?.[1]
+			if (code !== undefined) console.error(`login: enter the code ${code}`)
+		}
+		if (child.exitCode !== null && readStatus('codex', ['login', 'status']).live) {
+			live = true
+			break
+		}
+		if (child.exitCode === null && readStatus('codex', ['login', 'status']).live) {
+			live = true
+			break
+		}
+	}
+	if (child.exitCode === null && child.pid !== undefined) killTree(child.pid)
+	closeSync(journal)
+	console.log(
+		JSON.stringify({
+			bench: 'codex',
+			live,
+			url,
+			code,
+			durationMs: Date.now() - started,
+			journal: JOURNAL,
+			status: readStatus('codex', ['login', 'status']).text,
+		}),
+	)
+	return live ? 0 : 3
+}
+
+function loginClaude(): number {
+	const status = readStatus('claude', ['auth', 'status'])
+	console.log(JSON.stringify({ bench: 'claude', live: status.live, status: status.text }))
+	return status.live ? 0 : 3
+}
+
+async function main(argv: readonly string[]): Promise<number> {
+	const missing = readMissingFlags(argv, ['--cap'])
+	if (missing.length > 0) {
+		console.error(`login: ${missing.join(', ')} given with no value`)
+		return 64
+	}
+	if (argv.includes('--codex') && argv.includes('--claude')) {
+		console.error('usage: login.ts names one bench: --codex [--cap SECONDS] | --claude')
+		return 64
+	}
+	if (argv.includes('--codex')) return loginCodex(Number(readOption(argv, '--cap') ?? 600))
+	if (argv.includes('--claude')) return loginClaude()
+	console.error('usage: login.ts --codex [--cap SECONDS] | --claude')
+	return 64
+}
+
+main(process.argv.slice(2)).then((code) => {
+	process.exitCode = code
+})

package/dist/host/agents/skills/orkestrel-dispatch/scripts/result.ts

@@ -0,0 +1,129 @@
+// Read a bench lane's answer, session id, and liveness from its journal. Run from the checkout root:
+//   node .agents/skills/orkestrel-dispatch/scripts/result.ts --cursor tmp/cursor/UNIT.jsonl [--out tmp/cursor/UNIT-result.md]
+//   node .agents/skills/orkestrel-dispatch/scripts/result.ts --claude tmp/claude/UNIT.jsonl [--out tmp/claude/UNIT-result.md]
+//   node .agents/skills/orkestrel-dispatch/scripts/result.ts --codex tmp/codex/UNIT.jsonl [--out tmp/codex/UNIT-result.md]
+// A Cursor or Claude journal is the `--output-format stream-json` stream: the `init` event carries
+// the session id and the `result` event carries the answer. A Codex journal is the `--json` stream:
+// the `thread.started` event carries the thread id and the answer sits in the sibling `UNIT-last.md`
+// file that `--output-last-message` wrote. The summary also reads the sibling `UNIT.err` file that
+// launch.ts wrote (`exit`, `capped`, `durationMs`) and the journal's `bytes`, `ageMs`, and last
+// event, which is the liveness reading for a run still going. The answer is written to --out when
+// given, and a journal with no session or answer exits 3 so a driver cannot pass off an empty lane.
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { readMissingFlags, readNumber, readOption, readString } from './helpers.ts'
+
+interface Reading {
+	readonly session: string | undefined
+	readonly answer: string | undefined
+	readonly durationMs: number | undefined
+}
+
+interface Errors {
+	readonly exit: number | undefined
+	readonly capped: boolean | undefined
+	readonly durationMs: number | undefined
+}
+
+function readEvents(path: string): ReadonlyArray<Record<string, unknown>> {
+	const events: Array<Record<string, unknown>> = []
+	for (const line of readFileSync(path, 'utf8').split(/\r\n|\n/)) {
+		if (line.trim() === '') continue
+		try {
+			const parsed: unknown = JSON.parse(line)
+			if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+				events.push(Object.fromEntries(Object.entries(parsed)))
+			}
+		} catch {}
+	}
+	return events
+}
+
+function readAnswer(text: string | undefined): string | undefined {
+	return text === undefined || text.trim() === '' ? undefined : text
+}
+
+function readStream(events: ReadonlyArray<Record<string, unknown>>): Reading {
+	const init = events.find((event) => event.type === 'system' && event.subtype === 'init')
+	const result = events.find((event) => event.type === 'result')
+	return {
+		session: init === undefined ? undefined : readString(init, 'session_id'),
+		answer: result === undefined ? undefined : readAnswer(readString(result, 'result')),
+		durationMs: result === undefined ? undefined : readNumber(result, 'duration_ms'),
+	}
+}
+
+function readCodex(path: string, events: ReadonlyArray<Record<string, unknown>>): Reading {
+	const started = events.find((event) => event.type === 'thread.started')
+	const last = path.replace(/\.jsonl$/u, '-last.md')
+	return {
+		session: started === undefined ? undefined : readString(started, 'thread_id'),
+		answer: existsSync(last) ? readAnswer(readFileSync(last, 'utf8')) : undefined,
+		durationMs: undefined,
+	}
+}
+
+function readErrors(path: string): Errors {
+	const errors = path.replace(/\.jsonl$/u, '.err')
+	if (!existsSync(errors)) return { exit: undefined, capped: undefined, durationMs: undefined }
+	const match = readFileSync(errors, 'utf8').match(
+		/exit=(\S+) signal=\S+ capped=(true|false) duration_ms=(\d+)\s*$/u,
+	)
+	if (match === null) return { exit: undefined, capped: undefined, durationMs: undefined }
+	const exit = Number(match[1])
+	return {
+		exit: Number.isFinite(exit) ? exit : undefined,
+		capped: match[2] === 'true',
+		durationMs: Number(match[3]),
+	}
+}
+
+function describeEvent(event: Record<string, unknown> | undefined): string | undefined {
+	if (event === undefined) return undefined
+	const type = readString(event, 'type')
+	const subtype = readString(event, 'subtype')
+	return subtype === undefined ? type : `${type}/${subtype}`
+}
+
+function main(argv: readonly string[]): number {
+	const missing = readMissingFlags(argv, ['--cursor', '--claude', '--codex', '--out'])
+	if (missing.length > 0) {
+		console.error(`result: ${missing.join(', ')} given with no value`)
+		return 64
+	}
+	const modes = ['--cursor', '--claude', '--codex'].filter((flag) => argv.includes(flag))
+	const mode = modes[0]
+	const path = mode === undefined ? undefined : readOption(argv, mode)
+	const out = readOption(argv, '--out')
+	if (modes.length !== 1 || mode === undefined || path === undefined || !existsSync(path)) {
+		console.error(
+			'usage: result.ts (--cursor JOURNAL | --claude JOURNAL | --codex JOURNAL) [--out PATH]; name one mode',
+		)
+		return 64
+	}
+	const events = readEvents(path)
+	const reading = mode === '--codex' ? readCodex(path, events) : readStream(events)
+	const errors = readErrors(path)
+	const stat = statSync(path)
+	if (reading.answer !== undefined && out !== undefined) {
+		mkdirSync(dirname(out), { recursive: true })
+		writeFileSync(out, reading.answer)
+	}
+	console.log(
+		JSON.stringify({
+			journal: path,
+			session: reading.session,
+			durationMs: reading.durationMs ?? errors.durationMs,
+			exit: errors.exit,
+			capped: errors.capped,
+			bytes: stat.size,
+			ageMs: Math.max(0, Math.round(Date.now() - stat.mtimeMs)),
+			lastEvent: describeEvent(events.at(-1)),
+			answerLength: reading.answer?.length ?? 0,
+			out: reading.answer === undefined ? undefined : out,
+		}),
+	)
+	return reading.session === undefined || reading.answer === undefined ? 3 : 0
+}
+
+process.exitCode = main(process.argv.slice(2))