@joshuafolkken/kit 1.1035.0 → 1.1094.0

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

@@ -90,7 +90,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const issue_fold_cli = { JSON_KEY, USAGE, REASONS, read_arguments, size_verdict, run, main }
+const issue_fold_cli = { read_arguments, size_verdict, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/issue/issue-fold-existing-cli.ts

@@ -74,7 +74,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const issue_fold_existing_cli = { run, main, USAGE }
+const issue_fold_existing_cli = { run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/{git → issue}/issue-labels.ts

@@ -6,6 +6,11 @@ const BUG_LABEL = 'bug'
 const ENHANCEMENT_LABEL = 'enhancement'
 const BREAKING_CHANGE_LABEL = 'breaking-change'
 const IN_PROGRESS_LABEL = 'in-progress'
+// Applied by `kickoff` once its plan is on the issue, so the next command's `run:entry` reads the issue
+// as planned and starts at the implementation rather than planning again (joshuafolkken/kit#3042).
+// Namespaced like `run:solo`: a bare `planned` is a common roadmap label a person may already apply,
+// and reading one as kickoff's mark would skip the planning that never happened.
+const PLANNED_LABEL = 'run:planned'
 // Parks a child that cannot advance without a person deciding something. `epic:next` is what reads
 // it: a parked child is why a run reports "nothing left that time will fix" rather than waiting
 // forever (joshuafolkken/kit#860).
@@ -19,6 +24,11 @@ const RUN_SOLO_LABEL = 'run:solo'
 // (joshuafolkken/kit#2779). Without it an issue lacking `run:solo` could mean "judged parallel" or
 // "never judged", and `backlog:next` withholds the second (`epic-triage.ts`).
 const RUN_LANE_LABEL = 'run:lane'
+// Puts an issue at the head of the backlog's ranking (joshuafolkken/kit#2928). A person or a run may
+// apply it — a run only where it can cite a deadline or a stated urgency, or a policy a person wrote
+// (`backlogrun-steps.md`) — and **only a person removes it**: a run that could clear it could undo
+// the person's ordering. Read by `issue-rank.ts`, the one place the ranking keys are decided.
+const PRIORITY_HIGH_LABEL = 'priority:high'
 // Opts one issue outside any epic into unattended execution (joshuafolkken/kit#906). **Only a
 // person applies it.** `epicrun #<E>` approves the merges inside `#<E>`; this label is the only way
 // a person extends that approval past the epic's edge, so a label an AI could apply to itself would
@@ -202,6 +212,7 @@ const WORKFLOW_LABELS: ReadonlyArray<LabelDefinition> = [
 		description: 'Tracks a batch of child issues from one split',
 	},
 	{ name: IN_PROGRESS_LABEL, color: '0075ca', description: 'Work is actively in progress' },
+	{ name: PLANNED_LABEL, color: 'c2e0c6', description: 'kickoff posted the plan' },
 	{
 		name: RUN_SOLO_LABEL,
 		color: 'b60205',
@@ -212,6 +223,11 @@ const WORKFLOW_LABELS: ReadonlyArray<LabelDefinition> = [
 		color: '0e8a16',
 		description: 'Judged safe to run beside others in a backlogrun',
 	},
+	{
+		name: PRIORITY_HIGH_LABEL,
+		color: 'e99695',
+		description: 'Offered first in a backlogrun; only a person removes it',
+	},
 	...FILING_ROUTE_LABELS,
 	...DEPTH_LABELS,
 ]
@@ -318,10 +334,12 @@ const ALL_LABELS: ReadonlySet<string> = new Set([
 	ENHANCEMENT_LABEL,
 	BREAKING_CHANGE_LABEL,
 	IN_PROGRESS_LABEL,
+	PLANNED_LABEL,
 	NEEDS_DECISION_LABEL,
 	AUTO_OK_LABEL,
 	NEEDS_HUMAN_REVIEW_LABEL,
 	ALREADY_DONE_LABEL,
+	PRIORITY_HIGH_LABEL,
 	INTERRUPT_ROUTE_LABEL,
 	REVIEW_CAP_ROUTE_LABEL,
 	REVIEW_ROUND2_SKIPPED_LABEL,
@@ -364,6 +382,8 @@ export {
 	NEEDS_HUMAN_REVIEW_LABEL,
 	NOT_DIRECTLY_RUNNABLE_LABELS,
 	OTHER_CHANGE_LABEL,
+	PLANNED_LABEL,
+	PRIORITY_HIGH_LABEL,
 	RELEASE_CLASSIFICATION_LABELS,
 	RELEASE_CLASSIFICATION_NAMES,
 	REPOSITORY_LABELS,

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

@@ -58,7 +58,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv[0])
 }
 
-const issue_lint_cli = { problems, run, OK_MESSAGE, USAGE }
+const issue_lint_cli = { problems, run }
 
 const ARGV_OFFSET = 2
 

package/scripts/issue/issue-merged.ts

@@ -1,5 +1,5 @@
-import { git_gh_api_path } from '#scripts/git/git-gh-api-path'
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
+import { git_gh_api_path } from '#scripts/gh/git-gh-api-path'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 
 // Whether an issue was closed by a merge, read from its REST timeline (joshuafolkken/kit#2701). The
 // issue's own `state_reason` cannot tell: a pull request's `closes #N` and a person's "Close as

package/scripts/issue/issue-rank.ts

@@ -0,0 +1,89 @@
+import {
+	BUG_LABEL,
+	has_label_name,
+	INTERRUPT_ROUTE_LABEL,
+	PRIORITY_HIGH_LABEL,
+	RUN_SOLO_LABEL,
+} from './issue-labels'
+
+// The keys that decide which open issue is offered first (joshuafolkken/kit#2928), defined once for
+// every ranking that asks: the `🗒 Next issues` display, the `auto-ok` pickup and `backlog:next`.
+//
+// In order: `priority:high`, then a defect on the verification path (`bug` with `run:solo`, or
+// `route:interrupt`), then how many other open issues wait on it. Below those, the caller's own order
+// stands — the sort is stable, so recency and the defect-rate adjustment survive as the last key.
+//
+// **`run:solo` alone is not a key.** It means "runs alone", not "runs first": tidying that only touches
+// the verification path carries it too, and a low-priority one is not owed a place ahead of the queue.
+// Only a defect on that path is, because `wip-cap.md` holds a batch until it has merged.
+
+interface RankRow {
+	labels: ReadonlyArray<string>
+	dependents: number
+}
+
+// One open issue as its key and the keys of the issues it is blocked by. The caller names the key
+// format, so a ranking over listing rows and one over graph children each count in their own terms.
+interface DependencyRow {
+	key: string
+	blockers: ReadonlyArray<string>
+}
+
+const NO_DEPENDENTS = 0
+
+function flag(is_set: boolean): number {
+	return is_set ? 1 : 0
+}
+
+function is_priority(labels: ReadonlyArray<string>): boolean {
+	return has_label_name(labels, PRIORITY_HIGH_LABEL)
+}
+
+function is_verification_defect(labels: ReadonlyArray<string>): boolean {
+	if (has_label_name(labels, INTERRUPT_ROUTE_LABEL)) return true
+
+	return has_label_name(labels, BUG_LABEL) && has_label_name(labels, RUN_SOLO_LABEL)
+}
+
+// Negated so that the larger value sorts first under an ascending comparison.
+function keys_of(row: RankRow): ReadonlyArray<number> {
+	return [
+		-flag(is_priority(row.labels)),
+		-flag(is_verification_defect(row.labels)),
+		-row.dependents,
+	]
+}
+
+function compare(first: RankRow, second: RankRow): number {
+	const second_keys = keys_of(second)
+	const differences = keys_of(first).map((key, index) => key - (second_keys[index] ?? 0))
+
+	return differences.find((difference) => difference !== 0) ?? 0
+}
+
+// How many of the rows wait on each key. A blocker outside the rows counts nothing, because only an
+// open issue in the same pool can be held back by it.
+function count_dependents(rows: ReadonlyArray<DependencyRow>): ReadonlyMap<string, number> {
+	const counts = new Map<string, number>()
+
+	for (const row of rows) {
+		const blockers = new Set(row.blockers)
+
+		for (const blocker of blockers) counts.set(blocker, (counts.get(blocker) ?? NO_DEPENDENTS) + 1)
+	}
+
+	return counts
+}
+
+// The items in rank order, ties kept in the order they arrived.
+function rank<T>(items: ReadonlyArray<T>, row_of: (item: T) => RankRow): Array<T> {
+	return items
+		.map((item) => ({ item, row: row_of(item) }))
+		.toSorted((first, second) => compare(first.row, second.row))
+		.map((entry) => entry.item)
+}
+
+const issue_rank = { count_dependents, rank }
+
+export { issue_rank }
+export type { DependencyRow, RankRow }

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

@@ -1,8 +1,9 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { git_gh_command } from '#scripts/git/git-gh-command'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { bounded_pool } from '#scripts/lib/bounded-pool'
 import { issue_read, type IssueComment, type IssueFields } from './issue-read'
+import { issue_report_failures, type ReadFailureKind } from './issue-report-failures'
 
 // `josh issue:read <N> [<N> ...]` — the body *and* the comments of every issue named, in one call
 // (joshuafolkken/kit#1715).
@@ -25,7 +26,6 @@ import { issue_read, type IssueComment, type IssueFields } from './issue-read'
 // "no comments" — the block says which of the two it holds, because §2g's rule is that the later text
 // wins, and a comment nobody read cannot win anything.
 
-const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const ARGV_OFFSET = 2
 const ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u
@@ -35,8 +35,7 @@ const BLOCK_SEPARATOR = '\n\n---\n\n'
 // process, and an unbounded fan-out is answered with secondary rate limiting rather than with issues.
 const READ_CONCURRENCY = 8
 const ISSUE_FIELDS = 'title,state,body'
-
-type ReadFailureKind = 'missing' | 'unreadable'
+const FAILURE_TERMS = { success_kind: 'issue', misreading: 'the issue is empty' } as const
 
 interface IssueContent {
 	fields: IssueFields
@@ -69,16 +68,6 @@ function parse_numbers(argv: ReadonlyArray<string>): ReadonlyArray<string> | und
 	return [...new Set(numbers)]
 }
 
-function report_failure(kind: ReadFailureKind, issue_number: string): void {
-	if (kind === 'missing') {
-		console.error(`✖ issue #${issue_number} does not resolve — check the number and the repository`)
-	} else {
-		console.error(
-			`✖ could not read issue #${issue_number} — a rate limit, expired auth, or a dropped connection. This is not "the issue is empty"`,
-		)
-	}
-}
-
 // The comments are read beside the fields rather than after them: the two requests need nothing from
 // one another, and reading them in sequence would put back one of the two round trips this command
 // exists to remove.
@@ -126,34 +115,6 @@ function issue_blocks(report: IssueReport): ReadonlyArray<string> {
 	return [issue_read.format_issue(report.issue_number, fields, comments)]
 }
 
-function print_issues(reports: ReadonlyArray<IssueReport>): void {
-	const blocks = reports.flatMap((report) => issue_blocks(report))
-
-	if (blocks.length === 0) return
-
-	console.info(blocks.join(BLOCK_SEPARATOR))
-}
-
-function report_one_failure(report: IssueReport): boolean {
-	if (report.result.kind === 'issue') return false
-
-	report_failure(report.result.kind, report.issue_number)
-
-	return true
-}
-
-// Every number that produced no issue is named, so a caller is told which ones it has no answer for
-// rather than being left to subtract the printed blocks from what it asked.
-function report_failures(reports: ReadonlyArray<IssueReport>): number {
-	let has_failure = false
-
-	for (const report of reports) {
-		has_failure = report_one_failure(report) || has_failure
-	}
-
-	return has_failure ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE
-}
-
 async function run(argv: ReadonlyArray<string>): Promise<number> {
 	const issue_numbers = parse_numbers(argv)
 
@@ -165,9 +126,12 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 
 	const reports = await read_all(issue_numbers)
 
-	print_issues(reports)
+	issue_report_failures.print_blocks(
+		reports.flatMap((report) => issue_blocks(report)),
+		BLOCK_SEPARATOR,
+	)
 
-	return report_failures(reports)
+	return issue_report_failures.report_failures(reports, FAILURE_TERMS)
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {
@@ -175,10 +139,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 }
 
 const issue_read_cli = {
-	BLOCK_SEPARATOR,
-	ISSUE_FIELDS,
 	USAGE,
-	main,
 	parse_numbers,
 	read_block,
 	run,

package/scripts/issue/issue-read.ts

@@ -130,8 +130,6 @@ function format_issue(
 
 const issue_read = {
 	ISSUE_LABEL,
-	TITLE_LABEL,
-	STATE_LABEL,
 	NO_BODY,
 	NO_COMMENTS,
 	COMMENTS_UNREADABLE,

package/scripts/issue/issue-report-failures.ts

@@ -0,0 +1,80 @@
+// The failure report `issue:read` and `issue:state` share (joshuafolkken/kit#3046). Both read a batch
+// of numbers, print a block for each one that answered, and name every one that did not; only the
+// result kind that counts as an answer and what a gap must not be mistaken for differ between them.
+
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+
+// The two failure kinds a read can end in, kept apart all the way to the report: `missing` is the
+// number resolving to nothing and `unreadable` is a read that failed, and the documents ask a
+// caller to report the two differently. Folding them together to simplify the batch would destroy
+// exactly that distinction.
+type ReadFailureKind = 'missing' | 'unreadable'
+
+interface NumberReport<K extends string> {
+	issue_number: string
+	result: { kind: K | ReadFailureKind }
+}
+
+interface FailureTerms<K extends string> {
+	success_kind: K
+	// What a failed read would be misread as if it were printed silently — "the issue is empty".
+	misreading: string
+}
+
+function print_blocks(blocks: ReadonlyArray<string>, separator: string): void {
+	if (blocks.length === 0) return
+
+	console.info(blocks.join(separator))
+}
+
+// A number that resolves to nothing is an answer — a typo, or another repository's number quoted in
+// prose — and it is reported as one. Everything else is a gap, and the message says so, because the
+// caller's next move differs: a gap is retried, an answer is not.
+function report_failure(kind: ReadFailureKind, issue_number: string, misreading: string): void {
+	if (kind === 'missing') {
+		console.error(`✖ issue #${issue_number} does not resolve — check the number and the repository`)
+	} else {
+		console.error(
+			`✖ could not read issue #${issue_number} — a rate limit, expired auth, or a dropped connection. This is not "${misreading}"`,
+		)
+	}
+}
+
+function is_failure_kind(kind: string): kind is ReadFailureKind {
+	return kind === 'missing' || kind === 'unreadable'
+}
+
+function report_one_failure<K extends string>(
+	report: NumberReport<K>,
+	terms: FailureTerms<K>,
+): boolean {
+	const { kind } = report.result
+
+	if (!is_failure_kind(kind)) return false
+
+	report_failure(kind, report.issue_number, terms.misreading)
+
+	return true
+}
+
+// Every number that produced no answer is named, so a caller is told which ones it has no answer for
+// rather than being left to subtract the printed blocks from what it asked. A single failure makes
+// the exit code non-zero.
+function report_failures<K extends string>(
+	reports: ReadonlyArray<NumberReport<K>>,
+	terms: FailureTerms<K>,
+): number {
+	let has_failure = false
+
+	for (const report of reports) {
+		has_failure = report_one_failure(report, terms) || has_failure
+	}
+
+	return has_failure ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE
+}
+
+const issue_report_failures = { print_blocks, report_failures }
+
+export type { ReadFailureKind }
+export { issue_report_failures }

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

@@ -5,7 +5,7 @@ import { epic_audit_logic } from '#scripts/epic/epic-audit'
 import { epic_bundle, type BacklogIssue, type BundleDecision } from '#scripts/epic/epic-bundle'
 import { epic_bundle_cli } from '#scripts/epic/epic-bundle-cli'
 import { epic_bundle_gaps } from '#scripts/epic/epic-bundle-gaps'
-import { git_gh_command } from '#scripts/git/git-gh-command'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { issue_citation } from '#scripts/rules/issue-citation'
 import {
@@ -403,16 +403,10 @@ const issue_scout_cli = {
 	NO_REFERENCE_LINE,
 	CLOSED_UNREADABLE_LINE,
 	CLOSED_CEILING_LINE,
-	DRAFT_NUMBER,
 	read_arguments,
 	with_draft_body,
-	draft_of,
-	format_duplicates,
-	format_epic_decision,
-	format_report,
 	scout,
 	run,
-	main,
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))

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

@@ -1,9 +1,9 @@
-import { git_gh_command } from '#scripts/git/git-gh-command'
-import { EPIC_LABEL, has_any_label } from '#scripts/git/issue-labels'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { PAGE_CEILING_CAUSE } from '#scripts/git/listing-cutoff'
 import { parse_json_array_or_undefined } from '#scripts/git/parse-json-array'
 import { issue_label_schema } from '#scripts/git/schemas'
 import { z } from 'zod'
+import { EPIC_LABEL, has_any_label } from './issue-labels'
 import type { ScoutIssue } from './issue-scout'
 
 // The closed half of `issue:scout`'s duplicate scan (joshuafolkken/kit#1679), held apart from the CLI

package/scripts/issue/issue-scout.ts

@@ -232,10 +232,8 @@ function find_duplicates(
 
 const issue_scout = {
 	SIMILARITY_THRESHOLD,
-	MIN_SHARED_TOKENS,
 	MAX_CANDIDATES,
 	tokenize,
-	shared_tokens,
 	dice_similarity,
 	find_duplicates,
 }

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

@@ -1,7 +1,8 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { git_gh_command } from '#scripts/git/git-gh-command'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { bounded_pool } from '#scripts/lib/bounded-pool'
+import { issue_report_failures, type ReadFailureKind } from './issue-report-failures'
 import { issue_state, type IssueState } from './issue-state'
 
 // `josh issue:state <N> [<N> ...]` — print each issue's state and labels, in the spelling the
@@ -25,7 +26,6 @@ import { issue_state, type IssueState } from './issue-state'
 // answer as "not CLOSED" would report a child as failed because nobody could reach GitHub. The two
 // are told apart here and neither is a state.
 
-const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const ARGV_OFFSET = 2
 const REPO_FLAG = '--repo'
@@ -43,18 +43,13 @@ const READ_CONCURRENCY = 8
 // The two fields, under the names `gh issue view --json` gave them. `git-gh-issue-rest.ts` maps them
 // back from REST, which is what keeps `OPEN` / `CLOSED` / `MERGED` out of this file.
 const STATE_FIELDS = 'state,labels'
+const FAILURE_TERMS = { success_kind: 'state', misreading: 'the issue is open' } as const
 
 interface StateRequest {
 	issue_numbers: ReadonlyArray<string>
 	repo?: string
 }
 
-// The two failure kinds a read can end in, kept apart all the way to the report: `missing` is the
-// number resolving to nothing and `unreadable` is a read that failed, and the documents ask a
-// caller to report the two differently. Folding them together to simplify the batch would destroy
-// exactly that distinction.
-type ReadFailureKind = 'missing' | 'unreadable'
-
 // One issue's state, or the failure kind. Named for export because `run:prep` reads the state beside
 // the body and the dependency-update scope (joshuafolkken/kit#1978), reusing this read rather than a
 // second one that would drift from the `human_review` decision `parse_issue_state` owns.
@@ -146,19 +141,6 @@ function parse_request(argv: ReadonlyArray<string>): StateRequest | undefined {
 	return repo_flag.kind === 'named' ? { issue_numbers, repo: repo_flag.repo } : { issue_numbers }
 }
 
-// A number that resolves to nothing is an answer — a typo, or another repository's number quoted in
-// prose — and it is reported as one. Everything else is a gap, and the message says so, because the
-// caller's next move differs: a gap is retried, an answer is not.
-function report_failure(kind: ReadFailureKind, issue_number: string): void {
-	if (kind === 'missing') {
-		console.error(`✖ issue #${issue_number} does not resolve — check the number and the repository`)
-	} else {
-		console.error(
-			`✖ could not read issue #${issue_number} — a rate limit, expired auth, or a dropped connection. This is not "the issue is open"`,
-		)
-	}
-}
-
 // One number's read, reduced to what the report needs and nothing printed yet. Separating the two
 // is what lets the whole batch be in flight at once: the numbers are independent, so reading them
 // one after the other spends a round trip per number for no reason.
@@ -206,30 +188,7 @@ function print_states(reports: ReadonlyArray<IssueReport>): void {
 	const should_attribute = reports.length > 1
 	const blocks = reports.flatMap((report) => state_blocks(report, should_attribute))
 
-	if (blocks.length === 0) return
-
-	console.info(blocks.join(BLOCK_SEPARATOR))
-}
-
-function report_one_failure(report: IssueReport): boolean {
-	if (report.result.kind === 'state') return false
-
-	report_failure(report.result.kind, report.issue_number)
-
-	return true
-}
-
-// Every number that produced no state is named, so a caller is told which ones it has no answer for
-// rather than being left to subtract the printed blocks from what it asked. A single failure still
-// makes the exit code non-zero, exactly as it did when only one number could be passed.
-function report_failures(reports: ReadonlyArray<IssueReport>): number {
-	let has_failure = false
-
-	for (const report of reports) {
-		has_failure = report_one_failure(report) || has_failure
-	}
-
-	return has_failure ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE
+	issue_report_failures.print_blocks(blocks, BLOCK_SEPARATOR)
 }
 
 async function run(argv: ReadonlyArray<string>): Promise<number> {
@@ -245,7 +204,7 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 
 	print_states(reports)
 
-	return report_failures(reports)
+	return issue_report_failures.report_failures(reports, FAILURE_TERMS)
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {

package/scripts/issue/issue-state.ts

@@ -1,6 +1,6 @@
-import { has_any_label, NEEDS_HUMAN_REVIEW_LABEL } from '#scripts/git/issue-labels'
 import { parse_json_object_safe } from '#scripts/git/parse-json-array'
 import { z } from 'zod'
+import { has_any_label, NEEDS_HUMAN_REVIEW_LABEL } from './issue-labels'
 
 // The answer `josh issue:state` prints, kept apart from the reading and the printing so the shape of
 // the report is decided by one pure function (joshuafolkken/kit#1054).
@@ -96,10 +96,6 @@ function format_attributed_issue_state(issue_number: string, state: IssueState):
 
 const issue_state = {
 	NO_LABELS,
-	STATE_LABEL,
-	LABELS_LABEL,
-	HUMAN_REVIEW_LABEL_LINE,
-	ISSUE_LABEL,
 	parse_issue_state,
 	format_issue_state,
 	format_attributed_issue_state,

package/scripts/issue/markdown-section.ts

@@ -68,6 +68,6 @@ function section_lines(body: string, heading: string): ReadonlyArray<string> {
 	return end === -1 ? rest : rest.slice(0, end)
 }
 
-const markdown_section = { section_lines, is_heading, has_line, has_unfenced_line }
+const markdown_section = { section_lines, has_line, has_unfenced_line }
 
 export { markdown_section }

package/scripts/issue/measure-rerun-cli.ts

@@ -90,7 +90,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv[0], new Date())
 }
 
-const measure_rerun_cli = { run, rerun_one, USAGE, NO_BASELINE }
+const measure_rerun_cli = { run }
 
 const ARGV_OFFSET = 2
 

package/scripts/issue/reproduction-measure.ts

@@ -53,7 +53,7 @@ function has_command_output(body: string, heading: string = REPRODUCTION_HEADING
 	return reproduction.has_command && reproduction.has_output
 }
 
-const reproduction_measure = { REPRODUCTION_HEADING, has_command_output, parse_reproduction }
+const reproduction_measure = { has_command_output }
 
 export type { Reproduction }
 export { reproduction_measure }

package/scripts/josh/cli-body.ts

@@ -91,6 +91,6 @@ function resolve(input: {
 	return read_file_or_stdin(file_path)
 }
 
-const cli_body = { read_file_or_stdin, expand_escaped_newlines, has_value, resolve }
+const cli_body = { read_file_or_stdin, has_value, resolve }
 
 export { cli_body }

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

@@ -253,11 +253,8 @@ const file_map_stamp = {
 	changed_since,
 	create,
 	describes_base,
-	is_file_map,
-	is_writer_gone,
 	is_writer_running,
 	parse_stamp,
-	read_at,
 }
 
 export type { FileMapStamp, FileMapStampAccess }