@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/scripts/issue/issue-body-keys.ts

@@ -0,0 +1,227 @@
+import { session_language } from '#scripts/josh/session-language'
+
+// joshuafolkken/kit#7209: the single source of the Issue body's declaration keys, their fixed
+// values and the template's headings, as `issue-template.md` and `issue-template.en.md` write them. Each row
+// holds one column per body language, so a language is a column added here rather than a literal
+// changed across `scripts/`; the scan in `issue-body-keys.test.ts` keeps the literals here.
+// joshuafolkken/kit#7210: a body is written in the `JOSH_SESSION_LANG` column and read in either —
+// `canonical_line` rewrites a line written in the other column into the written one, so every reader
+// that matches the written text accepts both.
+
+interface Row {
+	ja: string
+	en: string
+}
+
+type Column = keyof Row
+
+const KEYS = {
+	kind: { ja: '種別', en: 'Type' },
+	purpose: { ja: '目的', en: 'Purpose' },
+	compatibility: { ja: '互換性', en: 'Compatibility' },
+	release: { ja: 'リリース分類', en: 'Release classification' },
+	judgement: { ja: '人の判断', en: 'Human judgement' },
+	decision_rule: { ja: '判定規則', en: 'Decision rule' },
+	close_condition: { ja: '中止条件', en: 'Close condition' },
+	priority: { ja: '優先度', en: 'Priority' },
+	security: { ja: 'セキュリティ', en: 'Security' },
+	cause_park: { ja: '原因の park', en: 'Cause park' },
+	cause_lane: { ja: '原因のレーン', en: 'Cause lane' },
+	cause_loss: { ja: '原因の損失', en: 'Cause loss' },
+	order: { ja: '実施順', en: 'Order' },
+	origin: { ja: '原因', en: 'Cause' },
+	size: { ja: '規模見積もり', en: 'Size estimate' },
+	no_split_reason: { ja: '分割しない理由', en: 'No-split reason' },
+	no_lines: { ja: '行を増やさない', en: 'No added lines' },
+	refactor_first: { ja: '先行リファクタ', en: 'Refactor first' },
+	enforcement: { ja: '強制', en: 'Enforcement' },
+	measurement: { ja: '計測', en: 'Measurement' },
+	measure_declaration: { ja: '計測宣言', en: 'Measure declaration' },
+	premise: { ja: '前提', en: 'Premise' },
+	measure_absent: { ja: '計測宣言なし', en: 'No measure declaration' },
+	sample_gate: { ja: '実施可能条件', en: 'Sample gate' },
+	not_before: { ja: '実施可能日', en: 'Not before' },
+	source: { ja: '出どころ', en: 'Source' },
+	constraint_source: { ja: '出所', en: 'Constraint source' },
+	constraint_reference: { ja: '参照', en: 'Constraint reference' },
+	constraint_instruction: { ja: '指示', en: 'Constraint instruction' },
+} as const satisfies Record<string, Row>
+
+const VALUES = {
+	bug: { ja: '不具合', en: 'defect' },
+	non_bug: { ja: '非不具合', en: 'non-defect' },
+	behavior_change: { ja: '振る舞い変更', en: 'behavior change' },
+	feature: { ja: '機能追加', en: 'feature' },
+	improvement: { ja: '機能改善', en: 'improvement' },
+	time_saving: { ja: '時間短縮', en: 'time saving' },
+	bug_fix: { ja: '不具合修正', en: 'bug fix' },
+	breaking: { ja: '破壊的変更', en: 'breaking change' },
+	not_needed: { ja: '不要', en: 'not needed' },
+	needed: { ja: '要', en: 'needed' },
+	normal: { ja: '通常', en: 'normal' },
+	high: { ja: '高', en: 'high' },
+	critical: { ja: '緊急', en: 'critical' },
+	last: { ja: '最後', en: 'last' },
+	unknown: { ja: '不明', en: 'unknown' },
+	none: { ja: 'なし', en: 'none' },
+} as const satisfies Record<string, Row>
+
+const HEADINGS = {
+	background: { ja: '背景', en: 'Background' },
+	symptom: { ja: '現象', en: 'Symptom' },
+	expected: { ja: '期待結果', en: 'Expected result' },
+	criteria: { ja: '受け入れ条件', en: 'Acceptance criteria' },
+	trigger: { ja: '発火点', en: 'Trigger' },
+	baseline: { ja: 'ベースライン', en: 'Baseline' },
+	reproduction: { ja: '再現', en: 'Reproduction' },
+	expected_effect: { ja: '期待効果', en: 'Expected effect' },
+	auto_execution_constraint: { ja: '自動実行の制約', en: 'Automatic execution constraint' },
+} as const satisfies Record<string, Row>
+
+// The size estimate's value: `<files>` and `<lines>` stand for its counts.
+const SIZE_VALUES = {
+	ja: '約 <files> ファイル / <lines> 行（テスト除く）',
+	en: 'about <files> files / <lines> lines (excluding tests)',
+} as const satisfies Row
+// Full- or half-width parentheses alike: the two read the same to the person typing the line.
+const SIZE_PATTERNS = [
+	/^約\s*(?<files>\d+)\s*ファイル\s*\/\s*(?<lines>\d+)\s*行\s*[（(]テスト除く[）)]$/u,
+	/^about\s*(?<files>\d+)\s*files?\s*\/\s*(?<lines>\d+)\s*lines?\s*\(excluding tests\)$/iu,
+]
+
+type IssueBodyKey = keyof typeof KEYS
+type IssueBodyValue = keyof typeof VALUES
+type IssueBodyHeading = keyof typeof HEADINGS
+
+const COLUMNS: ReadonlyArray<Column> = ['ja', 'en']
+const HEADING_PREFIX = '## '
+const BULLET = '- '
+const KEY_END = ':'
+// A value ends where a word could not go on: the line's end, a space or punctuation.
+const VALUE_END = /^(?:$|[^\p{L}\p{N}-])/u
+const VALUE_TEXTS = Object.values(VALUES)
+	.flatMap((row) => COLUMNS.map((at) => ({ row, text: row[at] })))
+	.toSorted((left, right) => right.text.length - left.text.length)
+
+// The column the body is written in: the session language's.
+function column(): Column {
+	return session_language.is_japanese(session_language.resolve_session_lang().lang) ? 'ja' : 'en'
+}
+
+function text_of(row: Row): string {
+	return row[column()]
+}
+
+function key(name: IssueBodyKey): string {
+	return text_of(KEYS[name])
+}
+
+function value(name: IssueBodyValue): string {
+	return text_of(VALUES[name])
+}
+
+// The start every declaration line of `name` shares: `- <key>:`.
+function prefix(name: IssueBodyKey): string {
+	return `- ${key(name)}:`
+}
+
+// A whole declaration line with a fixed value: `- <key>: <value>`.
+function line(name: IssueBodyKey, value_name: IssueBodyValue): string {
+	return `${prefix(name)} ${value(value_name)}`
+}
+
+// The declaration prefix in every column, for a match on the body as the filer wrote it.
+function prefix_variants(name: IssueBodyKey): ReadonlyArray<string> {
+	return COLUMNS.map((at) => `- ${KEYS[name][at]}:`)
+}
+
+// The declaration line in every column, for a match on the body as the filer wrote it.
+function line_variants(name: IssueBodyKey, value_name: IssueBodyValue): ReadonlyArray<string> {
+	return COLUMNS.map((at) => `- ${KEYS[name][at]}: ${VALUES[value_name][at]}`)
+}
+
+// A template heading as the body writes it: `## <heading>`.
+function heading(name: IssueBodyHeading): string {
+	return `## ${text_of(HEADINGS[name])}`
+}
+
+function size_value(files: string, lines: string): string {
+	return text_of(SIZE_VALUES)
+		.replace('<files>', () => files)
+		.replace('<lines>', () => lines)
+}
+
+// The counts a size estimate's value declares, in either column; `undefined` when it does not parse.
+function size_counts(text: string): Record<string, string> | undefined {
+	return SIZE_PATTERNS.map((pattern) => pattern.exec(text)?.groups).find(Boolean)
+}
+
+// The row whose text in any column is `text`.
+function row_named(rows: Record<string, Row>, text: string): Row | undefined {
+	return Object.values(rows).find((row) => COLUMNS.some((at) => row[at] === text))
+}
+
+function indent_of(raw: string): string {
+	return raw.slice(0, raw.length - raw.trimStart().length)
+}
+
+// `rest` with the fixed value it starts with rewritten into the written column; the longest value is
+// tried first, so a value is never read as a shorter one it ends with.
+function canonical_value(rest: string): string {
+	const trimmed = rest.trimStart()
+	const found = VALUE_TEXTS.find(
+		({ text }) => trimmed.startsWith(text) && VALUE_END.test(trimmed.slice(text.length)),
+	)
+
+	if (found === undefined) return rest
+
+	return `${indent_of(rest)}${text_of(found.row)}${trimmed.slice(found.text.length)}`
+}
+
+function canonical_declaration(raw: string): string | undefined {
+	const text = raw.trimStart()
+	const end = text.indexOf(KEY_END)
+	const row =
+		end !== -1 && text.startsWith(BULLET)
+			? row_named(KEYS, text.slice(BULLET.length, end))
+			: undefined
+
+	return row === undefined
+		? undefined
+		: `${indent_of(raw)}${BULLET}${text_of(row)}${KEY_END}${canonical_value(text.slice(end + 1))}`
+}
+
+function canonical_heading(raw: string): string | undefined {
+	const text = raw.trim()
+	const row = text.startsWith(HEADING_PREFIX)
+		? row_named(HEADINGS, text.slice(HEADING_PREFIX.length))
+		: undefined
+
+	return row === undefined ? undefined : `${indent_of(raw)}${HEADING_PREFIX}${text_of(row)}`
+}
+
+// `raw` with a heading, declaration key and fixed value written in any column rewritten into the
+// written column; any other line is unchanged.
+function canonical_line(raw: string): string {
+	return canonical_heading(raw) ?? canonical_declaration(raw) ?? raw
+}
+
+// Every row, for `issue-template.en.md`'s correspondence table to be held to (joshuafolkken/kit#7211).
+const TABLES = { keys: KEYS, values: VALUES, headings: HEADINGS }
+
+const issue_body_keys = {
+	canonical_line,
+	column,
+	heading,
+	line,
+	line_variants,
+	prefix,
+	prefix_variants,
+	size_counts,
+	size_value,
+	TABLES,
+	value,
+}
+
+export type { Column, IssueBodyHeading, IssueBodyKey, IssueBodyValue }
+export { issue_body_keys }

