@joshuafolkken/kit 1.1784.0 → 1.2114.0

package/scripts/issue/defect-origin-line.ts

@@ -1,5 +1,6 @@
 import { issue_bug_label } from './issue-bug-label'
 import { markdown_section } from './markdown-section'
+import { reproduction_measure } from './reproduction-measure'
 
 // The origin line a bug body declares under its background heading: the merged pull request that
 // introduced the defect, or "unknown" with the reason it could not be traced. `defect:report` groups
@@ -12,6 +13,8 @@ const MISSING_ORIGIN =
 	'missing origin line: a `- 種別: 不具合` body declares `- 原因: #<PR>` or `- 原因: 不明（<reason>）` under ## 背景 (`pnpm josh defect:origin <N>` lists candidates)'
 const MALFORMED_ORIGIN =
 	'malformed origin line: write `- 原因: #<PR>` or `- 原因: 不明（<reason>）` with a non-empty reason'
+const MISSING_REPRODUCTION =
+	'missing reproduction: a `- 原因: 不明（<reason>）` bug carries ## 再現 with a backticked command and its actual output in a fenced block'
 
 type DefectOrigin = { kind: 'pr'; pr: number } | { kind: 'unknown'; reason: string }
 
@@ -54,7 +57,22 @@ function problem(body: string): string | undefined {
 	return lines.every((line) => parse_line(line) !== undefined) ? undefined : MALFORMED_ORIGIN
 }
 
-const defect_origin_line = { MALFORMED_ORIGIN, MISSING_ORIGIN, parse, problem }
+// An untraced bug owes the lane a way to see it: without a reproduction the run starts by
+// investigating. A traced one (a pull request origin) already names where to look, so it owes none.
+function reproduction_problem(body: string): string | undefined {
+	if (!issue_bug_label.is_bug_fix(body) || parse(body)?.kind !== 'unknown') return undefined
+
+	return reproduction_measure.has_command_output(body) ? undefined : MISSING_REPRODUCTION
+}
+
+const defect_origin_line = {
+	MALFORMED_ORIGIN,
+	MISSING_ORIGIN,
+	MISSING_REPRODUCTION,
+	parse,
+	problem,
+	reproduction_problem,
+}
 
 export type { DefectOrigin }
 export { defect_origin_line }

package/scripts/issue/defect-rate-cli.ts

@@ -1,19 +1,8 @@
-import { git_gh_exec } from '#scripts/gh/git-gh-exec'
-import { issue_label_schema } from '#scripts/git/git-schemas'
-import { parse_json } from '#scripts/git/parse-json-array'
 import { shared_cache, type CacheSlot } from '#scripts/josh/shared-cache'
-import { bounded_pool } from '#scripts/lib/bounded-pool'
 import { z } from 'zod'
-import { defect_rate, type DefectRate, type RateIssue } from './defect-rate'
+import { defect_rate, type DefectRate } from './defect-rate'
+import { issue_search } from './issue-search'
 
-const PER_PAGE = '100'
-const FIRST_PAGE = 1
-const SECOND_PAGE = 2
-// The search API serves at most this many results, so a window past it holds no further page.
-const SEARCH_RESULT_CEILING = 1000
-// The search API allows 30 requests a minute; both searches together stay at the ~10 requests the
-// sequential walk made, so this bounds only how many are in flight at once.
-const PAGE_CONCURRENCY = 4
 const MS_PER_MINUTE = 60_000
 const CACHE_TTL_MINUTES = 15
 // A 14-day rate does not move within a quarter of an hour, and every `backlog:next` / `backlog:plan`
@@ -32,100 +21,14 @@ const defect_rate_schema = z.object({
 	is_capped: z.boolean(),
 })
 
