@joshuafolkken/kit 1.1453.0 → 1.1471.0

package/scripts/hooks/step-zero-notice.ts

@@ -65,8 +65,9 @@ function notice(raw_payload: string, root: string = process.cwd()): string | und
 
 	const target = STAMP.path(transcript)
 
-	if (STAMP.last_ms(target) !== hook_decision.NEVER_MS) return undefined
-	if (!STAMP.record(target, Date.now())) return undefined
+	if (STAMP.last_ms(target) !== hook_decision.NEVER_MS || !STAMP.record(target, Date.now())) {
+		return undefined
+	}
 
 	return NOTICE
 }

package/scripts/init/hook-command-rewrite.ts

@@ -65,8 +65,12 @@ function rewrite_command_value(value: string): string {
 		.split(PNPM_JOSH_PREFIX)
 		.join(BUNDLE_INVOCATION)
 
-	if (!rewritten.includes(claude_plugin_config.MARKETPLACE_PATH)) return rewritten
-	if (rewritten.includes(MISSING_INSTALL_GUARD)) return rewritten
+	if (
+		!rewritten.includes(claude_plugin_config.MARKETPLACE_PATH) ||
+		rewritten.includes(MISSING_INSTALL_GUARD)
+	) {
+		return rewritten
+	}
 
 	return `${MISSING_INSTALL_GUARD}${rewritten}`
 }

package/scripts/init/init-logic-deploy-vps.ts

