@joshuafolkken/kit 1.1784.0 → 1.2116.0

package/scripts/issue/issue-file-lane-hint.ts

@@ -0,0 +1,30 @@
+import { lane_net_read } from '#scripts/lane/lane-net-read'
+import { issue_cite } from './issue-cite'
+import { issue_priority } from './issue-priority'
+
+// joshuafolkken/kit#5225: a refused `josh issue:file --found-during <N>` prints the causing-lane line
+// filled from `josh lane:net <N>`, so the filer pastes it rather than running the command apart. Nothing
+// is printed when the body already declares a causing lane, or the ledger holds no dispatch and merge of
+// the lane yet.
+
+async function lines_of(
+	found_during: string | undefined,
+	body: string,
+): Promise<ReadonlyArray<string>> {
+	if (found_during === undefined || issue_priority.lane_minutes(body) > 0) return []
+	const minutes = await lane_net_read.net_minutes_of(Number(found_during))
+
+	if (minutes === undefined) return []
+	const line = `${issue_priority.LANE_PREFIX} ${String(minutes)} 分（${issue_cite.plain(found_during)}）`
+
+	return [
+		`↳ the causing lane from \`josh lane:net ${found_during}\`, to paste under \`## 背景\` when it caused this Issue:`,
+		line,
+	]
+}
+
+const issue_file_lane_hint = {
+	lines_of,
+}
+
+export { issue_file_lane_hint }

package/scripts/issue/issue-file.ts