package/scripts/issue/issue-body-or-comment.ts

@@ -68,7 +68,7 @@ async function post(issue_number: string, text: string, repo?: string): Promise<
 	}
 }
 
-const issue_body_or_comment = { post }
+const issue_body_or_comment = { is_author_trusted, post }
 
 export { issue_body_or_comment }
 export type { Destination, PostOutcome }

package/scripts/issue/issue-bug-label.ts

@@ -1,9 +1,12 @@
+import { issue_body_keys } from './issue-body-keys'
 import { markdown_section } from './markdown-section'
 
-const BUG_DECLARATION_LINE = '- 種別: 不具合'
+const BUG_DECLARATION_LINE = issue_body_keys.line('kind', 'bug')
 
 function is_bug_fix(body: string): boolean {
-	const background = markdown_section.section_lines(body, '## 背景').join('\n')
+	const background = markdown_section
+		.section_lines(body, issue_body_keys.heading('background'))
+		.join('\n')
 
 	return markdown_section.has_unfenced_line(background, BUG_DECLARATION_LINE)
 }

package/scripts/issue/issue-cap-files.ts

@@ -0,0 +1,111 @@
+import path from 'node:path'
+import { line_budget, type FileBudget, type LineBudget } from '#scripts/lines/line-budget'
+import { run_prep_locate } from '#scripts/run/run-prep-locate'
+import { issue_body_keys } from './issue-body-keys'
+import { size_estimate } from './size-estimate'
+
+// The files an Issue body names that sit at or past 90% of their code-line limit
+// (joshuafolkken/kit#7184). Adding lines to one makes the lane split the file mid-implementation
+// (`prompts/refactoring.md`) — an unplanned diff and review — so `issue:file` steers the filing to a
+// refactor Issue that splits it first, and `backlog:next` warns on one filed before this check.
+//
+// Counted as ESLint's `max-lines` counts them, through `line_budget` — the one counter the gate
+// agrees with. A body that adds no lines to the file declares `NO_LINES_PREFIX` with its reason; one
+// refiled after its refactor Issue declares `REFACTOR_PREFIX` with that Issue, which it waits on.
+
+const PERCENT = 100
+const CAP_PERCENT = 90
+const CAP_FRACTION = CAP_PERCENT / PERCENT
+const NO_LINES_PREFIX = issue_body_keys.prefix('no_lines')
+const REFACTOR_PREFIX = issue_body_keys.prefix('refactor_first')
+const ISSUE_REFERENCE = /^#\d+$/u
+const REFACTOR_GUIDE = 'prompts/refactoring.md'
+// The files `max-lines` limits: every script and component ESLint lints (`eslint/base.js`).
+const CODE_FILE = /\.(?:[cm]?[jt]sx?|svelte)$/u
+
+// A backticked repository path to a code file ESLint counts; a bare file name or a missing path is
+// not weighed — its limit and count would be guesses.
+function counted_paths(body: string, project_root: string): ReadonlyArray<string> {
+	return run_prep_locate
+		.names_of(body)
+		.filter((name) => CODE_FILE.test(name))
+		.filter((name) => line_budget.is_lintable_path(path.resolve(project_root, name)))
+}
+
+function is_near_cap(budget: LineBudget | undefined): budget is LineBudget {
+	if (budget === undefined) return false
+
+	return budget.code_lines >= Math.ceil(budget.limit * CAP_FRACTION)
+}
+
+function is_declared(body: string): boolean {
+	if ((size_estimate.declared(body, NO_LINES_PREFIX) ?? '') !== '') return true
+
+	return ISSUE_REFERENCE.test(size_estimate.declared(body, REFACTOR_PREFIX) ?? '')
+}
+
+function near_of(
+	named: ReadonlyArray<ReadonlyArray<string>>,
+	budgets: ReadonlyArray<FileBudget>,
+): ReadonlyArray<ReadonlyArray<FileBudget>> {
+	const near = budgets.filter((entry) => is_near_cap(entry.budget))
+
+	return named.map((paths) => near.filter((entry) => paths.includes(entry.file_path)))
+}
+
+// Per body, the named files near their cap — `[]` when none is or the body declares it adds no
+// lines. One ESLint run counts every body's files, and none runs when no body names one.
+async function near_cap_by_body(
+	bodies: ReadonlyArray<string>,
+	project_root: string,
+): Promise<ReadonlyArray<ReadonlyArray<FileBudget>>> {
+	const named = bodies.map((body) => (is_declared(body) ? [] : counted_paths(body, project_root)))
+	const paths = [...new Set(named.flat())]
+
+	if (paths.length === 0) return named.map(() => [])
+
+	return near_of(named, await line_budget.budgets_for(paths, project_root))
+}
+
+async function near_cap(body: string, project_root: string): Promise<ReadonlyArray<FileBudget>> {
+	const [near] = await near_cap_by_body([body], project_root)
+
+	return near ?? []
+}
+
+function described(entry: FileBudget): string {
+	const { budget } = entry
+
+	return budget === undefined
+		? entry.file_path
+		: `${entry.file_path} (${line_budget.describe(budget)})`
+}
+
+function named_line(near: ReadonlyArray<FileBudget>): string {
+	return `names ${near.map((entry) => described(entry)).join(', ')}, at or past ${String(CAP_PERCENT)}% of the code-line limit`
+}
+
+// The refusal `issue:file` prints: file the refactor first, then record it as this Issue's blocker.
+function problem(near: ReadonlyArray<FileBudget>): string | undefined {
+	if (near.length === 0) return undefined
+
+	return `${named_line(near)} — file a refactor Issue that splits it first (${REFACTOR_GUIDE}), refile this one declaring \`${REFACTOR_PREFIX} #<refactor>\`, then \`pnpm josh backlog:triage --apply <N> --blocked-by <refactor> --reason "<why>"\`; or declare \`${NO_LINES_PREFIX} <理由>\` when the change adds no lines to it`
+}
+
+// The line `backlog:next` warns with — the same finding, offered anyway (joshuafolkken/kit#7074).
+function note(near: ReadonlyArray<FileBudget>): string | undefined {
+	if (near.length === 0) return undefined
+
+	return `${named_line(near)} with no \`${NO_LINES_PREFIX}\` — split it first (${REFACTOR_GUIDE})`
+}
+
+const issue_cap_files = {
+	NO_LINES_PREFIX,
+	REFACTOR_PREFIX,
+	near_cap,
+	near_cap_by_body,
+	note,
+	problem,
+}
+
+export { issue_cap_files }

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