@@ -30,8 +30,10 @@ function patch_deploy_vps_pnpm(content: string): string {
 	const with_pnpm12 = content.replaceAll(PNPM_INSTALL_PATTERN, (command) =>
 		replace_outdated_install(command),
 	)
-	if (with_pnpm12.includes(VERSION_CHECK_MARKER)) return with_pnpm12
-	if (!OLD_PNPM_CHECK_PATTERN.test(with_pnpm12)) return with_pnpm12
+
+	if (with_pnpm12.includes(VERSION_CHECK_MARKER) || !OLD_PNPM_CHECK_PATTERN.test(with_pnpm12)) {
+		return with_pnpm12
+	}
 
 	return with_pnpm12
 		.replace(OLD_MAJOR_LINE_PATTERN, '')

package/scripts/issue/behavior-change-lint.ts

@@ -76,9 +76,12 @@ function firing_point_problem(body: string): string | undefined {
 }
 
 function baseline_problem(body: string): string | undefined {
-	if (!markdown_section.has_line(body, BASELINE_HEADING)) return undefined
-
-	if (baseline_measure.has_command_value(body)) return undefined
+	if (
+		!markdown_section.has_line(body, BASELINE_HEADING) ||
+		baseline_measure.has_command_value(body)
+	) {
+		return undefined
+	}
 
 	return 'baseline must be written as `command → value`, not prose (it has to be re-runnable)'
 }
@@ -86,9 +89,12 @@ function baseline_problem(body: string): string | undefined {
 // The reproduction section is checked for format only where the heading is present — a missing heading
 // is already reported by `heading_problems`, so reporting it here too would double the message.
 function reproduction_problem(body: string): string | undefined {
-	if (!markdown_section.has_line(body, REPRODUCTION_HEADING)) return undefined
-
-	if (reproduction_measure.has_command_output(body)) return undefined
+	if (
+		!markdown_section.has_line(body, REPRODUCTION_HEADING) ||
+		reproduction_measure.has_command_output(body)
+	) {
+		return undefined
+	}
 
 	return 'reproduction must be a command and its actual output (a fenced block), not prose ("確認した" is not re-runnable)'
 }

package/scripts/issue/issue-scout-cli.ts

@@ -73,8 +73,9 @@ function read_arguments(argv: ReadonlyArray<string>): ScoutArguments | undefined
 	const { values, positionals } = parsed
 	const [title] = positionals
 
-	if (has_invalid_arguments(title, values.body, values['body-file'])) return undefined
-	if (title === undefined) return undefined
+	if (title === undefined || has_invalid_arguments(title, values.body, values['body-file'])) {
+		return undefined
+	}
 
 	return { title, body: values.body ?? '', body_file: values['body-file'] }
 }

package/scripts/josh/file-map-stamp.ts

@@ -211,9 +211,7 @@ function is_own_record(stamp: FileMapStamp): boolean {
 function complete_at(target: string): string | undefined {
 	const stamp = read_at(target)
 
-	if (stamp === undefined) return undefined
-
-	if (!is_own_record(stamp)) return undefined
+	if (stamp === undefined || !is_own_record(stamp)) return undefined
 
 	return stamp_file.write_stamp(target, { ...stamp, completed_at: new Date().toISOString() })
 }

package/scripts/josh/hook-decision.ts

@@ -87,8 +87,8 @@ function deny_envelope(reason: string): string {
 }
 
 // **A rewrite, not a refusal**: the call proceeds with `updated_input` merged
-// over its own. `allow` is the decision the harness applies an `updatedInput` under; a settings `deny`
-// rule still wins over it, so this never widens what the call may do.
+// over its own and is allowed past the permission prompt; a settings `deny` rule still wins over it.
+// Where the line may carry commands the hook did not write, `flow_rewrite_envelope` is the one to use.
 function rewrite_envelope(updated_input: Record<string, unknown>, context: string): string {
 	return JSON.stringify({
 		systemMessage: context,
@@ -101,6 +101,20 @@ function rewrite_envelope(updated_input: Record<string, unknown>, context: strin
 	})
 }
 
+// **A rewrite that leaves the permission to the harness.** No `permissionDecision`, so the rewritten
+// call meets the same permission flow the typed one would have — whatever else rides the line beside
+// the rewritten part is prompted for, or not, exactly as before (joshuafolkken/kit#3875).
+function flow_rewrite_envelope(updated_input: Record<string, unknown>, context: string): string {
+	return JSON.stringify({
+		systemMessage: context,
+		hookSpecificOutput: {
+			hookEventName: HOOK_EVENT_NAME,
+			updatedInput: updated_input,
+			additionalContext: context,
+		},
+	})
+}
+
 // **A notice, not a decision.** It carries no `permissionDecision`, so the call proceeds exactly as it
 // would have; `additionalContext` is what reaches the model, and `systemMessage` is what the person
 // watching sees. Both are filled because either channel alone leaves one of the two blind — and the
@@ -476,6 +490,7 @@ const hook_decision = {
 	deny_envelope,
 	emit_outcome,
 	fault_notice,
+	flow_rewrite_envelope,
 	is_switch_enabled,
 	is_switch_opt_in,
 	load_environment_file,

package/scripts/josh/josh-commands-workflow.ts

@@ -47,7 +47,7 @@ const WORKFLOW_COMMANDS: Record<string, CommandEntry> = {
 		description: 'Send Telegram notification',
 		category: 'Workflow',
 		reference: [
-			'[--task-type <type>] [--body <text> | --body-file <path>] [--issue-url <url>] [--pr-url <url>] [--issue-title <text>] [--repo-name <name>]',
+			'[--task-type <type>] [--body <text> | --body-file <path>] [--issue-url <url>] [--pr-url <url>] [--issue-title <text>] [--repo-name <name>] [--recommended <text>] [--alternative <text>]...',
 			'automation',
 			['notifications'],
 		],

package/scripts/lane/lane-await.ts

@@ -89,8 +89,9 @@ function process_trace_default(issue: string): ProcessTrace {
 
 	process_tools.throw_if_missing(PGREP_COMMAND, result.error)
 
-	if (result.status === PROCESS_FOUND) return PROCESS_ALIVE
-	if (lane_handoff.is_ship_running(issue, process.cwd())) return PROCESS_ALIVE
+	if (result.status === PROCESS_FOUND || lane_handoff.is_ship_running(issue, process.cwd())) {
+		return PROCESS_ALIVE
+	}
 
 	return result.status === PROCESS_NOT_FOUND ? PROCESS_NONE : PROCESS_UNKNOWN
 }

package/scripts/lane/lane-child-invocation.ts

@@ -8,6 +8,8 @@ interface ShipStop extends ShipResume {
 }
 
 const CHILD_INVOCATION = 'fullrun'
+// What a brokered reviewer's prompt ends with, so the one pattern below finds it too.
+const REVIEW_INVOCATION = 'the reviewer of lane'
 const RESUME_GUIDE = '.claude/skills/workflow-commands/pre-gate-cut.md'
 // What a detached `josh ship --detach` supervisor's command line carries. It ends
 // with the `"<title> #<N>"` title on purpose, so the liveness pattern below finds it by the same trailing
@@ -31,10 +33,20 @@ function child_invocation(issue: string): string {
 // pattern stopped matching as finished — parking an issue that was still shipping. The supervisor's
 // command line ends with its `#<N>` title, so the one extended pattern covers both, and the wait, the
 // liveness read and the reaper keep searching with a single pattern.
+//
+// **A brokered reviewer counts as the child too** (joshuafolkken/kit#3878). The lane's broker starts it
+// for a ship and it outlives a ship that stopped waiting: unmatched, the lane read as finished, the
+// run parked the issue under it, and the reap left it running checks in the parked lane.
 function process_pattern(issue: string): string {
 	issue_number_shape.require_issue_number(issue)
 
-	return `(${CHILD_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`
+	return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`
+}
+
+function review_invocation(issue: string): string {
+	issue_number_shape.require_issue_number(issue)
+
+	return `${REVIEW_INVOCATION} ${issue_cite.plain(issue)}`
 }
 
 function resume_invocation(issue: string): string {
@@ -82,6 +94,7 @@ const lane_child_invocation = {
 	outage_resume_invocation,
 	process_pattern,
 	resume_invocation,
+	review_invocation,
 	ship_stop_invocation,
 }
 

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

@@ -47,25 +47,25 @@ const LANE_GUARD_POLICY: ReadonlyArray<LaneGuardEntry> = [
 		id: 'investigation',
 		mode_in_lane_child: 'notice',
 		because:
-			'a refusal ends a child turn so it cannot fire as one (kit#2138), which is why it was `off` from #2138 to #2382. The exemption reason — "the child is itself the delegated unit, so it cannot dispatch a sub-unit to read its own edit targets" — did not hold in measurement: kit#2382 re-measured the six lane children after #2347 (#2366 #2370 #2371 #2372 #2374 #2375) and every one dispatched sub-agents (10 launches, 2 of them investigation fan-outs) and read 4–17 files it never edited, all six over the threshold of 3. So the reading the guard exists to send out was there to send. It takes `notice`, not `off`: the child is nudged to delegate rather than killed, on the `additionalContext` path batching and duplicate-read already use, and the notice names the concrete unedited files this run read (the #2276 precedent) rather than the generic "delegate" #2164 → #2178 measured not to move the number. The density is a genuine experiment — re-measured on the next backlogrun, and a notice that still does not move it is redesigned rather than kept',
+			'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',
 	},
 	{
 		id: 'batching',
 		mode_in_lane_child: 'off',
 		because:
-			'a refusal ends a child turn so it cannot fire as one (kit#2138); kit#2164 replaced it with a notice, kit#2178 took that notice off after it did not move the density, and kit#2276 restored it — naming the concrete recent calls and recurring every single-call turn — as a genuine experiment to be redesigned rather than kept if the next backlogrun still missed 1.40. kit#2405 is that re-measurement, and it cuts the notice off (`off`). `josh time:density` read 1.13 calls per round trip over the ten most recent lanes (1.04 in the Issue’s per-message frame), short of the 1.40 target as every advisory attempt before it was (kit#1304/#1329/#1337/#1390/#2164/#2276). The cause is structural rather than wording: a `PreToolUse` hook cannot see the turn it is in — a turn’s later `tool_use` lines arrive 1.4–15s after its first — so it judges only closed turns, and a notice at turn close still asks for the parallel `tool_use` blocks the model resists. The one lever measured to move the density is a composite command the model emits in a single call (`read:files`/`edit:files`, kit#2202/#2311), which needs no notice. So per the issue’s instruction to discontinue advisory means when the target is missed, the notice is cut off rather than rewritten a seventh time; the density stays readable through `josh time:density`',
+			'a refusal ends a child turn and every advisory notice was measured not to move the call density, so the guard is off and the density stays readable through `josh time:density`',
 	},
 	{
 		id: 'duplicate-read',
 		mode_in_lane_child: 'notice',
 		because:
-			'a refusal ends a child turn so it cannot fire as one (kit#2138), and the unchanged re-reads the guard catches are measured in lane children above all (kit#2298 baseline: 8.0 per lane run) — so silencing it there (`off`) would neuter it exactly where the count lives. It takes `notice` instead: the child is nudged to scroll up to the earlier read rather than killed. The mode is a genuine experiment, as the batching notice is — a notice that does not reduce the duplicate reads on the next backlogrun is redesigned rather than kept',
+			'a refusal ends a child turn, yet unchanged re-reads are measured in lane children above all, so the child is nudged to scroll up to the earlier read by a notice rather than killed',
 	},
 	{
 		id: 'rule',
 		mode_in_lane_child: 'refuse',
 		because:
-			"it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules a child must still obey (`shell-body`, `piped-verification`); a blanket suppression would disarm exactly the guards written for the child. `implementation-cut` (joshuafolkken/kit#2310) needs `refuse` for the same reason the pre-gate cut does — kit#1864 and kit#2310 both measured a cut carried as prose firing 0 times, so a notice, being prose in front of the run, would drop enforcement without a procedural replacement. The pre-gate-cut refusal does collateral a sibling call batched in the same turn — a `PreToolUse` deny cancels the turn's other parallel calls, which is the harness behavior kit#2177 measured on #2160 (gate refused, its batched `review:brief` cancelled) — and that collateral is not avoidable at the guard level. `notice` was considered for the pre-gate-cut point and rejected: kit#1864 measured the cut taken 0 times while it was carried as prose, and a notice is prose in front of the run (kit#2178 measured a lane-child notice not moving the number), so a notice would drop enforcement without a procedural replacement. kit#2177 supplies that replacement in the procedure instead — the chain orders the cut before the gate, so the cut is issued on its own (its `cut` verdict ends the turn, batching with nothing) and the gate runs in the fresh process where the carried cut keeps this guard silent; the refusal therefore stays `refuse` as insurance and the collateral is gone from the default path rather than from the guard",
+			'it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules it must still obey, and a notice was rejected despite the collateral a refusal costs a batched sibling, because a cut carried as prose was measured never to fire',
 	},
 ]
 

package/scripts/lane/lane-ledger.ts

@@ -56,6 +56,12 @@ const gate_schema = z.object({
 // worth its load. `swapped_mb` is `machine_capacity`'s counter, every page swapped since boot.
 // Both memory fields were renamed with their meaning (joshuafolkken/kit#3593): an older row's
 // `free_mb` / `swap_mb` are stripped on read, so the two measurements never share a column.
+const process_kind_schema = z.object({
+	kind: z.string(),
+	cpu_percent: z.number(),
+	rss_mb: z.number(),
+	count: z.number(),
+})
 const load_schema = z.object({
 	kind: z.literal(KIND.LOAD),
 	at: z.string(),
@@ -63,6 +69,9 @@ const load_schema = z.object({
 	available_mb: z.number().optional(),
 	swapped_mb: z.number().optional(),
 	lanes: z.number().optional(),
+	// The heaviest process kinds at the instant of the sample (`lane-process-load.ts`), so the load the
+	// core budget's ledger does not explain can be read back by what made it (joshuafolkken/kit#3874).
+	processes: z.array(process_kind_schema).optional(),
 })
 // A lane child started on `issue` — the instant its implementation is timed from.
 const dispatch_schema = z.object({

package/scripts/lane/lane-load.ts

@@ -2,10 +2,12 @@ import { loadavg } from 'node:os'
 import { machine_capacity } from '#scripts/gate/machine-capacity'
 import { lane_await } from './lane-await'
 import type { LoadEntry } from './lane-ledger'
+import { lane_process_load } from './lane-process-load'
 import { lane_registry, type LaneInfo } from './lane-registry'
 
 // One machine-load sample for the lane-limit measurement: the one-minute load
-// average, available memory, the swap counter and how many lanes have a child working, read at one
+// average, available memory, the swap counter, how many lanes have a child working and the heaviest
+// process kinds (`lane-process-load.ts`), read at one
 // instant so `josh lane:stats` can set the load beside the lane count that produced it.
 //
 // **The memory is `machine_capacity`'s reading, the one the gate admits against.** `os.freemem()` reads
@@ -38,7 +40,11 @@ function rounded(megabytes: number | undefined): number | undefined {
 }
 
 async function sample(at: string): Promise<LoadEntry> {
-	const [memory, lanes] = await Promise.all([machine_capacity.read_memory(), read_lanes()])
+	const [memory, lanes, processes] = await Promise.all([
+		machine_capacity.read_memory(),
+		read_lanes(),
+		lane_process_load.read(),
+	])
 	const [load = 0] = loadavg()
 
 	return {
@@ -48,6 +54,7 @@ async function sample(at: string): Promise<LoadEntry> {
 		available_mb: rounded(memory.available_mb),
 		swapped_mb: rounded(memory.swapped_mb),
 		lanes,
+		processes,
 	}
 }
 

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

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { lane_capacity } from './lane-capacity'
 import { lane_ledger } from './lane-ledger'
+import { lane_process_stats } from './lane-process-stats'
 import { lane_sampler, type MeasureContext } from './lane-sampler'
 import { lane_stage_stats } from './lane-stage-stats'
 import { lane_stats } from './lane-stats'
@@ -119,6 +120,7 @@ async function stats_command(
 			`${lane_stats.header()}\n${row}`,
 			lane_stage_stats.table(entries, window),
 			lane_stop_stats.table(entries, window),
+			lane_process_stats.table(entries, window),
 		].join('\n\n'),
 	)
 

package/scripts/lane/lane-parked.ts

@@ -0,0 +1,18 @@
+import { has_label_name, NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
+import { issue_state_cli } from '#scripts/issue/issue-state-cli'
+
+// Whether an issue is parked for a person — the `needs-decision` label — read live, so a session a
+// lane's broker would start for it is refused once the run has parked it (joshuafolkken/kit#3878).
+//
+// **An issue whose state cannot be read is not parked**: the read gates every brokered review, so
+// reading an outage as a park would fail every review in flight for as long as GitHub is away.
+
+async function is_parked(issue: string): Promise<boolean> {
+	const read = await issue_state_cli.read_issue(issue)
+
+	return read.kind === 'state' && has_label_name(read.state.labels, NEEDS_DECISION_LABEL)
+}
+
+const lane_parked = { is_parked }
+
+export { lane_parked }

package/scripts/lane/lane-process-load.ts

@@ -0,0 +1,125 @@
+import { PROBE_TIMEOUT_MS } from '#scripts/lib/timeouts'
+import { execa } from 'execa'
+
+// What the machine's load is made of at one instant: every process grouped by the kind of tool it
+// runs, the heaviest kinds kept with their CPU and resident size, for a `load` sample to carry.
+//
+// **Why a load sample needs it.** The gate's static checks and unit suite are on the core budget's
+// ledger, so the load the ledger does not explain comes from somewhere else — review subagents, the
+// sessions themselves, a hook's unit run, an IDE — and a load average alone cannot say which.
+// joshuafolkken/kit#3874 measured load 93 with 1.6 lanes working and nothing on record to explain it.
+//
+// **The kind is read from the command line, not the executable name.** Every tool here is a `node`
+// process, so the name says nothing; the first pattern a command line matches names its kind, in the
+// order below, so `pnpm exec vitest` is `vitest` rather than `josh`. The IDE comes first: its language
+// servers run out of a `typescript` or `eslint` directory, and read as `tsc` or `eslint` they would
+// pass the IDE's load off as the gate's own checks — and a server the IDE starts on a plain `node`
+// runtime is known only by its `.vscode/extensions/` path. `claude` is the executable or its package,
+// never a `.claude/` path a session's Bash-tool shell or hook script runs through. `pnpm` is the
+// command, never the `.pnpm/` store a resolved binary's path runs through.
+//
+// **`%cpu` is the share of one core**, so 300 is three cores busy; it is `ps`'s decaying average,
+// which is what a one-minute sample beside the one-minute load average wants.
+
+const PS_ARGUMENTS = ['-A', '-o', 'rss=,%cpu=,args=']
+// `ps` prints `%cpu` with the locale's decimal separator, and a `0,7` would parse as NaN.
+const PS_ENVIRONMENT = { LC_ALL: 'C' }
+const FIELD_SEPARATOR = /\s+/u
+const KB_PER_MB = 1024
+// Enough to name what dominates and the runner-up behind it, short enough for one ledger line a minute.
+const TOP_KINDS = 5
+const OTHER_KIND = 'other'
+
+const KIND_PATTERNS: ReadonlyArray<readonly [string, RegExp]> = [
+	['vscode', /Visual Studio Code|Code Helper|\.vscode\/extensions\//u],
+	['vitest', /vitest/u],
+	['eslint', /eslint/u],
+	['tsc', /\btsc\b|svelte-check|typescript/u],
+	['cspell', /cspell/u],
+	['prettier', /prettier/u],
+	['playwright', /playwright/u],
+	['chrome', /Google Chrome/u],
+	['chromium', /chromium|headless_shell/iu],
+	['claude', /(?:^|\/)claude(?:\s|$)|@anthropic-ai\/claude-code\//u],
+	['josh', /josh\.ts|\btsx\b|(?<!\.)\bpnpm\b/u],
+	['node', /\bnode\b/u],
+]
+
+interface ProcessKind {
+	kind: string
+	cpu_percent: number
+	rss_mb: number
+	count: number
+}
+
+function kind_of(command_line: string): string {
+	return KIND_PATTERNS.find(([, pattern]) => pattern.test(command_line))?.[0] ?? OTHER_KIND
+}
+
+// One line of `ps`'s listing as its kind and readings; a header or a cut-short line reads as nothing.
+function process_of(line: string): Omit<ProcessKind, 'count'> | undefined {
+	const [rss, cpu, ...command] = line.trim().split(FIELD_SEPARATOR)
+	const reading = { cpu_percent: Number(cpu), rss_mb: Number(rss) / KB_PER_MB }
+
+	if (command.length === 0 || Number.isNaN(reading.cpu_percent + reading.rss_mb)) return undefined
+
+	return { kind: kind_of(command.join(' ')), ...reading }
+}
+
+function add_line(totals: Map<string, ProcessKind>, line: string): void {
+	const reading = process_of(line)
+
+	if (reading === undefined) return
+
+	const { kind } = reading
+	const total = totals.get(kind) ?? { kind, cpu_percent: 0, rss_mb: 0, count: 0 }
+
+	total.cpu_percent += reading.cpu_percent
+	total.rss_mb += reading.rss_mb
+	total.count += 1
+	totals.set(kind, total)
+}
+
+function rounded(total: ProcessKind): ProcessKind {
+	return { ...total, cpu_percent: Math.round(total.cpu_percent), rss_mb: Math.round(total.rss_mb) }
+}
+
+// The heaviest kinds first: by CPU, the load average's own measure, then by memory for idle kinds.
+function by_weight(left: ProcessKind, right: ProcessKind): number {
+	return right.cpu_percent - left.cpu_percent || right.rss_mb - left.rss_mb
+}
+
+function summarize(listing: string): Array<ProcessKind> {
+	const totals = new Map<string, ProcessKind>()
+
+	for (const line of listing.split('\n')) add_line(totals, line)
+
+	return [...totals.values()]
+		.map((total) => rounded(total))
+		.toSorted(by_weight)
+		.slice(0, TOP_KINDS)
+}
+
+// `undefined` where `ps` did not answer, so the sample records no breakdown rather than an empty one.
+async function read(): Promise<Array<ProcessKind> | undefined> {
+	try {
+		const { stdout } = await execa('ps', PS_ARGUMENTS, {
+			env: PS_ENVIRONMENT,
+			timeout: PROBE_TIMEOUT_MS,
+		})
+
+		return summarize(stdout)
+	} catch {
+		return undefined
+	}
+}
+
+const lane_process_load = {
+	TOP_KINDS,
+	kind_of,
+	read,
+	summarize,
+}
+
+export type { ProcessKind }
+export { lane_process_load }

package/scripts/lane/lane-process-stats.ts

@@ -0,0 +1,93 @@
+import type { LedgerEntry, LoadEntry } from './lane-ledger'
+import type { ProcessKind } from './lane-process-load'
+import { lane_stats, type StatsWindow } from './lane-stats'
+
+// What the period's machine load was made of: the process kinds the load samples carried
+// (`lane-process-load.ts`), one row per kind, printed by `josh lane:stats` under the stop table so the
+// load the core budget's ledger does not explain is read back by what made it (joshuafolkken/kit#3874).
+//
+// **A kind is averaged over the samples it appears in**, never over every sample. A sample keeps only
+// its heaviest kinds, so a kind absent from one was below them rather than idle, and a zero there would
+// understate it; `samples` says how often it was among the heaviest, which is the weight to read it by.
+//
+// **CPU is in cores** — `ps`'s share of one core over a hundred — so the column reads against the load
+// average and the machine's core count without a conversion.
+
+const COLUMNS = [
+	'process',
+	'cpu mean (cores)',
+	'cpu peak (cores)',
+	'rss peak (GB)',
+	'samples',
+] as const
+const PERCENT_PER_CORE = 100
+const MB_PER_GB = 1024
+const DECIMALS = 1
+
+interface KindRow {
+	kind: string
+	readings: Array<ProcessKind>
+}
+
+function is_load(entry: LedgerEntry): entry is LoadEntry {
+	return entry.kind === 'load'
+}
+
+function group(samples: ReadonlyArray<LoadEntry>): Array<KindRow> {
+	const rows = new Map<string, KindRow>()
+	const readings = samples.flatMap((sample) => sample.processes ?? [])
+
+	for (const reading of readings) {
+		const row = rows.get(reading.kind) ?? { kind: reading.kind, readings: [] }
+
+		row.readings.push(reading)
+		rows.set(reading.kind, row)
+	}
+
+	return [...rows.values()]
+}
+
+function cores(readings: ReadonlyArray<ProcessKind>): Array<number> {
+	return readings.map((reading) => reading.cpu_percent / PERCENT_PER_CORE)
+}
+
+// A row has one reading at least, so its mean always exists.
+function mean_cores(row: KindRow): number {
+	return lane_stats.mean(cores(row.readings)) ?? 0
+}
+
+function cell(value: number | undefined): string {
+	return value === undefined ? lane_stats.MISSING : value.toFixed(DECIMALS)
+}
+
+function kind_cells(row: KindRow): Array<string> {
+	const rss_peak = lane_stats.peak(row.readings.map((reading) => reading.rss_mb))
+
+	return [
+		row.kind,
+		cell(mean_cores(row)),
+		cell(lane_stats.peak(cores(row.readings))),
+		cell(rss_peak === undefined ? undefined : rss_peak / MB_PER_GB),
+		String(row.readings.length),
+	]
+}
+
+function by_mean_cpu(left: KindRow, right: KindRow): number {
+	return mean_cores(right) - mean_cores(left)
+}
+
+// The period's table: `entries` is the whole ledger, filtered here to `window`. A period whose samples
+// carried no breakdown prints the header alone.
+function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+	const rows = group(lane_stats.in_window(entries, window).filter(is_load)).toSorted(by_mean_cpu)
+
+	return [
+		lane_stats.to_row(COLUMNS),
+		lane_stats.to_row(COLUMNS.map(() => '---')),
+		...rows.map((row) => lane_stats.to_row(kind_cells(row))),
+	].join('\n')
+}
+
+const lane_process_stats = { table }
+
+export { lane_process_stats }

package/scripts/lane/lane-registry.ts

@@ -175,9 +175,14 @@ function parse_block(block: string, root: string): LaneInfo | undefined {
 	const branch = line_value(lines, BRANCH_PREFIX)
 	const issue = branch_issue(branch)
 
-	if (directory === undefined || branch === undefined || issue === undefined) return undefined
-
-	if (!is_lane_directory(root, issue, directory)) return undefined
+	if (
+		directory === undefined ||
+		branch === undefined ||
+		issue === undefined ||
+		!is_lane_directory(root, issue, directory)
+	) {
+		return undefined
+	}
 
 	return build_lane(issue, branch, directory, is_gone(directory))
 }

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

@@ -15,6 +15,7 @@ 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 { lane_parked } from './lane-parked'
 import type { LaneInfo } from './lane-registry'
 import { lane_relaunch } from './lane-relaunch'
 
@@ -105,14 +106,22 @@ function provider_of(lane: LaneInfo): AgentProvider {
 
 // **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.
+// 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).
 
-async function launch_review(lane: LaneInfo, round: ReviewRound): Promise<boolean> {
+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}`
+}
+
+async function launch_review(lane: LaneInfo, round: ReviewRound): Promise<boolean> {
+	const target = review_paths(lane.directory)
 	const built = agent_argv.resolve_in(
-		prompt_of(target.brief, target.findings),
+		review_prompt(lane, round),
 		agent_role_profile.REVIEWER,
 		lane.directory,
 	)
@@ -143,7 +152,11 @@ function relaunch(lane: LaneInfo, stop: ShipStop): boolean {
 	return result.kind === 'launched'
 }
 
+// **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<boolean> {
+	if (await lane_parked.is_parked(lane.issue)) return false
+
 	if (action.kind === 'relaunch') return relaunch(lane, action.stop)
 
 	return await launch_review(lane, action.round)
@@ -336,6 +349,13 @@ function is_serving(directory: string, issue: string): boolean {
 	return target !== undefined && live_response(target) !== undefined
 }
 
+// **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<boolean> {
 	const target = response_path(directory, issue)
 	const response = target === undefined ? undefined : live_response(target)
@@ -344,10 +364,14 @@ async function request(directory: string, issue: string, action: BrokerAction):
 
 	const nonce = randomUUID()
 	const body = { session: response.session, nonce, action }
+	const pending = request_path(directory, issue)
+
+	stamp_file.replace_stamp(pending, body)
+	const is_success = await wait_response(target, response.session, nonce)
 
-	stamp_file.replace_stamp(request_path(directory, issue), body)
+	withdraw(pending, nonce)
 
-	return await wait_response(target, response.session, nonce)
+	return is_success
 }
 
 const lane_session_broker = {