@joshuafolkken/kit 1.1383.0 → 1.1387.0

package/scripts/init/start-steps.ts

@@ -18,6 +18,7 @@ interface StepContext {
 	profile: ProjectProfile
 	visibility: Visibility
 	init_command: string | undefined
+	push_preflight_command: string | undefined
 }
 
 interface RunContext extends StepContext {
@@ -69,6 +70,13 @@ function self_run_refusal(root: string): string | undefined {
 	return self_sync_guard.self_sync_refusal(PACKAGE_DIR, root)
 }
 
+// A caller's command line runs without a shell, split the way execa splits one.
+function run_command_line(command_line: string, extra: ReadonlyArray<string>, root: string): void {
+	const [command = '', ...args] = parseCommandString(command_line)
+
+	run_local(command, [...args, ...extra], root)
+}
+
 function create_git_repository(context: StepContext): void {
 	initial_commit.create_repository(context.root)
 }
@@ -84,9 +92,7 @@ function initialize(context: StepContext): void {
 		return
 	}
 
-	const [command = '', ...args] = parseCommandString(context.init_command)
-
-	run_local(command, [...args, '--profile', context.profile], context.root)
+	run_command_line(context.init_command, ['--profile', context.profile], context.root)
 }
 
 function commit_all(context: StepContext): void {
@@ -122,6 +128,26 @@ function baseline_of(
 	return start_setup_pr.changed_paths(context.root)
 }
 
+// A toolkit's own pre-push hook can need something kit knows nothing about (app-kit's needs a Docker
+// daemon), and a push it refuses lands after `gh repo create` has made the repository. So the caller
+// names a check that runs only when the plan pushes, before the first step: a run that does not push
+// is never stopped by it, and one it stops has written nothing (#3702).
+function run_push_preflight(steps: ReadonlyArray<StartStep>, context: StepContext): void {
+	const command_line = context.push_preflight_command
+
+	if (command_line === undefined || !start_plan.has_push(steps)) return
+
+	console.info(`\nPush preflight: ${command_line}`)
+
+	try {
+		run_command_line(command_line, [], context.root)
+	} catch (error) {
+		const cause = error_text.message_of(error)
+
+		throw new Error(start_plan.preflight_report(command_line, cause), { cause: error })
+	}
+}
+
 type StepAction = (context: RunContext) => void | Promise<void>
 
 const STEP_ACTIONS: Readonly<Record<StartStep, StepAction>> = {
@@ -150,6 +176,8 @@ async function run_step(
 
 async function run_steps(steps: ReadonlyArray<StartStep>, context: StepContext): Promise<void> {
 	const labels = start_plan.step_labels(context.init_command)
+
+	run_push_preflight(steps, context)
 	const run_context: RunContext = { ...context, baseline: baseline_of(steps, context) }
 
 	for (const [index, step] of steps.entries()) {

package/scripts/init/start.ts

@@ -15,8 +15,9 @@ import { start_steps } from './start-steps'
 const ARGUMENT_START_INDEX = 2
 const READY_MESSAGE = 'GitHub workflow ready. Use kickoff new in your assistant to plan an Issue.'
 const START_USAGE =
-	'josh start [--profile basic|full] [--yes] [--github] [--public] [--init-command <command>]'
+	'josh start [--profile basic|full] [--yes] [--github] [--public] [--init-command <command>] [--push-preflight-command <command>]'
 const INIT_COMMAND_FLAG = '--init-command'
+const PUSH_PREFLIGHT_COMMAND_FLAG = '--push-preflight-command'
 const YES_FLAG = '--yes'
 const GITHUB_FLAG = '--github'
 const PUBLIC_FLAG = '--public'
@@ -28,34 +29,38 @@ interface Prepared {
 	choices: Choices
 }
 
-interface InitCommandSplit {
-	init_command: string | undefined
+interface CommandSplit {
+	command: string | undefined
 	rest: ReadonlyArray<string>
 }
 
 // A value that is blank or another flag means the command itself was left out, which would otherwise
-// swallow the next switch or hand the initialize step nothing to run.
+// swallow the next switch or hand its step nothing to run.
 function is_command_value(value: string | undefined): value is string {
 	return value !== undefined && value.trim() !== '' && !value.startsWith('-')
 }
 
 // The command arrives as the one argument after its flag and is removed together with it.
-function split_init_command(args: ReadonlyArray<string>): InitCommandSplit {
-	const index = args.indexOf(INIT_COMMAND_FLAG)
+function split_command(args: ReadonlyArray<string>, flag: string): CommandSplit {
+	const index = args.indexOf(flag)
 
-	if (index === -1) return { init_command: undefined, rest: args }
+	if (index === -1) return { command: undefined, rest: args }
 
 	const value = args[index + 1]
 
 	if (!is_command_value(value)) throw new Error(`Usage: ${START_USAGE}`)
 
-	return { init_command: value, rest: args.filter((_, at) => at !== index && at !== index + 1) }
+	return { command: value, rest: args.filter((_, at) => at !== index && at !== index + 1) }
 }
 
-// The switches and the initialize command are peeled off first, so what remains is exactly the
+// The switches and the caller's commands are peeled off first, so what remains is exactly the
 // `--profile` pair `josh init` accepts — one parser for the profile in both commands.
 function parse_start_options(args: ReadonlyArray<string>): StartOptions {
-	const { init_command, rest } = split_init_command(args)
+	const init = split_command(args, INIT_COMMAND_FLAG)
+	const { command: push_preflight_command, rest } = split_command(
+		init.rest,
+		PUSH_PREFLIGHT_COMMAND_FLAG,
+	)
 	const profile_args = rest.filter((argument) => !SWITCHES.has(argument))
 
 	return {
@@ -63,7 +68,8 @@ function parse_start_options(args: ReadonlyArray<string>): StartOptions {
 		is_yes: rest.includes(YES_FLAG),
 		is_github: rest.includes(GITHUB_FLAG),
 		visibility: rest.includes(PUBLIC_FLAG) ? 'public' : 'private',
-		init_command,
+		init_command: init.command,
+		push_preflight_command,
 	}
 }
 
@@ -112,12 +118,13 @@ async function main(args: ReadonlyArray<string>, is_tty: boolean): Promise<void>
 	const { steps, interaction, choices } = prepare(args, is_tty, process.cwd())
 
 	const { root, options } = choices
-	const { visibility, init_command } = options
+	const { visibility, init_command, push_preflight_command } = options
 
 	console.info(start_plan.plan_summary(steps, start_plan.step_labels(init_command)))
 	const profile = await resolve_profile(choices, interaction)
+	const context = { root, profile, visibility, init_command, push_preflight_command }
 
-	await start_steps.run_steps(steps, { root, profile, visibility, init_command })
+	await start_steps.run_steps(steps, context)
 	console.info(`\n${READY_MESSAGE}`)
 }
 

package/scripts/josh/josh-commands-project.ts

@@ -17,7 +17,7 @@ const PROJECT_COMMANDS: Record<string, CommandEntry> = {
 		description: 'Set a project up for the GitHub Issue workflow, from git init to the setup PR',
 		category: 'Project',
 		reference: [
-			`${PROFILE_ARGUMENTS} [--yes] [--github] [--public] [--init-command <command>]`,
+			`${PROFILE_ARGUMENTS} [--yes] [--github] [--public] [--init-command <command>] [--push-preflight-command <command>]`,
 			'developer',
 			['files', 'git', 'network', 'processes'],
 		],

package/scripts/run/board/run-board-header.ts

@@ -74,13 +74,15 @@ interface BoardCounts {
 	remaining: number
 }
 
-type RunMark = 'running' | 'idle' | 'human' | 'stopped'
+// `setup` is a run with no child running that is getting one ready (`run-board-setup.ts`).
+type RunMark = 'running' | 'setup' | 'idle' | 'human' | 'stopped'
 
 type TextColor = Parameters<typeof styleText>[0]
 
 // The run's state as a colored glyph before its name.
 const RUN_MARKS: Readonly<Record<RunMark, { glyph: string; color: TextColor }>> = {
 	running: { glyph: '▶', color: 'green' },
+	setup: { glyph: '▶', color: 'green' },
 	idle: { glyph: '⏸', color: 'yellow' },
 	human: { glyph: '✋', color: 'magenta' },
 	stopped: { glyph: '■', color: 'gray' },
@@ -99,23 +101,33 @@ function counts_of(layout: BoardLayout): BoardCounts {
 	return { total, settled, parked, running, remaining: total - settled - running }
 }
 
+// The marks of a run that is working: they turn the spinner, and only they can go stale.
+const WORKING_MARKS: ReadonlySet<RunMark> = new Set<RunMark>(['running', 'setup'])
+// What follows the stage once the plan is read: how many issues the run is setting up for.
+const STAGE_SEPARATOR = ' · '
+const PLANNED = 'planned'
+
 // Nothing running: the run is waiting on a person when all the plan has left is what
-// `needs-decision` holds, and otherwise idle.
-function quiet_mark(layout: BoardLayout | undefined): RunMark {
-	return layout?.waves.length === 0 && layout.people.length > 0 ? 'human' : 'idle'
+// `needs-decision` holds; otherwise it is getting a child ready, or idle.
+function quiet_mark(header: BoardHeader): RunMark {
+	const { layout } = header
+
+	if (layout?.waves.length === 0 && layout.people.length > 0) return 'human'
+
+	return header.activity.is_preparing === true ? 'setup' : 'idle'
 }
 
 // The run's state, each state overriding the ones below it.
 function mark_of(header: BoardHeader, running: number): RunMark {
 	if (header.activity.is_stopped) return 'stopped'
 
-	return running > 0 ? 'running' : quiet_mark(header.layout)
+	return running > 0 ? 'running' : quiet_mark(header)
 }
 
-// A running run turns the spinner in place of ▶, both one column wide; every other mark stands still.
+// A working run turns the spinner in place of ▶, both one column wide; every other mark stands still.
 function run_part(mark: RunMark, spinner: string | undefined): string {
 	const { glyph, color } = RUN_MARKS[mark]
-	const shown = mark === 'running' ? (spinner ?? glyph) : glyph
+	const shown = WORKING_MARKS.has(mark) ? (spinner ?? glyph) : glyph
 
 	return styleText(color, `${shown} ${RUN_NAME}`)
 }
@@ -153,7 +165,7 @@ function ended_part(header: BoardHeader): string {
 }
 
 // The `💓` under the run's age, in the `⏰`'s own format with its digits right-aligned to `width` —
-// only a running run can be stale, so only it is colored. Only an ended run draws anything else there:
+// only a working run can be stale, so only it is colored. Only an ended run draws anything else there:
 // the minute it ended.
 function beat_part(header: BoardHeader, mark: RunMark, width: number): string {
 	const age = age_of(header)
@@ -162,7 +174,7 @@ function beat_part(header: BoardHeader, mark: RunMark, width: number): string {
 
 	const part = `${HEADER_ICONS.heartbeat} ${span_of(age).padStart(width)}`
 
-	return mark === 'running' ? aged(part, age) : part
+	return WORKING_MARKS.has(mark) ? aged(part, age) : part
 }
 
 // A run's age over the `💓`, or over the minute an ended run ended: the shorter of the two lengths is
@@ -243,9 +255,23 @@ function progress_parts(counts: BoardCounts, header: BoardHeader): Array<string>
 	]
 }
 
-// The run's progress, then what its plan read is doing.
-function progress_part(counts: BoardCounts, header: BoardHeader): string {
-	const parts = [...progress_parts(counts, header), loading_part(header), plan_warning(header)]
+// The stage a run is at before its first child launches, standing where the progress will: a tally of
+// nothing settled says less than what the run is doing. Only a run marked as setting up is at a stage:
+// a stopped run and one waiting on a person keep their progress.
+function stage_part(counts: BoardCounts, header: BoardHeader, mark: RunMark): string | undefined {
+	const { setup } = header.activity
+
+	if (setup === undefined || mark !== 'setup') return undefined
+	if (!is_plan_read(header)) return setup
+
+	return `${setup}${STAGE_SEPARATOR}${String(counts.total)} ${PLANNED}`
+}
+
+// The run's stage or its progress, then what its plan read is doing.
+function progress_part(counts: BoardCounts, header: BoardHeader, mark: RunMark): string {
+	const stage = stage_part(counts, header, mark)
+	const progress = stage === undefined ? progress_parts(counts, header) : [stage]
+	const parts = [...progress, loading_part(header), plan_warning(header)]
 
 	return parts.filter((part) => part !== undefined).join(GAP)
 }
@@ -286,7 +312,7 @@ function header_lines(header: BoardHeader): Array<string> {
 	const columns = [
 		column_of([run_part(mark, header.spinner), repo_part(header, mark)]),
 		column_of(time_parts(header, mark)),
-		[progress_part(counts, header), machine_part(counts, header)],
+		[progress_part(counts, header, mark), machine_part(counts, header)],
 	]
 
 	return [0, 1].map((line) => columns.map((column) => column[line]).join(GAP))

package/scripts/run/board/run-board-read.ts

@@ -1,8 +1,10 @@
 import type { NamedPlan } from '#scripts/backlog/backlog-plan'
+import { backlogrun_launch } from '#scripts/backlog/backlogrun-launch'
 import { lane_registry } from '#scripts/lane/lane-registry'
 import { run_carry } from '#scripts/run/carry/run-carry'
 import { run_carry_ended } from '#scripts/run/carry/run-carry-ended'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_stranded_detect } from '#scripts/run/run-stranded-detect'
 import { run_board_scope } from './run-board-scope'
 import { run_board_span, type BoardSpan } from './run-board-span'
 
@@ -18,6 +20,9 @@ interface LocalRead {
 	lanes: ReadonlyArray<string>
 	// The session a stopped run is resumed from; `undefined` otherwise.
 	resume: string | undefined
+	// The run is carried but nothing drives it — its owner and its supervisor are both gone
+	// (`run-stranded.ts`). Drawn as a stopped run, since no one is looking for its next issue.
+	is_stranded: boolean
 }
 
 interface SpanHere {
@@ -28,10 +33,11 @@ interface SpanHere {
 function span_here(repository: string): SpanHere {
 	const read = run_carry.read_carry(run_carry.carry_path(repository))
 	const ended = run_carry_ended.read_ended(run_carry_ended.ended_path(repository))
+	const launch = backlogrun_launch.pending_launch(repository)
 
 	return {
-		span: run_board_span.span_of(read, ended),
-		resume: run_board_span.resume_of(read, ended),
+		span: run_board_span.span_of(read, ended, launch),
+		resume: run_board_span.resume_of(read, ended, launch),
 	}
 }
 
@@ -53,6 +59,7 @@ async function read_local(): Promise<LocalRead | undefined> {
 		events: run_board_span.events_of(events, span),
 		lanes: lanes.map((lane) => lane.issue),
 		resume,
+		is_stranded: run_stranded_detect.is_stranded_at(repository),
 	}
 }
 

package/scripts/run/board/run-board-setup.ts

@@ -0,0 +1,73 @@
+import { run_event_scope } from '#scripts/run/event/run-event-scope'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+
+// What the run's `setup` events (`run-event-setup.ts`) tell `run:board`: the stage a run is at before
+// its first child launches, whether it is preparing a launch now, and which lanes are not children yet.
+// The events carry it all — nothing here infers a stage from which records exist.
+
+const KIND = run_event_stream.EVENT_KIND
+
+interface SetupRead {
+	// The newest stage's own words while the run is starting; `undefined` from the first launch — or a
+	// drain before one — on, when the plan's counts say more than a stage does.
+	setup: string | undefined
+	// The run is getting a child ready: any stage while it is starting, a lane opening after that.
+	is_preparing: boolean
+}
+
+const NO_SETUP: SetupRead = { setup: undefined, is_preparing: false }
+
+function is_setup(event: RunEvent): boolean {
+	return event.kind === KIND.SETUP
+}
+
+function has_launched(events: ReadonlyArray<RunEvent>): boolean {
+	return events.some((event) => event.kind === KIND.CHILD_LAUNCH)
+}
+
+// The start is over at the first launch, or at a drain that came before one: a run whose backlog
+// emptied with nothing launched is watching, and the hand-off each wake of that watch writes is not a
+// run getting ready.
+function has_started(events: ReadonlyArray<RunEvent>): boolean {
+	return has_launched(events) || events.some((event) => event.kind === KIND.DRAIN)
+}
+
+// A lane is opening while the stage naming its issue is newer than the run's newest position: the
+// launch it leads to, or whatever the run did instead, ends it. A stage that names no issue — a
+// hand-off between two children — prepares nothing a person waits on.
+function is_opening(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
+	if (run_event_scope.issue_named(stage) === undefined) return false
+
+	const position = events.findLast((event) => !run_event_stream.TRACE_KINDS.has(event.kind))
+
+	return position === undefined || position.pos < stage.pos
+}
+
+function read(events: ReadonlyArray<RunEvent>): SetupRead {
+	const stage = events.findLast((event) => is_setup(event))
+
+	if (stage === undefined) return NO_SETUP
+	if (!has_started(events)) return { setup: stage.text, is_preparing: true }
+
+	return { setup: undefined, is_preparing: is_opening(events, stage) }
+}
+
+function names(event: RunEvent, issue: number): boolean {
+	return Number(run_event_scope.issue_named(event)) === issue
+}
+
+// A lane the stream saw no launch for is not yet this run's child when the run says it is still
+// setting up: it has launched nothing at all, so any lane here is an earlier run's, or it is opening
+// this very lane. A stream with no stage on it says neither, and the lane is read as before.
+function is_lane_pending(events: ReadonlyArray<RunEvent>, issue: number): boolean {
+	const stages = events.filter((event) => is_setup(event))
+
+	if (stages.length === 0) return false
+
+	return !has_launched(events) || stages.some((stage) => names(stage, issue))
+}
+
+const run_board_setup = { is_lane_pending, read }
+
+export { run_board_setup }
+export type { SetupRead }

package/scripts/run/board/run-board-span.ts

@@ -1,3 +1,4 @@
+import type { PendingLaunch } from '#scripts/backlog/backlogrun-launch'
 import type { CarryRead } from '#scripts/run/carry/run-carry'
 import type { EndedRun } from '#scripts/run/carry/run-carry-ended'
 import { run_event_scope } from '#scripts/run/event/run-event-scope'
@@ -27,9 +28,40 @@ function ended_span(ended: EndedRun | undefined): BoardSpan | undefined {
 	return { invocation: ended.invocation, started_ms, ended_ms }
 }
 
+// A run `josh backlogrun` launched and its parent has not claimed yet: it has no carry record, so the
+// launch record is the only one that says a run is here and since when.
+function launch_span(launch: PendingLaunch | undefined): BoardSpan | undefined {
+	const started_ms = launch === undefined ? undefined : moment_of(launch.started_at)
+
+	if (launch === undefined || started_ms === undefined) return undefined
+
+	return { invocation: launch.invocation, started_ms, ended_ms: undefined }
+}
+
+// With no carry record: the run on its way, else the one that last ended. **A launch older than that
+// end is the ended run's own** — its parent outlives `run:carry --end` for a moment — so it never
+// redraws a finished run as one starting.
+function idle_span(
+	ended: EndedRun | undefined,
+	launch: PendingLaunch | undefined,
+): BoardSpan | undefined {
+	const last = ended_span(ended)
+	const coming = launch_span(launch)
+
+	if (coming === undefined) return last
+
+	return (last?.ended_ms ?? 0) >= coming.started_ms ? last : coming
+}
+
 // The running run wins over the ended one, so a run that begins replaces the finished board at once.
-function span_of(read: CarryRead, ended: EndedRun | undefined): BoardSpan | undefined {
-	if (read.kind !== 'carried') return read.kind === 'none' ? ended_span(ended) : undefined
+// **The launch's start is the carry's**: `run:carry --begin` inherits it for the parent the launch
+// started, so the clock does not restart when the record appears.
+function span_of(
+	read: CarryRead,
+	ended: EndedRun | undefined,
+	launch?: PendingLaunch,
+): BoardSpan | undefined {
+	if (read.kind !== 'carried') return read.kind === 'none' ? idle_span(ended, launch) : undefined
 
 	const started_ms = moment_of(read.carry.started_at)
 
@@ -38,12 +70,22 @@ function span_of(read: CarryRead, ended: EndedRun | undefined): BoardSpan | unde
 	return { invocation: read.carry.invocation, started_ms, ended_ms: undefined }
 }
 
-// The session a person resumes a stopped run from: only while the ended run is
-// the one drawn, and only when it stopped rather than finished. A run that begins hides it at once.
-function resume_of(read: CarryRead, ended: EndedRun | undefined): string | undefined {
-	if (read.kind !== 'none' || ended?.stopped === undefined) return undefined
+// Whether the span drawn with no carry record is the ended run's, rather than a launch's.
+function is_ended_drawn(ended: EndedRun | undefined, launch: PendingLaunch | undefined): boolean {
+	return idle_span(ended, launch)?.ended_ms !== undefined
+}
 
-	return ended.session
+// The session a person resumes a stopped run from: only while the ended run is
+// the one drawn, and only when it stopped rather than finished. A run that begins — or is on its way —
+// hides it at once.
+function resume_of(
+	read: CarryRead,
+	ended: EndedRun | undefined,
+	launch?: PendingLaunch,
+): string | undefined {
+	if (read.kind !== 'none' || !is_ended_drawn(ended, launch)) return undefined
+
+	return ended?.stopped === undefined ? undefined : ended.session
 }
 
 function is_within(event: RunEvent, span: BoardSpan): boolean {

package/scripts/run/board/run-board-status.ts

@@ -7,6 +7,7 @@ import { run_event_scope } from '#scripts/run/event/run-event-scope'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
 import type { ClosedIssue } from './run-board-closed'
 import { run_board_phase, type Phase } from './run-board-phase'
+import { run_board_setup, type SetupRead } from './run-board-setup'
 
 // What each issue of a run is doing now, read from the run's own event stream and its open lanes.
 // Local reads only — no `gh` call — so `run:board` can redraw it every few seconds; the plan these
@@ -26,8 +27,9 @@ interface ItemStatus {
 	track?: ReadonlyArray<Phase> | undefined
 }
 
-// The run as a whole, read off the same stream.
-interface RunActivity {
+// The run as a whole, read off the same stream. The setup half is `run-board-setup.ts`'s, absent
+// where a stream carries no stage.
+interface RunActivity extends Partial<SetupRead> {
 	last_event_ms: number | undefined
 	// The run's last position is a `stop` that names no child — the run itself ended.
 	is_stopped: boolean
@@ -125,16 +127,17 @@ function fold_events(events: ReadonlyArray<RunEvent>): Map<number, ItemStatus> {
 function is_running_lane(
 	issue: number,
 	status: ItemStatus | undefined,
+	events: ReadonlyArray<RunEvent>,
 	in_run: ReadonlySet<number>,
 ): boolean {
-	if (status === undefined) return in_run.has(issue)
+	if (status !== undefined) return status.state === 'running'
 
-	return status.state === 'running'
+	return in_run.has(issue) && !run_board_setup.is_lane_pending(events, issue)
 }
 
 // Every child the run has touched, with the lane each running child holds. A lane the stream never saw
 // launched — a run restored after the stream rolled — still reads as running while its issue is in the
-// run's plan (`in_run`).
+// run's plan (`in_run`); one the run is still setting up for stays waiting until its launch.
 function statuses_of(
 	events: ReadonlyArray<RunEvent>,
 	lanes: ReadonlyArray<string>,
@@ -146,7 +149,7 @@ function statuses_of(
 		const issue = Number(lane)
 		const status = statuses.get(issue)
 
-		if (is_running_lane(issue, status, in_run)) {
+		if (is_running_lane(issue, status, events, in_run)) {
 			statuses.set(issue, { state: 'running', ...status, lane: `lane ${lane}` })
 		}
 	}
@@ -251,6 +254,7 @@ function activity_of(events: ReadonlyArray<RunEvent>, is_ended = false): RunActi
 	const position = events.findLast((event) => !run_event_stream.TRACE_KINDS.has(event.kind))
 
 	return {
+		...run_board_setup.read(events),
 		last_event_ms: last === undefined ? undefined : moment(last),
 		is_stopped: is_ended || is_run_stop(position),
 	}

package/scripts/run/board/run-board-tick.ts

@@ -11,7 +11,7 @@ import type { LocalRead } from './run-board-read'
 import { run_board_render, type FrameBounds } from './run-board-render'
 import { run_board_spin, type Spun } from './run-board-spin'
 import { run_board_state, type BoardPorts, type BoardState, type Pace } from './run-board-state'
-import { run_board_status } from './run-board-status'
+import { run_board_status, type RunActivity } from './run-board-status'
 import { run_board_usage } from './run-board-usage'
 
 // One `run:board` redraw. **Three speeds**: the frame is redrawn once a second, on the second, so
@@ -116,6 +116,14 @@ interface Redraw {
 	now_ms: number
 }
 
+// A run `run:carry --end` closed and one nobody drives any more are both drawn as stopped.
+function activity_here(local: LocalRead): RunActivity {
+	return run_board_status.activity_of(
+		local.events,
+		local.ended_ms !== undefined || local.is_stranded,
+	)
+}
+
 function header_of(
 	state: BoardState,
 	local: LocalRead,
@@ -126,7 +134,7 @@ function header_of(
 		now_ms: redraw.now_ms,
 		started_ms: local.started_ms,
 		ended_ms: local.ended_ms,
-		activity: run_board_status.activity_of(local.events, local.ended_ms !== undefined),
+		activity: activity_here(local),
 		layout,
 		baseline_total: state.baseline_total,
 		plan_fetched_ms: state.fetched_ms,

package/scripts/run/carry/run-carry-added.ts

@@ -51,7 +51,7 @@ function add_issues(
 ): RunCarry {
 	const next: RunCarry = { ...carry, added: next_added(carry, additions) }
 
-	stamp_file.write_stamp(target, next)
+	stamp_file.replace_stamp(target, next)
 
 	return next
 }

package/scripts/run/carry/run-carry-change.ts

@@ -83,7 +83,7 @@ function apply_change(
 		retrospective: effective.retrospective === true || carry.retrospective,
 	}
 
-	stamp_file.write_stamp(target, next)
+	stamp_file.replace_stamp(target, next)
 
 	return next
 }