@joshuafolkken/kit 1.1784.0 → 1.2116.0

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

@@ -0,0 +1,41 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { lane_plan_check } from './lane-plan-check'
+
+// `josh lane:plan <issue> <path>... [--probe]` — the command line over `lane-plan-check.ts`, which holds
+// the check and the yield so `run:entry` can import them without this entry's main guard.
+
+const ARGV_OFFSET = 2
+const FAILURE_EXIT_CODE = 1
+const PROBE_FLAG = '--probe'
+const USAGE = 'Usage: josh lane:plan <issue-number> <path> [<path> ...] [--probe]'
+const { YIELD_EXIT_CODE } = lane_plan_check
+
+async function run(
+	argv: ReadonlyArray<string>,
+	directory: string = process.cwd(),
+): Promise<number> {
+	const plan = lane_plan_check.plan_of(
+		argv.filter((token) => token !== PROBE_FLAG),
+		new Date(),
+	)
+	const action = argv.includes(PROBE_FLAG)
+		? lane_plan_check.probe_answer
+		: lane_plan_check.check_plan
+
+	if (plan !== undefined) return await action(lane_plan_check.placed(plan, directory), directory)
+
+	console.error(USAGE)
+
+	return FAILURE_EXIT_CODE
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const lane_plan_cli = { USAGE, YIELD_EXIT_CODE, run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { lane_plan_cli }

package/scripts/lane/lane-plan.ts

@@ -0,0 +1,144 @@
+import { backlog_overlap, type Clash, type Declared } from '#scripts/backlog/backlog-overlap'
+import { git_common_directory } from '#scripts/git/git-common-directory'
+import { durable_state } from '#scripts/josh/durable-state'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { json_value } from '#scripts/lib/json-value'
+import { z } from 'zod'
+
+// The files a lane child plans to edit, recorded by `josh lane:plan` once its work summary settles.
+//
+// **An issue body names the paths its reporter saw, not the ones the change touches.**
+// joshuafolkken/kit#4858 and joshuafolkken/kit#4859 declared disjoint paths, ran side by side, and both
+// edited `scripts/lane/lane-overrun.ts`; the second ship stopped on the conflict (joshuafolkken/kit#4864).
+// The plan is the first moment the touched files are known, so it is recorded here and read as the
+// declaration in place of the body — by `lane:plan` to hold the later lane back, and by `backlog:next`.
+//
+// **Keyed to the repository and the issue, not the work tree**, and kept in the common git directory
+// (`durable-state.ts`): the lane records it from its own work tree and the parent reads it from the main
+// checkout, both resolve the same directory, and a reboot does not drop a running lane's plan.
+// `lane:close` releases it with the lane (`release`).
+
+const lane_plan_schema = z.object({
+	issue: z.number(),
+	paths: z.array(z.string()),
+	planned_at: z.string(),
+	cleared: z.boolean().optional(),
+	// The lane gave its lane back on this plan (`lane-yield.ts`), so the plan outlives the lane.
+	yielded: z.boolean().optional(),
+})
+
+type LanePlan = z.infer<typeof lane_plan_schema>
+
+function plan_path(repository: string, issue: number): string {
+	return durable_state.path(durable_state.PREFIX.LANE_PLAN, repository, `-${String(issue)}.json`)
+}
+
+function record(plan: LanePlan, directory: string): boolean {
+	const repository = git_common_directory.repository(directory)
+
+	if (repository === undefined) return false
+
+	stamp_file.replace_stamp(plan_path(repository, plan.issue), plan)
+
+	return true
+}
+
+function remove(issue: number, directory: string): void {
+	const repository = git_common_directory.repository(directory)
+
+	if (repository !== undefined) stamp_file.remove_stamp(plan_path(repository, issue))
+}
+
+function read(issue: number, directory: string): LanePlan | undefined {
+	const repository = git_common_directory.repository(directory)
+	const text =
+		repository === undefined ? undefined : stamp_file.read_stamp_text(plan_path(repository, issue))
+
+	return text === undefined ? undefined : json_value.parse_with(text, lane_plan_schema)
+}
+
+// Whether `issue` has no plan that `lane:plan` cleared, in a repository that can hold one — a checkout
+// with no common git directory cannot record a plan, so it is never asked for one. A plan recorded but
+// not cleared — a yield, an unread listing — lifts no hold: the record is written before the check.
+function is_uncleared(issue: number, directory: string): boolean {
+	return (
+		git_common_directory.repository(directory) !== undefined &&
+		read(issue, directory)?.cleared !== true
+	)
+}
+
+// What an ended lane does with its plan. A plan the lane yielded on (`lane-yield.ts`,
+// joshuafolkken/kit#4926) stays: `backlog:next` holds the issue back on it while the holder runs, and
+// its next lane keeps the place in line it took. Any other plan goes — cleared, or left by a lane that
+// ended before its check answered — so the issue's next lane plans afresh rather than inheriting the
+// files and the place in line of a run that is over.
+function release(issue: number, directory: string): void {
+	if (read(issue, directory)?.yielded !== true) remove(issue, directory)
+}
+
+// `declared` with each issue's recorded plan, if any, in place of what it declares (joshuafolkken/kit#4937).
+function with_plans(declared: Declared, directory: string): Declared {
+	const replaced = [...declared].map(([issue, paths]): [number, ReadonlySet<string>] => [
+		issue,
+		new Set(read(issue, directory)?.paths ?? paths),
+	])
+
+	return new Map(replaced)
+}
+
+// Whether `other` holds its files ahead of `plan`: it was cleared, or it planned first. A cleared lane
+// may already be editing, so a kept place in line never takes its files from it.
+function goes_before(other: LanePlan, plan: LanePlan): boolean {
+	return other.cleared === true || other.planned_at < plan.planned_at
+}
+
+// The `holders` whose plan goes before `plan` — the only ones it yields to. Of two uncleared plans the
+// earlier goes first, so two lanes that plan the same file never yield to each other.
+function earlier_holders(
+	plan: LanePlan,
+	holders: ReadonlyArray<number>,
+	directory: string,
+): Array<number> {
+	return holders.filter((holder) => {
+		const other = holder === plan.issue ? undefined : read(holder, directory)
+
+		return other !== undefined && goes_before(other, plan)
+	})
+}
+
+// The first file of `plan` that a lane in `declared` — its recorded plan, else its body — holds ahead of
+// it. `lane:plan` yields on it, and a named run holds the yielded issue back on the same answer.
+function clash_of(plan: LanePlan, declared: Declared, directory: string): Clash | undefined {
+	const holders = earlier_holders(plan, [...declared.keys()], directory)
+
+	return backlog_overlap.path_clash(new Set(plan.paths), declared, holders)
+}
+
+function is_yielded(issue: number, directory: string): boolean {
+	return read(issue, directory)?.yielded === true
+}
+
+// Whether `issue` yielded on a plan that a lane in `declared` still holds one of its files ahead of —
+// what a named run holds the issue back on, as `backlog:next` does on the same kept plan
+// (joshuafolkken/kit#4926). Without it the run relaunches the issue at once, and the lane yields again.
+function is_yield_held(issue: number, declared: Declared, directory: string): boolean {
+	const plan = read(issue, directory)
+
+	return plan?.yielded === true && clash_of(plan, declared, directory) !== undefined
+}
+
+const lane_plan = {
+	clash_of,
+	earlier_holders,
+	is_uncleared,
+	is_yield_held,
+	is_yielded,
+	read,
+	record,
+	release,
+	remove,
+	with_plans,
+}
+
+export { lane_plan }
+export type { LanePlan }

package/scripts/lane/lane-registry.ts

@@ -1,4 +1,4 @@
-import { existsSync, statSync } from 'node:fs'
+import { chmodSync, existsSync, statSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { ENV_FILE_NAME } from '#ports'
 import type { AgentProfile } from '#scripts/agent/agent-role-profile'
@@ -20,6 +20,8 @@ import { lane_paths } from './lane-paths'
 // that can go stale. A counter, or a ledger beside the trees, would let a lane that was closed and
 // reopened take a seat a running lane is still using.
 
+const OWNER_ONLY_MODE = 0o600
+
 interface LaneInfo {
 	issue: string
 	branch: string
@@ -109,6 +111,15 @@ function read_environment(directory: string): string | undefined {
 	return file_reader.read_if_readable(path.join(directory, ENV_FILE_NAME))
 }
 
+// The lane's `.env` carries the root's secrets (the Telegram token), so it is readable by its owner
+// alone. `mode` applies only to a file the write creates, so an existing one is narrowed after.
+function write_environment(directory: string, content: string): void {
+	const file = path.join(directory, ENV_FILE_NAME)
+
+	writeFileSync(file, content, { mode: OWNER_ONLY_MODE })
+	chmodSync(file, OWNER_ONLY_MODE)
+}
+
 function dispatched_at(directory: string): number | undefined {
 	return statSync(path.join(directory, ENV_FILE_NAME), { throwIfNoEntry: false })?.mtimeMs
 }
@@ -307,6 +318,8 @@ const lane_registry = {
 	registered_directories,
 	unreadable_lanes,
 	used_seats,
+	write_environment,
+	OWNER_ONLY_MODE,
 }
 
 export type { LaneInfo }

package/scripts/lane/lane-relaunch.ts

@@ -7,7 +7,7 @@ import { lane_dispatch_log } from './lane-dispatch-log'
 import type { LaneInfo } from './lane-registry'
 
 // Relaunching a lane child session into its own lane — a fresh agent process started detached, under
-// the lane's stored profile at the effort of the phase it resumes into, logging to the lane's dispatch
+// the lane's stored profile at the effort (and any model override) of the phase it resumes into, logging to the lane's dispatch
 // log and carrying the dispatch mark afresh. **It was `run:cut`'s alone until a second caller needed it**:
 // the detached `josh ship` supervisor hands a stopped stage back to an agent
 // the same way the pre-gate cut hands the gate to one, so the launch is shared rather than copied — the

package/scripts/lane/lane-round-one-stats.ts

@@ -0,0 +1,51 @@
+import { lane_ledger, type LedgerEntry, type RoundOneEntry } from './lane-ledger'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// How a `josh ship`'s round 1 ended: the ledger's `round-one` entries of one period, one row per
+// verdict, with each reviewed verdict's share of the rounds the ship ran. The `clean` share is the rate
+// a ship-time round 1 passed with no fix — the number the "CI beside the review" break-even of
+// `docs/maintainers/lane-limit-measurement.md` is read against (joshuafolkken/kit#4620). A `reused`
+// round never ran, so it has a count and no share.
+
+const COLUMNS = ['round 1', 'rounds', 'share'] as const
+const VERDICTS = ['clean', 'fixed', 'blocking'] as const
+const { ROUND_ONE_REUSED: REUSED } = lane_ledger
+const NO_SHARE = '-'
+const PERCENT = 100
+
+function is_round_one(entry: LedgerEntry): entry is RoundOneEntry {
+	return entry.kind === lane_ledger.KIND.ROUND_ONE
+}
+
+function count_of(rounds: ReadonlyArray<RoundOneEntry>, verdict: string): number {
+	return rounds.filter((round) => round.verdict === verdict).length
+}
+
+function share_of(count: number, ran: number): string {
+	if (ran === 0) return NO_SHARE
+
+	return `${String(Math.round((count * PERCENT) / ran))}%`
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const rounds = lane_stats.in_window(entries, window).filter(is_round_one)
+	const counts = VERDICTS.map((verdict) => count_of(rounds, verdict))
+	const ran = counts.reduce((sum, count) => sum + count, 0)
+	const rows = VERDICTS.map((verdict, index) => {
+		const count = counts[index] ?? 0
+
+		return lane_stats.to_row([verdict, String(count), share_of(count, ran)])
+	})
+
+	return [
+		lane_stats.to_row(COLUMNS),
+		lane_stats.to_row(COLUMNS.map(() => '---')),
+		...rows,
+		lane_stats.to_row([REUSED, String(count_of(rounds, REUSED)), NO_SHARE]),
+	].join('\n')
+}
+
+const lane_round_one_stats = { table }
+
+export { lane_round_one_stats }

package/scripts/lane/lane-sampler.ts

@@ -1,5 +1,7 @@
-import { lane_ledger } from './lane-ledger'
+import { lane_ledger_write } from './lane-ledger-write'
 import { lane_load } from './lane-load'
+import type { LaneSpan } from './lane-net-time'
+import { lane_sleep } from './lane-sleep'
 
 // The machine-load sampler: one `load` entry appended to the lane ledger, once or on a timer.
 //
@@ -14,7 +16,8 @@ const SAMPLE_INTERVAL_MS = 60_000
 // Where the ledger is and what "now" is, overridable so a test reads a fixed ledger at a fixed instant.
 interface MeasureContext {
 	ledger_path?: string
-	// The run's event stream `lane:stats` reads parks from; absent, the repository's own.
+	// The run's event stream `lane:stats` reads parks from and a sleep is recorded on; absent, the
+	// repository's own.
 	events_path?: string
 	// The lane transcript directories `lane:stats` reads tool calls from; absent, this repository's lanes'.
 	transcript_directories?: ReadonlyArray<string>
@@ -24,7 +27,7 @@ interface MeasureContext {
 async function take(context: MeasureContext = {}): Promise<void> {
 	const at = new Date(context.now_ms ?? Date.now()).toISOString()
 
-	await lane_ledger.record(await lane_load.sample(at), context.ledger_path)
+	await lane_ledger_write.record(await lane_load.sample(at), context.ledger_path)
 }
 
 // A timer tick has no caller to raise into, and a sample that could not be read must never end the run
@@ -37,10 +40,26 @@ async function take_quietly(context: MeasureContext): Promise<void> {
 	}
 }
 
-/** Sample now and then every minute; the returned function stops it. */
+// A sleep that could not be recorded is a gap in the measurement, the same as an unread sample.
+async function record_quietly(span: LaneSpan, context: MeasureContext): Promise<void> {
+	try {
+		await lane_sleep.record(span, context.events_path)
+	} catch {
+		// Best-effort: an unrecorded sleep counts as lane time, never as a failure of the run.
+	}
+}
+
+/** Sample now and then every minute, recording a tick the host slept through; the returned function stops it. */
 function start(context: MeasureContext = {}): () => void {
+	let last_ms = Date.now()
+
 	void take_quietly(context)
 	const timer = setInterval(() => {
+		const now_ms = Date.now()
+		const slept = lane_sleep.gap_of(last_ms, now_ms, SAMPLE_INTERVAL_MS)
+
+		last_ms = now_ms
+		if (slept !== undefined) void record_quietly(slept, context)
 		void take_quietly(context)
 	}, SAMPLE_INTERVAL_MS).unref()
 

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

@@ -1,8 +1,12 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
 import { agent_argv } from '#scripts/agent/agent-argv'
 import { agent_role_profile, type AgentProvider } from '#scripts/agent/agent-role-profile'
 import { api_auth } from '#scripts/agent/api-auth'
+import { distributed_paths } from '#scripts/init/distributed-paths'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { error_text } from '#scripts/lib/error-message'
+import { review_attest, type ReviewSlot } from '#scripts/review/review-attest'
 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'
@@ -16,13 +20,14 @@ 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.
+// starting the round-1 reviewers or the 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 SUBMIT_SCRIPT = 'scripts/review/review-submit-cli.ts'
 const ANTHROPIC_PROVIDER: AgentProvider = 'anthropic'
 const stop_schema = z
 	.object({
@@ -30,18 +35,45 @@ const stop_schema = z
 		title: z.string(),
 		flags: z.array(z.string()).readonly(),
 		is_review: z.boolean(),
+		unpinned_ok: z.array(z.string()).readonly().exactOptional(),
 		conflicts: z.array(z.string()).readonly().default([]),
 		cause: z.enum(run_ship_stop_cause.CAUSE).exactOptional(),
 		is_review_stale: z.boolean().exactOptional(),
 		context: run_ship_stop_context.stop_context_schema.exactOptional(),
 	})
 	.strict()
+// `slots` is omitted for `/code-review` alone, so a supervisor still on the code before it reads the
+// request as before; it names the reviews a ship runs side by side (joshuafolkken/kit#4672).
+const slots_schema = z.array(z.enum(review_attest.REVIEW_SLOTS)).readonly()
 const action_schema = z.discriminatedUnion('kind', [
-	z.object({ kind: z.literal('review'), round: z.enum(['1', '2']) }).strict(),
+	z
+		.object({
+			kind: z.literal('review'),
+			round: z.enum(['1', '2']),
+			slots: slots_schema.exactOptional(),
+		})
+		.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 })
+	.strict()
 type ReviewRound = Extract<z.infer<typeof action_schema>, { kind: 'review' }>['round']
-type BrokerAction = { kind: 'review'; round: ReviewRound } | { kind: 'relaunch'; stop: ShipStop }
+
+interface ReviewAction {
+	kind: 'review'
+	round: ReviewRound
+	slots?: ReadonlyArray<ReviewSlot>
+}
+
+type BrokerAction = ReviewAction | { kind: 'relaunch'; stop: ShipStop }
+
+interface ReviewPaths {
+	brief: string
+	findings: string
+	log: string
+}
+
 type BrokerAnswer = { is_success: true } | { is_success: false; reason: string }
 
 const SUCCESS: BrokerAnswer = { is_success: true }
@@ -50,11 +82,18 @@ function failure(reason: string): BrokerAnswer {
 	return { is_success: false, reason }
 }
 
-function review_paths(directory: string): { brief: string; findings: string; log: string } {
+// **Each review slot has its own files**: `/code-review` and the interaction review run side by side
+// (joshuafolkken/kit#4672), so neither overwrites the other's brief, findings or log.
+function review_paths(
+	directory: string,
+	slot: ReviewSlot = review_attest.REVIEW_SLOT.CODE,
+): ReviewPaths {
+	const prefix = slot === review_attest.REVIEW_SLOT.CODE ? '' : 'interaction-'
+
 	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'),
+		brief: stamp_file.stamp_path(`${BRIEF_PREFIX}${prefix}`, directory, '.md'),
+		findings: stamp_file.stamp_path(`${FINDINGS_PREFIX}${prefix}`, directory, '.txt'),
+		log: stamp_file.stamp_path(`${LOG_PREFIX}${prefix}`, directory, '.log'),
 	}
 }
 
@@ -69,13 +108,27 @@ function provider_of(lane: LaneInfo): AgentProvider {
 // 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
+function action_slots(action: ReviewAction): ReadonlyArray<ReviewSlot> {
+	return action.slots ?? [review_attest.REVIEW_SLOT.CODE]
+}
+
+// **A lane branched before `review:submit` is handed its findings path** (joshuafolkken/kit#4799): the
+// reviewer runs the lane's own josh, and a supervisor reloaded onto main serves lanes that predate it.
+function has_submit(directory: string): boolean {
+	return [SUBMIT_SCRIPT, `${distributed_paths.KIT_PACKAGE_PATH_PREFIX}${SUBMIT_SCRIPT}`].some(
+		(script) => existsSync(path.join(directory, script)),
+	)
+}
+
+function review_prompt(lane: LaneInfo, action: ReviewAction, slot: ReviewSlot): string {
+	const { brief, findings } = review_paths(lane.directory, slot)
+	const round_prompt =
+		action.round === '1' ? run_ship_review.reviewer_prompt : run_ship_review.verification_prompt
+	const prompt_of = run_ship_review.slot_prompt(round_prompt, slot, action_slots(action))
 	const tail = lane_child_invocation.review_invocation(lane.issue)
+	const findings_path = has_submit(lane.directory) ? undefined : findings
 
-	return `${prompt_of(target.brief, target.findings, lane.issue)} This is ${tail}`
+	return `${prompt_of(brief, slot, lane.issue, findings_path)} This is ${tail}`
 }
 
 // **A reviewer that could not authenticate names it** with `api_auth.AUTH_FAILURE_NOTE`, read off its
@@ -96,16 +149,21 @@ function reviewer_answer(result: AttachedLaunchResult, log_path: string): Broker
 	return result.exit_code === 0 ? SUCCESS : exited_answer(result.exit_code, log_path)
 }
 
-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)
+async function launch_review(
+	lane: LaneInfo,
+	action: ReviewAction,
+	slot: ReviewSlot,
+): Promise<BrokerAnswer> {
+	const target = review_paths(lane.directory, slot)
+	const prompt = review_prompt(lane, action, slot)
+	const built = agent_argv.review_in(prompt, Number(action.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))
+	console.error(agent_role_profile.describe_review(Number(action.round), built.profile))
 	const result = await detached_launch.launch_attached(
 		{
 			argv: built.argv,
@@ -120,6 +178,16 @@ async function launch_review(lane: LaneInfo, round: ReviewRound): Promise<Broker
 	return reviewer_answer(result, target.log)
 }
 
+// **The slots' reviewers run side by side**, and the answer is the first failure among them — each
+// slot's findings file then says which review finished (`run-ship-reviewer.ts`).
+async function launch_reviews(lane: LaneInfo, action: ReviewAction): Promise<BrokerAnswer> {
+	const answers = await Promise.all(
+		action_slots(action).map(async (slot) => await launch_review(lane, action, slot)),
+	)
+
+	return answers.find((reply) => !reply.is_success) ?? SUCCESS
+}
+
 // 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)) {
@@ -142,7 +210,7 @@ async function perform(lane: LaneInfo, action: BrokerAction): Promise<BrokerAnsw
 
 	if (action.kind === 'relaunch') return relaunch(lane, action.stop)
 
-	return await launch_review(lane, action.round)
+	return await launch_reviews(lane, action)
 }
 
 // What the server answers: a thrown action is a failure naming its error, never a dead server.
@@ -154,7 +222,14 @@ async function answer(lane: LaneInfo, action: BrokerAction): Promise<BrokerAnswe
 	}
 }
 
-const lane_session_action = { SUCCESS, action_schema, answer, failure, review_paths }
+const lane_session_action = {
+	SUCCESS,
+	action_schema,
+	answer,
+	failure,
+	request_schema,
+	review_paths,
+}
 
 export type { BrokerAction, BrokerAnswer, ReviewRound }
 export { lane_session_action }