@joshuafolkken/kit 1.872.0

package/scripts/run/run-ending-cli.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { parseArgs } from 'node:util'
+import {
+	run_ending,
+	UNREADABLE_VERDICT,
+	type EndingDecision,
+	type EndingRequest,
+} from './run-ending'
+import { run_issue_number } from './run-issue-number'
+
+// `josh run:ending <N> --output <path> [--repo <owner/repo>]` — one verdict about how the dispatched
+// lane child running `<N>` ended (joshuafolkken/kit#2139).
+//
+// The stdout/stderr split is the contract `run:liveness` and `run:hold` keep: exactly one verdict
+// token on stdout on every path, the reason and the basis on stderr. `unreadable` exits non-zero,
+// because a caller that could not read a trace must not act as though it had classified the ending.
+
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+const ARGV_OFFSET = 2
+const USAGE = 'Usage: josh run:ending <issue-number> --output <path> [--repo <owner/repo>]'
+
+function report(decision: EndingDecision): number {
+	console.error(`${decision.reason}\n${decision.evidence}`)
+	console.info(decision.verdict)
+
+	return decision.verdict === UNREADABLE_VERDICT ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE
+}
+
+// A read that threw is the same answer as a trace that could not be read, printed as the verdict a
+// caller can branch on rather than as a stack trace.
+function report_unreadable(reason: string): number {
+	console.error(reason)
+	console.info(UNREADABLE_VERDICT)
+
+	return FAILURE_EXIT_CODE
+}
+
+function report_usage(): number {
+	console.error(USAGE)
+
+	return FAILURE_EXIT_CODE
+}
+
+const OPTIONS = {
+	output: { type: 'string' },
+	repo: { type: 'string' },
+} as const
+
+type ParsedValues = Partial<Record<keyof typeof OPTIONS, string>>
+
+interface ParsedArguments {
+	positionals: ReadonlyArray<string>
+	values: ParsedValues
+}
+
+function read_arguments(argv: ReadonlyArray<string>): ParsedArguments | undefined {
+	try {
+		return parseArgs({ args: [...argv], options: OPTIONS, allowPositionals: true })
+	} catch {
+		return undefined
+	}
+}
+
+function is_valid(parsed: ParsedArguments): boolean {
+	return (
+		parsed.positionals.length === 1 &&
+		run_issue_number.ISSUE_NUMBER_PATTERN.test(parsed.positionals[0] ?? '') &&
+		parsed.values.output !== undefined
+	)
+}
+
+// Reached only through `is_valid`, so the fallbacks are unreachable defaults rather than behavior.
+function to_request(parsed: ParsedArguments): EndingRequest {
+	return {
+		issue: parsed.positionals[0] ?? '',
+		output_path: parsed.values.output ?? '',
+		...(parsed.values.repo !== undefined && { repo: parsed.values.repo }),
+	}
+}
+
+function parse_request(argv: ReadonlyArray<string>): EndingRequest | undefined {
+	const parsed = read_arguments(argv)
+
+	if (parsed === undefined || !is_valid(parsed)) return undefined
+
+	return to_request(parsed)
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	const request = parse_request(argv)
+
+	if (request === undefined) return report_usage()
+
+	try {
+		return report(await run_ending.check(request))
+	} catch (error) {
+		return report_unreadable(error instanceof Error ? error.message : String(error))
+	}
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const run_ending_cli = { USAGE, main, parse_request, run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { run_ending_cli }

package/scripts/run/run-ending.ts

@@ -0,0 +1,239 @@
+import { readFileSync } from 'node:fs'
+import { agent_exit_record } from '#scripts/agent/agent-exit-record'
+import { api_outage } from '#scripts/agent/api-outage'
+import type { ClaudeResultEvent } from '#scripts/agent/claude-result-event'
+import { git_gh_issue_read } from '#scripts/git/git-gh-issue-read'
+import { issue_state } from '#scripts/issue/issue-state'
+import { run_cut } from './run-cut'
+import { run_hold } from './run-hold'
+import { run_issue_number } from './run-issue-number'
+import { run_liveness } from './run-liveness'
+
+// `josh run:ending <N>` — how a dispatched lane child *ended*, not whether it is still moving
+// (joshuafolkken/kit#2139). `run:liveness` answers "still working, or stopped?"; a normally-exited
+// child that stopped mid-implementation is invisible to it — the output freezes exactly as a
+// completed child's does, and `is_error: false` looks like success. Measured on 2026-09-19: the child
+// for joshuafolkken/kit#2118 ended `subtype: success`, left three uncommitted files, opened no PR, and
+// `run:cut --resume` answered `fresh` — a mid-implementation exit that read as a clean finish, and the
+// cause took a person opening 875KB of JSONL to find.
+//
+// **The verdict is read from three traces the child leaves behind, never from `is_error`.** A cut
+// record for this issue means it handed off; a CLOSED Issue means it completed and merged; an OPEN
+// Issue with no cut means it ended in the middle. The exit record's own `is_error: false` is *not* a
+// completion — completion is the CLOSED Issue — which is the one distinction that was missing. The exit
+// record is read for the *basis* the park comment carries: which fields said so, and how many tool
+// calls the harness refused (`permission_denials`, the direct cause of the 2118 stop).
+//
+// **The words are a different question from `run:liveness`'s four**, deliberately non-overlapping:
+// `merged` / `cut` / `outage` / `abandoned` / `unreadable` answer "how did it end", where `alive` /
+// `stopped` / `settled` / `undetermined` answer "is it still going".
+//
+// **`outage` splits the mid-implementation ending in two** (joshuafolkken/kit#2240). A child that ended
+// mid-implementation because it could not reach the API is not a child that stalled on its own: the
+// exit record carries a transport-failure signature, read mechanically by `api-outage.ts`. The parent
+// reads it to leave the outage child re-dispatchable rather than parking it and counting it against
+// the consecutive-failure guard, which is meant to notice the environment — not to be tripped by it.
+
+const MERGED_VERDICT = 'merged'
+const CUT_VERDICT = 'cut'
+const OUTAGE_VERDICT = 'outage'
+const ABANDONED_VERDICT = 'abandoned'
+const UNREADABLE_VERDICT = 'unreadable'
+
+type EndingVerdict =
+	| typeof MERGED_VERDICT
+	| typeof CUT_VERDICT
+	| typeof OUTAGE_VERDICT
+	| typeof ABANDONED_VERDICT
+	| typeof UNREADABLE_VERDICT
+
+// `state` alone answers the merged-vs-open question; the labels a settled child carries are
+// `run:liveness`'s concern, not this one. gh's `--json` casing is upper, so the compare is against
+// `CLOSED`, the same spelling `run-liveness.ts` reads `OPEN` in.
+const STATE_FIELD = 'state'
+const CLOSED_STATE = 'CLOSED'
+
+const EXIT_UNREADABLE = 'exit record unreadable'
+
+interface EndingTraces {
+	exit_record: ClaudeResultEvent | undefined
+	is_child_closed: boolean | undefined
+	is_cut_taken: boolean
+	is_tree_dirty: boolean
+}
+
+interface EndingDecision {
+	evidence: string
+	reason: string
+	verdict: EndingVerdict
+}
+
+interface EndingRequest {
+	issue: string
+	output_path: string
+	repo?: string
+}
+
+const REASONS: Record<EndingVerdict, string> = {
+	[MERGED_VERDICT]: 'The child ran to completion: its Issue is CLOSED.',
+	[CUT_VERDICT]:
+		'The child took a cut and handed the run to a successor: a cut record for this issue is carried.',
+	[OUTAGE_VERDICT]:
+		'The child could not reach the API: its exit record ended in error on a transport-failure signature. Do not count it against the consecutive-failure guard — the environment, not the child, is at fault.',
+	[ABANDONED_VERDICT]:
+		'The child ended mid-implementation without a cut: its Issue is OPEN and no cut was recorded. A normal exit code does not make this a completion.',
+	[UNREADABLE_VERDICT]:
+		'A trace could not be read — the Issue state or the exit record — so how the child ended cannot be told.',
+}
+
+// The mid-implementation ending, split by whether the exit record could not reach the API. A missing
+// record is unreadable; an outage record is `outage`; anything else is `abandoned`.
+function mid_implementation_verdict(record: ClaudeResultEvent | undefined): EndingVerdict {
+	if (record === undefined) return UNREADABLE_VERDICT
+
+	return api_outage.is_outage(record) ? OUTAGE_VERDICT : ABANDONED_VERDICT
+}
+
+// The verdict never consults `is_error` for completion: a child that exits `is_error: false` while its
+// Issue is still OPEN and uncut is `abandoned`, not `merged` — the exact confusion this command
+// removes. `is_error` is read only inside the outage split, where a transport failure ends in error.
+function verdict_of(traces: EndingTraces): EndingVerdict {
+	if (traces.is_cut_taken) return CUT_VERDICT
+	if (traces.is_child_closed === undefined) return UNREADABLE_VERDICT
+	if (traces.is_child_closed) return MERGED_VERDICT
+
+	return mid_implementation_verdict(traces.exit_record)
+}
+
+function describe_exit(record: ClaudeResultEvent): string {
+	const number_turns = record.num_turns === undefined ? 'unknown' : String(record.num_turns)
+
+	return `exit record: subtype=${record.subtype ?? 'unknown'}, is_error=${String(record.is_error)}, num_turns=${number_turns}, permission_denials=${String(record.permission_denials)}`
+}
+
+// The refused interactive ask, as a clause the park comment can carry the question and options in — or
+// empty when the child asked nothing (joshuafolkken/kit#2201). This is the backstop for a child that
+// slipped past the `PreToolUse` refusal: the question is stranded in the exit record's
+// `permission_denials`, and lifting it here spares the parent opening the JSONL by hand.
+function refused_ask_clause(record: ClaudeResultEvent | undefined): string {
+	const ask = record?.refused_ask
+
+	return ask === undefined ? '' : ` the refused interactive ask was — ${ask};`
+}
+
+// The basis the park comment carries: which exit-record fields were read, the count of refused tool
+// calls, any refused interactive ask, and whether uncommitted work is still on disk for the parent to
+// stash.
+function abandoned_evidence(traces: EndingTraces): string {
+	const record =
+		traces.exit_record === undefined ? EXIT_UNREADABLE : describe_exit(traces.exit_record)
+	const ask = refused_ask_clause(traces.exit_record)
+	const tree = traces.is_tree_dirty ? 'uncommitted work remains' : 'the tree is clean'
+
+	return `${record};${ask} the Issue is OPEN and no cut was recorded (${tree}), so the child ended mid-implementation — include this basis in the park comment.`
+}
+
+// The basis an outage verdict carries: the exit-record fields, and the transport-failure signature the
+// reason matched, so a person sees why it was read as the environment failing rather than the child.
+function outage_evidence(record: ClaudeResultEvent | undefined): string {
+	if (record === undefined) return EXIT_UNREADABLE
+
+	const marker = api_outage.outage_marker(record)
+
+	return `${describe_exit(record)}; the exit record ended in error on a transport-failure signature (${marker ?? 'unknown'}), so the child never reached the API.`
+}
+
+function evidence_of(verdict: EndingVerdict, traces: EndingTraces): string {
+	if (verdict === ABANDONED_VERDICT) return abandoned_evidence(traces)
+	if (verdict === OUTAGE_VERDICT) return outage_evidence(traces.exit_record)
+
+	return traces.exit_record === undefined ? EXIT_UNREADABLE : describe_exit(traces.exit_record)
+}
+
+function decide(traces: EndingTraces): EndingDecision {
+	const verdict = verdict_of(traces)
+
+	return { evidence: evidence_of(verdict, traces), reason: REASONS[verdict], verdict }
+}
+
+// CLOSED is completion; anything else is OPEN as far as this command cares. A read that produced
+// nothing — an unreachable API, a body that is not a state report — is `undefined`, which the verdict
+// reads as unreadable rather than guessing OPEN and reporting a completed child as abandoned.
+async function read_child_closed(issue: string, repo?: string): Promise<boolean | undefined> {
+	const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELD, repo)
+
+	if (json === undefined) return undefined
+
+	const state = issue_state.parse_issue_state(json)
+
+	return state === undefined ? undefined : state.state === CLOSED_STATE
+}
+
+// The non-mutating read behind `run:cut --resume`'s `fresh` / `resume` answer: a carried cut record
+// naming this issue's invocation means the child handed off. `--resume` itself is not called — it
+// adopts the cut and spends the hand-off, which a read-only classifier must not do. An expired record
+// is a hand-off no successor took, so it is not read as a live cut and falls through to the OPEN case.
+async function read_cut_taken(issue: string): Promise<boolean> {
+	const directory = await run_cut.worktree_directory()
+
+	if (directory === undefined) return false
+
+	const read = run_cut.read_cut(run_cut.cut_path(directory))
+
+	return read.kind === 'carried' && read.cut.invocation === run_cut.invocation_for(issue)
+}
+
+function read_exit(output_path: string): ClaudeResultEvent | undefined {
+	const safe_path = run_liveness.to_safe_path(output_path)
+
+	if (safe_path === undefined) return undefined
+
+	try {
+		// Validated by `run_liveness.to_safe_path` — normalized, required absolute, confined to the
+		// allowed roots — the same check `josh lane:output` gates a transcript path with, reused rather
+		// than re-spelled so the two cannot disagree.
+		return agent_exit_record.read_exit_record(readFileSync(safe_path, 'utf8')) // NOSONAR
+	} catch {
+		return undefined
+	}
+}
+
+async function read_traces(request: EndingRequest): Promise<EndingTraces> {
+	const [is_child_closed, is_cut_taken, is_tree_dirty] = await Promise.all([
+		read_child_closed(request.issue, request.repo),
+		read_cut_taken(request.issue),
+		run_hold.is_tree_dirty(),
+	])
+
+	return {
+		exit_record: read_exit(request.output_path),
+		is_child_closed,
+		is_cut_taken,
+		is_tree_dirty,
+	}
+}
+
+async function check(request: EndingRequest): Promise<EndingDecision> {
+	run_issue_number.require_issue_number(request.issue)
+
+	return decide(await read_traces(request))
+}
+
+const run_ending = {
+	check,
+	decide,
+	describe_exit,
+	read_child_closed,
+	read_cut_taken,
+	read_exit,
+}
+
+export type { EndingDecision, EndingRequest, EndingTraces, EndingVerdict }
+export {
+	ABANDONED_VERDICT,
+	CUT_VERDICT,
+	MERGED_VERDICT,
+	OUTAGE_VERDICT,
+	run_ending,
+	UNREADABLE_VERDICT,
+}

package/scripts/run/run-entry-cli.ts

@@ -0,0 +1,135 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { josh_command } from '#scripts/josh/josh-run'
+import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import { run_entry, type EntryParts } from './run-entry'
+import { run_hold_cli } from './run-hold-cli'
+import { run_next } from './run-next'
+import { run_prep } from './run-prep'
+import { run_prep_cli } from './run-prep-cli'
+import { run_step } from './run-step'
+
+// `josh run:entry <N>` — one call for the fixed entry sequence a lane opens on (joshuafolkken/kit#2372).
+// The loop used to spend a round trip on `run:hold`, one on `cost --cut`, one on `run:prep` and one on
+// `run:step`, re-billing a lane's full context each time; this runs all four internally and prints one
+// composite report, the same way `backlog:offer` folds `backlog:next` → `backlog:budget` and `run:prep`
+// folds three reads.
+//
+// **The stops short-circuit.** A `busy` / `unknown` hold and an `over` budget both end the run, so the
+// composite reports them without reading the issue — the gate `fullrun.md` steps 1 and 3 stop on stays a
+// gate, decided from the token rather than a sentence. `cost --cut` is skipped in a dispatched lane
+// child, where the parent owns the budget question — the same lane-aware skip `run:prep` makes for
+// `latest`.
+
+const ARGV_OFFSET = 2
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+const ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u
+const USAGE = 'Usage: josh run:entry <issue-number>'
+const should_forward_stderr = true
+const NEWLINE = '\n'
+
+const HOLD_STOP_NOTE =
+	'(tree not held — see the reason above; clean up and retry, or release with `pnpm josh run:release`)'
+const COST_STOP_NOTE = '(session budget spent — see the figure above; resume in a fresh session)'
+
+// Exactly one issue number, or the call is refused — `run:entry` opens one run, and a second number
+// would claim and read a second issue a caller reads as this one's.
+function parse_number(argv: ReadonlyArray<string>): string | undefined {
+	const [first] = argv
+
+	if (first === undefined || argv.length !== 1 || !ISSUE_NUMBER_PATTERN.test(first)) {
+		return undefined
+	}
+
+	return first
+}
+
+function first_line(out: string): string {
+	return out.split(NEWLINE)[0] ?? ''
+}
+
+// `run:hold <N>` prints one token — `hold`, `busy` or `unknown` — and forwards its explanation to
+// stderr, so the composite branches on the token and the reader still sees why.
+async function claim_hold(issue_number: string): Promise<string> {
+	const held = await josh_command.josh_run(['run:hold', issue_number], should_forward_stderr)
+
+	return first_line(held.out)
+}
+
+// A dispatched lane child never asks the session boundary — the parent owns it once per session
+// (`backlogrun-progress.md` → "The hand-off") — so this records `skipped` rather than reading a budget
+// nothing in the lane acts on, the same shape `run:prep` skips `latest` in a lane.
+async function check_cost(): Promise<string> {
+	if (lane_child_marker.is_child_of(process.cwd())) return run_entry.COST_SKIPPED
+
+	const cut = await josh_command.josh_run(['cost', '--cut'], should_forward_stderr)
+
+	return first_line(cut.out)
+}
+
+interface Reads {
+	report: string
+	verdict: string
+}
+
+// The issue reads and the pre-implementation verdict, from the one gather `run:prep` and `run:next`
+// already share (joshuafolkken/kit#2188) rather than a second copy — the report is `run:prep`'s
+// formatter, the verdict is `run:step`'s `pre_verdict` over the same parts.
+async function gather_reads(issue_number: string): Promise<Reads> {
+	const reads = await run_prep_cli.gather(issue_number)
+	const parts = run_prep_cli.to_parts(issue_number, reads)
+	const verdict = run_step.pre_verdict(run_next.to_input(parts))
+
+	return { report: run_prep.format_report(parts), verdict }
+}
+
+function emit(parts: EntryParts): number {
+	console.info(run_entry.format_report(parts))
+
+	return run_entry.exit_code(parts)
+}
+
+// The summary of a run that stopped before it read the issue: the token that stopped it, no verdict,
+// and the note that stands in for the report body.
+function stop_report(issue_number: string, hold: string, cost: string, report: string): number {
+	return emit({ issue_number, hold, cost, verdict: run_entry.NO_VERDICT, report })
+}
+
+async function open_run(issue_number: string): Promise<number> {
+	const hold = await claim_hold(issue_number)
+
+	if (hold !== run_hold_cli.HOLD_VERDICT) {
+		return stop_report(issue_number, hold, run_entry.COST_SKIPPED, HOLD_STOP_NOTE)
+	}
+
+	const cost = await check_cost()
+
+	if (cost === run_entry.COST_OVER) return stop_report(issue_number, hold, cost, COST_STOP_NOTE)
+
+	const reads = await gather_reads(issue_number)
+
+	return emit({ issue_number, hold, cost, verdict: reads.verdict, report: reads.report })
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	const issue_number = parse_number(argv)
+
+	if (issue_number === undefined) {
+		console.error(USAGE)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	return await open_run(issue_number)
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const run_entry_cli = { SUCCESS_EXIT_CODE, USAGE, check_cost, claim_hold, main, parse_number, run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { run_entry_cli }

package/scripts/run/run-entry.ts

@@ -0,0 +1,95 @@
+import { run_hold_cli } from './run-hold-cli'
+import { run_step } from './run-step'
+
+// `josh run:entry <N>` — the one call a `fullrun` makes to open a run (joshuafolkken/kit#2372). It
+// folds the fixed entry sequence a lane spends four separate round trips on — claim the tree
+// (`run:hold`), read the session budget (`cost --cut`), gather the issue reads (`run:prep`), and decide
+// the pre-implementation step (`run:step`) — into one composite, the same shape `backlog:offer` folded
+// the parent loop head on (joshuafolkken/kit#2162). Context cost grows with the square of a lane's
+// round trips, so collapsing four into one is where the fold pays the most.
+//
+// **This module is the pure half**, kept apart from the chaining CLI the way `run-prep.ts` is kept from
+// `run-prep-cli.ts` and `run-review.ts` from its steps. It shapes the summary line the reader branches
+// on, and answers the two things a test must pin without a hold ever being written or a session ever
+// read: the exit code the loop reads, and whether the run may proceed to implement.
+
+const SUMMARY_PREFIX = 'entry #'
+const SUMMARY_DASH = ' — '
+const FIELD_SEPARATOR = ' · '
+const HOLD_LABEL = 'hold: '
+const COST_LABEL = 'cost: '
+const VERDICT_LABEL = 'verdict: '
+const SECTION_SEPARATOR = '\n\n'
+
+// The three cost verdicts this composite reads: the two `cost --cut` prints on its first line, and the
+// stand-in a dispatched lane child records when the parent owns the budget question and this skips it.
+const COST_UNDER = 'under'
+const COST_OVER = 'over'
+const COST_SKIPPED = 'skipped'
+
+// The placeholder verdict for a summary printed before the pre-implementation step was reached — a
+// short-circuit on a `busy` hold or an `over` budget prints the summary without a `run:step` answer.
+const NO_VERDICT = '-'
+
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+
+interface EntryParts {
+	issue_number: string
+	// `run:hold`'s single token — `hold`, `busy` or `unknown`.
+	hold: string
+	// `cost --cut`'s first-line verdict, or `skipped` in a lane child.
+	cost: string
+	// `run:step`'s pre-implementation verdict, or `-` when a stop short-circuited before it.
+	verdict: string
+	// The `run:prep` report body, or the one-line note that stands in for it on a short-circuit.
+	report: string
+}
+
+// The leading line carries the three facts a run branches on — did the tree claim, is the budget
+// spent, and which flow the pre-implementation step names — so the decision is read off the first line
+// without parsing the report below it, exactly as `run:prep`'s own summary does.
+function summary(parts: EntryParts): string {
+	const fields = [
+		`${HOLD_LABEL}${parts.hold}`,
+		`${COST_LABEL}${parts.cost}`,
+		`${VERDICT_LABEL}${parts.verdict}`,
+	]
+
+	return `${SUMMARY_PREFIX}${parts.issue_number}${SUMMARY_DASH}${fields.join(FIELD_SEPARATOR)}`
+}
+
+function format_report(parts: EntryParts): string {
+	return [summary(parts), parts.report].join(SECTION_SEPARATOR)
+}
+
+// The tree must be held and the budget not spent, or the run stops before it reads anything else — the
+// two gates `fullrun.md` steps 1 and 3 stop on, decided from the tokens rather than from a sentence.
+function can_proceed(hold: string, cost: string): boolean {
+	return hold === run_hold_cli.HOLD_VERDICT && cost !== COST_OVER
+}
+
+// Non-zero when the run cannot proceed to its flow: a tree not held, a spent budget, or a state the
+// reads could not resolve (`unknown`). A readable `update-deps`, `human-review` or `already-done`
+// verdict is a flow the reader routes on, not a failure, so it exits zero — the same contract
+// `run:prep` keeps, where a bundled read that succeeded exits zero whatever the state says.
+function exit_code(parts: EntryParts): number {
+	const is_ok = can_proceed(parts.hold, parts.cost) && parts.verdict !== run_step.UNKNOWN
+
+	return is_ok ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
+}
+
+const run_entry = {
+	COST_OVER,
+	COST_SKIPPED,
+	COST_UNDER,
+	NO_VERDICT,
+	SUMMARY_PREFIX,
+	exit_code,
+	format_report,
+	can_proceed,
+	summary,
+}
+
+export type { EntryParts }
+export { run_entry }