@joshuafolkken/kit 1.1471.0 → 1.1514.0

package/scripts/lane/lane-guard-policy.ts

@@ -45,9 +45,9 @@ interface LaneGuardEntry {
 const LANE_GUARD_POLICY: ReadonlyArray<LaneGuardEntry> = [
 	{
 		id: 'investigation',
-		mode_in_lane_child: 'notice',
+		mode_in_lane_child: 'refuse',
 		because:
-			'a refusal ends a child turn, yet lane children were measured reading files they never edited, so the child is nudged to delegate by a notice rather than killed',
+			'the notice was measured not to move the reading — 52% of lane cost stayed in main-line exploration — and the refusal fires once per accumulation, a round trip the child survives as it survives the rule row, so the child is refused like the main line',
 	},
 	{
 		id: 'batching',

package/scripts/lane/lane-handoff.ts

@@ -24,6 +24,13 @@ function is_ship_running(issue: string, directory: string): boolean {
 	)
 }
 
+// When the detached ship for `issue` that is still live was launched, or `undefined` where none is.
+function ship_running_since(issue: string, directory: string): number | undefined {
+	const repository = git_common_directory.repository(directory)
+
+	return repository === undefined ? undefined : run_ship_detach.running_since(repository, issue)
+}
+
 // This session is the dispatched lane child for `directory` and its own ship is running.
 function is_handed_off(directory: string, source: MarkerSource = process.env): boolean {
 	const issue = lane_child_marker.marked_issue(source)
@@ -33,6 +40,6 @@ function is_handed_off(directory: string, source: MarkerSource = process.env): b
 	return is_ship_running(issue, directory)
 }
 
-const lane_handoff = { is_handed_off, is_ship_running }
+const lane_handoff = { is_handed_off, is_ship_running, ship_running_since }
 
 export { lane_handoff }

package/scripts/lane/lane-install.ts

@@ -1,5 +1,6 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
+import { core_budget } from '#scripts/gate/core-budget'
 import { buffered_process } from '#scripts/lib/buffered-process'
 import { INSTALL_TIMEOUT_MS } from '#scripts/lib/timeouts'
 
@@ -68,10 +69,17 @@ function has_manifest(directory: string): boolean {
 async function install_dependencies(directory: string): Promise<InstallResult> {
 	if (!has_manifest(directory)) return { is_installed: true, output: NO_MANIFEST_OUTPUT }
 
-	const result = await buffered_process.run_buffered_process(INSTALL_ARGUMENTS, {
-		cwd: directory,
-		timeout_ms: INSTALL_TIMEOUT_MS,
-	})
+	// The install claims its place in the core budget (joshuafolkken/kit#3944): a batch opens its lanes
+	// together, and each install ran beside the other lanes' gates off the ledger.
+	const result = await core_budget.with_command_reservation(
+		core_budget.CORE_WEIGHTS.install,
+		async () =>
+			await buffered_process.run_buffered_process(INSTALL_ARGUMENTS, {
+				cwd: directory,
+				timeout_ms: INSTALL_TIMEOUT_MS,
+			}),
+		{ memory_mb: core_budget.MEMORY_MB.install, command: 'lane install' },
+	)
 
 	return { is_installed: !buffered_process.is_process_failed(result), output: result.output }
 }

package/scripts/lane/lane-ledger.ts

@@ -36,9 +36,16 @@ const KIND = {
 	DISPATCH: 'dispatch',
 	STAGE: 'stage',
 	STOP: 'stop',
+	OVERLAP: 'overlap',
 } as const
 
 const merge_schema = z.object({ kind: z.literal(KIND.MERGE), at: z.string(), issue: z.number() })
+const check_schema = z.object({
+	label: z.string(),
+	elapsed_ms: z.number(),
+	is_passed: z.boolean(),
+	is_reused: z.boolean().optional(),
+})
 const gate_schema = z.object({
 	kind: z.literal(KIND.GATE),
 	at: z.string(),
@@ -50,6 +57,9 @@ const gate_schema = z.object({
 	// The whole cores busy outside this gate, beyond the machine's baseline, at its start or its end —
 	// whichever was higher. Absent when the machine could not be read.
 	external_cores: z.number().optional(),
+	// Each check's own duration and verdict, so `josh lane:stats` can name the check a slow gate waited
+	// on. A reused check started no process: its row says so, and its zero is no timing.
+	checks: z.array(check_schema).optional(),
 })
 // `available_mb`, `swapped_mb` and `lanes` are optional because each read can fail on its own — a
 // platform with no memory reading, a `git worktree` call that did not answer — and a sample is still
@@ -98,6 +108,18 @@ const stop_schema = z.object({
 	issue: z.number(),
 	reason: z.string(),
 })
+// A `josh ship` on `issue` whose actual change overlapped the open pull requests of `lanes` on `paths`
+// before its sync: it waited `waited_ms` for their ships to end, and `is_cleared` is false where the
+// wait ran out first (joshuafolkken/kit#3901).
+const overlap_schema = z.object({
+	kind: z.literal(KIND.OVERLAP),
+	at: z.string(),
+	issue: z.number(),
+	lanes: z.array(z.number()),
+	paths: z.array(z.string()),
+	waited_ms: z.number(),
+	is_cleared: z.boolean(),
+})
 const entry_schema = z.discriminatedUnion('kind', [
 	merge_schema,
 	gate_schema,
@@ -105,6 +127,7 @@ const entry_schema = z.discriminatedUnion('kind', [
 	dispatch_schema,
 	stage_schema,
 	stop_schema,
+	overlap_schema,
 ])
 
 type LedgerEntry = z.infer<typeof entry_schema>
@@ -114,10 +137,13 @@ type LoadEntry = z.infer<typeof load_schema>
 type DispatchEntry = z.infer<typeof dispatch_schema>
 type StageEntry = z.infer<typeof stage_schema>
 type StopEntry = z.infer<typeof stop_schema>
+type OverlapEntry = z.infer<typeof overlap_schema>
 // What a finished gate reports; the ledger stamps the kind and the time.
 type GateRecord = Omit<GateEntry, 'kind' | 'at'>
+type GateCheckRecord = z.infer<typeof check_schema>
 type StageRecord = Omit<StageEntry, 'kind' | 'at'>
 type StopRecord = Omit<StopEntry, 'kind' | 'at'>
+type OverlapRecord = Omit<OverlapEntry, 'kind' | 'at'>
 
 function target_of(repository: string): string {
 	return stamp_file.stamp_path(LEDGER_PREFIX, repository, LEDGER_SUFFIX)
@@ -194,6 +220,10 @@ async function record_stop(stop: StopRecord, path?: string): Promise<void> {
 	await record({ kind: KIND.STOP, at: now_iso(), ...stop }, path)
 }
 
+async function record_overlap(overlap: OverlapRecord, path?: string): Promise<void> {
+	await record({ kind: KIND.OVERLAP, at: now_iso(), ...overlap }, path)
+}
+
 function parse_line(line: string): LedgerEntry | undefined {
 	return entry_schema.safeParse(json_value.parse_or_undefined(line)).data
 }
@@ -224,11 +254,23 @@ const lane_ledger = {
 	record_dispatch,
 	record_gate,
 	record_merge,
+	record_overlap,
 	record_stage,
 	record_stop,
 	target,
 	target_of,
 }
 
-export type { DispatchEntry, GateEntry, LedgerEntry, LoadEntry, MergeEntry, StageEntry, StopEntry }
+export type {
+	DispatchEntry,
+	GateCheckRecord,
+	GateEntry,
+	LedgerEntry,
+	LoadEntry,
+	MergeEntry,
+	OverlapEntry,
+	OverlapRecord,
+	StageEntry,
+	StopEntry,
+}
 export { lane_ledger }

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { backlog_ready } from '#scripts/backlog/backlog-ready'
+import { backlog_ready, type LaneUse } from '#scripts/backlog/backlog-ready'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { lane_capacity, type LimitChoice } from './lane-capacity'
 import { lane_limit_override } from './lane-limit-override'
@@ -37,13 +37,13 @@ interface LimitPorts {
 	read_override: () => Promise<number | undefined>
 	write_override: (limit: number | undefined) => Promise<boolean>
 	emit_raise: (text: string) => Promise<void>
-	live_lane_count: () => Promise<number>
+	lane_use: () => Promise<LaneUse>
 }
 
 interface LimitStatus {
 	limit: number
 	override: number | undefined
-	in_use: number
+	use: LaneUse
 }
 
 const SHOW: LimitRequest = { kind: 'show' }
@@ -55,7 +55,7 @@ const DEFAULT_PORTS: LimitPorts = {
 	read_override: lane_limit_override.read_override,
 	write_override: lane_limit_override.write_override,
 	emit_raise: lane_limit_override.emit_raise,
-	live_lane_count: backlog_ready.live_lane_count,
+	lane_use: backlog_ready.lane_use,
 }
 
 function refuse(message: string): number {
@@ -98,9 +98,10 @@ function limit_text(limit: number): string {
 
 function status_line(status: LimitStatus): string {
 	const source = status.override === undefined ? lane_capacity.LANE_LIMIT_KEY : OVERRIDE_SOURCE
-	const free = lane_capacity.free_lanes(status.limit, status.in_use)
+	const { occupied, seated } = status.use
+	const free = lane_capacity.free_lanes(status.limit, occupied, seated)
 
-	return `lane limit ${limit_text(status.limit)} (${source}) · in use ${String(status.in_use)} · free ${String(free)}`
+	return `lane limit ${limit_text(status.limit)} (${source}) · in use ${String(occupied)} · free ${String(free)}`
 }
 
 async function show(ports: LimitPorts): Promise<number> {
@@ -110,9 +111,7 @@ async function show(ports: LimitPorts): Promise<number> {
 
 	const override = await ports.read_override()
 
-	console.info(
-		status_line({ limit: choice.limit, override, in_use: await ports.live_lane_count() }),
-	)
+	console.info(status_line({ limit: choice.limit, override, use: await ports.lane_use() }))
 
 	return SUCCESS_EXIT_CODE
 }

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

@@ -3,6 +3,7 @@ import { setInterval as every } from 'node:timers/promises'
 import { fileURLToPath } from 'node:url'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { lane_capacity } from './lane-capacity'
+import { lane_check_stats } from './lane-check-stats'
 import { lane_ledger } from './lane-ledger'
 import { lane_process_stats } from './lane-process-stats'
 import { lane_sampler, type MeasureContext } from './lane-sampler'
@@ -121,6 +122,7 @@ async function stats_command(
 			lane_stage_stats.table(entries, window),
 			lane_stop_stats.table(entries, window),
 			lane_process_stats.table(entries, window),
+			lane_check_stats.table(entries, window),
 		].join('\n\n'),
 	)
 

package/scripts/lane/lane-preserve.ts

@@ -1,5 +1,6 @@
 import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
 import { git_stash } from '#scripts/git/stash/git-stash'
+import { error_text } from '#scripts/lib/error-message'
 
 // Keeping a lane's uncommitted work before something discards or restarts it — `run:merge` closing a
 // lane, `lane:restart` handing it to a fresh session. The stash stack outlives the tree, so the push is
@@ -30,6 +31,32 @@ async function announce(issue: string, message: string, cause: string): Promise<
 	await git_gh_issue_write.issue_try_comment(issue, preserved_comment(message, cause))
 }
 
+// The tree's work kept before a stopped child's lane is reused or closed: `saved` with the stash, or
+// none for a clean tree, and `unsaved` with the reason when the tree could not be read or pushed — the
+// caller then leaves the tree as it is rather than handing it on or deleting it.
+type KeptWork =
+	| { kind: 'saved'; stash: string | undefined }
+	| { kind: 'unsaved'; directory: string; reason: string }
+
+async function stash_of(
+	issue: string,
+	directory: string,
+	occasion: string,
+): Promise<string | undefined> {
+	if (!(await git_stash.has_changes(directory))) return undefined
+
+	return await push_work(issue, directory, occasion)
+}
+
+/** Stash the tree's uncommitted work, if any, answering `unsaved` rather than throwing. */
+async function keep_work(issue: string, directory: string, occasion: string): Promise<KeptWork> {
+	try {
+		return { kind: 'saved', stash: await stash_of(issue, directory, occasion) }
+	} catch (error) {
+		return { kind: 'unsaved', directory, reason: error_text.message_of(error) }
+	}
+}
+
 /** `push_work`, then `announce` — for a caller with no reason to separate the two. */
 async function stash_work(
 	issue: string,
@@ -44,6 +71,7 @@ async function stash_work(
 	return message
 }
 
-const lane_preserve = { announce, push_work, stash_work }
+const lane_preserve = { announce, keep_work, stash_work }
 
+export type { KeptWork }
 export { lane_preserve }

package/scripts/lane/lane-registry.ts

@@ -1,4 +1,4 @@
-import { existsSync } from 'node:fs'
+import { existsSync, statSync } from 'node:fs'
 import path from 'node:path'
 import { ENV_FILE_NAME } from '#ports'
 import type { AgentProfile } from '#scripts/agent/agent-role-profile'
@@ -38,6 +38,9 @@ interface LaneInfo {
 	// instead of waiting for the pool to drain before it can be cut.
 	output: string | undefined
 	profile?: AgentProfile | undefined
+	// When the lane last took a child: `lane:open` writes its `.env`, and every dispatch records its
+	// unit there (`lane-output.ts`). `undefined` where the `.env` cannot be read.
+	dispatched_ms?: number | undefined
 	is_stranded: boolean
 }
 
@@ -106,6 +109,10 @@ function read_environment(directory: string): string | undefined {
 	return file_reader.read_if_readable(path.join(directory, ENV_FILE_NAME))
 }
 
+function dispatched_at(directory: string): number | undefined {
+	return statSync(path.join(directory, ENV_FILE_NAME), { throwIfNoEntry: false })?.mtimeMs
+}
+
 // A lane is identified by its branch rather than by where it sits, so nothing here compares two
 // spellings of one path — git prints the resolved one, and a lane root reached through a symlink
 // would otherwise read as no lane at all.
@@ -151,6 +158,7 @@ function build_lane(
 		preview_port: held.preview_port,
 		output,
 		profile,
+		dispatched_ms: is_stranded ? undefined : dispatched_at(directory),
 		is_stranded,
 	}
 }
@@ -241,11 +249,6 @@ async function has_lanes_in_flight(): Promise<boolean> {
 	return lanes.some((lane) => !lane.is_stranded)
 }
 
-/** The lanes in use: the open work trees an interruption has not stranded. */
-function live_count(lanes: ReadonlyArray<LaneInfo>): number {
-	return lanes.filter((lane) => !lane.is_stranded).length
-}
-
 /** The seats live lanes hold — what a new lane's seat has to avoid. */
 function used_seats(lanes: ReadonlyArray<LaneInfo>): Array<number> {
 	return lanes.map((lane) => lane.seat).filter((seat): seat is number => seat !== undefined)
@@ -277,7 +280,6 @@ const lane_registry = {
 	find_open_lane,
 	has_lanes_in_flight,
 	list_lanes,
-	live_count,
 	main_repository_root,
 	parse_block,
 	read_environment,

package/scripts/lane/lane-restart.ts

@@ -1,14 +1,12 @@
-import { git_stash } from '#scripts/git/stash/git-stash'
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { IN_PROGRESS_LABEL } from '#scripts/issue/issue-labels'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { session_cite } from '#scripts/issue/session-cite'
-import { error_text } from '#scripts/lib/error-message'
 import { run_cut } from '#scripts/run/cut/run-cut'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { lane_dispatch, type DispatchOutcome } from './lane-dispatch'
-import { lane_preserve } from './lane-preserve'
+import { lane_preserve, type KeptWork } from './lane-preserve'
 import { lane_reap } from './lane-reap'
 import { lane_registry, type LaneInfo } from './lane-registry'
 
@@ -38,11 +36,7 @@ const NO_LANE_KIND = 'no-lane'
 const NOT_RUNNING_KIND = 'not-running'
 const UNCLAIMED_KIND = 'unclaimed'
 
-interface Unsaved {
-	kind: 'unsaved'
-	directory: string
-	reason: string
-}
+type Unsaved = Extract<KeptWork, { kind: 'unsaved' }>
 
 interface Restarted {
 	kind: 'restarted'
@@ -55,7 +49,6 @@ type Refused =
 	| { kind: typeof NOT_RUNNING_KIND }
 	| { kind: typeof UNCLAIMED_KIND; reason: string }
 type RestartOutcome = Restarted | Unsaved | Refused
-type Saved = Unsaved | { kind: 'saved'; stash: string | undefined }
 
 // A cut the stopped child carried would hand its successor the old session's hand-off at
 // `run:cut --resume`; the fresh session has to start from the Issue instead.
@@ -65,22 +58,6 @@ function end_carried_cut(lane: LaneInfo): void {
 	if (carried !== undefined) run_cut.end_cut(carried.target)
 }
 
-async function stash_of(lane: LaneInfo): Promise<string | undefined> {
-	if (!(await git_stash.has_changes(lane.directory))) return undefined
-
-	return await lane_preserve.push_work(lane.issue, lane.directory, RESTART_OCCASION)
-}
-
-// A tree that could not be read or pushed is left as it is: re-dispatching into it would hand the fresh
-// session the stopped one's half-done work as though it were its own.
-async function save_work(lane: LaneInfo): Promise<Saved> {
-	try {
-		return { kind: 'saved', stash: await stash_of(lane) }
-	} catch (error) {
-		return { kind: 'unsaved', directory: lane.directory, reason: error_text.message_of(error) }
-	}
-}
-
 async function record_restart(issue: string): Promise<void> {
 	await run_event_stream_emit.emit(
 		run_event_stream.EVENT_KIND.RESTART,
@@ -88,9 +65,11 @@ async function record_restart(issue: string): Promise<void> {
 	)
 }
 
+// A tree that could not be read or pushed is left as it is: re-dispatching into it would hand the fresh
+// session the stopped one's half-done work as though it were its own.
 async function relaunch(lane: LaneInfo): Promise<RestartOutcome> {
 	end_carried_cut(lane)
-	const saved = await save_work(lane)
+	const saved = await lane_preserve.keep_work(lane.issue, lane.directory, RESTART_OCCASION)
 
 	if (saved.kind === 'unsaved') return saved
 	const dispatch = await lane_dispatch.dispatch_child(lane.issue, 'restart')

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 }