-const search_item_schema = z.object({
-	body: z.string().nullish(),
-	labels: z.array(issue_label_schema),
-})
-
-// One page of `search/issues`.
-const search_page_schema = z.object({
-	total_count: z.number(),
-	incomplete_results: z.boolean(),
-	items: z.array(search_item_schema),
-})
-
-type SearchPage = z.infer<typeof search_page_schema>
-
-interface SearchResult {
-	issues: ReadonlyArray<RateIssue>
-	is_capped: boolean
-}
-
-function search_path(query: string, page: number = FIRST_PAGE): string {
-	const parameters = new URLSearchParams({ q: query, per_page: PER_PAGE })
-
-	if (page !== FIRST_PAGE) parameters.set('page', String(page))
-
-	return `search/issues?${parameters.toString()}`
-}
-
-// How many pages the search holds, read off the first page's own count. Bounded by the API's
-// ceiling, past which GitHub serves no page at all — so this asks for exactly the pages `gh api
-// --paginate` would walk to.
-function page_count(first: SearchPage): number {
-	return Math.ceil(Math.min(first.total_count, SEARCH_RESULT_CEILING) / Number(PER_PAGE))
-}
-
-async function read_page(query: string, page: number): Promise<SearchPage | undefined> {
-	const raw = await git_gh_exec.exec_gh_api({ path: search_path(query, page) })
-
-	return parse_json.parse_json_object_or_undefined(raw, search_page_schema)
-}
-
-// Every page of one search. Not `gh api --paginate`: it follows each page's `next` link one page
-// after another, at about 1.5 s a page, on every `backlog:plan`. The first page names the total, so
-// the rest are fetched together; any page that does not read fails the whole search.
-async function read_pages(query: string): Promise<ReadonlyArray<SearchPage> | undefined> {
-	const first = await read_page(query, FIRST_PAGE)
-
-	if (first === undefined) return undefined
-
-	const rest_numbers = Array.from(
-		{ length: Math.max(page_count(first) - FIRST_PAGE, 0) },
-		(_value, index) => index + SECOND_PAGE,
-	)
-	const rest = await bounded_pool.bounded_map(
-		rest_numbers,
-		PAGE_CONCURRENCY,
-		async (page) => await read_page(query, page),
-	)
-
-	return rest.every((page) => page !== undefined) ? [first, ...rest] : undefined
-}
-
-function to_result(pages: ReadonlyArray<SearchPage>): SearchResult {
-	const issues = pages.flatMap((page) =>
-		page.items.map((item) => ({
-			body: item.body ?? '',
-			labels: item.labels.map((label) => label.name),
-		})),
-	)
-	// The search API serves at most 1000 results, and says so only by a total larger than what it
-	// handed back — a window past that ceiling is measured on part of itself.
-	const total = pages[0]?.total_count ?? 0
-	const is_incomplete = pages.some((page) => page.incomplete_results)
-
-	return { issues, is_capped: is_incomplete || total > issues.length }
-}
-
-async function search(query: string): Promise<SearchResult | undefined> {
-	try {
-		const pages = await read_pages(query)
-
-		return pages === undefined ? undefined : to_result(pages)
-	} catch {
-		return undefined
-	}
-}
-
 async function measure_uncached(
 	repo: string,
 	days: number,
 	since: string,
 ): Promise<DefectRate | undefined> {
 	const [filed, completed] = await Promise.all([
-		search(defect_rate.filed_query(repo, since)),
-		search(defect_rate.completed_query(repo, since)),
+		issue_search.search(defect_rate.filed_query(repo, since)),
+		issue_search.search(defect_rate.completed_query(repo, since)),
 	])
 
 	if (filed === undefined || completed === undefined) return undefined
@@ -158,6 +61,6 @@ async function measure_window(
 	)
 }
 
-const defect_rate_cli = { RATE_CACHE, search_path, measure_window }
+const defect_rate_cli = { RATE_CACHE, measure_window }
 
 export { defect_rate_cli }

package/scripts/issue/defect-report.ts

@@ -1,3 +1,4 @@
+import { run_record_path } from '#scripts/josh/run-record-path'
 import { defect_origin_line } from './defect-origin-line'
 
 // Defects grouped by the pull request each one's origin line names: how many per pull request, per
@@ -14,9 +15,6 @@ const SCRIPT_AREA_DEPTH = 2
 const ROOT_AREA = '(root)'
 const UNREAD_AREA = '(pull request not read)'
 const TEST_FILE = /\.(?:test|e2e)\.ts$|\.snap$/u
-// The run's own records — observations, accepted metrics — which nearly every merge adds, so they
-// say nothing about what the pull request changed.
-const RUN_RECORD_ROOT = '.josh/'
 
 type ChangeKind = 'add' | 'fix' | 'remove'
 
@@ -54,8 +52,10 @@ interface DefectReport {
 	added_within_week: ReadonlyMap<number, number>
 }
 
