@joshuafolkken/kit 1.3101.0 → 1.3125.0

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

@@ -17,6 +17,7 @@ import { lane_sinks_issues } from './lane-sinks-issues'
 import { lane_stats, type StatsWindow } from './lane-stats'
 import { lane_stats_request, type StatsRequest, type StatsStart } from './lane-stats-request'
 import { lane_stats_tables, type PeriodRecords } from './lane-stats-tables'
+import { lane_table_rows } from './lane-table-rows'
 import { lane_transcript_stats } from './lane-transcript-stats'
 import { lane_value } from './lane-value'
 import { lane_value_cell, type CellAddress, type CellFilter } from './lane-value-cell'
@@ -46,7 +47,7 @@ const CELL_METRIC = 'cell'
 const VALUE_DIGITS = 2
 const USAGE = [
 	'Usage: josh lane:sample [--every <seconds>]',
-	'       josh lane:stats --period <days> [--limit <lane-limit>]',
+	'       josh lane:stats --period <days> [--limit <lane-limit>] [--all]',
 	'       josh lane:stats --period <days> --sinks [<minutes>]',
 	'       josh lane:stats --period <days> --over <minutes>',
 	'       josh lane:stats --period <days> --why <minutes>',
@@ -178,7 +179,7 @@ async function stats_text(
 	const records = await period_records(context, window)
 	const limit = await lane_limit_history.label(request.limit, records.entries, window)
 	const row = lane_stats.row(records.entries, window, { limit })
-	const tables = lane_stats_tables.tables_of(records, window)
+	const tables = lane_stats_tables.tables_of(records, window, { is_all: request.is_all })
 
 	return [`${lane_stats.header()}\n${row}`, ...tables].join('\n\n')
 }
@@ -307,7 +308,8 @@ async function cell_value(
 	window: StatsWindow,
 	context: MeasureContext,
 ): Promise<Measured> {
-	const tables = lane_stats_tables.tables_of(await period_records(context, window), window)
+	const records = await period_records(context, window)
+	const tables = lane_stats_tables.tables_of(records, window, lane_table_rows.ALL_ROWS)
 	const { MISSING } = lane_value_missing
 	const is_several = lane_value_cell.is_several(tables, address)
 

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

@@ -342,7 +342,7 @@ function files_text(issue: number, over: FilesOver): string {
 }
 
 function waiver_text(issue: number, over: Oversize): string {
-	return `size warning (${over.reason}): ${session_cite.issue(issue)}'s plan is past its ${String(over.limit)} bar, recorded and noted on the ledger — a warning, not a stop; finish this Issue, never split it — an overrun at the merge is recorded as a pre-split miss (split-assessment.md → "${split_assess.NOTICE_SECTION}").`
+	return `size warning (${over.reason}): ${session_cite.issue(issue)}'s plan is past its ${String(over.limit)} bar, recorded and noted on the ledger — a warning, not a stop; finish this Issue, never split it — an overrun past the cap at the merge is recorded as a pre-split miss (split-assessment.md → "${split_assess.NOTICE_SECTION}").`
 }
 
 function measure_bar(over: MeasureOver): string {

package/scripts/lane/lane-size-record.ts

@@ -7,8 +7,9 @@ import { lane_ledger_write } from './lane-ledger-write'
 // before the merge — after it the branch is gone — so `lane:stats` can calibrate the split guide
 // against real lanes (joshuafolkken/kit#5384). Best-effort, like every ledger line: an unreadable
 // Issue, an Issue with no estimate or an unmeasurable branch records nothing and never blocks a merge.
-// A diff past the split notice bar is recorded `missed` — a pre-split miss, since the started lane
-// was never split (joshuafolkken/kit#7183).
+// A diff past the split cap is recorded `missed` — a pre-split miss, since the started lane was never
+// split (joshuafolkken/kit#7183). The notice bar (declared × measured ratio) stays a warning: a median
+// ratio puts about half of all lanes past it however good the estimates are (joshuafolkken/kit#7579).
 
 async function measure_and_record(issue: string): Promise<void> {
 	const declared = await issue_declared_size.read(issue)
@@ -20,7 +21,7 @@ async function measure_and_record(issue: string): Promise<void> {
 		issue: Number(issue),
 		declared,
 		actual: { files: measurement.files, lines: measurement.lines },
-		missed: split_assess.notice(measurement, declared) !== undefined,
+		missed: split_assess.is_over_cap(measurement.files, measurement.lines, measurement.guide),
 	})
 }
 

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

@@ -1,11 +1,15 @@
 import { issue_cite } from '#scripts/issue/issue-cite'
+import { split_cap } from '#scripts/split/split-cap'
 import type { LedgerEntry, SizeEntry } from './lane-ledger-schema'
 import { lane_stats, type StatsWindow } from './lane-stats'
+import { lane_table_rows, type TableOptions } from './lane-table-rows'
 
 // Compare actual non-test changes with the declaration for merged lanes only. A followup retry
 // may record size twice; use the latest measurement before each merge (joshuafolkken/kit#5384). A merge
-// recorded past the split notice bar counts as a pre-split miss, listed with its declared and actual size
-// so the pre-dispatch assessment can be tuned (joshuafolkken/kit#7183).
+// recorded `missed` past the split cap counts as a pre-split miss, listed with its declared and actual
+// size so the pre-dispatch assessment can be tuned (joshuafolkken/kit#7183). The cap check drops a
+// flag recorded before #7579 past the notice bar alone; a measured guide's cap is never below the
+// default cap, so it drops no flag recorded past the cap (joshuafolkken/kit#7579).
 const COLUMNS = [
 	'measured lanes',
 	'files actual / declared median',
@@ -13,6 +17,7 @@ const COLUMNS = [
 	'pre-split misses',
 ]
 const MISS_COLUMNS = ['pre-split miss', 'files declared → actual', 'lines declared → actual']
+const MISS_ROWS = 10
 const DECIMALS = 1
 
 interface SizeRatios {
@@ -75,8 +80,9 @@ function change_cell(size: SizeEntry, axis: 'files' | 'lines'): string {
 	return `${String(size.declared[axis])} → ${String(size.actual[axis])}`
 }
 
-// One row per merged lane recorded past the split notice bar; none prints no table.
-function miss_rows(misses: ReadonlyArray<SizeEntry>): Array<string> {
+// One row per pre-split miss, at most `MISS_ROWS` unless `options`
+// asks for all; none prints no table.
+function miss_rows(misses: ReadonlyArray<SizeEntry>, options: TableOptions): Array<string> {
 	if (misses.length === 0) return []
 	const rows = misses.map((size) =>
 		lane_stats.to_row([
@@ -86,12 +92,18 @@ function miss_rows(misses: ReadonlyArray<SizeEntry>): Array<string> {
 		]),
 	)
 
-	return ['', ...header(MISS_COLUMNS), ...rows]
+	return ['', ...header(MISS_COLUMNS), ...lane_table_rows.capped(rows, MISS_ROWS, options)]
 }
 
-function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string {
+function table(
+	entries: ReadonlyArray<LedgerEntry>,
+	window: StatsWindow,
+	options: TableOptions,
+): string {
 	const sizes = merged_sizes(entries, window)
-	const misses = sizes.filter((size) => size.missed === true)
+	const misses = sizes.filter(
+		(size) => size.missed === true && split_cap.is_over(size.actual.files, size.actual.lines),
+	)
 
 	return [
 		...header(COLUMNS),
@@ -101,11 +113,11 @@ function table(entries: ReadonlyArray<LedgerEntry>, window: StatsWindow): string
 			ratio_cell(sizes, 'lines'),
 			String(misses.length),
 		]),
-		...miss_rows(misses),
+		...miss_rows(misses, options),
 	].join('\n')
 }
 
-const lane_size_stats = { lines_ratio, merged_sizes, ratios, table }
+const lane_size_stats = { MISS_ROWS, lines_ratio, merged_sizes, ratios, table }
 
 export { lane_size_stats }
 export type { SizeRatios }

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

@@ -12,10 +12,12 @@ const STATS_OPTIONS = {
 	over: { type: 'string' },
 	why: { type: 'string' },
 	pairs: { type: 'boolean' },
+	all: { type: 'boolean' },
 } as const
 
 interface StatsFlags {
 	limit?: string | undefined
+	all?: boolean | undefined
 	sinks?: boolean | undefined
 	over?: string | undefined
 	why?: string | undefined
@@ -41,6 +43,8 @@ interface StatsRequest {
 	why: number | undefined
 	// `--pairs`: the scoped pair table (`lane-pairs.ts`).
 	is_pairs: boolean
+	// `--all`: every row of the per-lane tables (`lane-table-rows.ts`).
+	is_all: boolean
 }
 
 // A positive finite number, or `undefined` for anything else — a typo must not become a zero period.
@@ -111,7 +115,12 @@ function threshold_choice(text: string | undefined): { minutes: number | undefin
 	return minutes === undefined ? undefined : { minutes }
 }
 
-// Each alternate table is exclusive and carries no lane-limit label.
+// The flags only the period's row and tables read.
+function is_period_only(values: StatsFlags): boolean {
+	return values.limit !== undefined || values.all === true
+}
+
+// Each alternate table is exclusive and carries no lane-limit label and no row cap.
 function is_one_table(values: StatsFlags): boolean {
 	const selected = [
 		values.sinks === true,
@@ -120,7 +129,7 @@ function is_one_table(values: StatsFlags): boolean {
 		values.pairs === true,
 	].filter(Boolean).length
 
-	return selected <= 1 && (selected === 0 || values.limit === undefined)
+	return selected <= 1 && (selected === 0 || !is_period_only(values))
 }
 
 // The one table the flags choose, `undefined` for a refused combination.
@@ -154,7 +163,7 @@ function stats_request(rest: ReadonlyArray<string>): StatsRequest | undefined {
 
 	if (start === undefined || table === undefined) return undefined
 
-	return { start, limit: parsed.values.limit, ...table }
+	return { start, limit: parsed.values.limit, is_all: parsed.values.all === true, ...table }
 }
 
 const lane_stats_request = { positive, since_of, stats_request }

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

@@ -12,6 +12,7 @@ import { lane_gap_stats } from './lane-gap-stats'
 import { lane_held_stats } from './lane-held-stats'
 import { lane_implement_rate } from './lane-implement-rate'
 import { lane_implement_read } from './lane-implement-read'
+import { lane_implement_read_calls } from './lane-implement-read-calls'
 import { lane_implement_stats } from './lane-implement-stats'
 import type { lane_ledger } from './lane-ledger'
 import { lane_paused_spans } from './lane-paused-spans'
@@ -25,6 +26,7 @@ import { lane_stage_stats } from './lane-stage-stats'
 import type { StatsWindow } from './lane-stats'
 import { lane_stop_check_stats } from './lane-stop-check-stats'
 import { lane_stop_stats } from './lane-stop-stats'
+import type { TableOptions } from './lane-table-rows'
 import { lane_test_related_stats } from './lane-test-related-stats'
 import type { ToolCall } from './lane-transcript-calls'
 import { lane_transcript_stats } from './lane-transcript-stats'
@@ -50,6 +52,7 @@ function call_tables(
 	return [
 		lane_implement_stats.table(calls, window, paused),
 		lane_implement_read.table(calls, window, paused),
+		lane_implement_read_calls.table(calls, window, paused),
 		lane_turn_stats.table(entries, calls, window),
 	]
 }
@@ -71,23 +74,41 @@ function stop_tables(
 	]
 }
 
-// The tables under the period's row, in the order `lane:stats` prints them.
-function tables_of({ entries, events, calls }: PeriodRecords, window: StatsWindow): Array<string> {
+// The tables of a lane's review rounds, its size against the plan and what it waited on before work.
+function plan_tables(
+	{ entries, events }: PeriodRecords,
+	window: StatsWindow,
+	options: TableOptions,
+): Array<string> {
 	return [
-		lane_stage_stats.table(entries, window),
-		lane_ship_lap_stats.table(entries, window),
-		lane_ci_path_stats.table(entries, window),
-		...call_tables(entries, calls, window),
-		...stop_tables(entries, events, window),
 		lane_round_one_stats.table(entries, window),
 		lane_round_two_stats.table(entries, window),
 		lane_early_push_stats.table(entries, window),
 		lane_split_stats.table(entries, window),
-		lane_size_stats.table(entries, window),
+		lane_size_stats.table(entries, window, options),
 		lane_implement_rate.table(entries, window),
 		lane_held_stats.table(entries, window),
 		lane_dispatch_wait_stats.table(entries, window, events),
-		lane_core_wait_stats.table(entries, window),
+		lane_core_wait_stats.table(entries, window, options),
+	]
+}
+
+// The tables under the period's row, in the order `lane:stats` prints them; `options` caps the
+// per-lane tables (`lane-table-rows.ts`).
+function tables_of(
+	records: PeriodRecords,
+	window: StatsWindow,
+	options: TableOptions,
+): Array<string> {
+	const { entries, events, calls } = records
+
+	return [
+		lane_stage_stats.table(entries, window),
+		lane_ship_lap_stats.table(entries, window),
+		lane_ci_path_stats.table(entries, window),
+		...call_tables(entries, calls, window),
+		...stop_tables(entries, events, window),
+		...plan_tables(records, window, options),
 		lane_process_stats.table(entries, window),
 		lane_check_stats.table(entries, window),
 		lane_claim_stats.table(entries, window),

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

@@ -1,5 +1,6 @@
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
 import { run_ship_planned } from '#scripts/run/ship/run-ship-planned'
+import { run_ship_pre_detach } from '#scripts/run/ship/run-ship-pre-detach'
 import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
 import { lane_ledger, type LedgerEntry, type StopEntry } from './lane-ledger'
 import type { IssueAt } from './lane-spans'
@@ -128,11 +129,19 @@ function noticed(cause: string, stop: IssueAt, notices: ReadonlyArray<IssueAt>):
 	return is_noticed ? `${cause}${NOTICED}` : cause
 }
 
+// An `unpinned` precondition counts under the path its stop took, `unpinned:no-reason`
+// (joshuafolkken/kit#7552); one recorded before it had the path stays `unpinned`.
+function with_path(kind: string, stop: StopEntry): string {
+	if (kind !== run_ship_pre_detach.UNPINNED || stop.unpinned === undefined) return kind
+
+	return `${kind}:${stop.unpinned.path}`
+}
+
 // A stop recorded before it named its preconditions (joshuafolkken/kit#4166) or its finding kinds
 // (joshuafolkken/kit#4426) counts under its cause.
 function causes_of(stop: StopEntry, notices: ReadonlyArray<IssueAt>): ReadonlyArray<string> {
 	const { preconditions = [], findings = [] } = stop
-	const kinds = [...preconditions, ...findings]
+	const kinds = [...preconditions.map((kind) => with_path(kind, stop)), ...findings]
 
 	if (kinds.length === 0) return [stop.cause ?? UNRECORDED_CAUSE]
 

package/scripts/lane/lane-table-rows.ts

@@ -0,0 +1,26 @@
+// A per-lane table's rows capped for `josh lane:stats`' default output (joshuafolkken/kit#7578): a
+// period of hundreds of lanes printed every row and overflowed a session's output cap. The rows past
+// the cap become one note; `--all` prints every row, and `josh lane:value cell` always reads them all.
+
+interface TableOptions {
+	// `--all`: every row, no note.
+	is_all: boolean
+}
+
+const ALL_ROWS: TableOptions = { is_all: true }
+
+function omitted_note(omitted: number): string {
+	return `… ${String(omitted)} more rows omitted — \`--all\` prints every row`
+}
+
+// The first `cap` of `rows`, in their order, and a note naming how many were left out.
+function capped(rows: ReadonlyArray<string>, cap: number, options: TableOptions): Array<string> {
+	if (options.is_all || rows.length <= cap) return [...rows]
+
+	return [...rows.slice(0, cap), '', omitted_note(rows.length - cap)]
+}
+
+const lane_table_rows = { ALL_ROWS, capped }
+
+export { lane_table_rows }
+export type { TableOptions }

package/scripts/lib/timeouts.ts

@@ -30,9 +30,10 @@ const GH_API_TIMEOUT_MS = 20_000
 const COMMAND_TIMEOUT_MS = 30_000
 // A type-aware ESLint run over a few files. A cold one is seconds; this is two orders beyond that.
 const LINT_TIMEOUT_MS = 180_000
-// A `pnpm install` or a global install, which can download the whole dependency tree on a cold
-// store. Ten minutes covers that fetch and still ends the command when a registry never answers. It
-// is well under `SUITE_TIMEOUT_MS` because it blocks a command a person is waiting on.
+// A `pnpm install`, a global install or a `--lockfile-only` resolution, which can fetch the whole
+// dependency tree (tarballs, or every package's metadata) on a cold store or cache. Ten minutes covers
+// that fetch and still ends the command when a registry never answers. It is well under
+// `SUITE_TIMEOUT_MS` because it blocks a command a person is waiting on.
 const INSTALL_TIMEOUT_MS = 600_000
 // A check or step that can run a consumer's full unit suite or a `pnpm add` — long enough for a cold
 // suite on a large consumer, short enough that a hung child ends the run instead of holding it open

package/scripts/registry-migration/migrate-lock.ts

@@ -75,21 +75,53 @@ function strip_tarball(resolution: unknown): void {
 	if (yaml_document.is_mapping_document(resolution)) delete resolution['tarball']
 }
 
+// Registry metadata that differs between registries without changing what resolves: npm marks
+// packages deprecated, and lists this scope's optional peers where GitHub Packages omits them.
+function strip_registry_metadata(key: string, entry: Record<string, unknown>): void {
+	delete entry['deprecated']
+	if (!key.startsWith(SCOPE)) return
+	delete entry['peerDependenciesMeta']
+	strip_tarball(entry['resolution'])
+}
+
+function mapping_entries(section: unknown): Array<[string, Record<string, unknown>]> {
+	if (!yaml_document.is_mapping_document(section)) return []
+
+	return Object.entries(section).filter((pair): pair is [string, Record<string, unknown>] =>
+		yaml_document.is_mapping_document(pair[1]),
+	)
+}
+
 function strip_resolutions(document: Record<string, unknown>): void {
-	if (!yaml_document.is_mapping_document(document['packages'])) return
-	const scoped = Object.entries(document['packages']).filter(([key]) => key.startsWith(SCOPE))
+	const entries = mapping_entries(document['packages'])
 
-	for (const [, entry] of scoped) {
-		if (yaml_document.is_mapping_document(entry)) strip_tarball(entry['resolution'])
-	}
+	for (const [key, entry] of entries) strip_registry_metadata(key, entry)
 }
 
-// Compare every document, importer, snapshot and unrelated resolution. The resolver may only
-// replace this scope's tarball locations; integrity and unrelated metadata must stay unchanged.
+function sort_peers(entry: Record<string, unknown>): void {
+	const peers: unknown = entry['transitivePeerDependencies']
+	if (!Array.isArray(peers)) return
+	entry['transitivePeerDependencies'] = peers
+		.map(String)
+		.toSorted((left, right) => left.localeCompare(right))
+}
+
+// That peer metadata reorders this scope's transitive peer lists; their members still compare.
+function sort_peer_lists(document: Record<string, unknown>): void {
+	const scoped = mapping_entries(document['snapshots']).filter(([key]) => key.startsWith(SCOPE))
+
+	for (const [, entry] of scoped) sort_peers(entry)
+}
+
+// Compare every document, importer, snapshot and resolution. The resolver may only replace this
+// scope's tarball locations and registry metadata; versions, integrity and the graph must stay.
 function graph(content: string): Array<Record<string, unknown>> {
 	const documents = yaml_document.parse_yaml_documents(content)
 
-	for (const document of documents) strip_resolutions(document)
+	for (const document of documents) {
+		strip_resolutions(document)
+		sort_peer_lists(document)
+	}
 
 	return documents
 }

package/scripts/registry-migration/migrate.ts

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'n
 import path from 'node:path'
 import { error_text } from '#scripts/lib/error-message'
 import { timed_fetch } from '#scripts/lib/timed-fetch'
-import { COMMAND_TIMEOUT_MS } from '#scripts/lib/timeouts'
+import { COMMAND_TIMEOUT_MS, INSTALL_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import { npm_registry } from '#scripts/version/npm-registry'
 import { execaSync } from 'execa'
 import { migrate_files } from './migrate-files'
@@ -42,6 +42,8 @@ function resolve(directory: string): void {
 			'update',
 			'--patches',
 			'--lockfile-only',
+			// Without it pnpm raises each range to its locked version, in package.json and the lock.
+			'--no-save',
 			'--ignore-scripts',
 			'--ignore-pnpmfile',
 			'--lockfile-dir',
@@ -49,7 +51,7 @@ function resolve(directory: string): void {
 		],
 		{
 			cwd: directory,
-			timeout: COMMAND_TIMEOUT_MS,
+			timeout: INSTALL_TIMEOUT_MS,
 			stdio: 'pipe',
 		},
 	)
@@ -174,7 +176,8 @@ function validate(root: string, version: string, dependencies: MigrationDependen
 
 	if (actual !== migrate_lock.PNPM_VERSION) {
 		throw new Error(
-			`Verified pnpm version: ${migrate_lock.PNPM_VERSION}; actual: ${actual}; no files changed`,
+			`Verified pnpm version: ${migrate_lock.PNPM_VERSION}; actual: ${actual}; no files changed. ` +
+				`Run \`pnpm self-update ${migrate_lock.PNPM_VERSION}\` in the project root, then run the migration again`,
 		)
 	}
 

package/scripts/release/release-publish.ts

@@ -3,6 +3,7 @@ import { git_pr_merge_checked } from '#scripts/gh/git-pr-merge-checked'
 import { git_command } from '#scripts/git/git-command'
 import { git_remote_branch } from '#scripts/git/git-remote-branch'
 import { repository_lock } from '#scripts/git/repository-lock'
+import { pre_push_related_switch } from '#scripts/hooks/pre-push-related-switch'
 import { IGNORE_FOR_RELEASE_LABEL } from '#scripts/issue/issue-labels'
 import { PACKAGE_JSON } from '#scripts/lib/package-manifest'
 import { write_version } from '#scripts/version/bump-version'
@@ -10,6 +11,7 @@ import { release_approval_prune } from './release-approval-prune'
 import { release_issue_close } from './release-issue-close'
 import type { ReleasePlan } from './release-plan'
 import { release_progress } from './release-progress'
+import { release_step_time } from './release-step-time'
 import { release_tag } from './release-tag'
 import { release_worktree } from './release-worktree'
 
@@ -26,6 +28,13 @@ const FAILURE_EXIT_CODE = 1
 const RELEASE_LOCK_PREFIX = 'josh-release-lock-'
 // A release waits on CI for minutes, so a second run refuses rather than queueing behind it.
 const RELEASE_LOCK_MAX_WAIT_MS = 0
+// The release push runs the related unit tests rather than the whole suite: this worktree is new, so
+// no gate record covers it, and the release pull request's CI runs the whole suite over the same tree
+// before it merges (joshuafolkken/kit#7539).
+const RELATED_PUSH_ENVIRONMENT = {
+	[pre_push_related_switch.SWITCH_ENV_KEY]: pre_push_related_switch.SWITCH_ON,
+}
+const { STEP, timed } = release_step_time
 
 function branch_name_for(version: string): string {
 	return `release/v${version}`
@@ -106,12 +115,20 @@ async function clear_the_way(branch_name: string): Promise<void> {
 // before that creation, because `worktree_add` makes the branch local and `branch_exists` would then
 // report every release as already taken. This runs after `process.chdir` into the work tree, so the
 // version write and the git commands all act on it rather than on the root.
-async function commit_release(plan: ReleasePlan): Promise<string> {
+async function commit_version(plan: ReleasePlan): Promise<void> {
 	write_version(plan.next_version)
 	await git_command.add_path(PACKAGE_JSON)
 	await release_approval_prune.prune()
 	await git_command.commit(commit_message(plan.next_version))
-	await git_command.push()
+}
+
+async function commit_release(plan: ReleasePlan): Promise<string> {
+	await timed(STEP.COMMIT, async () => {
+		await commit_version(plan)
+	})
+	await timed(STEP.PUSH, async () => {
+		await git_command.push(RELATED_PUSH_ENVIRONMENT)
+	})
 	const pr_url = await git_gh_command.pr_create(
 		commit_message(plan.next_version),
 		pull_request_body(plan),
@@ -159,7 +176,10 @@ async function publish_locked(plan: ReleasePlan): Promise<number> {
 
 	await clear_the_way(branch_name)
 
-	const directory = await release_worktree.create(branch_name)
+	const directory = await timed(
+		STEP.WORKTREE,
+		async () => await release_worktree.create(branch_name),
+	)
 	const previous_cwd = process.cwd()
 
 	try {

package/scripts/release/release-step-time.ts

@@ -0,0 +1,61 @@
+import { time_format } from '#scripts/time-runtime/time-format'
+
+// The local half of `pnpm josh release` — the work tree and its install, the commit, the push — prints
+// one line per step with its elapsed time, so the push's pre-hook cost can be read after a run; the
+// pull request, CI and publish halves are already timed by their GitHub runs (joshuafolkken/kit#7540).
+// `run_ship_lap.timed` is not reused: it only writes the lane ledger inside a ship stage and prints
+// nothing, so a release outside any stage would get no line from it.
+
+const STEP = {
+	WORKTREE: 'work tree and install',
+	COMMIT: 'commit',
+	PUSH: 'push',
+} as const
+
+const FAILED_SUFFIX = ' (failed)'
+
+interface StepClock {
+	now: () => number
+	print: (line: string) => void
+}
+
+function monotonic_now(): number {
+	return performance.now()
+}
+
+function print_info(line: string): void {
+	console.info(line)
+}
+
+const DEFAULT_CLOCK: StepClock = { now: monotonic_now, print: print_info }
+
+function step_line(step: string, elapsed_ms: number, is_failed: boolean): string {
+	const suffix = is_failed ? FAILED_SUFFIX : ''
+
+	return `⏱️ Release ${step}: ${time_format.format_seconds(elapsed_ms)}${suffix}`
+}
+
+// A step that threw still prints the time it ran before failing, then its error goes on unchanged.
+async function timed<T>(
+	step: string,
+	run: () => Promise<T>,
+	clock: StepClock = DEFAULT_CLOCK,
+): Promise<T> {
+	const started_ms = clock.now()
+	const outcome = { is_failed: true }
+
+	try {
+		const result = await run()
+
+		outcome.is_failed = false
+
+		return result
+	} finally {
+		clock.print(step_line(step, clock.now() - started_ms, outcome.is_failed))
+	}
+}
+
+const release_step_time = { STEP, timed }
+
+export type { StepClock }
+export { release_step_time }

package/scripts/review/disposition-batch-filing.ts

@@ -56,8 +56,21 @@ function background_lines(finding: BatchFinding, issue: number): ReadonlyArray<s
 	]
 }
 
+// The plain-language summary `issue:file` requires first, for the person deciding on the finding.
+function summary_lines(issue: number): ReadonlyArray<string> {
+	return [
+		issue_body_keys.heading('summary'),
+		'',
+		`**${cite(issue)} のレビューで見つかり、その場では直さずに持ち越した指摘です。**`,
+		'',
+		'レビューの回数に上限があるため、上限に達した時点で残った指摘をここへ移しました。下の現象が起きないように直せば完了です。',
+		'',
+	]
+}
+
 function body_of(finding: BatchFinding, issue: number): string {
 	return [
+		...summary_lines(issue),
 		`parent: ${cite(issue)}`,
 		'',
 		...background_lines(finding, issue),

package/scripts/rules/git-argv.ts

@@ -59,6 +59,7 @@ const VALUE_TAKING_GLOBALS: ReadonlySet<string> = new Set([
 	'--namespace',
 	'--exec-path',
 	'--super-prefix',
+	'--attr-source',
 	CONFIG_ENV,
 ])
 
@@ -198,13 +199,18 @@ function config_value(flag: string, next: string | undefined): string | undefine
 	return ATTACHED_CONFIG.exec(flag)?.[1]
 }
 
+// The git global options in front of the subcommand among the words after `git`, values included:
+// `-C p -c k=v status` gives `['-C', 'p', '-c', 'k=v']`.
+function globals_of(words: ReadonlyArray<string>): Array<string> {
+	return words.slice(0, after_globals(words))
+}
+
 function config_arguments_of(segment: string): Array<string> {
-	const words = arguments_of(segment, GIT_COMMAND) ?? []
+	const words = globals_of(arguments_of(segment, GIT_COMMAND) ?? [])
 	const values: Array<string> = []
-	const end = after_globals(words)
 	let index = 0
 
-	while (index < end) {
+	while (index < words.length) {
 		const flag = words[index] ?? ''
 		const value = config_value(flag, words[index + NEXT])
 
@@ -235,6 +241,7 @@ function short_cluster_has(token: string, letters: string): boolean {
 const git_argv = {
 	arguments_of,
 	config_arguments_of,
+	globals_of,
 	parse,
 	program_of,
 	short_cluster_has,