@joshuafolkken/kit 1.1050.0 → 1.1128.0

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

@@ -4,11 +4,15 @@ import { josh_command } from '#scripts/josh/josh-run'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { run_cut_report } from './run-cut-report'
 import { run_entry, type EntryParts } from './run-entry'
+import { run_entry_stop } from './run-entry-stop'
 import { run_halfrun_resume } from './run-halfrun-resume'
 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_prrun_resume } from './run-prrun-resume'
+import { run_stage, type StageCommand, type StageDecision } from './run-stage'
+import { run_stage_read, type StageRead } from './run-stage-read'
 import { run_step } from './run-step'
 
 // `josh run:entry <N>` — one call for the fixed entry sequence a lane opens on (joshuafolkken/kit#2372).
@@ -27,13 +31,17 @@ 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 USAGE = 'Usage: josh run:entry <issue-number> [--to kickoff|halfrun|prrun|fullrun]'
+const TO_FLAG = '--to'
+// The flag and its command.
+const TO_ARGUMENT_COUNT = 2
 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)'
+const { BUDGET_REASON, HOLD_REASON } = run_entry_stop
 const HALFRUN_RESUME_TOKEN = 'halfrun'
 
 // Exactly one issue number, or the call is refused — `run:entry` opens one run, and a second number
@@ -48,16 +56,42 @@ function parse_number(argv: ReadonlyArray<string>): string | undefined {
 	return first
 }
 
+interface EntryRequest {
+	issue_number: string
+	command: StageCommand
+}
+
+// `--to <command>` names how far the run goes (joshuafolkken/kit#3042); absent, it is `fullrun`.
+// Anything else is refused.
+function parse_command(rest: ReadonlyArray<string>): StageCommand | undefined {
+	if (rest.length === 0) return run_stage.DEFAULT_COMMAND
+
+	const [flag, value] = rest
+
+	if (flag !== TO_FLAG || rest.length !== TO_ARGUMENT_COUNT) return undefined
+
+	return run_stage.to_command(value)
+}
+
+function parse_request(argv: ReadonlyArray<string>): EntryRequest | undefined {
+	const issue_number = parse_number(argv.slice(0, 1))
+	const command = parse_command(argv.slice(1))
+
+	return issue_number === undefined || command === undefined ? undefined : { issue_number, command }
+}
+
 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. `--fullrun` marks the
