@joshuafolkken/kit 1.1050.0 → 1.1128.0

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

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'node:url'
 import { run_halfrun_resume } from './run-halfrun-resume'
 import { run_hold, type HoldRead, type RunHold } from './run-hold'
 import { run_preflight, type PreflightDecision } from './run-preflight'
+import { run_prrun_resume } from './run-prrun-resume'
 import { run_tidy_cli } from './run-tidy-cli'
 
 // `josh run:hold [<N>]` and `josh run:release [<N> | --force]` — the working-tree guard the typed
@@ -48,11 +49,13 @@ const FORCE_FLAG = '--force'
 // implementation cut outside a lane resumes as `fullrun #N` (joshuafolkken/kit#2760).
 const FULLRUN_FLAG = '--fullrun'
 const HALFRUN_STOP_FLAG = '--halfrun-stop'
+// A `prrun`'s stop before merge (joshuafolkken/kit#3023): its record keeps the commit it stopped on.
+const PRRUN_STOP_FLAG = '--prrun-stop'
 // The most a claim reads: the issue number and the one flag after it.
 const MAX_CLAIM_ARGUMENTS = 2
 const ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u
 const USAGE =
-	'Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop]] | josh run:release [<issue-number> | --force]'
+	'Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --prrun-stop]] | josh run:release [<issue-number> | --force]'
 
 const HOLD_VERDICT = 'hold'
 const BUSY_VERDICT = 'busy'
@@ -65,6 +68,7 @@ const HELD_VERDICT = 'held'
 
 const FORCE_RELEASE_KIND = 'force-release'
 const HALFRUN_STOP_KIND = 'halfrun-stop'