@@ -36,6 +36,10 @@ interface FileArguments {
 	labels: ReadonlyArray<string>
 	repo: string | undefined
 	distinct: ReadonlyArray<number>
+	// `--found-during <N>`: the work item the filing came from when it is not the checkout's own — a
+	// long lane the parent investigated, the Issue a prerequisite or an observation came out of. The
+	// filing cap counts per origin (`issue-file-cap.ts`); absent, the finder is read (`issue-file-fold.ts`).
+	found_during: string | undefined
 	// `--over-cap`: the run is blocked by this filing, so the WIP cap does not hold it (`issue-wip.ts`).
 	is_over_cap: boolean
 	// `--no-auto-ok`: the Issue needs a person's judgement, so `auto-ok` is not applied (`issue-auto-ok.ts`).
@@ -43,6 +47,9 @@ interface FileArguments {
 	// `--release`: the change reaches a consumer only once published, so the Issue is linked to the
 	// repository's release Issue as a blocker (`issue-release-cli.ts`).
 	is_release: boolean
+	// `--blocks-finder`: an interrupt the finder cannot go on without, so the finder is recorded as
+	// blocked by it (`issue-file-interrupt.ts`). An interrupt that blocks nobody omits it (`wip-cap.md`).
+	is_blocking_finder: boolean
 }
 
 const OPTIONS = {
@@ -51,9 +58,11 @@ const OPTIONS = {
 	label: { type: 'string', multiple: true },
 	repo: { type: 'string' },
 	distinct: { type: 'string', multiple: true },
+	'found-during': { type: 'string' },
 	'over-cap': { type: 'boolean' },
 	'no-auto-ok': { type: 'boolean' },
 	release: { type: 'boolean' },
+	'blocks-finder': { type: 'boolean' },
 } as const
 
 // The label a `--route` value names, or `undefined` when it names none — read against the route
@@ -95,15 +104,27 @@ function has_text(value: string | undefined): value is string {
 	return value !== undefined && value.trim() !== ''
 }
 
-// The labelled half of the arguments, or `undefined` when a route or `--distinct` entry is not one the
-// command knows.
-function labelled_of(values: ParsedValues): Pick<FileArguments, 'route' | 'distinct'> | undefined {
+// `--found-during 3423` or `#3423` → `'3423'`; `undefined` when absent, `false` when it names no single
+// issue number, so a typo is refused rather than counted against no origin.
+function found_during_of(value: string | undefined): string | undefined | false {
+	if (value === undefined) return undefined
+	const numbers = distinct_numbers([value])
+
+	return numbers?.length === 1 ? String(numbers[0]) : false
+}
+
+type Labelled = Pick<FileArguments, 'route' | 'distinct' | 'found_during'>
+
+// The labelled half of the arguments, or `undefined` when a route, `--distinct` or `--found-during`
+// entry is not one the command knows.
+function labelled_of(values: ParsedValues): Labelled | undefined {
 	const route = route_of(values)
 	const distinct = distinct_numbers(values.distinct ?? [])
+	const found_during = found_during_of(values['found-during'])
 
-	if (route === false || distinct === undefined) return undefined
+	if (route === false || distinct === undefined || found_during === false) return undefined
 
-	return { route, distinct }
+	return { route, distinct, found_during }
 }
 
 function arguments_of(values: ParsedValues, title: string | undefined): FileArguments | undefined {
@@ -121,6 +142,7 @@ function arguments_of(values: ParsedValues, title: string | undefined): FileArgu
 		is_over_cap: values['over-cap'] === true,
 		is_auto_ok_opted_out: values['no-auto-ok'] === true,
 		is_release: values.release === true,
+		is_blocking_finder: values['blocks-finder'] === true,
 	}
 }
 
@@ -143,7 +165,7 @@ function is_undeclared_classification(label: string, body: string): boolean {
 // the body declares (`issue_classification.labels_for`, which merges case-insensitively), then any
 // extra `--label`, then `auto-ok` when the filing is judged in (`issue-auto-ok.ts`) and no `--label`
 // already named it, `not-before` while the body's start time is ahead (`issue-not-before-label.ts`), and
-// the declared priority's label unless a `--label` typed one (`issue-priority.ts`).
+// the filed priority's label (the declaration, else its floor) unless a `--label` typed one (`issue-priority.ts`).
 // One request applies them all, so no label is a separate step to forget.
 function labels_of(args: FileArguments, body: string, is_auto_ok = false): ReadonlyArray<string> {
 	const extra = args.labels.filter((label) => !is_undeclared_classification(label, body))
@@ -221,12 +243,27 @@ function unacknowledged(
 	return candidates.filter((candidate) => !distinct.includes(candidate))
 }
 
+// The candidates the filing has already answered: its `--distinct` numbers and, filing into this
+// repository, its `--found-during` origin. The work the finding turned up during is never its duplicate,
+// though a body citing it makes the scout name it (joshuafolkken/kit#4762). The origin is an Issue here,
+// so in another repository the same number is an unrelated Issue the scout may rightly hold.
+function acknowledged(
+	args: Pick<FileArguments, 'distinct' | 'found_during'>,
+	target: string,
+	current: string,
+): ReadonlyArray<number> {
+	if (args.found_during === undefined || !is_same_repository(target, current)) return args.distinct
+
+	return [...args.distinct, Number(args.found_during)]
+}
+
 const issue_file = {
 	parse,
 	labels_of,
 	origin_problem,
 	triage_problem,
 	unacknowledged,
+	acknowledged,
 	is_same_repository,
 }
 

package/scripts/issue/issue-labels.ts

@@ -83,6 +83,9 @@ const ALREADY_DONE_LABEL = 'already-done'
 // closes such an Issue, so the merge reference a sweep reads is missing; this label is what tells the
 // run's own close from a person's, so every sweep counts it as merged (`issue-merged.ts`).
 const MEASURED_LABEL = 'measured'
+// Rides beside `measured` when the measurement fell short of the expected effect it checked
+// (`josh issue:measured --unmet`); `josh effect:audit` reads it as the mechanism to retire or shrink.
+const MEASURED_UNMET_LABEL = 'measured:unmet'
 // Marks the Issue that tracks a repository's next release. An Issue whose
 // change reaches a consumer only once published is linked to it as a `blocked_by` blocker
 // (`josh issue:release`), so "merged but not yet released" is visible in the backlog. A run applies
@@ -255,6 +258,12 @@ const WORKFLOW_LABELS: ReadonlyArray<LabelDefinition> = [
 		color: '6f42c1',
 		description: 'Measurement-only — a run recorded the result and closed it',
 	},
+	{
+		name: MEASURED_UNMET_LABEL,
+		color: '6f42c1',
+		description:
+			'The measurement fell short of the expected effect — retire or shrink the mechanism',
+	},
 	{
 		name: DEFERRED_LABEL,
 		color: 'd4c5f9',
@@ -345,9 +354,14 @@ function has_label_name(labels: ReadonlyArray<string>, wanted: string): boolean
 	return label_name_of(labels, wanted) !== undefined
 }
 
-// Whether label names carry any park label (`PARKED_LABELS`), compared as `has_label_name` does.
+// The park label (`PARKED_LABELS`) label names carry, compared as `has_label_name` does.
+function parked_label_of(labels: ReadonlyArray<string>): string | undefined {
+	return [...PARKED_LABELS].find((label) => has_label_name(labels, label))
+}
+
+// Whether label names carry any park label (`PARKED_LABELS`).
 function has_parked_label(labels: ReadonlyArray<string>): boolean {
-	return [...PARKED_LABELS].some((label) => has_label_name(labels, label))
+	return parked_label_of(labels) !== undefined
 }
 
 // Every workflow label this package manages. The label-reference scan
@@ -368,6 +382,7 @@ const ALL_LABELS: ReadonlySet<string> = new Set([
 	NEEDS_HUMAN_REVIEW_LABEL,
 	ALREADY_DONE_LABEL,
 	MEASURED_LABEL,
+	MEASURED_UNMET_LABEL,
 	DEFERRED_LABEL,
 	PRIORITY_CRITICAL_LABEL,
 	PRIORITY_HIGH_LABEL,
@@ -410,11 +425,13 @@ export {
 	INTERRUPT_ROUTE_LABEL,
 	label_name_of,
 	MEASURED_LABEL,
+	MEASURED_UNMET_LABEL,
 	NEEDS_DECISION_LABEL,
 	NEEDS_HUMAN_REVIEW_LABEL,
 	NOT_BEFORE_LABEL,
 	NOT_DIRECTLY_RUNNABLE_LABELS,
 	OTHER_CHANGE_LABEL,
+	parked_label_of,
 	PARKED_LABELS,
 	PLANNED_LABEL,
 	PRIORITY_CRITICAL_LABEL,

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

@@ -1,15 +1,21 @@
 import { readFile } from 'node:fs/promises'
+import { aggregation_split } from './aggregation-split'
 import { behavior_change_lint } from './behavior-change-lint'
 import { expected_effect_lint } from './expected-effect-lint'
 import { issue_classification } from './issue-classification'
 import { issue_lint } from './issue-lint'
 import { issue_not_before } from './issue-not-before'
+import { issue_priority } from './issue-priority'
+import { issue_template_section } from './issue-template-section'
+import { measure_declaration } from './measure-declaration'
+import { size_estimate } from './size-estimate'
 
 // `josh issue:lint <path>` — read an Issue body from a file and print `ok`, or every template problem
 // one per line, exiting non-zero. It reads a path rather than stdin so it can
 // lint a body written to a file before the `gh api … issues` call that files it. A body that declares
 // itself a behavior-change Issue is additionally held to the firing-point, baseline and reproduction
-// rules, and one that declares a run-time-shortening aim to the expected-effect estimate.
+// rules, and one that declares a run-time-shortening aim to the expected-effect estimate. Every
+// non-epic body declares its size estimate; the guide it is judged against is `issue:file`'s check.
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
@@ -17,10 +23,23 @@ const OK_MESSAGE = 'ok'
 const NO_LABELS = 'none'
 const USAGE = 'Usage: josh issue:lint <path-to-issue-body>'
 
+const MISSING_HEADING_PREFIX = 'missing heading: '
+
+// A missing-heading problem followed by that section of the template, so the filer pastes it in rather
+// than reopening `issue-template.md`; any other problem, or a heading the template lacks, is unchanged.
+function with_template(problem: string): string {
+	if (!problem.startsWith(MISSING_HEADING_PREFIX)) return problem
+	const template = issue_template_section.section(problem.slice(MISSING_HEADING_PREFIX.length))
+
+	return template === undefined ? problem : `${problem}\n${template}`
+}
+
 // Every problem a body has: the four base template headings it lacks, then the behavior-change and
 // expected-effect problems (each empty for an Issue that does not declare itself one).
 function problems(body: string): ReadonlyArray<string> {
-	const missing = issue_lint.missing_headings(body).map((heading) => `missing heading: ${heading}`)
+	const missing = issue_lint
+		.missing_headings(body)
+		.map((heading) => `${MISSING_HEADING_PREFIX}${heading}`)
 
 	return [
 		...missing,
@@ -28,7 +47,13 @@ function problems(body: string): ReadonlyArray<string> {
 		...expected_effect_lint.problems(body),
 		...issue_classification.problems(body),
 		...issue_not_before.problems(body),
+		...measure_declaration.problems(body),
+		...size_estimate.problems(body),
+		...aggregation_split.problems(body),
+		issue_priority.order_problem(body),
 	]
+		.filter((problem) => problem !== undefined)
+		.map((problem) => with_template(problem))
 }
 
 function report(found: ReadonlyArray<string>, body: string): number {

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

@@ -1,48 +1,26 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { epic_close } from '#scripts/epic/epic-close'
-import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { issue_evidence_exit } from '#scripts/issue/issue-evidence-exit'
-import { MEASURED_LABEL } from '#scripts/issue/issue-labels'
-import { session_cite } from '#scripts/issue/session-cite'
+import { issue_measured_close } from '#scripts/issue/issue-measured-close'
 
 // `josh issue:measured <N> --evidence-file <path>` — the completion of a measurement-only Issue
 // (`issue-comments.md` → "A measurement-only Issue"): the result comment, the
-// `measured` label, the close and the `run:release`, in that order (`issue-evidence-exit.ts`).
-//
-// **The close is the run's own**: such an Issue changes no code, so no pull request's `closes #N`
-// can close it, and an OPEN child `run:merge` reads as `failed` and parks with `run:stalled`. A
-// CLOSED one it reads as `merged` (`run-merge.ts` → `classify_child`). The label goes on before the
-// close because it is what every sweep — `run:carry --end`, `run:tidy` — tells this close from a
-// person's by (`issue-merged.ts`); a close without it would be one they never count as merged.
+// `measured` label, the close and the `run:release`, in that order (`issue-evidence-exit.ts`,
+// `issue-measured-close.ts`). `--unmet` records that the measurement fell short of the expected
+// effect, with the `measured:unmet` label `josh effect:audit` reads.
 
 const ARGV_OFFSET = 2
-
-async function apply_label(issue_number: string): Promise<boolean> {
-	const write = await git_gh_command.issue_apply_label(issue_number, MEASURED_LABEL)
-
-	if (!write.is_applied) console.error(`${MEASURED_LABEL} not applied: ${write.reason}`)
-
-	return write.is_applied
-}
-
-// A closed measurement may be its epic's last child, and no `followup` runs for it — so the epic
-// auto-close is run here, through the one entry every child close takes (`epic-close.ts`).
-async function close_issue(issue_number: string): Promise<boolean> {
-	const is_closed = await git_gh_command.issue_close(issue_number, undefined)
-
-	if (is_closed) await epic_close.close_completed_epics({ issue_number, is_merged: true })
-	else console.error(`Issue ${session_cite.issue(issue_number)} not closed`)
-
-	return is_closed
-}
-
-async function label_and_close(issue_number: string): Promise<boolean> {
-	return (await apply_label(issue_number)) && (await close_issue(issue_number))
-}
+const UNMET_FLAG = '--unmet'
 
 async function run(argv: ReadonlyArray<string>): Promise<number> {
-	return await issue_evidence_exit.run(argv, { command: 'issue:measured', finish: label_and_close })
+	const exit = argv.includes(UNMET_FLAG)
+		? issue_measured_close.MEASURED_UNMET_EXIT
+		: issue_measured_close.MEASURED_EXIT
+
+	return await issue_evidence_exit.run(
+		argv.filter((argument) => argument !== UNMET_FLAG),
+		exit,
+	)
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {

package/scripts/issue/issue-measured-close.ts

@@ -0,0 +1,58 @@
+import { epic_close } from '#scripts/epic/epic-close'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { issue_evidence_exit, type EvidenceExit } from '#scripts/issue/issue-evidence-exit'
+import { MEASURED_LABEL, MEASURED_UNMET_LABEL } from '#scripts/issue/issue-labels'
+import { session_cite } from '#scripts/issue/session-cite'
+
+// The writes that complete a measurement-only Issue — the result comment, the `measured` label and
+// the close — shared by `josh issue:measured` and `backlog:drive`'s declared measurement
+// (`backlog-measure-close.ts`), out of the CLI so the drive imports no main guard.
+//
+// **The close is the run's own**: such an Issue changes no code, so no pull request's `closes #N`
+// can close it, and an OPEN child `run:merge` reads as `failed` and parks with `run:stalled`. A
+// CLOSED one it reads as `merged` (`run-merge.ts` → `classify_child`). The label goes on before the
+// close because it is what every sweep — `run:carry --end`, `run:tidy` — tells this close from a
+// person's by (`issue-merged.ts`); a close without it would be one they never count as merged.
+
+async function apply_label(issue_number: string, label: string = MEASURED_LABEL): Promise<boolean> {
+	const write = await git_gh_command.issue_apply_label(issue_number, label)
+
+	if (!write.is_applied) console.error(`${label} not applied: ${write.reason}`)
+
+	return write.is_applied
+}
+
+// A closed measurement may be its epic's last child, and no `followup` runs for it — so the epic
+// auto-close is run here, through the one entry every child close takes (`epic-close.ts`).
+async function close_issue(issue_number: string): Promise<boolean> {
+	const is_closed = await git_gh_command.issue_close(issue_number, undefined)
+
+	if (is_closed) await epic_close.close_completed_epics({ issue_number, is_merged: true })
+	else console.error(`Issue ${session_cite.issue(issue_number)} not closed`)
+
+	return is_closed
+}
+
+async function label_and_close(issue_number: string): Promise<boolean> {
+	return (await apply_label(issue_number)) && (await close_issue(issue_number))
+}
+
+// A measurement that fell short carries `measured:unmet` too, put on first: the close is the last write.
+async function mark_unmet_and_close(issue_number: string): Promise<boolean> {
+	return (
+		(await apply_label(issue_number, MEASURED_UNMET_LABEL)) && (await label_and_close(issue_number))
+	)
+}
+
+const COMMAND = 'issue:measured'
+const MEASURED_EXIT: EvidenceExit = { command: COMMAND, finish: label_and_close }
+const MEASURED_UNMET_EXIT: EvidenceExit = { command: COMMAND, finish: mark_unmet_and_close }
+
+// The same writes for evidence composed in process, with no hold of its own to release.
+async function close(issue_number: string, evidence: string): Promise<boolean> {
+	return await issue_evidence_exit.write({ issue_number, evidence }, MEASURED_EXIT)
+}
+
+const issue_measured_close = { MEASURED_EXIT, MEASURED_UNMET_EXIT, close }
+
+export { issue_measured_close }

package/scripts/issue/issue-not-before-label.ts

@@ -5,7 +5,7 @@ import { parse_json_array_or_undefined } from '#scripts/git/parse-json-array'
 import { error_text } from '#scripts/lib/error-message'
 import { has_label_name, NOT_BEFORE_LABEL, REPOSITORY_LABELS } from './issue-labels'
 import { issue_not_before } from './issue-not-before'
-import { issue_sample_gate } from './issue-sample-gate'
+import { issue_sample_prime } from './issue-sample-prime'
 import { session_cite } from './session-cite'
 
 // joshuafolkken/kit#4079: the body's start-time declaration held an issue back from `backlog:next`,
@@ -126,7 +126,7 @@ async function sweep(
 	const seen = new Set(scanned.map((issue) => issue.number))
 	const labelled = await read_labelled()
 
-	await issue_sample_gate.prime(labelled.map((issue) => issue.body))
+	await issue_sample_prime.prime(labelled.map((issue) => issue.body))
 	await sync([...scanned, ...labelled.filter((issue) => !seen.has(issue.number))], now)
 }
 

package/scripts/issue/issue-not-before.ts

@@ -13,7 +13,10 @@ const PREFIX = '- 実施可能日:'
 const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z$/u
 // What `toISOString` writes after the minutes the declaration spells.
 const ISO_TAIL = ':00.000Z'
-const MALFORMED = `\`${PREFIX}\` must be a UTC time written YYYY-MM-DDTHH:MMZ`
+// The refusal ends in a line ready to paste (joshuafolkken/kit#5225); a far-future date, so the
+// example never reads as already due.
+const EXAMPLE = `${PREFIX} 2099-01-01T09:00Z`
+const MALFORMED = `\`${PREFIX}\` must be a UTC time written YYYY-MM-DDTHH:MMZ\n${EXAMPLE}`
 const HEADING_MARKS = /^#{1,6}\s+/u
 // joshuafolkken/kit#4438: a start condition written as its own heading is never read — every reader
 // sees only the declaration line under the background heading — so the issue is offered at once.

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

@@ -0,0 +1,60 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { session_cite } from '#scripts/issue/session-cite'
+import { issue_priority_raise, type RaiseResult } from './issue-priority-raise'
+
+// `josh issue:priority <N>` — apply `priority:high` to an open issue whose body reached the high
+// floor after filing, as a recurrence's appended cause-loss line does (joshuafolkken/kit#4960).
+
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+const ARGV_OFFSET = 2
+const USAGE = 'Usage: josh issue:priority <issue-number>'
+
+const REPORTS: Readonly<Record<RaiseResult, string>> = {
+	raised: 'applied `priority:high` — its body reaches the high floor.',
+	labelled: 'already carries a priority label — left as it is.',
+	below: 'stays below the high floor — no label applied.',
+	unreadable: 'could not be read — no label applied.',
+	failed: 'reaches the high floor, but applying `priority:high` failed.',
+}
+
+const FAILURES: ReadonlySet<RaiseResult> = new Set(['unreadable', 'failed'])
+
+function parse_number(argv: ReadonlyArray<string>): string | undefined {
+	const [first] = argv
+
+	if (first === undefined || argv.length !== 1) return undefined
+
+	return issue_number_shape.ISSUE_NUMBER_PATTERN.test(first) ? first : undefined
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	const issue_number = parse_number(argv)
+
+	if (issue_number === undefined) {
+		console.error(USAGE)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	const result = await issue_priority_raise.raise(issue_number)
+	const line = `Issue ${session_cite.issue(issue_number)} ${REPORTS[result]}`
+	const is_failure = FAILURES.has(result)
+
+	if (is_failure) console.error(line)
+	else console.info(line)
+
+	return is_failure ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const issue_priority_cli = { run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { issue_priority_cli }

package/scripts/issue/issue-priority-raise.ts

@@ -0,0 +1,55 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { issue_label_schema } from '#scripts/git/git-schemas'
+import { parse_json_object_or_undefined } from '#scripts/git/parse-json-array'
+import { z } from 'zod'
+import { PRIORITY_HIGH_LABEL } from './issue-labels'
+import { issue_priority } from './issue-priority'
+
+// joshuafolkken/kit#4960: an open Issue's body can reach the high floor after it was filed — a
+// recurrence appends a cause-loss line to it — and the body edit applies no label. This re-reads the
+// body and applies `priority:high` once its floor is high, as `josh issue:file` would have.
+
+type RaiseResult = 'raised' | 'labelled' | 'below' | 'unreadable' | 'failed'
+
+const read_schema = z.object({
+	labels: z.array(issue_label_schema).optional(),
+	body: z.string().nullish(),
+})
+
+interface LabelsAndBody {
+	labels: ReadonlyArray<string>
+	body: string
+}
+
+async function read_issue(issue_number: string): Promise<LabelsAndBody | undefined> {
+	const raw = await git_gh_command.issue_get_labels_and_body(issue_number)
+	const parsed = raw === undefined ? undefined : parse_json_object_or_undefined(raw, read_schema)
+
+	if (parsed === undefined) return undefined
+
+	return { labels: (parsed.labels ?? []).map((label) => label.name), body: parsed.body ?? '' }
+}
+
+// A priority label already on the issue wins, as a typed one does at filing.
+function decision(read: LabelsAndBody): RaiseResult | undefined {
+	if (issue_priority.is_typed(read.labels)) return 'labelled'
+
+	return issue_priority.floor_of(read.body) === 'high' ? undefined : 'below'
+}
+
+async function raise(issue_number: string): Promise<RaiseResult> {
+	const read = await read_issue(issue_number)
+
+	if (read === undefined) return 'unreadable'
+	const decided = decision(read)
+
+	if (decided !== undefined) return decided
+	const is_applied = await git_gh_command.issue_add_label(issue_number, PRIORITY_HIGH_LABEL)
+
+	return is_applied ? 'raised' : 'failed'
+}
+
+const issue_priority_raise = { raise }
+
+export type { RaiseResult }
+export { issue_priority_raise }