+// The run's own records, which nearly every merge adds, say nothing about what the pull request
+// changed.
 function changed(files: ReadonlyArray<PrFile>): ReadonlyArray<PrFile> {
-	return files.filter((file) => !file.filename.startsWith(RUN_RECORD_ROOT))
+	return files.filter((file) => !run_record_path.is_run_record(file.filename))
 }
 
 // A pull request that brought in a new non-test file added a mechanism; one that took out more than it

package/scripts/issue/effect-audit-cli.ts

@@ -0,0 +1,178 @@
+#!/usr/bin/env tsx
+import { writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { bounded_pool } from '#scripts/lib/bounded-pool'
+import { cli_flags } from '#scripts/lib/cli-flags'
+import { defect_rate } from './defect-rate'
+import { effect_audit, type AuditRow, type FollowUp } from './effect-audit'
+import { issue_sample_prime } from './issue-sample-prime'
+import { issue_search, type SearchIssue } from './issue-search'
+import { session_cite } from './session-cite'
+
+// `josh effect:audit [--days <N>] [--draft <N>]` — every run-time-shortening issue closed in the window,
+// one line each: its expected effect, its follow-up measurements and their verdict (`effect-audit.ts`).
+// `--draft <N>` writes the retirement candidate for an issue whose measurement fell short and prints the
+// `issue:file` line that files it once its placeholders are filled.
+
+const ARGV_OFFSET = 2
+const FAILURE_EXIT_CODE = 1
+const DEFAULT_DAYS = 30
+const PULL_CONCURRENCY = 4
+const USAGE = 'Usage: josh effect:audit [--days <N>] [--draft <issue-number>]'
+const OPTIONS = { days: { type: 'string' }, draft: { type: 'string' } } as const
+
+interface AuditRequest {
+	days: number
+	draft: number | undefined
+}
+
+interface Audit {
+	rows: ReadonlyArray<AuditRow>
+	since: string
+	is_capped: boolean
+	unattributed: number
+}
+
+interface CitedFollowUp {
+	issue: SearchIssue
+	pr: number
+}
+
+function positive(text: string | undefined): number | undefined {
+	const value = Number(text)
+
+	return Number.isSafeInteger(value) && value > 0 ? value : undefined
+}
+
+function with_draft(days: number, text: string | undefined): AuditRequest | undefined {
+	if (text === undefined) return { days, draft: undefined }
+	const draft = positive(text)
+
+	return draft === undefined ? undefined : { days, draft }
+}
+
+function parse_request(argv: ReadonlyArray<string>): AuditRequest | undefined {
+	const parsed = cli_flags.values_of(argv, OPTIONS)
+	if (parsed === undefined) return undefined
+	const days = positive(parsed.days ?? String(DEFAULT_DAYS))
+
+	return days === undefined ? undefined : with_draft(days, parsed.draft)
+}
+
+// The issue the cited pull request closes; an unreadable pull request leaves the follow-up unattributed,
+// and the listing counts it.
+async function measured_issue(pr: number): Promise<number | undefined> {
+	try {
+		const pull = await issue_sample_prime.read_source(pr)
+
+		return pull.closes
+	} catch {
+		return undefined
+	}
+}
+
+// Each cited pull request is read once, a few at a time: the follow-up search spans every date.
+async function closes_by_pull(
+	prs: ReadonlyArray<number>,
+): Promise<ReadonlyMap<number, number | undefined>> {
+	const unique = [...new Set(prs)]
+	const closes = await bounded_pool.bounded_map(unique, PULL_CONCURRENCY, measured_issue)
+
+	return new Map(unique.map((pr, index) => [pr, closes[index]]))
+}
+
+// A follow-up citing the issue form names what it measures itself; only a cited pull request is read.
+async function follow_ups_of(candidates: ReadonlyArray<SearchIssue>): Promise<Array<FollowUp>> {
+	const cited = candidates
+		.map((issue) => ({ issue, pr: effect_audit.cited_pull(issue) }))
+		.filter((entry): entry is CitedFollowUp => entry.pr !== undefined)
+	const closes = await closes_by_pull(cited.map(({ pr }) => pr))
+	const by_issue = candidates
+		.map((issue) => ({ issue, measures: effect_audit.cited_issue(issue) }))
+		.filter(({ measures }) => measures !== undefined)
+
+	return [...cited.map(({ issue, pr }) => ({ issue, measures: closes.get(pr) })), ...by_issue]
+}
+
+async function read_audit(repo: string, days: number, now_ms: number): Promise<Audit | undefined> {
+	const since = defect_rate.window_start(now_ms, days)
+	const [origins, follow_ups] = await Promise.all([
+		issue_search.search(effect_audit.origin_query(repo, since)),
+		issue_search.search(effect_audit.follow_up_query(repo)),
+	])
+
+	if (origins === undefined || follow_ups === undefined) return undefined
+
+	const linked = await follow_ups_of(follow_ups.issues)
+	const rows = effect_audit.rows(origins.issues, linked)
+	const unattributed = linked.filter((follow_up) => follow_up.measures === undefined).length
+
+	return { rows, since, is_capped: origins.is_capped || follow_ups.is_capped, unattributed }
+}
+
+function print_audit(audit: Audit): number {
+	console.info(effect_audit.summary(audit.rows, audit.since))
+	for (const row of audit.rows) console.info(session_cite.text(effect_audit.format_row(row)))
+	if (audit.is_capped) console.info('(capped: the search served part of the window only)')
+
+	if (audit.unattributed > 0) {
+		console.info(
+			`(${String(audit.unattributed)} follow-ups measure no issue: their pull request could not be read or closes none)`,
+		)
+	}
+
+	return 0
+}
+
+function print_draft(rows: ReadonlyArray<AuditRow>, issue: number): number {
+	const row = rows.find((candidate) => candidate.origin.number === issue)
+
+	if (row?.result !== 'unmet') {
+		console.error(
+			`${session_cite.issue(issue)} is not an issue of the window whose measurement fell short`,
+		)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	const file = path.join(tmpdir(), `josh-effect-retire-${String(issue)}.md`)
+
+	writeFileSync(file, effect_audit.draft_body(row))
+	console.info(`Fill in the <...> lines of ${file}, then file it:`)
+	console.info(
+		`pnpm josh issue:file "${effect_audit.draft_title(row)}" --body-file ${file} --label run:lane`,
+	)
+
+	return 0
+}
+
+async function audit_of(request: AuditRequest, now_ms: number): Promise<Audit | undefined> {
+	const repo = await git_gh_command.repo_get_name_with_owner()
+
+	return repo === undefined ? undefined : await read_audit(repo, request.days, now_ms)
+}
+
+async function run(argv: ReadonlyArray<string>, now_ms: number = Date.now()): Promise<number> {
+	const request = parse_request(argv)
+	if (request === undefined) return (console.error(USAGE), FAILURE_EXIT_CODE)
+	const audit = await audit_of(request, now_ms)
+
+	if (audit === undefined) {
+		return (console.error('effect:audit: the issue search could not be read'), FAILURE_EXIT_CODE)
+	}
+
+	return request.draft === undefined ? print_audit(audit) : print_draft(audit.rows, request.draft)
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const effect_audit_cli = { run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { effect_audit_cli }

package/scripts/issue/effect-audit.ts

@@ -0,0 +1,185 @@
+import { expected_effect_lint } from './expected-effect-lint'
+import { issue_cite } from './issue-cite'
+import { has_label_name, MEASURED_LABEL, MEASURED_UNMET_LABEL } from './issue-labels'
+import { issue_sample_gate } from './issue-sample-gate'
+import type { SearchIssue } from './issue-search'
+
+// joshuafolkken/kit#4958: a run-time-shortening issue states its expected effect at filing
+// (`expected-effect-lint.ts`), and nothing read it again once merged. This sets each closed one beside
+// the follow-up measurements of it — issues whose run condition names the pull request that closed it
+// — and their recorded verdict: `measured:unmet` fell short, `measured` alone reached it, anything else
+// is not measured yet. A shortfall is drafted as a retirement candidate for `issue:file`.
+
+const EFFECT_LABELS: ReadonlyArray<string> = ['効く率', '1 回あたりの得', '外れたときの損']
+const NO_VALUE = '—'
+const RESULTS = ['met', 'unmet', 'unmeasured'] as const
+
+type EffectResult = (typeof RESULTS)[number]
+
+interface AuditRow {
+	origin: SearchIssue
+	follow_ups: ReadonlyArray<SearchIssue>
+	result: EffectResult
+}
+
+// A follow-up and the issue it measures: the one its run condition's pull request closes. A body
+// naming other issues (a parent, lanes it compares against) measures none of them.
+interface FollowUp {
+	issue: SearchIssue
+	measures: number | undefined
+}
+
+const RESULT_WORDS: Readonly<Record<EffectResult, string>> = {
+	met: '届いた',
+	unmet: '届かなかった',
+	unmeasured: '未計測',
+}
+
+// Plain: the rows feed an issue body as well as the session, which links them where it prints them.
+function cite(issue: SearchIssue): string {
+	return issue_cite.plain(issue.number)
+}
+
+// The closed time-shortening issues of the window. The search narrows by the declaration's words; the
+// exact line under the background heading is checked on each body, since the search matches the
+// follow-ups' own "confirm the shortening" aim too.
+function origin_query(repo: string, since: string): string {
+	return `repo:${repo} is:issue is:closed reason:completed closed:>=${since} "目的: 時間短縮" in:body`
+}
+
+// Every follow-up measurement, of any date: one may be filed before or long after its origin closed.
+function follow_up_query(repo: string): string {
+	return `repo:${repo} is:issue "実施可能条件" in:body`
+}
+
+// The pull request a follow-up's run condition names, or `undefined` for an issue that declares none
+// or cites the issue whose closing pull request it waits on.
+function cited_pull(issue: SearchIssue): number | undefined {
+	return issue_sample_gate.cited_via(issue.body, 'pull')
+}
+
+// The issue a follow-up's run condition names by the issue form — the issue it measures, unread.
+function cited_issue(issue: SearchIssue): number | undefined {
+	return issue_sample_gate.cited_via(issue.body, 'issue')
+}
+
+// One shortfall outweighs any reach: a mechanism some measurement found wanting is the one to look at.
+function result_of(follow_ups: ReadonlyArray<SearchIssue>): EffectResult {
+	if (follow_ups.some((issue) => has_label_name(issue.labels, MEASURED_UNMET_LABEL))) return 'unmet'
+
+	return follow_ups.some((issue) => has_label_name(issue.labels, MEASURED_LABEL))
+		? 'met'
+		: 'unmeasured'
+}
+
+function row_of(origin: SearchIssue, follow_ups: ReadonlyArray<FollowUp>): AuditRow {
+	const measuring = follow_ups
+		.filter((follow_up) => follow_up.measures === origin.number)
+		.map((follow_up) => follow_up.issue)
+
+	return { origin, follow_ups: measuring, result: result_of(measuring) }
+}
+
+function rows(
+	origins: ReadonlyArray<SearchIssue>,
+	follow_ups: ReadonlyArray<FollowUp>,
+): ReadonlyArray<AuditRow> {
+	return origins
+		.filter((origin) => expected_effect_lint.is_target(origin.body))
+		.map((origin) => row_of(origin, follow_ups))
+}
+
+function effect_text(body: string): string {
+	return EFFECT_LABELS.map(
+		(label) => `${label} ${expected_effect_lint.value_of(body, label) ?? NO_VALUE}`,
+	).join(' · ')
+}
+
+function follow_up_text(follow_ups: ReadonlyArray<SearchIssue>): string {
+	if (follow_ups.length === 0) return 'なし'
+
+	return follow_ups.map((issue) => `${cite(issue)} (${issue.state})`).join(', ')
+}
+
+function format_row(row: AuditRow): string {
+	const effect = `期待効果: ${effect_text(row.origin.body)}`
+	const measured = `後続計測: ${follow_up_text(row.follow_ups)}`
+
+	return `${cite(row.origin)} — ${effect} — ${measured} — 結果: ${RESULT_WORDS[row.result]}`
+}
+
+function tally(audit_rows: ReadonlyArray<AuditRow>, result: EffectResult): string {
+	return `${RESULT_WORDS[result]} ${String(audit_rows.filter((row) => row.result === result).length)}`
+}
+
+function summary(audit_rows: ReadonlyArray<AuditRow>, since: string): string {
+	const tallies = RESULTS.map((result) => tally(audit_rows, result)).join(' · ')
+
+	return `effect:audit — closed since ${since}: ${String(audit_rows.length)} issues · ${tallies}`
+}
+
+function unmet_measurements(row: AuditRow): string {
+	return row.follow_ups
+		.filter((issue) => has_label_name(issue.labels, MEASURED_UNMET_LABEL))
+		.map((issue) => cite(issue))
+		.join(', ')
+}
+
+function draft_title(row: AuditRow): string {
+	return `Retire or shrink the mechanism of ${cite(row.origin)}, which fell short of its expected effect`
+}
+
+function background_lines(origin: string, measurements: string): ReadonlyArray<string> {
+	return [
+		'## 背景',
+		'',
+		'- 種別: 非不具合',
+		'- 目的: 機能改善',
+		'- 人の判断: 不要',
+		'- 優先度: 通常',
+		'- 規模見積もり: 約 <N> ファイル / <M> 行（テスト除く）',
+		`- 出どころ: ${measurements} の計測（\`measured:unmet\`）`,
+		'',
+		`${origin} で足した機構は、後続計測 ${measurements} で期待効果に届かなかった。効かない機構は利用者の実行時間・読む量・保守の負担を増やすので、撤去するか、効く範囲に縮小する。`,
+	]
+}
+
+// The retirement candidate's body. The scale line is what only the filer knows: `issue:lint` refuses
+// it until it is filled, and `issue:file`'s scout stops a duplicate.
+function draft_body(row: AuditRow): string {
+	const origin = cite(row.origin)
+	const measurements = unmet_measurements(row)
+
+	return [
+		...background_lines(origin, measurements),
+		'',
+		'## 現象',
+		'',
+		`- ${origin} の期待効果: ${effect_text(row.origin.body)}`,
+		`- 計測 ${measurements} の結果: 届かなかった`,
+		'',
+		'## 期待結果',
+		'',
+		`- ${origin} で足した機構が撤去されているか、効く範囲に縮小されている`,
+		'',
+		'## 受け入れ条件',
+		'',
+		`- [ ] ${origin} で足した機構を撤去するか縮小し、どちらを選んだかとその理由を記録する`,
+		'',
+	].join('\n')
+}
+
+const effect_audit = {
+	cited_issue,
+	cited_pull,
+	draft_body,
+	draft_title,
+	follow_up_query,
+	format_row,
+	origin_query,
+	rows,
+	summary,
+}
+
+export type { AuditRow, EffectResult, FollowUp }
+export { effect_audit }

package/scripts/issue/expected-effect-lint.ts

@@ -9,7 +9,18 @@ import { markdown_section } from './markdown-section'
 const DECLARATION_LINE = '- 目的: 時間短縮'
 const BACKGROUND_HEADING = '## 背景'
 const HEADING = '## 期待効果'
-const ITEM_LABELS: ReadonlyArray<string> = ['効く率', '1 回あたりの得', '外れたときの損', '出典']
+const RATE_LABEL = '効く率'
+const GAIN_LABEL = '1 回あたりの得'
+const ITEM_LABELS: ReadonlyArray<string> = [RATE_LABEL, GAIN_LABEL, '外れたときの損', '出典']
+// The numbers the backlog ranking reads off the rate and the gain (joshuafolkken/kit#5302).
+const WEEK = '週'
+const COUNT = /(?<![\d.])(?<count>\d+) ?回/gu
+const SPAN = /(?<![\d.])(?<weeks>\d+) ?週/u
+const ONE_WEEK = 1
+const DURATION = /(?<![\d.])(?<amount>\d+(?:\.\d+)?) ?(?<unit>[分秒])/u
+const SECONDS_UNIT = '秒'
+const SECONDS_PER_MINUTE = 60
+const NONE = 0
 // A template placeholder value — the `<...>` guidance a filed Issue replaces. It is not an estimate, but a
 // value that only opens with `<` (an upper bound such as `<1 min`) is one, so the placeholder must close with `>` too.
 const PLACEHOLDER = /^<.*>$/u
@@ -29,22 +40,64 @@ function item_value(line: string, label: string): string | undefined {
 	return line.slice(prefix.length).trim()
 }
 
-function has_item(lines: ReadonlyArray<string>, label: string): boolean {
-	return lines.some((line) => {
-		const value = item_value(line.trim(), label)
+function is_stated(value: string | undefined): value is string {
+	return value !== undefined && value.length > 0 && !PLACEHOLDER.test(value)
+}
+
+function stated_value(lines: ReadonlyArray<string>, label: string): string | undefined {
+	return lines.map((line) => item_value(line.trim(), label)).find((value) => is_stated(value))
+}
+
+function effect_lines(body: string): ReadonlyArray<string> {
+	const section = markdown_section.section_lines(body, HEADING).join('\n')
+
+	return markdown_section.unfenced_lines(section)
+}
+
+// The value the body's expected-effect section states for one item, or undefined when it states none.
+function value_of(body: string, label: string): string | undefined {
+	return stated_value(effect_lines(body), label)
+}
+
+// The weeks a rate is counted over: its stated span ("10 in 2 weeks", "1 every 2 weeks"), else one.
+function weeks_of(rate: string): number {
+	const weeks = SPAN.exec(rate)?.groups?.['weeks']
 
-		return value !== undefined && value.length > 0 && !PLACEHOLDER.test(value)
-	})
+	return Math.max(Number(weeks ?? ONE_WEEK), ONE_WEEK)
+}
+
+// The hits a week a rate states: its last count, so "5 of 23 a week" reads the 5 the speed-up applies to,
+// over its span of weeks. `0` when the rate names no week or no count.
+function weekly_hits(rate: string | undefined): number {
+	if (!rate?.includes(WEEK)) return NONE
+	const counts = [...rate.matchAll(COUNT)].map((match) => Number(match.groups?.['count']))
+
+	return (counts.at(-1) ?? NONE) / weeks_of(rate)
+}
+
+// The minutes one hit saves: the first number the gain states in seconds or minutes — a range written
+// with one closing unit ("3-6 min") reads its upper bound. `0` when it states none.
+function minutes_per_hit(gain = ''): number {
+	const groups = DURATION.exec(gain)?.groups
+	if (groups === undefined) return NONE
+	const amount = Number(groups['amount'])
+
+	return groups['unit'] === SECONDS_UNIT ? amount / SECONDS_PER_MINUTE : amount
+}
+
+// The minutes a week the declared speed-up saves — hits a week times the gain per hit — on the same
+// minute scale as `issue_priority.lost_minutes`. `0` when the rate or the gain is not a number.
+function weekly_minutes(body = ''): number {
+	return weekly_hits(value_of(body, RATE_LABEL)) * minutes_per_hit(value_of(body, GAIN_LABEL))
 }
 
 // Every expected-effect problem a body has, or an empty array. A body without the declaration has none.
 function problems(body: string): ReadonlyArray<string> {
 	if (!is_target(body)) return []
 	if (!markdown_section.has_line(body, HEADING)) return [`missing heading: ${HEADING}`]
-	const section = markdown_section.section_lines(body, HEADING).join('\n')
-	const lines = markdown_section.unfenced_lines(section)
+	const lines = effect_lines(body)
 
-	return ITEM_LABELS.filter((label) => !has_item(lines, label)).map(
+	return ITEM_LABELS.filter((label) => stated_value(lines, label) === undefined).map(
 		(label) => `missing expected-effect item: - ${label}: <value>`,
 	)
 }
@@ -55,6 +108,8 @@ const expected_effect_lint = {
 	ITEM_LABELS,
 	is_target,
 	problems,
+	value_of,
+	weekly_minutes,
 }
 
 export { expected_effect_lint }

package/scripts/issue/git-next-issues.ts

@@ -1,7 +1,9 @@
 import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { open_issue_schema, type OpenIssueData } from '#scripts/git/git-schemas'
 import { parse_json_array_safe } from '#scripts/git/parse-json-array'
+import { expected_effect_lint } from './expected-effect-lint'
 import { has_any_label, NOT_DIRECTLY_RUNNABLE_LABELS } from './issue-labels'
+import { issue_priority } from './issue-priority'
 import { issue_rank, type DependencyRow } from './issue-rank'
 import { session_cite } from './session-cite'
 
@@ -63,7 +65,10 @@ function order(
 	const dependents = issue_rank.count_dependents(candidates.map((issue) => dependency_row(issue)))
 
 	return issue_rank.rank(candidates, (issue) => ({
+		is_last: issue_priority.is_last(issue.body),
 		labels: (issue.labels ?? []).map((label) => label.name),
+		lost_minutes: issue_priority.lost_minutes(issue.body),
+		gain_minutes: expected_effect_lint.weekly_minutes(issue.body),
 		dependents: dependents.get(String(issue.number)) ?? 0,
 	}))
 }