+const PRRUN_STOP_KIND = 'prrun-stop'
 
 interface ClaimRequest {
 	kind: 'claim'
@@ -72,11 +76,20 @@ interface ClaimRequest {
 	is_fullrun?: boolean
 }
 
+interface StopRequest {
+	kind: typeof HALFRUN_STOP_KIND | typeof PRRUN_STOP_KIND
+	issue: string
+}
+
 type HoldRequest =
 	| ClaimRequest
+	| StopRequest
 	| { kind: 'release'; claimant: string }
 	| { kind: typeof FORCE_RELEASE_KIND }
-	| { kind: typeof HALFRUN_STOP_KIND; issue: string }
+
+function is_stop_request(request: HoldRequest): request is StopRequest {
+	return request.kind === HALFRUN_STOP_KIND || request.kind === PRRUN_STOP_KIND
+}
 
 const FORCE_RELEASE_REQUEST: HoldRequest = { kind: FORCE_RELEASE_KIND }
 
@@ -84,12 +97,20 @@ function release_request(claimant: string): HoldRequest {
 	return { kind: 'release', claimant }
 }
 
-// The flag after a numbered claim: absent, `--fullrun` or `--halfrun-stop`. Anything else is a usage
-// error.
+const STOP_KIND_BY_FLAG: ReadonlyMap<string, typeof HALFRUN_STOP_KIND | typeof PRRUN_STOP_KIND> =
+	new Map([
+		[HALFRUN_STOP_FLAG, HALFRUN_STOP_KIND],
+		[PRRUN_STOP_FLAG, PRRUN_STOP_KIND],
+	])
+
+// The flag after a numbered claim: absent, `--fullrun`, `--halfrun-stop` or `--prrun-stop`. Anything
+// else is a usage error.
 function numbered_claim(issue: string, flag: string | undefined): HoldRequest | undefined {
 	if (flag === undefined) return { kind: 'claim', issue }
 
-	if (flag === HALFRUN_STOP_FLAG) return { kind: HALFRUN_STOP_KIND, issue }
+	const stop_kind = STOP_KIND_BY_FLAG.get(flag)
+
+	if (stop_kind !== undefined) return { kind: stop_kind, issue }
 
 	return flag === FULLRUN_FLAG ? { kind: 'claim', issue, is_fullrun: true } : undefined
 }
@@ -293,8 +314,12 @@ async function read_worktree(): Promise<string | undefined> {
 
 // **A `halfrun` stop marks its own record** (joshuafolkken/kit#2796) — the positive "this run has ended
 // over its verified diff" that `run:entry` adopts on `fullrun #N`. Another run's record is left alone.
-function mark_halfrun_stop(target: string, issue: string): number {
-	const mark = run_halfrun_resume.mark_stop_at(target, issue)
+// A `prrun` stop marks its record the same way, with the commit it stopped on (joshuafolkken/kit#3023).
+async function mark_stop(target: string, request: StopRequest): Promise<number> {
+	const mark =
+		request.kind === PRRUN_STOP_KIND
+			? await run_prrun_resume.mark_stop_at(target, request.issue)
+			: run_halfrun_resume.mark_stop_at(target, request.issue)
 
 	if (mark === run_halfrun_resume.MARKED) return report_hold()
 
@@ -306,7 +331,7 @@ function mark_halfrun_stop(target: string, issue: string): number {
 async function dispatch(request: HoldRequest, target: string, is_linked: boolean): Promise<number> {
 	if (request.kind === 'claim') return await claim(target, request, is_linked)
 
-	if (request.kind === HALFRUN_STOP_KIND) return mark_halfrun_stop(target, request.issue)
+	if (is_stop_request(request)) return await mark_stop(target, request)
 
 	if (request.kind === FORCE_RELEASE_KIND) return force_release(target)
 
@@ -351,8 +376,6 @@ const run_hold_cli = {
 	RELEASED_VERDICT,
 	UNKNOWN_VERDICT,
 	USAGE,
-	blocking_message,
-	main,
 	parse_request,
 	run,
 }

package/scripts/run/run-hold.ts

@@ -1,5 +1,6 @@
 import { git_command } from '#scripts/git/git-command'
 import { stamp_file } from '#scripts/josh/stamp-file'
+import { error_text } from '#scripts/lib/error-message'
 import { z } from 'zod'
 
 // joshuafolkken/kit#1091: `epicrun` asks `epic-busy.ts` whether a *repository* already has a child in
@@ -52,6 +53,10 @@ interface RunHold {
 	// the positive record that the run has *ended* over its verified diff, which is what lets
 	// `fullrun #N` adopt the hold. A running `halfrun` or a `backlogrun` child never carries it.
 	is_halfrun_stop?: boolean | undefined
+	// Set only at a `prrun`'s stop before merge (`run:hold <N> --prrun-stop`, joshuafolkken/kit#3023): the
+	// commit the green pull request stood on, so `fullrun #N` can tell an untouched branch — merge it —
+	// from one that moved since and has to pass the gate and the review again.
+	prrun_stop_head?: string | undefined
 }
 
 type HoldRead =
@@ -92,6 +97,7 @@ const run_hold_schema = z.object({
 	pid: z.number(),
 	is_fullrun: z.boolean().optional(),
 	is_halfrun_stop: z.boolean().optional(),
+	prrun_stop_head: z.string().optional(),
 })
 
 // `undefined` for anything that is not a well-formed record, so the caller decides what a broken one
@@ -161,9 +167,24 @@ function create_hold(
 	return stamp_file.create_stamp(target, build_hold(issue, now, is_fullrun))
 }
 
-// The claim a `halfrun` stop leaves behind: the same exclusive create, carrying the stop mark.
+// What a stopped run's record carries on top of the claim: the `halfrun` stop's flag, or the commit a
+// `prrun` stop stood on (joshuafolkken/kit#3023).
+type StopMarkFields = Pick<RunHold, 'is_halfrun_stop' | 'prrun_stop_head'>
+
+const HALFRUN_STOP_FIELDS: StopMarkFields = { is_halfrun_stop: true }
+
+// The claim a stop leaves behind: the same exclusive create, carrying the stop mark.
+function create_stop_hold(
+	target: string,
+	issue: string,
+	mark: StopMarkFields,
+	now: Date = new Date(),
+): boolean {
+	return stamp_file.create_stamp(target, { ...build_hold(issue, now), ...mark })
+}
+
 function create_halfrun_stop_hold(target: string, issue: string, now: Date = new Date()): boolean {
-	return stamp_file.create_stamp(target, { ...build_hold(issue, now), is_halfrun_stop: true })
+	return create_stop_hold(target, issue, HALFRUN_STOP_FIELDS, now)
 }
 
 // **A tree with uncommitted work in it is never handed over, however old its record is.** No age can
@@ -176,7 +197,9 @@ async function is_tree_dirty(directory?: string): Promise<boolean> {
 		const status = await git_command.status(directory)
 
 		return status.trim() !== ''
-	} catch {
+	} catch (error) {
+		error_text.trace_swallowed('run_hold.is_tree_dirty', error)
+
 		return true
 	}
 }
@@ -260,8 +283,9 @@ const run_hold = {
 	UNNUMBERED_ISSUE,
 	classify,
 	create_halfrun_stop_hold,
+	create_stop_hold,
+	HALFRUN_STOP_FIELDS,
 	create_hold,
-	describe_holder,
 	foreign_release_message,
 	forced_release_message,
 	held_message,
@@ -270,7 +294,6 @@ const run_hold = {
 	is_own_hold,
 	is_tree_dirty,
 	own_release_command,
-	parse_hold,
 	race_message,
 	read_hold,
 	release_hold,
@@ -282,5 +305,5 @@ const run_hold = {
 	write_hold,
 }
 
-export type { HoldRead, RunHold }
+export type { HoldRead, RunHold, StopMarkFields }
 export { run_hold }

package/scripts/run/run-issue-number.ts

@@ -14,6 +14,6 @@ function require_issue_number(issue: string): void {
 	if (!ISSUE_NUMBER_PATTERN.test(issue)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue}`)
 }
 
-const run_issue_number = { BAD_ISSUE_MESSAGE, ISSUE_NUMBER_PATTERN, require_issue_number }
+const run_issue_number = { ISSUE_NUMBER_PATTERN, require_issue_number }
 
 export { run_issue_number }

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

@@ -89,10 +89,6 @@ interface ParsedArguments {
 	values: ParsedValues
 }
 
-function read_arguments(argv: ReadonlyArray<string>): ParsedArguments | undefined {
-	return cli_flags.parse_or_undefined({ args: [...argv], options: OPTIONS, allowPositionals: true })
-}
-
 function is_valid_target(parsed: ParsedArguments): boolean {
 	return (
 		parsed.positionals.length === 1 &&
@@ -136,7 +132,7 @@ function to_request(parsed: ParsedArguments): LivenessRequest {
 }
 
 function parse_request(argv: ReadonlyArray<string>): LivenessRequest | undefined {
-	const parsed = read_arguments(argv)
+	const parsed = cli_flags.arguments_of(argv, OPTIONS)
 
 	if (parsed === undefined || !is_valid(parsed)) return undefined
 
@@ -159,7 +155,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const run_liveness_cli = { USAGE, main, parse_request, run }
+const run_liveness_cli = { USAGE, parse_request, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/run/run-liveness.ts

@@ -3,8 +3,8 @@ import { homedir, tmpdir } from 'node:os'
 import path from 'node:path'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { agent_event, type AgentEventState } from '#scripts/agent/agent-event'
-import { git_gh_issue_read } from '#scripts/git/git-gh-issue-read'
-import { ALREADY_DONE_LABEL, NEEDS_DECISION_LABEL } from '#scripts/git/issue-labels'
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
+import { ALREADY_DONE_LABEL, NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
 import { issue_state } from '#scripts/issue/issue-state'
 import { PLATFORM_TEMP_ROOT } from '#scripts/josh/platform-temporary'
 import { run_hold } from './run-hold'
@@ -401,7 +401,6 @@ const run_liveness = {
 	decide,
 	describe_agent_state,
 	read_child_settled,
-	read_agent_state,
 	read_output_frozen,
 	sample_output,
 	to_safe_path,

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

@@ -1,10 +1,11 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { parseArgs } from 'node:util'
 import { api_outage } from '#scripts/agent/api-outage'
 import { CONTEXT_CUT_THRESHOLD } from '#scripts/cost-runtime/context-cut-threshold'
 import { issue_closing_pr } from '#scripts/issue/issue-closing-pr'
 import { issue_state_cli } from '#scripts/issue/issue-state-cli'
+import { lane_handoff } from '#scripts/lane/lane-handoff'
+import { cli_flags } from '#scripts/lib/cli-flags'
 import { run_carry, type CarryOwner, type RunCarry } from './run-carry'
 import { run_ending } from './run-ending'
 import { run_event_stream } from './run-event-stream'
@@ -12,8 +13,6 @@ import { run_event_stream_emit } from './run-event-stream-emit'
 import { run_issue_number } from './run-issue-number'
 import { run_merge, type ChildOutcome, type EndingSignals } from './run-merge'
 import { run_merge_steps, type MergeContext } from './run-merge-steps'
-import { run_ship_detach } from './run-ship-detach'
-import { run_ship_probe } from './run-ship-probe'
 
 // `josh run:merge <N>` — one composite command for a `backlogrun` merge event (joshuafolkken/kit#2024).
 // The parent's context is the largest and its per-turn cost the highest, and the event was two turns:
@@ -70,14 +69,6 @@ interface ParsedArguments {
 	values: Partial<Record<'epic' | 'output' | 'over' | 'owner' | 'repo', string>>
 }
 
-function read_args(argv: ReadonlyArray<string>): ParsedArguments | undefined {
-	try {
-		return parseArgs({ args: [...argv], options: OPTIONS, allowPositionals: true, strict: true })
-	} catch {
-		return undefined
-	}
-}
-
 // Absent owner is "no owner declared", which the carry guard reads as not provably foreign; a present
 // but malformed pid invalidates the invocation rather than silently counting unguarded.
 function to_owner(raw: string | undefined): CarryOwner | undefined {
@@ -171,7 +162,7 @@ function to_context(parsed: ParsedArguments): MergeContext | undefined {
 }
 
 function parse(argv: ReadonlyArray<string>): MergeContext | undefined {
-	const parsed = read_args(argv)
+	const parsed = cli_flags.arguments_of(argv, OPTIONS)
 
 	return parsed === undefined ? undefined : to_context(parsed)
 }
@@ -316,7 +307,10 @@ async function on_cut(ctx: MergeContext): Promise<MergeVerdict> {
 
 // A child that parked itself: nothing is counted, but the park is written to the stream as a failed
 // child's is, so a reader restoring the run from its events sees the child settled (joshuafolkken/kit#2508).
+// Its `in-progress` is dropped as a failed child's is: left on, it outlived the `needs-decision` a
+// person later lifted, and a `run:solo` child then held the whole backlog (joshuafolkken/kit#3017).
 async function on_parked(ctx: MergeContext): Promise<MergeVerdict> {
+	await run_merge_steps.remove_in_progress(ctx.child)
 	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.PARK, `#${ctx.child} parked`)
 
 	return emit(await run_merge_steps.ask_next(ctx), SUCCESS_EXIT_CODE)
@@ -355,18 +349,10 @@ const HANDLERS: Readonly<Record<ChildOutcome, (ctx: MergeContext) => Promise<Mer
 	shipping: on_shipping,
 }
 
-async function is_ship_running(child: string): Promise<boolean> {
-	const repository = await run_ship_probe.repository_directory()
-
-	return (
-		repository !== undefined && run_ship_detach.read_result(repository, child)?.result === 'running'
-	)
-}
-
 // The whole merge event for one returned child, in-process: read its state, classify it, and run the
 // handler. The CLI prints the token; `backlog:drive` branches on the outcome (joshuafolkken/kit#2508).
 async function merge_child(ctx: MergeContext): Promise<MergeResult> {
-	if (await is_ship_running(ctx.child)) {
+	if (lane_handoff.is_ship_running(ctx.child, process.cwd())) {
 		return { outcome: 'shipping', ...(await on_shipping()) }
 	}
 
@@ -405,8 +391,6 @@ const run_merge_cli = {
 	RESUMED_TOKEN,
 	RETRY_TOKEN,
 	STOP_TOKEN,
-	USAGE,
-	main,
 	merge_child,
 	parse,
 	run,

package/scripts/run/run-merge-steps.ts

@@ -1,9 +1,9 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
-import { git_followup_issue_close } from '#scripts/git/git-followup-issue-close'
-import { git_gh_issue_write } from '#scripts/git/git-gh-issue-write'
-import { git_stash } from '#scripts/git/git-stash'
-import { IN_PROGRESS_LABEL, NEEDS_DECISION_LABEL } from '#scripts/git/issue-labels'
+import { git_followup_issue_close } from '#scripts/followup/git-followup-issue-close'
+import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
+import { git_stash } from '#scripts/git/stash/git-stash'
+import { IN_PROGRESS_LABEL, NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { lane_close } from '#scripts/lane/lane-close'
 import { lane_reap } from '#scripts/lane/lane-reap'
@@ -347,7 +347,6 @@ async function ask_next(ctx: MergeContext): Promise<string> {
 
 const run_merge_steps = {
 	CUT_RELAUNCH_CAUSE,
-	apply_carry,
 	ask_next,
 	do_failed,
 	do_merged,
@@ -355,6 +354,7 @@ const run_merge_steps = {
 	has_resumable_cut,
 	is_over_budget,
 	refused_carry,
+	remove_in_progress,
 	resume_cut,
 }
 

package/scripts/run/run-merge.ts

@@ -3,7 +3,7 @@ import {
 	EPIC_LABEL,
 	has_label_name,
 	NEEDS_DECISION_LABEL,
-} from '#scripts/git/issue-labels'
+} from '#scripts/issue/issue-labels'
 import type { IssueState } from '#scripts/issue/issue-state'
 import type { CarryChange, RunCarry } from './run-carry'
 

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

@@ -41,7 +41,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const run_next_cli = { USAGE, main, run }
+const run_next_cli = { run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/run/run-parent-cut-hook.ts

@@ -3,6 +3,7 @@ import { cost_cli, type CostVerdict } from '#scripts/cost-runtime/cost-cli'
 import { cost_format } from '#scripts/cost-runtime/cost-format'
 import { cost_verdict } from '#scripts/cost-runtime/cost-verdict'
 import { hook_decision } from '#scripts/josh/hook-decision'
+import { error_text } from '#scripts/lib/error-message'
 import { implementation_cut_verdict } from '#scripts/rules/implementation-cut-verdict'
 import { run_carry, type RunCarry } from './run-carry'
 import { run_headless } from './run-headless'
@@ -104,7 +105,9 @@ async function refusal_for(
 function is_unit_call(raw_payload: string): boolean {
 	try {
 		return (hook_decision.parse_hook_payload(raw_payload)?.agent_id ?? '') !== ''
-	} catch {
+	} catch (error) {
+		error_text.trace_swallowed('run_parent_cut_hook.is_unit_call', error)
+
 		return false
 	}
 }
@@ -135,7 +138,6 @@ async function parent_cut_reason(
 const run_parent_cut_hook = {
 	PARENT_CUT_REASON,
 	QUIET_WINDOW_MS,
-	STAMP_PREFIX,
 	SWITCH_ENV_KEY,
 	parent_cut_reason,
 }

package/scripts/run/run-preflight.ts

@@ -1,5 +1,5 @@
+import { git_gh_pr_read } from '#scripts/gh/git-gh-pr-read'
 import { git_command } from '#scripts/git/git-command'
-import { git_gh_pr_read } from '#scripts/git/git-gh-pr-read'
 import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
 import { z } from 'zod'
 import { run_hold } from './run-hold'
@@ -89,7 +89,7 @@ const STASH_LABEL_PREFIX = 'run:hold reclaimed before #'
 // so the shape it may take is pinned beside the interpolation rather than only in the CLI that
 // happens to be today's single caller. `run:liveness` interpolates it the same way, so the pattern
 // and the refusal live in one module both read (joshuafolkken/kit#1485).
-const { ISSUE_NUMBER_PATTERN, require_issue_number } = run_issue_number
+const { require_issue_number } = run_issue_number
 const UNREADABLE_PR_MESSAGE = 'The pull request could not be read for branch '
 
 function needs_reclaim(tree: TreeState): boolean {
@@ -385,15 +385,8 @@ async function check(issue: string): Promise<PreflightDecision> {
 }
 
 const run_preflight = {
-	CLEAN_ADVICE,
-	CLEAN_REASON,
 	CLEAN_VERDICT,
-	ISSUE_NUMBER_PATTERN,
-	PARK_ADVICE,
-	PARK_VERDICT,
-	RECLAIM_VERDICT,
 	RESUME_ADVICE,
-	RESUME_VERDICT,
 	MERGED_PR,
 	STASH_LABEL_PREFIX,
 	check,

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

@@ -1,9 +1,10 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { git_stash } from '#scripts/git/git-stash'
+import { git_stash } from '#scripts/git/stash/git-stash'
 import { issue_read_cli, type BlockRead } from '#scripts/issue/issue-read-cli'
 import { issue_state_cli, type StateRead } from '#scripts/issue/issue-state-cli'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import { error_text } from '#scripts/lib/error-message'
 import { latest_scope_cli } from '#scripts/version/latest-scope-cli'
 import { run_prep, type PrepParts } from './run-prep'
 import { run_prep_locate } from './run-prep-locate'
@@ -82,7 +83,9 @@ async function lane_has_changes(): Promise<boolean> {
 
 	try {
 		return await git_stash.has_changes(process.cwd())
-	} catch {
+	} catch (error) {
+		error_text.trace_swallowed('run_prep_cli.lane_has_changes', error)
+
 		return false
 	}
 }
@@ -150,7 +153,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 // `gather` and `to_parts` are exported so `run:next` reads the same state from the same three reads
 // rather than growing a second copy of the gather (joshuafolkken/kit#2188) — `run:next` is the
 // consumer of `run:prep` the epic #2166 wanted.
-const run_prep_cli = { USAGE, gather, main, parse_number, run, to_parts }
+const run_prep_cli = { gather, parse_number, run, to_parts }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/run/run-prep-locate.ts

@@ -159,7 +159,7 @@ async function locate(text: string): Promise<string> {
 	return format_locations(located)
 }
 
-const run_prep_locate = { extract_targets, format_locations, locate, parse_hits }
+const run_prep_locate = { extract_targets, locate, parse_hits }
 
 export type { Hit, Located }
 export { run_prep_locate }

package/scripts/run/run-progress-args.ts

@@ -12,6 +12,12 @@ import { run_progress_config } from './run-progress-config'
 // only a heartbeat the caller restarts on the next interval, so the two guard different things and
 // only one has anything to lose by being short.
 const DEFAULT_MAX_HOURS = 1
+// **`--wait` is bounded by a run, not by three intervals** (joshuafolkken/kit#3102). It no longer exits
+// at its first report — the reports go to the event stream — so its one-hour bound would be the last
+// wake that asks the parent for no judgement, a restart an hour. Eight hours is `run:hold`'s expiry;
+// what ends a finished run's watcher sooner is `josh followup` removing its life record, and a stop
+// tearing it down in the same turn.
+const DEFAULT_WAIT_MAX_HOURS = 8
 const MS_PER_HOUR = 3_600_000
 
 const OPTIONS = {
@@ -37,7 +43,7 @@ interface ParsedValues {
 }
 
 function read_arguments(argv: ReadonlyArray<string>): ParsedValues | undefined {
-	return cli_flags.parse_or_undefined({ args: [...argv], options: OPTIONS })?.values
+	return cli_flags.values_of(argv, OPTIONS)
 }
 
 // A hand-typed `--interval` outranks the environment, the environment outranks the interval the
@@ -48,14 +54,24 @@ function to_interval_ms(raw: string | undefined): number {
 	return run_progress_config.resolve_interval_ms(raw)
 }
 
-function to_max_ms(raw: string | undefined): number {
+function default_hours(is_wait: boolean): number {
+	return is_wait ? DEFAULT_WAIT_MAX_HOURS : DEFAULT_MAX_HOURS
+}
+
+function to_max_ms(raw: string | undefined, is_wait = false): number {
 	const hours = Number(raw)
 	const is_usable = raw !== undefined && Number.isFinite(hours) && hours > 0
 
-	return (is_usable ? hours : DEFAULT_MAX_HOURS) * MS_PER_HOUR
+	return (is_usable ? hours : default_hours(is_wait)) * MS_PER_HOUR
 }
 
-const run_progress_args = { DEFAULT_MAX_HOURS, read_arguments, to_interval_ms, to_max_ms }
+const run_progress_args = {
+	DEFAULT_MAX_HOURS,
+	DEFAULT_WAIT_MAX_HOURS,
+	read_arguments,
+	to_interval_ms,
+	to_max_ms,
+}
 
 export type { ParsedValues }
 export { run_progress_args }