@@ -22,8 +22,8 @@ import { issue_cite, type CiteTarget } from './issue-cite'
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
-// The same bound `issue:read` puts on its batch read: every read is a `gh` process, and an unbounded
-// fan-out is answered with secondary rate limiting rather than with titles.
+// Every read is a `gh` process, and an unbounded fan-out is answered with secondary rate limiting
+// rather than with titles.
 const READ_CONCURRENCY = 8
 const TITLE_FIELD = 'title'
 const LINE_SEPARATOR = '\n'

package/scripts/issue/issue-cite.ts

@@ -36,11 +36,28 @@ interface CiteTarget {
 // assembled. It is for text GitHub renders or a program reads: an Issue or PR
 // body, a comment, a commit message, a pattern, a key. GitHub links that text itself, so it needs no
 // link of its own; what a session reads goes through `session_cite.issue` instead, and the scan in
-// `session-cite-scan.test.ts` refuses a bare `#${…}` assembled anywhere else.
+// `session-cite-scan.test.ts` refuses a bare `#${…}` assembled anywhere else. It is not exported: a
+// caller reaches it through `plain_for`, which makes it say why (joshuafolkken/kit#6810).
 function plain(number: number | string, repo = ''): string {
 	return `${repo}#${String(number)}`
 }
 
+// Why a bare `#N` is right where it is assembled, declared at the call rather than in a central list
+// (joshuafolkken/kit#6807):
+// - `github`: GitHub renders it — a commit message, a PR or Issue title or body, a comment, a query.
+// - `telegram`: a person reads it on Telegram.
+// - `program`: a program reads it back — the run event stream, a process pattern, a child prompt, a
+//   parse key, a stash name.
+// - `terminal`: a person reads it in a terminal frame or a detached driver's stderr, unlinked.
+// - `linked`: the caller prints it through `session_cite.text` or `issue_citation.linkify`.
+type PlainReason = 'github' | 'linked' | 'program' | 'telegram' | 'terminal'
+
+// `plain` with its reason required, so a call that does not say why its text stays plain does not
+// compile; the reason is the declaration, so it is not read here.
+function plain_for(_reason: PlainReason, number: number | string, repo = ''): string {
+	return plain(number, repo)
+}
+
 function issue_url(slug: string, number: string): string {
 	return `${GITHUB_URL_PREFIX}${slug}${ISSUE_PATH}${number}`
 }
@@ -125,10 +142,10 @@ const issue_cite = {
 	missing_line,
 	no_repo_line,
 	parse_target,
-	plain,
+	plain_for,
 	reference,
 	unreadable_line,
 }
 
-export type { CiteTarget, IssueCiter }
+export type { CiteTarget, IssueCiter, PlainReason }
 export { issue_cite }

package/scripts/issue/issue-classification.ts

@@ -1,11 +1,30 @@
+import { pr_classification } from '#scripts/ci/pr-classification'
+import { error_text } from '#scripts/lib/error-message'
 import { defect_origin_line } from './defect-origin-line'
+import { issue_body_keys } from './issue-body-keys'
 import { issue_bug_label } from './issue-bug-label'
-import { BREAKING_CHANGE_LABEL, BUG_LABEL, ENHANCEMENT_LABEL, has_label_name } from './issue-labels'
+import {
+	BREAKING_CHANGE_LABEL,
+	BUG_LABEL,
+	ENHANCEMENT_LABEL,
+	has_label_name,
+	OTHER_CHANGE_LABEL,
+} from './issue-labels'
 import { markdown_section } from './markdown-section'
 
-const FEATURE_DECLARATIONS = ['- 目的: 機能追加', '- 目的: 機能改善', '- 目的: 時間短縮']
-const BREAKING_DECLARATION = '- 互換性: 破壊的変更'
-const NON_BUG_DECLARATION = '- 種別: 非不具合'
+const BACKGROUND_HEADING = issue_body_keys.heading('background')
+const FEATURE_DECLARATIONS = [
+	issue_body_keys.line('purpose', 'feature'),
+	issue_body_keys.line('purpose', 'improvement'),
+	issue_body_keys.line('purpose', 'time_saving'),
+]
+const BREAKING_DECLARATION = issue_body_keys.line('compatibility', 'breaking')
+const NON_BUG_DECLARATION = issue_body_keys.line('kind', 'non_bug')
+// The non-bug line as the filer wrote it, in either language (joshuafolkken/kit#7210).
+const NON_BUG_LINE = new RegExp(
+	String.raw`^ {0,3}(?:${issue_body_keys.line_variants('kind', 'non_bug').join('|')})[ \t]*$`,
+	'mu',
+)
 const CLASSIFICATION_LABELS = [BUG_LABEL, ENHANCEMENT_LABEL, BREAKING_CHANGE_LABEL]
 const CONFLICT = 'bug and enhancement declarations cannot be combined'
 const MISSING_BUG_CLASSIFICATION = 'missing bug classification'
@@ -13,7 +32,7 @@ const CONFLICTING_BUG_CLASSIFICATIONS = 'conflicting bug classifications'
 
 function required_labels(body: string): ReadonlyArray<string> {
 	const labels: Array<string> = []
-	const background = markdown_section.section_lines(body, '## 背景').join('\n')
+	const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join('\n')
 
 	if (issue_bug_label.is_bug_fix(body)) labels.push(BUG_LABEL)
 
@@ -35,7 +54,7 @@ function labels_for(body: string, existing: ReadonlyArray<string>): ReadonlyArra
 }
 
 function bug_classification_problem(body: string): string | undefined {
-	const background = markdown_section.section_lines(body, '## 背景').join('\n')
+	const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join('\n')
 	const has_bug = issue_bug_label.is_bug_fix(body)
 	const has_non_bug = markdown_section.has_unfenced_line(background, NON_BUG_DECLARATION)
 
@@ -51,10 +70,49 @@ function label_conflict(body: string): string | undefined {
 	return labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL) ? CONFLICT : undefined
 }
 
-function problems(body: string): ReadonlyArray<string> {
+// The refusal `josh pr` would give this body filed with `labels`, so a body that cannot ship is
+// refused here.
+function selection_problem(body: string, labels: ReadonlyArray<string>): string | undefined {
+	try {
+		pr_classification.select_classification(labels, body)
+
+		return undefined
+	} catch (error) {
+		return error_text.message_of(error)
+	}
+}
+
+// A non-bug body whose declarations and `labels` (the ones it is filed with; the body's own when
+// left out) resolve to no release classification can only mean `other-change`, so it is written in
+// under the non-bug line. Any other body is returned unchanged.
+function with_release_classification(
+	body: string,
+	labels: ReadonlyArray<string> = required_labels(body),
+): string {
+	const line = pr_classification.declaration(OTHER_CHANGE_LABEL)
+	const amended = body.replace(NON_BUG_LINE, (non_bug) => `${non_bug}\n${line}`)
+
+	if (selection_problem(body, labels) === undefined) return body
+
+	return selection_problem(amended, labels) === undefined ? amended : body
+}
+
+function release_problem(body: string, labels: ReadonlyArray<string>): string | undefined {
+	if (bug_classification_problem(body) !== undefined || label_conflict(body) !== undefined) {
+		return undefined
+	}
+
+	return selection_problem(with_release_classification(body, labels), labels)
+}
+
+function problems(
+	body: string,
+	labels: ReadonlyArray<string> = required_labels(body),
+): ReadonlyArray<string> {
 	const found = [
 		bug_classification_problem(body),
 		label_conflict(body),
+		release_problem(body, labels),
 		defect_origin_line.problem(body),
 		defect_origin_line.reproduction_problem(body),
 	]
@@ -67,6 +125,7 @@ const issue_classification = {
 	labels_for,
 	problems,
 	required_labels,
+	with_release_classification,
 }
 
 export { issue_classification }

package/scripts/issue/issue-closing-pr.ts

@@ -24,32 +24,46 @@ import { z } from 'zod'
 // number closes a different issue — its cross-reference here is a mention, not a close.
 
 const LINE_SEPARATOR = '\n'
-// One compact JSON object per merged pull request that cross-references the issue, and a
+// One compact JSON object per pull request that cross-references the issue, and a
 // `{"reopened":true}` marker per reopen, in timeline order.
 const TIMELINE_FILTER = [
 	'.[]',
-	'| if .event == "cross-referenced" and .source.issue.pull_request.merged_at != null',
-	'then {url: .source.issue.html_url, repo: .source.issue.repository.full_name, body: (.source.issue.body // "")}',
+	'| if .event == "cross-referenced" and .source.issue.pull_request != null',
+	'then {url: .source.issue.html_url, repo: .source.issue.repository.full_name, body: (.source.issue.body // ""), state: (if .source.issue.pull_request.merged_at != null then "merged" else .source.issue.state end)}',
 	'elif .event == "reopened" then {reopened: true}',
 	'else empty end',
 ].join(' ')
 
-const reference_schema = z.object({ url: z.string(), repo: z.string(), body: z.string() })
+const reference_schema = z.object({
+	url: z.string(),
+	repo: z.string(),
+	body: z.string(),
+	state: z.enum(['open', 'closed', 'merged']).default('merged'),
+})
 const reopen_schema = z.object({ reopened: z.literal(true) })
 const row_schema = z.union([reference_schema, reopen_schema])
 
 type MergedReference = z.infer<typeof reference_schema>
 type TimelineRow = z.infer<typeof row_schema>
+type ClosingRead = { kind: 'read'; url: string | undefined } | { kind: 'unreadable' }
+type ClosingNumberRead = { kind: 'read'; number: number | undefined } | { kind: 'unreadable' }
 
 function is_reference(row: TimelineRow): row is MergedReference {
 	return 'url' in row
 }
 
+function parse_row(line: string): TimelineRow {
+	const row = parse_json_object_or_undefined(line, row_schema)
+	if (row === undefined) throw new Error('the issue timeline contains an unreadable row')
+
+	return row
+}
+
 function parse_references(raw: string): Array<MergedReference> {
 	const rows = raw
 		.split(LINE_SEPARATOR)
-		.map((line) => parse_json_object_or_undefined(line, row_schema))
-		.filter((row) => row !== undefined)
+		.filter((line) => line.trim() !== '')
+		.map((line) => parse_row(line))
 	const last_reopen = rows.findLastIndex((row) => !is_reference(row))
 
 	return rows.slice(last_reopen + 1).filter((row) => is_reference(row))
@@ -63,38 +77,59 @@ function pick_closing_pr(
 	return references.find(
 		(reference) =>
 			reference.repo === repo &&
+			reference.state === 'merged' &&
 			git_closes_keyword.parse_closes_issue_number(reference.body) === issue,
 	)?.url
 }
 
-// Every doubt falls to `undefined` — an unreadable timeline or repository name leaves the child
-// judged as it was, never closed on a guess.
-async function read_closing_pr(issue: string): Promise<string | undefined> {
+async function read_closing_result(issue: string): Promise<ClosingRead> {
 	try {
+		// The canonical name, not the remote as typed: the timeline names the repository GitHub's way
+		// (joshuafolkken/kit#6752).
 		const [raw, repo] = await Promise.all([
 			git_gh_exec.exec_gh_api({
 				path: `${git_gh_api_path.issue_api_path(issue)}/timeline?per_page=100`,
 				should_paginate: true,
 				jq_filter: TIMELINE_FILTER,
 			}),
-			git_gh_repo.repo_get_name_with_owner(),
+			git_gh_repo.repo_get_canonical_name_with_owner(),
 		])
 
-		if (repo === undefined) return undefined
+		if (repo === undefined) return { kind: 'unreadable' }
 
-		return pick_closing_pr(parse_references(raw), issue, repo)
+		return { kind: 'read', url: pick_closing_pr(parse_references(raw), issue, repo) }
 	} catch {
-		return undefined
+		return { kind: 'unreadable' }
 	}
 }
 
+// Legacy callers leave the child unchanged when discovery is unavailable.
+async function read_closing_pr(issue: string): Promise<string | undefined> {
+	const result = await read_closing_result(issue)
+
+	return result.kind === 'read' ? result.url : undefined
+}
+
+async function read_closing_number_result(issue: number): Promise<ClosingNumberRead> {
+	const result = await read_closing_result(String(issue))
+	if (result.kind === 'unreadable') return result
+	const number =
+		result.url === undefined ? undefined : Number(result.url.slice(result.url.lastIndexOf('/') + 1))
+
+	return { kind: 'read', number }
+}
+
 // The closing pull request's number, read off the URL `read_closing_pr` answers.
 async function read_closing_number(issue: number): Promise<number | undefined> {
-	const url = await read_closing_pr(String(issue))
+	const result = await read_closing_number_result(issue)
 
-	return url === undefined ? undefined : Number(url.slice(url.lastIndexOf('/') + 1))
+	return result.kind === 'read' ? result.number : undefined
 }
 
-const issue_closing_pr = { read_closing_number, read_closing_pr }
+const issue_closing_pr = {
+	read_closing_number,
+	read_closing_number_result,
+	read_closing_pr,
+}
 
 export { issue_closing_pr }