@joshuafolkken/kit 1.1514.0 → 1.2114.0

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

@@ -1,11 +1,14 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
-import { git_followup_issue_close } from '#scripts/followup/git-followup-issue-close'
 import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
 import { git_stash } from '#scripts/git/stash/git-stash'
 import { issue_cite } from '#scripts/issue/issue-cite'
-import { NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
+import { has_label_name, NOT_BEFORE_LABEL, RUN_STALLED_LABEL } from '#scripts/issue/issue-labels'
+import { issue_not_before } from '#scripts/issue/issue-not-before'
+import { issue_park } from '#scripts/issue/issue-park'
+import { issue_sample_prime } from '#scripts/issue/issue-sample-prime'
+import { issue_state_cli } from '#scripts/issue/issue-state-cli'
 import { session_cite } from '#scripts/issue/session-cite'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { lane_close } from '#scripts/lane/lane-close'
@@ -15,6 +18,7 @@ import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
 import { lane_relaunch } from '#scripts/lane/lane-relaunch'
 import { lane_vacant } from '#scripts/lane/lane-vacant'
 import { poll } from '#scripts/lib/poll'
+import { settled_together } from '#scripts/lib/settled-together'
 import {
 	run_carry,
 	type CarryChange,
@@ -23,9 +27,11 @@ import {
 } from '#scripts/run/carry/run-carry'
 import { run_carry_conversation } from '#scripts/run/carry/run-carry-conversation'
 import { run_cut, type RunCut } from '#scripts/run/cut/run-cut'
+import type { StallCause } from '#scripts/run/park/run-stalled'
 import { run_label } from '#scripts/run/run-label'
-import { run_merge } from './run-merge'
-import { run_merge_ship } from './run-merge-ship'
+import { run_merge, type EndingSignals } from './run-merge'
+import { run_merge_cap } from './run-merge-cap'
+import { run_merge_close } from './run-merge-close'
 
 // The result of attempting to apply a carry change. Distinguishing `refused` from `applied` lets
 // callers surface the refusal as a hard failure rather than silently continuing on a carry that was
@@ -48,33 +54,27 @@ const LANES = '--lanes'
 const REPO_FLAG = '--repo'
 const LANE_CLOSE_OCCASION = 'lane close'
 const GIT_ENTRY = '.git'
-const MERGE_CLOSER = 'pnpm josh run:merge'
-const SINGLE_READ = { attempts: 1, interval_ms: 0 }
 const OPEN_STATE = 'OPEN'
 const SYNC_RETRY = { attempts: 3, interval_ms: 5000 }
-// What the driver judged when it parks a child, stated on the issue.
-const FAILED_CAUSE = 'the child’s session ended with its issue still open and unfinished.'
-const CUT_RELAUNCH_CAUSE =
-	'its lane held a declared cut, but no successor could be relaunched from it (or it already was once).'
 
-// One returned child's context, gathered from the command line by the CLI.
-interface MergeContext {
+// One returned child's context, gathered from the command line by the CLI, and the ending signals its
+// handlers act on — each one's meaning is `EndingSignals`'s.
+interface MergeContext extends Pick<
+	EndingSignals,
+	'merged_pr' | 'is_streak_exempt' | 'capped_note' | 'resume_ms'
+> {
 	child: string
 	epic: string | undefined
 	repo: string | undefined
-	// The hand-off threshold, or `undefined` where no AI session owns the loop — the supervisor's
-	// `backlog:drive` has no context to cut, so a merge there is never handed back as `over`.
-	over: number | undefined
+	// `true` where the merge asks the session's `pnpm josh cost --cut` verdict, or `undefined` where no
+	// AI session owns the loop — the supervisor's `backlog:drive` has no context to cut, so a merge
+	// there is never handed back as `over`.
+	over: true | undefined
 	owner: CarryOwner
 	// The child's transcript output path, when the caller passed `--output`. Read to tell an API-outage
 	// ending apart from a genuine child failure; absent leaves outage detection off, so the child is
 	// classified from its GitHub state alone.
 	output?: string | undefined
-	// The merged pull request that closes the child, when GitHub left the child OPEN after the merge —
-	// the one `merged` child whose issue this command still has to close.
-	merged_pr?: string | undefined
-	// The outage is a ship stop no relaunch answered: re-dispatched, but not added to the streak.
-	is_unanswered?: boolean | undefined
 }
 
 interface FailedResult {
@@ -83,12 +83,16 @@ interface FailedResult {
 	// Set when the carry record refused the count because this session is not its owner. The caller
 	// surfaces this as a hard failure rather than continuing.
 	is_refused: boolean
-	// The open `blocked-by` blockers the child was released to wait on, cited — empty for a child that
-	// was parked (or refused) instead.
-	blockers: ReadonlyArray<string>
+	// What the child was released to wait on — its open `blocked-by` blockers, cited, and a start date
+	// still ahead — empty for a child that was parked (or refused) instead.
+	waits: ReadonlyArray<string>
+	// The short name of why a parked child was parked, which its park event carries.
+	cause?: string | undefined
 }
 
-const NO_BLOCKERS: ReadonlyArray<string> = []
+const NO_WAITS: ReadonlyArray<string> = []
+// The wait a `not-before` label alone records: the label carries no date, only that one is ahead.
+const NOT_BEFORE_WAIT = 'a start date still ahead (`not-before`)'
 
 // A captured `pnpm josh` subprocess: its output is read back rather than inherited, and a non-zero
 // exit is a value to branch on rather than a throw. The step's stderr stays piped here — `run:merge`
@@ -167,8 +171,17 @@ async function sync_main(): Promise<void> {
 	if (!is_synced) throw new Error(`main:sync failed: ${error_output}`)
 }
 
+// `lane:close` says on stderr what it terminated — the child and whatever else ran from the checkout
+// (joshuafolkken/kit#4304) — so that stderr is passed on rather than dropped with the capture. An
+// `incomplete` close — a process that outlived even a SIGKILL — is logged and the run carries on: the
+// merge cannot be undone, and the supervisor closes the lane again each pass until it ends
+// (joshuafolkken/kit#4300).
 async function close_lane(child: string): Promise<void> {
-	await josh(['lane:close', child])
+	const result = await josh(['lane:close', child])
+	const said = result.err?.trimEnd() ?? ''
+
+	if (said !== '') console.error(said)
+	if (result.code !== 0) console.error(`${session_cite.issue(child)}: lane:close is incomplete`)
 }
 
 async function stash_work(child: string, directory: string): Promise<void> {
@@ -200,26 +213,38 @@ async function preserve_uncommitted(child: string): Promise<boolean> {
 	}
 }
 
+async function close_preserved_lane(child: string): Promise<void> {
+	if (await preserve_uncommitted(child)) await close_lane(child)
+}
+
 function kept_lane_comment(directory: string): string {
 	return `The split left this issue's lane open: it still holds a commit, an uncommitted change or a live process — ${directory}`
 }
 
-// A child promoted to an epic by a split leaves its lane holding a seat: the epic root is never
-// dispatched again, so nothing else would ever close it. The lane is closed only when it holds
-// nothing — no commit, no change, no live process (`lane_vacant`); any other lane is kept, and why is
-// stated on the issue.
-async function close_split_lane(child: string): Promise<void> {
+// A child that ended without a merge closes its lane only when the lane holds nothing — no commit, no
+// change, no live process (`lane_vacant`); any other lane is kept for whoever resumes the issue.
+// Returns the kept lane, `undefined` where there was none or it was closed. joshuafolkken/kit#4028:
+// three children that ended doing nothing left lanes that filled the limit.
+async function close_vacant_lane(child: string): Promise<LaneInfo | undefined> {
 	const lane = await lane_registry.find_open_lane(child)
 
-	if (lane === undefined) return
+	if (lane === undefined) return undefined
 
-	if (await lane_vacant.is_vacant(lane)) {
-		await close_lane(child)
+	if (!(await lane_vacant.is_vacant(lane))) return lane
 
-		return
-	}
+	await close_lane(child)
 
-	await git_gh_issue_write.issue_try_comment(child, kept_lane_comment(lane.directory))
+	return undefined
+}
+
+// A child promoted to an epic by a split leaves its lane holding a seat: the epic root is never
+// dispatched again, so nothing else would ever close it. A lane it keeps is stated on the issue.
+async function close_split_lane(child: string): Promise<void> {
+	const kept = await close_vacant_lane(child)
+
+	if (kept !== undefined) {
+		await git_gh_issue_write.issue_try_comment(child, kept_lane_comment(kept.directory))
+	}
 }
 
 // The progress comment is a human-readable mirror of the carry record, so it is best-effort and only
@@ -230,50 +255,59 @@ async function post_counters(ctx: MergeContext, carry: RunCarry | undefined): Pr
 	await git_gh_issue_write.issue_try_comment(ctx.epic, run_merge.counters_comment(carry))
 }
 
-// A child merged while GitHub left it OPEN is closed here, through the one close `followup` uses
-// The state was just read OPEN, so it is read once rather than waited on. A
-// close that fails is reported with its recovery and does not undo the merge being counted.
-async function close_merged_open(ctx: MergeContext): Promise<void> {
-	if (ctx.merged_pr === undefined) return
-
-	try {
-		await git_followup_issue_close.ensure_issue_closed(
-			{ issue_number: ctx.child, pr_url: ctx.merged_pr, closer: MERGE_CLOSER },
-			SINGLE_READ,
-		)
-	} catch {
-		console.error(
-			`${session_cite.issue(ctx.child)}: could not be closed — ${git_followup_issue_close.CLOSE_RECOVERY}`,
-		)
-	}
+// Count the merge, which resets the failure streak.
+async function count_merged(ctx: MergeContext): Promise<ApplyCarryResult> {
+	return await apply_carry(ctx, {
+		...run_merge.change_of('merged'),
+		merged_issue: Number(ctx.child),
+	})
 }
 
-// A merged child: count the merge (which resets the failure streak), return to the default branch,
-// stash any uncommitted work the lane still holds and close it, and mirror the counters onto the epic. Returns the carry when the ownership check
-// fails — the caller treats a non-undefined return as a hard refusal and must not offer a next child.
-// Returns `undefined` on success.
-async function do_merged(ctx: MergeContext): Promise<RunCarry | undefined> {
+// A merged child: closed if GitHub left it OPEN, with the epics it completed (`run-merge-close.ts`),
+// while the primary checkout returns to the default branch; then counted and put on record by `record`,
+// dated to the moment the ownership check passed (joshuafolkken/kit#4734); then the lane — stashed of
+// any uncommitted work — is closed while the counters are mirrored onto the epic. **A failed sync
+// leaves neither the count nor the record**, so the run's next pass (a restored drive, `run:carry
+// --end`) still reads the child as unsettled and collects it again. **What the next offer reads ends
+// before this returns**: the closed issue and epics, the count, the lane's freed seat, and the default
+// branch whose code the next `josh` runs. Returns the carry when the ownership check fails — the caller
+// treats a non-undefined return as a hard refusal and must not offer a next child. Returns `undefined`
+// on success.
+async function do_merged(
+	ctx: MergeContext,
+	record: (child: string, at: Date) => Promise<void>,
+): Promise<RunCarry | undefined> {
 	const refused = await refused_carry(ctx)
 
 	if (refused !== undefined) return refused
 
-	await close_merged_open(ctx)
-	await sync_main()
-	const result = await apply_carry(ctx, {
-		...run_merge.change_of('merged'),
-		merged_issue: Number(ctx.child),
-	})
+	const confirmed_at = new Date()
+
+	await settled_together(run_merge_close.close_merged(ctx), sync_main())
+	const result = await count_merged(ctx)
 
 	if (result.kind === 'refused') return result.carry
 
-	if (await preserve_uncommitted(ctx.child)) await close_lane(ctx.child)
-	await post_counters(ctx, result.kind === 'applied' ? result.carry : undefined)
+	await record(ctx.child, confirmed_at)
+
+	const carry = result.kind === 'applied' ? result.carry : undefined
+
+	await Promise.all([close_preserved_lane(ctx.child), post_counters(ctx, carry)])
 
 	return undefined
 }
 
+// A child that ended without a merge: end whatever of its process still runs, drop its stale
+// `in-progress`, and close its lane if the child left nothing in it. The reap comes first, so the lane
+// reads with no live process.
+async function release_child(child: string): Promise<void> {
+	lane_reap.reap_child(await lane_registry.lane_location(child))
+	await run_label.unmark(child)
+	await close_vacant_lane(child)
+}
+
 function refused_result(carry: RunCarry): FailedResult {
-	return { carry, is_parked: false, is_refused: true, blockers: NO_BLOCKERS }
+	return { carry, is_parked: false, is_refused: true, waits: NO_WAITS }
 }
 
 // The child's open `blocked-by` blockers, cited. A read that fails answers none, so the child is
@@ -286,66 +320,87 @@ async function open_blockers(child: string): Promise<ReadonlyArray<string>> {
 			.filter((blocker) => blocker.state === OPEN_STATE)
 			.map((blocker) => issue_cite.plain(blocker.number, blocker.repo))
 	} catch {
-		return NO_BLOCKERS
+		return NO_WAITS
 	}
 }
 
-// A child that ended unfinished while an open blocker it records still has to land first is waiting,
-// not failed: nothing is counted and `needs-decision` is not applied — the
-// order is already recorded, so there is nothing for a person to decide — and its stale `in-progress`
-// is dropped so the offer hands it back on its own once the blockers merge. The ownership guard is
-// still asked, so a session that does not own the run cannot release a child it never dispatched.
-async function do_waiting(
-	ctx: MergeContext,
-	blockers: ReadonlyArray<string>,
-): Promise<FailedResult> {
+// Whether the child carries `not-before` — the body's start date copied to a label. Read only where the
+// body could not be: the body is the source, so a label it no longer backs is never a wait.
+async function has_not_before_label(ctx: MergeContext): Promise<boolean> {
+	const read = await issue_state_cli.read_issue(ctx.child, ctx.repo)
+
+	return read.kind === 'state' && has_label_name(read.state.labels, NOT_BEFORE_LABEL)
+}
+
+// The child's declared start date while it is still ahead (joshuafolkken/kit#4076), or its `not-before`
+// label when the body could not be read (joshuafolkken/kit#4102), or the samples it still waits on. A
+// due date or none answers none, so the child is parked as before.
+async function start_date_wait(ctx: MergeContext): Promise<ReadonlyArray<string>> {
+	const body = await git_gh_command.issue_get_body(ctx.child, ctx.repo)
+
+	if (body === undefined) return (await has_not_before_label(ctx)) ? [NOT_BEFORE_WAIT] : NO_WAITS
+
+	await issue_sample_prime.prime([body])
+	const reason = issue_not_before.waiting_reason(body)
+
+	return reason === undefined ? NO_WAITS : [reason]
+}
+
+// A child that ended unfinished while an open blocker it records still has to land first, or while
+// its declared start date is still ahead, is waiting, not failed: nothing is counted and
+// `needs-decision` is not applied — when it runs is already recorded, so there is nothing for a person
+// to decide — and its stale `in-progress` is dropped so the offer hands it back on its own once the
+// blockers merge and the date arrives. The ownership guard is still asked, so a session that does not
+// own the run cannot release a child it never dispatched.
+async function do_waiting(ctx: MergeContext, waits: ReadonlyArray<string>): Promise<FailedResult> {
 	const refused = await refused_carry(ctx)
 
 	if (refused !== undefined) return refused_result(refused)
 
-	lane_reap.reap_child(ctx.child)
-	await run_label.unmark(ctx.child)
-	await git_gh_issue_write.issue_try_comment(ctx.child, run_merge.waiting_comment(blockers))
+	await release_child(ctx.child)
+	await git_gh_issue_write.issue_try_comment(ctx.child, run_merge.waiting_comment(waits))
 
-	return { carry: undefined, is_parked: false, is_refused: false, blockers }
+	return { carry: undefined, is_parked: false, is_refused: false, waits }
 }
 
 // A failed child: count the failure, end whatever of its process is still running (a child judged
 // abandoned that hung on a wait loop would otherwise answer the pgrep liveness check `alive` for its
-// issue number forever), drop the stale `in-progress`, and park it with `needs-decision` so the next
-// offer does not hand the same child straight back. Returns the record so the caller can read the
-// streak against the guard. Returns `is_refused: true` without touching labels when the carry record
+// issue number forever), drop the stale `in-progress`, and park it with `run:stalled` so the next
+// offer does not hand the same child straight back. Not `needs-decision`: the failure is mechanical,
+// and nothing is asked of a person but to fix its cause (joshuafolkken/kit#4102). Returns the record
+// so the caller can read the streak against the guard. Returns `is_refused: true` without touching labels when the carry record
 // rejected the count. A park is always explained on the issue — `cause` says what was judged, and the
 // comment what was read and what a person does next.
-async function park_failed(ctx: MergeContext, cause: string): Promise<FailedResult> {
+async function park_failed(ctx: MergeContext, cause: StallCause): Promise<FailedResult> {
 	const result = await apply_carry(ctx, run_merge.change_of('failed'))
 
 	if (result.kind === 'refused') return refused_result(result.carry)
 
 	const carry = result.kind === 'applied' ? result.carry : undefined
 
-	lane_reap.reap_child(ctx.child)
-	await run_label.unmark(ctx.child)
-	const is_parked = await git_gh_issue_write.issue_add_label(ctx.child, NEEDS_DECISION_LABEL)
+	await release_child(ctx.child)
+	const reason = { child: ctx.child, cause: cause.why, carry, output: ctx.output }
+	const park = await issue_park.apply(ctx.child, RUN_STALLED_LABEL, run_merge.park_comment(reason))
 
-	if (is_parked) {
-		const reason = { child: ctx.child, cause, carry, output: ctx.output }
-
-		await git_gh_issue_write.issue_try_comment(ctx.child, run_merge.park_comment(reason))
+	return {
+		carry,
+		is_parked: park.is_labelled,
+		is_refused: false,
+		waits: NO_WAITS,
+		cause: cause.short,
 	}
-
-	return { carry, is_parked, is_refused: false, blockers: NO_BLOCKERS }
 }
 
-// A child that ended unfinished: waiting when it records an open blocker (`do_waiting`), parked
-// otherwise (`park_failed`) — an order already recorded is never a decision for a person. Without a
-// cause of the caller's, a child whose detached ship ended is parked for the ship's stop.
-async function do_failed(ctx: MergeContext, cause?: string): Promise<FailedResult> {
-	const blockers = await open_blockers(ctx.child)
+// A child that ended unfinished: waiting when it records an open blocker or a start date still ahead
+// (`do_waiting`), parked otherwise (`park_failed`) — a recorded order or date is never a decision for a
+// person. Without a cause of the caller's, a child whose detached ship ended is parked for the ship's
+// stop.
+async function do_failed(ctx: MergeContext, cause?: StallCause): Promise<FailedResult> {
+	const waits = [...(await open_blockers(ctx.child)), ...(await start_date_wait(ctx))]
 
-	if (blockers.length > 0) return await do_waiting(ctx, blockers)
+	if (waits.length > 0) return await do_waiting(ctx, waits)
 
-	return await park_failed(ctx, cause ?? run_merge_ship.cause(ctx.child) ?? FAILED_CAUSE)
+	return await park_failed(ctx, run_merge_cap.park_cause(ctx.child, cause, ctx.capped_note))
 }
 
 // The outcome of counting an outage: the record to read the streak against, and whether the count was
@@ -362,7 +417,7 @@ interface OutageResult {
 // outage streak against its guard. Returns `is_refused: true` without touching labels when the carry
 // record rejected the count.
 async function count_outage(ctx: MergeContext): Promise<ApplyCarryResult> {
-	if (ctx.is_unanswered !== true) return await apply_carry(ctx, run_merge.change_of('outage'))
+	if (ctx.is_streak_exempt !== true) return await apply_carry(ctx, run_merge.change_of('outage'))
 
 	const refused = await refused_carry(ctx)
 
@@ -374,8 +429,7 @@ async function do_outage(ctx: MergeContext): Promise<OutageResult> {
 
 	if (result.kind === 'refused') return { carry: result.carry, is_refused: true }
 
-	lane_reap.reap_child(ctx.child)
-	await run_label.unmark(ctx.child)
+	await release_child(ctx.child)
 
 	return { carry: result.kind === 'applied' ? result.carry : undefined, is_refused: false }
 }
@@ -428,11 +482,12 @@ async function resume_cut(child: string): Promise<boolean> {
 }
 
 // The hand-off check, asked at a merge alone. A subprocess that cannot measure exits non-zero, which
-// is read as `over` — "could not measure" is never "still cheap". No threshold is no session to measure.
-async function is_over_budget(over: number | undefined): Promise<boolean> {
+// is read as `over` — "could not measure" is never "still cheap". No check is no session to measure.
+// `--cut`, not a number: the threshold is priced at the session's own model.
+async function is_over_budget(over: true | undefined): Promise<boolean> {
 	if (over === undefined) return false
 
-	const result = await josh(['cost', '--over', String(over)])
+	const result = await josh(['cost', '--cut'])
 
 	return result.code !== 0 || result.out === OVER
 }
@@ -452,9 +507,9 @@ async function ask_next(ctx: MergeContext): Promise<string> {
 }
 
 const run_merge_steps = {
-	CUT_RELAUNCH_CAUSE,
 	ask_next,
 	close_split_lane,
+	release_child,
 	do_failed,
 	do_merged,
 	do_outage,

package/scripts/run/merge/run-merge-usage-limit.ts

@@ -0,0 +1,53 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+
+// A returned child a Claude usage limit stopped (joshuafolkken/kit#4745). Nothing is counted and no park
+// label is put on it — the limit is the account's, not the child's — so it is released for the backlog
+// to offer again, and the stop is written to the event stream with the time the limit resets.
+// `backlog:drive` reads that time back and launches nothing before it. **It is no `OUTAGE`**: the
+// per-child cap counts those (`run-merge-cap.ts`), and a wait for a known reset is no outage streak.
+// Script-emitted, so English.
+
+const KIND = run_event_stream.EVENT_KIND.USAGE_LIMIT
+const RESUMES_AT = /resumes at (\S+)$/u
+
+function stop_text(child: string, reset_ms: number): string {
+	return `${issue_cite.plain(child)} usage limit — resumes at ${new Date(reset_ms).toISOString()}`
+}
+
+async function record(child: string, reset_ms: number): Promise<void> {
+	await run_event_stream_emit.emit(KIND, stop_text(child, reset_ms))
+}
+
+// The time a stop's text names, or `undefined` when it does not parse.
+function time_of(text: string): number | undefined {
+	const parsed = Date.parse(RESUMES_AT.exec(text)?.[1] ?? '')
+
+	return Number.isNaN(parsed) ? undefined : parsed
+}
+
+// The reset the newest usage-limit stop names, in epoch milliseconds, or `undefined` when the stream
+// holds none — every lane shares the one account, so the newest stop is the limit in force.
+function resume_ms(events: ReadonlyArray<RunEvent>): number | undefined {
+	const newest = events.findLast((event) => event.kind === KIND)
+
+	return newest === undefined ? undefined : time_of(newest.text)
+}
+
+// The reset a usage limit still holds launches until at `now_ms`, or `undefined` once it has passed —
+// what `run:board` names a waiting row's hold by (joshuafolkken/kit#4796).
+function held_until(events: ReadonlyArray<RunEvent>, now_ms: number): number | undefined {
+	const reset_ms = resume_ms(events)
+
+	return reset_ms !== undefined && reset_ms > now_ms ? reset_ms : undefined
+}
+
+// Whether a usage limit still holds launches at `now_ms` — the production `usage_limited` port.
+async function is_held(now_ms: number): Promise<boolean> {
+	return held_until(await run_event_stream_emit.current_events(), now_ms) !== undefined
+}
+
+const run_merge_usage_limit = { held_until, is_held, record, resume_ms }
+
+export { run_merge_usage_limit }

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

@@ -0,0 +1,53 @@
+import { lane_registry } from '#scripts/lane/lane-registry'
+import { lane_withdraw_closed } from '#scripts/lane/lane-withdraw-closed'
+import { lane_yield } from '#scripts/lane/lane-yield'
+import { run_event_scope } from '#scripts/run/event/run-event-scope'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+
+// The lane of a child `run:merge` booked `withdrawn` (joshuafolkken/kit#4916). A person's
+// `lane:withdraw` already stopped the child, closed its lane and put itself on the stream, so nothing is
+// left to do. A child whose issue closed without a merge had no such withdrawal: its lane is still open,
+// so it is withdrawn here through the `run:wake` sweep's guarded path — kept where its branch has
+// commits on no remote, else stopped, its work stashed, the lane closed and the withdrawal put on the
+// stream — and never booked as a merge. A withdrawal that could not read the child stopped and closed
+// nothing, so it asks for a retry rather than leak the lane.
+
+const UNMERGED_REASON = 'its issue was closed without a merged pull request'
+
+interface Collected {
+	// The withdrawal's note, or `undefined` where a withdrawal is on the stream or no lane is open.
+	note: string | undefined
+	is_retry: boolean
+}
+
+const NOTHING_LEFT: Collected = { note: undefined, is_retry: false }
+
+/** Withdraw `#<child>`'s open lane unless a withdrawal that closed it is already on the stream. */
+async function collect(child: string): Promise<Collected> {
+	const events = await run_event_stream_emit.current_events()
+
+	if (run_event_scope.is_withdrawn(events, child)) return NOTHING_LEFT
+	const lane = await lane_registry.find_open_lane(child)
+
+	return lane === undefined
+		? NOTHING_LEFT
+		: await lane_withdraw_closed.withdraw_lane(lane, UNMERGED_REASON, 'merge')
+}
+
+/**
+ * Close the open lane of `#<child>`, which gave it back (`lane-yield.ts`): the child noted its yield
+ * from inside the lane, which it could not close, so the lane is closed here, named as the yield. A
+ * lane already closed — a second `run:merge` — leaves nothing to do.
+ */
+async function collect_yield(child: string): Promise<Collected> {
+	const lane = await lane_registry.find_open_lane(child)
+
+	return lane === undefined
+		? NOTHING_LEFT
+		: await lane_withdraw_closed.withdraw_lane(lane, lane_yield.YIELD_REASON, 'yield')
+}
+
+const run_merge_withdrawn = { UNMERGED_REASON, collect, collect_yield }
+
+export type { Collected }
+export { run_merge_withdrawn }