-// hold as this entry's, since `run:entry` is `fullrun #N`'s alone (joshuafolkken/kit#2760).
-async function claim_hold(issue_number: string): Promise<string> {
+// hold as a run whose implementation cut resumes as `fullrun #N` (joshuafolkken/kit#2760) — a
+// `fullrun`'s, and a `prrun`'s, which runs `fullrun`'s steps; a `halfrun`'s hold is never marked.
+async function claim_hold(issue_number: string, command: StageCommand): Promise<string> {
+	const mark = command === run_stage.HALFRUN ? [] : ['--fullrun']
 	const held = await josh_command.josh_run(
-		['run:hold', issue_number, '--fullrun'],
+		['run:hold', issue_number, ...mark],
 		should_forward_stderr,
 	)
 
@@ -103,6 +137,23 @@ function stop_report(issue_number: string, hold: string, cost: string, report: s
 	return emit({ issue_number, hold, cost, verdict: run_entry.NO_VERDICT, report })
 }
 
+// A stop this command decided carries its own chores (joshuafolkken/kit#3099): the `confirmation`
+// Telegram always, and the release where this call claimed the hold — `run_entry_stop` says why.
+interface StopCall {
+	parts: Pick<EntryParts, 'issue_number' | 'hold' | 'cost' | 'report'>
+	command: StageCommand
+	reason: string
+	should_release: boolean
+}
+
+async function stop_run({ parts, command, reason, should_release }: StopCall): Promise<number> {
+	const code = stop_report(parts.issue_number, parts.hold, parts.cost, parts.report)
+
+	await run_entry_stop.stop({ issue_number: parts.issue_number, command, reason, should_release })
+
+	return code
+}
+
 interface Resume {
 	token: string
 	code: number
@@ -131,55 +182,116 @@ function resume_report(issue_number: string, resume: Resume): number {
 // **A `halfrun` stopped before its commit is resumed, not claimed** (joshuafolkken/kit#2796): its hold
 // is kept over the verified diff, so the claim below would answer `busy` against it. The budget is asked
 // first, as for any run; then the hold is adopted and the run goes to the gate, skipping everything up
-// to and including implementation.
-async function resume_halfrun(issue_number: string): Promise<number> {
+// to and including implementation. **A `prrun` stopped before its merge is resumed the same way**
+// (joshuafolkken/kit#3023), under the token that says what is left of it.
+async function resume_stopped(
+	{ issue_number, command }: EntryRequest,
+	token: string,
+	stopped_run: { adopt: (issue: string) => Promise<boolean> },
+): Promise<number> {
 	const cost = await check_cost()
 
 	if (cost === run_entry.COST_OVER) {
-		return stop_report(issue_number, HALFRUN_RESUME_TOKEN, cost, COST_STOP_NOTE)
+		const parts = { issue_number, hold: token, cost, report: COST_STOP_NOTE }
+
+		return await stop_run({ parts, command, reason: BUDGET_REASON, should_release: false })
 	}
 
-	if (!(await run_halfrun_resume.adopt(issue_number))) {
-		return stop_report(issue_number, run_hold_cli.BUSY_VERDICT, cost, HOLD_STOP_NOTE)
+	if (!(await stopped_run.adopt(issue_number))) {
+		const parts = { issue_number, hold: run_hold_cli.BUSY_VERDICT, cost, report: HOLD_STOP_NOTE }
+
+		return await stop_run({ parts, command, reason: HOLD_REASON, should_release: false })
 	}
 
-	console.info(`entry #${issue_number} — resume: ${HALFRUN_RESUME_TOKEN}`)
+	console.info(`entry #${issue_number} — resume: ${token}`)
 
 	return SUCCESS_EXIT_CODE
 }
 
-async function open_run(issue_number: string): Promise<number> {
-	const resume = await ask_resume(issue_number)
+// The stopped run a decision picks up: a `halfrun` stop resumes at the gate, a `prrun` stop at
+// `followup` under its own token. `undefined` for any other start, so the ordinary claim decides.
+async function resume_any(
+	request: EntryRequest,
+	decision: StageDecision,
+	stage: StageRead,
+): Promise<number | undefined> {
+	if (decision.state === run_stage.HALFRUN_STOPPED) {
+		return await resume_stopped(request, HALFRUN_RESUME_TOKEN, run_halfrun_resume)
+	}
 
-	if (resume.token !== run_cut_report.FRESH_VERDICT) return resume_report(issue_number, resume)
+	return stage.prrun_token === undefined
+		? undefined
+		: await resume_stopped(request, stage.prrun_token, run_prrun_resume)
+}
 
-	if (await run_halfrun_resume.is_pending(issue_number)) return await resume_halfrun(issue_number)
+// **A command whose stopping point the issue has already reached redoes nothing** (joshuafolkken/kit#3042)
+// — the stage line is the whole report. A merged issue is the exception: the ordinary entry already
+// answers it (`already-done`, or `keep-work` over a lane's uncommitted work), so it is left to that.
+function is_settled(decision: StageDecision): boolean {
+	return decision.is_reached && decision.state !== run_stage.MERGED
+}
 
-	const hold = await claim_hold(issue_number)
+async function claim_run({ issue_number, command }: EntryRequest): Promise<number> {
+	const hold = await claim_hold(issue_number, command)
 
 	if (hold !== run_hold_cli.HOLD_VERDICT) {
-		return stop_report(issue_number, hold, run_entry.COST_SKIPPED, HOLD_STOP_NOTE)
+		const parts = { issue_number, hold, cost: run_entry.COST_SKIPPED, report: HOLD_STOP_NOTE }
+
+		return await stop_run({ parts, command, reason: HOLD_REASON, should_release: false })
 	}
 
 	const cost = await check_cost()
 
-	if (cost === run_entry.COST_OVER) return stop_report(issue_number, hold, cost, COST_STOP_NOTE)
+	if (cost === run_entry.COST_OVER) {
+		const parts = { issue_number, hold, cost, report: COST_STOP_NOTE }
+
+		return await stop_run({ parts, command, reason: BUDGET_REASON, should_release: true })
+	}
 
 	const reads = await gather_reads(issue_number)
 
 	return emit({ issue_number, hold, cost, verdict: reads.verdict, report: reads.report })
 }
 
+// A carried cut is asked first, before anything is read (`run:cut --resume`); `kickoff` claims and cuts
+// nothing, so it never asks. `undefined` when no cut is waiting.
+async function resume_cut(request: EntryRequest): Promise<number | undefined> {
+	if (request.command === run_stage.KICKOFF) return undefined
+
+	const resume = await ask_resume(request.issue_number)
+
+	return resume.token === run_cut_report.FRESH_VERDICT
+		? undefined
+		: resume_report(request.issue_number, resume)
+}
+
+// `kickoff` stops at the stage line whatever it says — it plans, and claims nothing.
+async function open_run(request: EntryRequest): Promise<number> {
+	const { issue_number, command } = request
+	const cut = await resume_cut(request)
+
+	if (cut !== undefined) return cut
+
+	const stage = await run_stage_read.read_stage(issue_number)
+	const decision = run_stage.decide(stage.state, command)
+
+	console.info(run_stage.format_decision(issue_number, decision))
+
+	if (command === run_stage.KICKOFF || is_settled(decision)) return SUCCESS_EXIT_CODE
+
+	return (await resume_any(request, decision, stage)) ?? (await claim_run(request))
+}
+
 async function run(argv: ReadonlyArray<string>): Promise<number> {
-	const issue_number = parse_number(argv)
+	const request = parse_request(argv)
 
-	if (issue_number === undefined) {
+	if (request === undefined) {
 		console.error(USAGE)
 
 		return FAILURE_EXIT_CODE
 	}
 
-	return await open_run(issue_number)
+	return await open_run(request)
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {
@@ -188,12 +300,8 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 
 const run_entry_cli = {
 	HALFRUN_RESUME_TOKEN,
-	SUCCESS_EXIT_CODE,
-	USAGE,
-	check_cost,
-	claim_hold,
-	main,
 	parse_number,
+	parse_request,
 	run,
 }
 

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

@@ -0,0 +1,104 @@
+import { josh_command } from '#scripts/josh/josh-run'
+import { telegram_notify } from '#scripts/notify/telegram-notify'
+import { lane_park } from '#scripts/rules/lane-park'
+
+// What `run:entry` does on the way out of a stop it decided itself (joshuafolkken/kit#3099).
+//
+// **The stop's chores used to be the agent's to remember, and the `Stop` hook was what reminded it.**
+// `fullrun.md` step 3 asked the agent, on an `over` budget, to send the `confirmation` Telegram and then
+// run `pnpm josh run:release` — two calls after a command had already decided the run was over. Across
+// eleven measured sessions the hook sent a reply back five times for exactly those two calls, each one a
+// further turn re-reading the whole context. The command that decides the stop knows everything the
+// chores need, so it does them, and the hook stays a safety net that a normal run never trips.
+//
+// **The release is the claim's own undo, and only where this call made the claim.** A resume over a
+// stopped `halfrun` / `prrun` stops on the budget before adopting anything, and the hold there is the
+// stopped run's — kept on purpose over its verified diff — so that stop notifies and releases nothing.
+// A `busy` / `unknown` hold is another run's, or none at all, so it is never released here either.
+//
+// **A dispatched lane child sends no Telegram from here.** Its stop must park the Issue before it
+// notifies, and `lane_park`'s guard delivers that rule at the `josh notify` call — a Telegram sent from
+// inside this command would pass that guard by and satisfy the `Stop` hook with no park behind it.
+
+interface StopNotice {
+	issue_number: string
+	command: string
+	reason: string
+	should_release: boolean
+}
+
+interface StopPorts {
+	notify: (input: { issue_title: string; body: string; recovery: string }) => Promise<boolean>
+	release: (issue_number: string) => Promise<boolean>
+	is_parking_child: () => boolean
+}
+
+const RECOVERY = 'If this did not arrive, the run:entry output in the session names the stop.'
+const NOTIFY_FAILED_NOTE =
+	'(the confirmation Telegram could not be sent — send it with `pnpm josh notify --task-type confirmation` before stopping)'
+const RELEASED_NOTE = '(hold released by run:entry — the tree is free for the resume)'
+const RELEASE_FAILED_NOTE =
+	'(the hold could not be released — run `pnpm josh run:release` before stopping)'
+const should_forward_stderr = true
+const SUCCESS_EXIT_CODE = 0
+
+const BUDGET_REASON = 'the session budget is spent'
+const HOLD_REASON = 'the working tree is not held for this run — see the run:entry output'
+
+async function release(issue_number: string): Promise<boolean> {
+	const released = await josh_command.josh_run(['run:release', issue_number], should_forward_stderr)
+
+	return released.code === SUCCESS_EXIT_CODE
+}
+
+function is_parking_child(): boolean {
+	return lane_park.is_parking_child()
+}
+
+const DEFAULT_PORTS: StopPorts = { notify: telegram_notify.confirm, release, is_parking_child }
+
+function body_of(notice: StopNotice): string {
+	return `${notice.command} #${notice.issue_number} stopped at entry: ${notice.reason}.\nResume with \`${notice.command} #${notice.issue_number}\`.`
+}
+
+// The release runs first, so the resume the Telegram names finds the tree free when a person acts on it.
+// The marker line is printed only for a Telegram that went out: the `Stop` hook reads it as the notify,
+// and a failed send has to leave the hook still asking for one. The released note, likewise, is printed
+// only for a release that succeeded, so a failed one leaves the agent still asked to release.
+async function release_claim(notice: StopNotice, ports: StopPorts): Promise<void> {
+	if (!notice.should_release) return
+
+	const is_released = await ports.release(notice.issue_number)
+
+	console.info(is_released ? RELEASED_NOTE : RELEASE_FAILED_NOTE)
+}
+
+async function notify_stop(notice: StopNotice, ports: StopPorts): Promise<void> {
+	if (ports.is_parking_child()) return
+
+	const is_sent = await ports.notify({
+		issue_title: `${notice.command} #${notice.issue_number} stopped`,
+		body: body_of(notice),
+		recovery: RECOVERY,
+	})
+
+	console.info(is_sent ? lane_park.COMMAND_NOTIFY_MARKER : NOTIFY_FAILED_NOTE)
+}
+
+async function stop(notice: StopNotice, ports: StopPorts = DEFAULT_PORTS): Promise<void> {
+	await release_claim(notice, ports)
+	await notify_stop(notice, ports)
+}
+
+const run_entry_stop = {
+	BUDGET_REASON,
+	HOLD_REASON,
+	NOTIFY_FAILED_NOTE,
+	RELEASED_NOTE,
+	RELEASE_FAILED_NOTE,
+	body_of,
+	stop,
+}
+
+export { run_entry_stop }
+export type { StopNotice, StopPorts }

package/scripts/run/run-entry.ts

@@ -84,7 +84,6 @@ const run_entry = {
 	COST_SKIPPED,
 	COST_UNDER,
 	NO_VERDICT,
-	SUMMARY_PREFIX,
 	exit_code,
 	format_report,
 	can_proceed,

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

@@ -193,8 +193,6 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 }
 
 const run_event_cli = {
-	USAGE,
-	main,
 	run,
 	watch_start,
 }

package/scripts/run/run-event-follow.ts

@@ -52,6 +52,7 @@ async function follow(
 	let read = ports.read(position)
 
 	while (read.events.length === 0 && ports.now() < deadline) {
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await ports.sleep(options.tick_ms)
 		read = ports.read(position)
 	}

package/scripts/run/run-event-render.ts

@@ -69,7 +69,7 @@ function render(event: RunEvent, lang: string): string {
 	return [clock_of(event.at), label_of(event.kind, lang), event.text].join(FIELD_SEPARATOR)
 }
 
-const run_event_render = { KIND_LABELS, clock_of, label_of, render }
+const run_event_render = { clock_of, label_of, render }
 
 export type { KindLabel }
 export { run_event_render }

package/scripts/run/run-event-scope.ts

@@ -91,6 +91,22 @@ const SHIP_POSITION_KINDS: ReadonlySet<string> = new Set([
 	run_event_stream.EVENT_KIND.SHIP_STOP,
 ])
 
+const KIND = run_event_stream.EVENT_KIND
+
+// The parent's record of the batch around a child — its dispatch, park and split, the retrospective
+// whose summary may name an issue it filed, and the strand whose text carries the whole invocation
+// (`backlogrun #<N1> #<N2> …`). Each can name the child, yet none is a position the child itself is at,
+// so a lane child never reads one as its own.
+const BATCH_RECORD_KINDS: ReadonlySet<string> = new Set([
+	KIND.CHILD_LAUNCH,
+	KIND.PARK,
+	KIND.SPLIT,
+	KIND.RETROSPECTIVE,
+	KIND.STRANDED,
+])
+
+const ISSUE_REFERENCE = /#(\d+)/u
+
 function is_foreign_ship_event(event: RunEvent, issue: string): boolean {
 	return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`#${issue} `)
 }
@@ -99,16 +115,49 @@ function is_own_ship_event(event: RunEvent, issue: string): boolean {
 	return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue)
 }
 
+// **A lane child's position is read only from events that name its own issue** (joshuafolkken/kit#3039).
+// The parent and every lane append to one stream under one carry scope, so anything else on it is another
+// run's: another lane's merge told a planned child to stop, the parent's stall (which names no issue)
+// pointed it at `backlog:next`, and another lane's cut at `run:cut --resume`. The child's own merge and
+// outage stay, so the parent-only stop in `run-step.ts` still holds; the parent keeps reading everything.
+function names_issue(event: RunEvent, issue: string): boolean {
+	return ISSUE_REFERENCE.exec(event.text)?.[1] === issue
+}
+
+function is_lane_position(event: RunEvent, issue: string): boolean {
+	return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue)
+}
+
+// A lane child's attempt begins at its own newest launch. A child re-dispatched after an outage — or
+// relaunched after a cut, whose resume `run:cut --resume` answers at the entry — shares the scope with
+// its previous attempt, and that attempt's outage would otherwise stop the new one at its entry `run:step`.
+function since_own_launch(events: ReadonlyArray<RunEvent>, issue: string): ReadonlyArray<RunEvent> {
+	const launch = events.findLastIndex(
+		(event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue),
+	)
+
+	return events.slice(launch + 1)
+}
+
+function is_foreign_event(event: RunEvent, issue: string, is_lane_child: boolean): boolean {
+	if (is_lane_child) return !is_lane_position(event, issue)
+
+	return is_foreign_ship_event(event, issue)
+}
+
 // The newest position for one issue's run: the scoped last event with other issues' ship positions left
-// out, and — where no scope applies, as in an interactive `fullrun` with no carry record — the issue's own
-// newest ship position, which its issue number already scopes. A determined scope with nothing in it yet
-// reads nothing: an earlier invocation's stop for the same issue is not this invocation's position.
+// out — and, for a lane child, every event not naming its issue — and, where no scope applies, as in
+// an interactive `fullrun` with no carry record, the issue's own newest ship position, which its issue
+// number already scopes. A determined scope with nothing in it yet reads nothing: an earlier invocation's
+// stop for the same issue is not this invocation's position.
 function last_issue_event(
 	events: ReadonlyArray<RunEvent>,
 	scope: EventScope,
 	issue: string,
+	is_lane_child: boolean,
 ): RunEvent | undefined {
-	const own = events.filter((event) => !is_foreign_ship_event(event, issue))
+	const attempt = is_lane_child ? since_own_launch(events, issue) : events
+	const own = attempt.filter((event) => !is_foreign_event(event, issue, is_lane_child))
 
 	if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope)
 

package/scripts/run/run-event-stream-emit.ts

@@ -1,3 +1,4 @@
+import { error_text } from '#scripts/lib/error-message'
 import { run_carry } from './run-carry'
 import { run_event_scope } from './run-event-scope'
 import { run_event_stream, type RunEvent } from './run-event-stream'
@@ -62,8 +63,10 @@ async function emit_once(kind: string, text: string): Promise<boolean> {
 		if (target === undefined || run_event_stream.read_last(target)?.kind === kind) return false
 
 		return run_event_stream.append(target, kind, text, now_iso()).appended
-	} catch {
+	} catch (error) {
 		// Best-effort: a failed append is dropped rather than raised into the loop's work.
+		error_text.trace_swallowed('run_event_stream_emit.emit_once', error)
+
 		return false
 	}
 }
@@ -98,8 +101,10 @@ async function emit_once_since(kind: string, text: string, reset_kind: string):
 		}
 
 		return run_event_stream.append(target, kind, text, now_iso()).appended
-	} catch {
+	} catch (error) {
 		// Best-effort: a failed append is dropped rather than raised into the caller's work.
+		error_text.trace_swallowed('run_event_stream_emit.emit_once_since', error)
+
 		return false
 	}
 }

package/scripts/run/run-event-stream.ts

@@ -238,13 +238,10 @@ const run_event_stream = {
 	EVENT_CAP,
 	EVENT_KIND,
 	EVENT_KINDS,
-	EVENT_PREFIX,
-	EVENT_SUFFIX,
 	TRACE_KINDS,
 	append,
 	format_event,
 	has_since,
-	is_event_kind,
 	read_events,
 	read_from,
 	read_last,

package/scripts/run/run-event-watch.ts

@@ -22,6 +22,7 @@ async function watch(ports: WatchPorts, position: number): Promise<number> {
 	let next = position
 
 	while (ports.should_continue()) {
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		const read = await ports.pass(next)
 
 		for (const event of read.events) ports.write(ports.render(event))

package/scripts/run/run-halfrun-resume.ts

@@ -1,4 +1,4 @@
-import { run_hold, type HoldRead, type RunHold } from './run-hold'
+import { run_hold, type HoldRead, type RunHold, type StopMarkFields } from './run-hold'
 
 // joshuafolkken/kit#2796: a `halfrun` stops before its commit and **keeps** its hold, because the
 // uncommitted, hand-verified work is exactly what a second run would trample. The person then types
@@ -38,7 +38,13 @@ function is_own_record(read: HoldRead, issue: string): boolean {
 	return hold === undefined || hold.issue === issue || hold.issue === run_hold.UNNUMBERED_ISSUE
 }
 
-function mark_stop_at(target: string, issue: string): StopMark {
+// `mark` is the `halfrun` stop's by default; a `prrun` stop passes its own (joshuafolkken/kit#3023), so
+// the own-record check is one check whichever run is stopping.
+function mark_stop_at(
+	target: string,
+	issue: string,
+	mark: StopMarkFields = run_hold.HALFRUN_STOP_FIELDS,
+): StopMark {
 	const read = run_hold.read_hold(target)
 
 	if (read.kind === 'unreadable') return UNREADABLE
@@ -47,7 +53,14 @@ function mark_stop_at(target: string, issue: string): StopMark {
 
 	run_hold.release_hold(target)
 
-	return run_hold.create_halfrun_stop_hold(target, issue) ? MARKED : FOREIGN
+	return run_hold.create_stop_hold(target, issue, mark) ? MARKED : FOREIGN
+}
+
+// The stopped run's record is replaced by this `fullrun`'s, shared with the `prrun` resume.
+function take_over(target: string, issue: string): boolean {
+	run_hold.release_hold(target)
+
+	return run_hold.create_hold(target, issue, new Date(), true)
 }
 
 // `false` leaves the record untouched, so the ordinary claim that follows decides the tree exactly as
@@ -55,9 +68,7 @@ function mark_stop_at(target: string, issue: string): StopMark {
 function adopt_at(target: string, issue: string, is_dirty: boolean): boolean {
 	if (!is_halfrun_stop(run_hold.read_hold(target), issue, is_dirty)) return false
 
-	run_hold.release_hold(target)
-
-	return run_hold.create_hold(target, issue, new Date(), true)
+	return take_over(target, issue)
 }
 
 // **An unreadable git directory is no resume**, never a crash: `run:entry` must still print its one
@@ -95,9 +106,11 @@ const run_halfrun_resume = {
 	UNREADABLE,
 	adopt,
 	adopt_at,
-	is_halfrun_stop,
+	hold_of,
+	hold_target,
 	is_pending,
 	mark_stop_at,
+	take_over,
 }
 
 export type { StopMark }

package/scripts/run/run-headless.ts

@@ -1,7 +1,7 @@
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { lane_reap } from '#scripts/lane/lane-reap'
+import { lane_registry } from '#scripts/lane/lane-registry'
 import { run_carry, type CarryRead, type RunCarry } from './run-carry'
-import { run_watcher_guard } from './run-watcher-guard'
 
 // The headless `backlogrun` parent (joshuafolkken/kit#2437). `run:wake` starts a cut's successor as
 // `claude -p`, and there a turn that ends is the process that ends: its background `lane:await` and
@@ -51,7 +51,7 @@ async function read_carry_here(): Promise<CarryRead | undefined> {
 async function must_keep_waiting(source: EnvironmentSource = process.env): Promise<boolean> {
 	const is_candidate = is_headless(source) && lane_child_marker.marked_issue(source) === undefined
 
-	if (!is_candidate || !(await run_watcher_guard.has_lanes_in_flight())) return false
+	if (!is_candidate || !(await lane_registry.has_lanes_in_flight())) return false
 
 	return is_driving(await read_carry_here())
 }