@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/scripts/lane/lane-session-action.ts

@@ -0,0 +1,146 @@
+import { agent_argv } from '#scripts/agent/agent-argv'
+import { agent_role_profile, type AgentProvider } from '#scripts/agent/agent-role-profile'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { error_text } from '#scripts/lib/error-message'
+import { detached_launch, type AttachedLaunchResult } from '#scripts/run/detached-launch'
+import { run_ship_review } from '#scripts/run/ship/run-ship-review'
+import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
+import { run_ship_stop_context } from '#scripts/run/ship/run-ship-stop-context'
+import { z } from 'zod'
+import { lane_child_invocation, type ShipStop } from './lane-child-invocation'
+import { lane_child_marker } from './lane-child-marker'
+import { lane_parked } from './lane-parked'
+import type { LaneInfo } from './lane-registry'
+import { lane_relaunch } from './lane-relaunch'
+
+// The actions a lane's session broker performs for the ship that asked (`lane-session-broker.ts`):
+// starting the round-1 or round-2 reviewer, or relaunching the lane's child after a stopped ship.
+// **A failure names its reason**: a bare `false` left every relaunch a stale supervisor refused
+// unexplained in the ship log (joshuafolkken/kit#3974).
+
+const BRIEF_PREFIX = 'josh-ship-review-brief-'
+const FINDINGS_PREFIX = 'josh-ship-review-findings-'
+const LOG_PREFIX = 'josh-ship-review-log-'
+const ANTHROPIC_PROVIDER: AgentProvider = 'anthropic'
+const stop_schema = z
+	.object({
+		stage: z.enum(run_ship_stage.STAGE),
+		title: z.string(),
+		flags: z.array(z.string()).readonly(),
+		is_review: z.boolean(),
+		conflicts: z.array(z.string()).readonly().default([]),
+		context: run_ship_stop_context.stop_context_schema.exactOptional(),
+	})
+	.strict()
+const action_schema = z.discriminatedUnion('kind', [
+	z.object({ kind: z.literal('review'), round: z.enum(['1', '2']) }).strict(),
+	z.object({ kind: z.literal('relaunch'), stop: stop_schema }).strict(),
+])
+type ReviewRound = Extract<z.infer<typeof action_schema>, { kind: 'review' }>['round']
+type BrokerAction = { kind: 'review'; round: ReviewRound } | { kind: 'relaunch'; stop: ShipStop }
+type BrokerAnswer = { is_success: true } | { is_success: false; reason: string }
+
+const SUCCESS: BrokerAnswer = { is_success: true }
+
+function failure(reason: string): BrokerAnswer {
+	return { is_success: false, reason }
+}
+
+function review_paths(directory: string): { brief: string; findings: string; log: string } {
+	return {
+		brief: stamp_file.stamp_path(BRIEF_PREFIX, directory, '.md'),
+		findings: stamp_file.stamp_path(FINDINGS_PREFIX, directory, '.txt'),
+		log: stamp_file.stamp_path(LOG_PREFIX, directory, '.log'),
+	}
+}
+
+// The reviewer runs on the lane's own provider, so a Claude lane's server never starts a Codex reviewer
+// and an OpenAI lane's never starts a Claude one.
+function provider_of(lane: LaneInfo): AgentProvider {
+	return lane.profile?.provider ?? ANTHROPIC_PROVIDER
+}
+
+// **The reviewer carries the lane's mark explicitly**: the supervisor serving a Claude lane is no lane child,
+// so a reviewer inheriting its environment would descend from the carry record's owner unmarked and be
+// read as the `backlogrun` parent by every hook. **Its prompt ends with the review invocation**, so the
+// lane's liveness read and the park's reap find it as they find the child (joshuafolkken/kit#3878).
+
+function review_prompt(lane: LaneInfo, round: ReviewRound): string {
+	const target = review_paths(lane.directory)
+	const prompt_of =
+		round === '1' ? run_ship_review.reviewer_prompt : run_ship_review.verification_prompt
+	const tail = lane_child_invocation.review_invocation(lane.issue)
+
+	return `${prompt_of(target.brief, target.findings, lane.issue)} This is ${tail}`
+}
+
+function reviewer_answer(result: AttachedLaunchResult): BrokerAnswer {
+	if (result.kind === 'failed') return failure(`the reviewer could not start: ${result.note}`)
+
+	return result.exit_code === 0
+		? SUCCESS
+		: failure(`the reviewer exited with code ${String(result.exit_code)}`)
+}
+
+async function launch_review(lane: LaneInfo, round: ReviewRound): Promise<BrokerAnswer> {
+	const target = review_paths(lane.directory)
+	const built = agent_argv.review_in(review_prompt(lane, round), Number(round), lane.directory)
+	if (built.kind === 'rejected') return failure(`the reviewer profile was rejected: ${built.note}`)
+
+	if (built.profile.provider !== provider_of(lane)) {
+		return failure(`the reviewer resolved to ${built.profile.provider}, not the lane's provider`)
+	}
+
+	console.error(agent_role_profile.describe_review(Number(round), built.profile))
+	const result = await detached_launch.launch_attached(
+		{
+			argv: built.argv,
+			cwd: lane.directory,
+			log_path: target.log,
+			profile: built.profile,
+			env: lane_child_marker.env_for(lane.issue),
+		},
+		console.error,
+	)
+
+	return reviewer_answer(result)
+}
+
+// An OpenAI lane's successor is its supervisor's to start, never a relaunch's.
+function relaunch(lane: LaneInfo, stop: ShipStop): BrokerAnswer {
+	if (lane_relaunch.is_openai_lane(lane)) {
+		return failure('an OpenAI lane is relaunched by its own supervisor')
+	}
+
+	const invocation = lane_child_invocation.ship_stop_invocation(lane.issue, stop)
+	const phase = agent_role_profile.IMPLEMENTATION_PHASE
+	const result = lane_relaunch.relaunch(lane, invocation, phase, console.error)
+
+	return result.kind === 'launched'
+		? SUCCESS
+		: failure(`the relaunch did not start: ${result.note}`)
+}
+
+// **A parked issue gets no session**: a request can be read long after it was written, so the park is
+// read when the action runs, never when it was asked for (joshuafolkken/kit#3878).
+async function perform(lane: LaneInfo, action: BrokerAction): Promise<BrokerAnswer> {
+	if (await lane_parked.is_parked(lane.issue)) return failure('the issue is parked')
+
+	if (action.kind === 'relaunch') return relaunch(lane, action.stop)
+
+	return await launch_review(lane, action.round)
+}
+
+// What the server answers: a thrown action is a failure naming its error, never a dead server.
+async function answer(lane: LaneInfo, action: BrokerAction): Promise<BrokerAnswer> {
+	try {
+		return await perform(lane, action)
+	} catch (error) {
+		return failure(`the broker failed: ${error_text.message_of(error)}`)
+	}
+}
+
+const lane_session_action = { SUCCESS, action_schema, answer, failure, review_paths }
+
+export type { BrokerAction, BrokerAnswer, ReviewRound }
+export { lane_session_action }

package/scripts/lane/lane-session-broker.ts

@@ -1,22 +1,14 @@
 import { randomUUID } from 'node:crypto'
-import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
+import { mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { setTimeout as sleep } from 'node:timers/promises'
-import { agent_argv } from '#scripts/agent/agent-argv'
-import { agent_role_profile, type AgentProvider } from '#scripts/agent/agent-role-profile'
 import { git_common_directory } from '#scripts/git/git-common-directory'
 import { stamp_file } from '#scripts/josh/stamp-file'
-import { error_text } from '#scripts/lib/error-message'
 import { json_value } from '#scripts/lib/json-value'
-import { detached_launch } from '#scripts/run/detached-launch'
-import { run_ship_review } from '#scripts/run/ship/run-ship-review'
-import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
 import { z } from 'zod'
 import { lane_broker_server, type BrokerServer } from './lane-broker-server'
-import { lane_child_invocation, type ShipStop } from './lane-child-invocation'
-import { lane_child_marker } from './lane-child-marker'
 import type { LaneInfo } from './lane-registry'
-import { lane_relaunch } from './lane-relaunch'
+import { lane_session_action, type BrokerAction, type BrokerAnswer } from './lane-session-action'
 
 // The sessions a lane child's detached `josh ship` cannot start itself, started for it by a process
 // that can: the round-1 and round-2 reviewer, and the fresh child a stopped ship hands back to. An
@@ -24,13 +16,11 @@ import { lane_relaunch } from './lane-relaunch'
 // Claude lane is served by the `run:wake` supervisor (`claude-lane-broker.ts`), because Claude Code removes its
 // token from what its Bash tool starts, so a token-only credential never reaches the ship the child
 // launched (joshuafolkken/kit#3817). **The request names an action, never a command**: the server
-// rebuilds the argv from the registered lane, so a child can ask for nothing but these two sessions.
+// rebuilds the argv from the registered lane, so a child can ask for nothing but these two sessions
+// (`lane-session-action.ts`).
 
 const REQUEST_PREFIX = '.josh-review-request-'
 const RESPONSE_PREFIX = '.josh-review-response-'
-const BRIEF_PREFIX = 'josh-ship-review-brief-'
-const FINDINGS_PREFIX = 'josh-ship-review-findings-'
-const LOG_PREFIX = 'josh-ship-review-log-'
 const CACHE_DIRECTORY = ['node_modules', '.cache']
 const POLL_MS = 100
 // The heartbeat is kept for a ship branched before the server record, and read only where a
@@ -40,22 +30,8 @@ const LEGACY_HEARTBEAT_LIMIT_MS = 3000
 const MINUTE_MS = 60_000
 const REQUEST_LIMIT_MINUTES = 30
 const REQUEST_LIMIT_MS = REQUEST_LIMIT_MINUTES * MINUTE_MS
-const ANTHROPIC_PROVIDER: AgentProvider = 'anthropic'
-const stop_schema = z
-	.object({
-		stage: z.enum(run_ship_stage.STAGE),
-		title: z.string(),
-		flags: z.array(z.string()).readonly(),
-		is_review: z.boolean(),
-		conflicts: z.array(z.string()).readonly().default([]),
-	})
-	.strict()
-const action_schema = z.discriminatedUnion('kind', [
-	z.object({ kind: z.literal('review'), round: z.enum(['1', '2']) }).strict(),
-	z.object({ kind: z.literal('relaunch'), stop: stop_schema }).strict(),
-])
 const request_schema = z
-	.object({ session: z.uuid(), nonce: z.uuid(), action: action_schema })
+	.object({ session: z.uuid(), nonce: z.uuid(), action: lane_session_action.action_schema })
 	.strict()
 const response_schema = z
 	.object({
@@ -65,18 +41,13 @@ const response_schema = z
 		heartbeat_at: z.number().int().positive(),
 	})
 	.strict()
+// **A failure's reason sits beside the response, never in it**: a ship branched before the reason parses
+// the response strictly, so a new field would read as no server (joshuafolkken/kit#3974).
+const reason_schema = z.object({ nonce: z.string(), reason: z.string() }).strict()
 type BrokerRequest = z.infer<typeof request_schema>
 type BrokerResponse = z.infer<typeof response_schema>
-type ReviewRound = Extract<z.infer<typeof action_schema>, { kind: 'review' }>['round']
-type BrokerAction = { kind: 'review'; round: ReviewRound } | { kind: 'relaunch'; stop: ShipStop }
-
-function review_paths(directory: string): { brief: string; findings: string; log: string } {
-	return {
-		brief: stamp_file.stamp_path(BRIEF_PREFIX, directory, '.md'),
-		findings: stamp_file.stamp_path(FINDINGS_PREFIX, directory, '.txt'),
-		log: stamp_file.stamp_path(LOG_PREFIX, directory, '.log'),
-	}
-}
+
+const { failure } = lane_session_action
 
 function request_path(directory: string, issue: string): string {
 	return path.join(directory, ...CACHE_DIRECTORY, `${REQUEST_PREFIX}${issue}.json`)
@@ -89,6 +60,10 @@ function response_path(directory: string, issue: string): string | undefined {
 	return path.join(path.dirname(common), ...CACHE_DIRECTORY, `${RESPONSE_PREFIX}${issue}.json`)
 }
 
+function reason_path(response: string): string {
+	return `${response}.reason`
+}
+
 function read_record<T>(target: string, schema: z.ZodType<T>): T | undefined {
 	try {
 		return json_value.parse_with(readFileSync(target, 'utf8'), schema)
@@ -97,90 +72,25 @@ function read_record<T>(target: string, schema: z.ZodType<T>): T | undefined {
 	}
 }
 
-// The reviewer runs on the lane's own provider, so a Claude lane's server never starts a Codex reviewer
-// and an OpenAI lane's never starts a Claude one.
-function provider_of(lane: LaneInfo): AgentProvider {
-	return lane.profile?.provider ?? ANTHROPIC_PROVIDER
-}
-
-// **The reviewer carries the lane's mark explicitly**: the supervisor serving a Claude lane is no lane child,
-// so a reviewer inheriting its environment would descend from the carry record's owner unmarked and be
-// read as the `backlogrun` parent by every hook.
-
-async function launch_review(lane: LaneInfo, round: ReviewRound): Promise<boolean> {
-	const target = review_paths(lane.directory)
-	const prompt_of =
-		round === '1' ? run_ship_review.reviewer_prompt : run_ship_review.verification_prompt
-	const built = agent_argv.resolve_in(
-		prompt_of(target.brief, target.findings),
-		agent_role_profile.REVIEWER,
-		lane.directory,
-	)
-	if (built.kind === 'rejected' || built.profile.provider !== provider_of(lane)) return false
-
-	const result = await detached_launch.launch_attached(
-		{
-			argv: built.argv,
-			cwd: lane.directory,
-			log_path: target.log,
-			profile: built.profile,
-			env: lane_child_marker.env_for(lane.issue),
-		},
-		console.error,
-	)
-
-	return result.kind === 'completed' && result.exit_code === 0
-}
-
-// An OpenAI lane's successor is its supervisor's to start, never a relaunch's.
-function relaunch(lane: LaneInfo, stop: ShipStop): boolean {
-	if (lane_relaunch.is_openai_lane(lane)) return false
-
-	const invocation = lane_child_invocation.ship_stop_invocation(lane.issue, stop)
-	const phase = agent_role_profile.IMPLEMENTATION_PHASE
-	const result = lane_relaunch.relaunch(lane, invocation, phase, console.error)
-
-	return result.kind === 'launched'
-}
-
-async function perform(lane: LaneInfo, action: BrokerAction): Promise<boolean> {
-	if (action.kind === 'relaunch') return relaunch(lane, action.stop)
-
-	return await launch_review(lane, action.round)
-}
-
-function write_response(target: string, body: BrokerResponse): void {
+function write_record(target: string, body: BrokerResponse | z.infer<typeof reason_schema>): void {
 	const temporary = `${target}.${String(process.pid)}.tmp`
 
 	writeFileSync(temporary, JSON.stringify(body))
 	renameSync(temporary, target)
 }
 
-async function launched(lane: LaneInfo, action: BrokerAction): Promise<boolean> {
-	try {
-		return await perform(lane, action)
-	} catch (error) {
-		error_text.trace_swallowed('lane_session_broker.launched', error)
-
-		return false
-	}
-}
-
 async function process_request(
 	lane: LaneInfo,
 	response: string,
 	received: BrokerRequest,
 	state: { current: BrokerResponse },
 ): Promise<void> {
-	const is_success = await launched(lane, received.action)
+	const answer = await lane_session_action.answer(lane, received.action)
+	const { session, nonce } = received
 
-	state.current = {
-		session: received.session,
-		nonce: received.nonce,
-		is_success,
-		heartbeat_at: Date.now(),
-	}
-	write_response(response, state.current)
+	if (!answer.is_success) write_record(reason_path(response), { nonce, reason: answer.reason })
+	state.current = { session, nonce, is_success: answer.is_success, heartbeat_at: Date.now() }
+	write_record(response, state.current)
 }
 
 async function serve(
@@ -223,7 +133,7 @@ function prepare(lane: LaneInfo): { response: string; current: BrokerResponse }
 		heartbeat_at: Date.now(),
 	}
 
-	write_response(response, current)
+	write_record(response, current)
 
 	return { response, current }
 }
@@ -231,7 +141,7 @@ function prepare(lane: LaneInfo): { response: string; current: BrokerResponse }
 function start_heartbeat(state: { current: BrokerResponse }, response: string): NodeJS.Timeout {
 	const heartbeat = setInterval(() => {
 		state.current = { ...state.current, heartbeat_at: Date.now() }
-		write_response(response, state.current)
+		write_record(response, state.current)
 	}, LEGACY_HEARTBEAT_MS)
 
 	heartbeat.unref()
@@ -251,6 +161,7 @@ async function stop_server(
 	await serving
 	clearInterval(heartbeat)
 	unlinkSync(response)
+	rmSync(reason_path(response), { force: true })
 	lane_broker_server.remove(response)
 }
 
@@ -293,31 +204,47 @@ function session_response(target: string, session: string): BrokerResponse | und
 	return response?.session === session ? response : undefined
 }
 
+// A failure from a server that predates the reason leaves none.
+function answer_of(target: string, response: BrokerResponse): BrokerAnswer {
+	if (response.is_success) return lane_session_action.SUCCESS
+
+	const record = read_record(reason_path(target), reason_schema)
+	const reason = record?.nonce === response.nonce ? record.reason : 'it gave no reason'
+
+	return failure(`the broker answered a failure: ${reason}`)
+}
+
+// The server's answer to this request, or `undefined` while it is still being served.
 function response_verdict(
 	target: string,
 	session: string,
 	nonce: string,
-): 'wait' | 'success' | 'failure' {
+): BrokerAnswer | undefined {
 	const response = session_response(target, session)
 
-	if (!is_live_response(target, response, lane_broker_server.is_running)) return 'failure'
-	if (response.nonce !== nonce) return 'wait'
+	if (!is_live_response(target, response, lane_broker_server.is_running)) {
+		return failure('the broker stopped serving before it answered')
+	}
 
-	return response.is_success ? 'success' : 'failure'
+	return response.nonce === nonce ? answer_of(target, response) : undefined
 }
 
-async function wait_response(target: string, session: string, nonce: string): Promise<boolean> {
+async function wait_response(
+	target: string,
+	session: string,
+	nonce: string,
+): Promise<BrokerAnswer> {
 	const deadline = Date.now() + REQUEST_LIMIT_MS
 
 	while (Date.now() < deadline) {
 		const verdict = response_verdict(target, session, nonce)
-		if (verdict !== 'wait') return verdict === 'success'
+		if (verdict !== undefined) return verdict
 
 		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await sleep(POLL_MS)
 	}
 
-	return false
+	return failure(`the broker gave no answer within ${String(REQUEST_LIMIT_MINUTES)} minutes`)
 }
 
 function live_response(target: string): BrokerResponse | undefined {
@@ -336,18 +263,33 @@ function is_serving(directory: string, issue: string): boolean {
 	return target !== undefined && live_response(target) !== undefined
 }
 
-async function request(directory: string, issue: string, action: BrokerAction): Promise<boolean> {
+// **A request nobody waits for any more is taken back**: a server busy with an earlier request reads the
+// file only once it is free, and a relaunch the ship had already given up on then started a session in a
+// lane the run had parked in the meantime (joshuafolkken/kit#3878). A newer request is left alone.
+function withdraw(pending: string, nonce: string): void {
+	if (read_record(pending, request_schema)?.nonce === nonce) stamp_file.remove_stamp(pending)
+}
+
+async function request(
+	directory: string,
+	issue: string,
+	action: BrokerAction,
+): Promise<BrokerAnswer> {
 	const target = response_path(directory, issue)
 	const response = target === undefined ? undefined : live_response(target)
 
-	if (target === undefined || response === undefined) return false
+	if (target === undefined || response === undefined) return failure('no broker serves this lane')
 
 	const nonce = randomUUID()
 	const body = { session: response.session, nonce, action }
+	const pending = request_path(directory, issue)
 
-	stamp_file.replace_stamp(request_path(directory, issue), body)
+	stamp_file.replace_stamp(pending, body)
+	const answer = await wait_response(target, response.session, nonce)
 
-	return await wait_response(target, response.session, nonce)
+	withdraw(pending, nonce)
+
+	return answer
 }
 
 const lane_session_broker = {
@@ -355,9 +297,10 @@ const lane_session_broker = {
 	request,
 	request_path,
 	response_path,
-	review_paths,
+	review_paths: lane_session_action.review_paths,
 	with_server,
 }
 
-export type { BrokerAction, ReviewRound }
 export { lane_session_broker }
+
+export { type ReviewRound, type BrokerAction, type BrokerAnswer } from './lane-session-action'

package/scripts/lane/lane-spent.ts

@@ -178,10 +178,13 @@ function issues_traced(traced: ReadonlyArray<TracedLane>, trace: ProcessTrace):
 	return traced.filter(([, answer]) => answer === trace).map(([issue]) => issue)
 }
 
+function traced_of(lanes: ReadonlyArray<LaneInfo>, probes: SpentProbes): Array<TracedLane> {
+	return lanes.map((lane): TracedLane => [lane.issue, trace_of(lane, probes)])
+}
+
 /** The lanes in use — what a run being replaced must not be stopped over. */
 async function lanes_in_use(probes: SpentProbes = LIVE_PROBES): Promise<LaneUse> {
-	const lanes = await lane_registry.list_lanes()
-	const traced = lanes.map((lane): TracedLane => [lane.issue, trace_of(lane, probes)])
+	const traced = traced_of(await lane_registry.list_lanes(), probes)
 
 	return {
 		working: issues_traced(traced, PROCESS_ALIVE),
@@ -189,7 +192,15 @@ async function lanes_in_use(probes: SpentProbes = LIVE_PROBES): Promise<LaneUse>
 	}
 }
 
-const lane_spent = { kept_reason, lanes_in_use, sort_lanes }
+/** The lanes no child is working in, read as such — never one whose probe did not answer. */
+function idle_lanes(
+	lanes: ReadonlyArray<LaneInfo>,
+	probes: SpentProbes = LIVE_PROBES,
+): Array<string> {
+	return issues_traced(traced_of(lanes, probes), PROCESS_NONE)
+}
+
+const lane_spent = { idle_lanes, kept_reason, lanes_in_use, sort_lanes }
 
 export type { KeptLane, LaneUse, SpentProbes, SpentSort }
 export { lane_spent }

package/scripts/lane/lane-stats.ts

@@ -258,6 +258,7 @@ const lane_stats = {
 	MISSING,
 	header,
 	in_window,
+	mean,
 	median,
 	peak,
 	row,

package/scripts/lane/lane-withdraw-cli.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { cli_flags } from '#scripts/lib/cli-flags'
+import { lane_withdraw, type WithdrawOutcome } from './lane-withdraw'
+
+// `josh lane:withdraw <issue> --reason <text>` — every explanation on standard error, and a withdrawal
+// that did not end with the Issue closed exits non-zero, so a caller never takes a half-done one as done.
+
+const ARGV_OFFSET = 2
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+const USAGE = 'Usage: josh lane:withdraw <issue-number> --reason <text>'
+const OPTIONS = { reason: { type: 'string' } } as const
+
+interface Request {
+	issue: string
+	reason: string
+}
+
+function issue_of(positionals: ReadonlyArray<string>): string | undefined {
+	const [issue, ...rest] = positionals
+
+	return rest.length === 0 && issue_number_shape.is_issue_number(issue ?? '') ? issue : undefined
+}
+
+// A reason of only whitespace is no reason: the Issue would close with an empty `Why:` line.
+function reason_of(value: unknown): string | undefined {
+	const reason = cli_flags.string_of(value)?.trim()
+
+	return reason === '' ? undefined : reason
+}
+
+function parse_request(argv: ReadonlyArray<string>): Request | undefined {
+	const parsed = cli_flags.arguments_of(argv, OPTIONS)
+	if (parsed === undefined) return undefined
+	const issue = issue_of(parsed.positionals)
+	const reason = reason_of(parsed.values.reason)
+
+	return issue === undefined || reason === undefined ? undefined : { issue, reason }
+}
+
+function exit_code_of(outcome: WithdrawOutcome): number {
+	return outcome.kind === 'withdrawn' && outcome.is_closed ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	const request = parse_request(argv)
+
+	if (request === undefined) {
+		console.error(USAGE)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	const outcome = await lane_withdraw.withdraw(request.issue, request.reason)
+
+	console.error(lane_withdraw.describe(outcome, request.issue))
+
+	return exit_code_of(outcome)
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const lane_withdraw_cli = { run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { lane_withdraw_cli }