@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/scripts/issue/defect-report.ts

@@ -0,0 +1,160 @@
+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
+// change kind, and per area of the tree it touched, plus how many each pull request that added a
+// mechanism drew within a week of merging. Read from the bodies and the pull requests' files only,
+// so nothing here asks for a judgement.
+
+const WEEK_DAYS = 7
+const MS_PER_DAY = 86_400_000
+const WEEK_MS = WEEK_DAYS * MS_PER_DAY
+const SCRIPTS_ROOT = 'scripts'
+// `scripts/<dir>` — the two leading segments of a path under `scripts/`.
+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'
+
+interface ReportIssue {
+	number: number
+	created_at: string
+	body: string
+}
+
+interface PrFile {
+	filename: string
+	status: string
+	additions: number
+	deletions: number
+}
+
+interface OriginPr {
+	pr: number
+	merged_at: string
+	kind: ChangeKind
+	areas: ReadonlyArray<string>
+}
+
+interface Attributed {
+	issue: ReportIssue
+	pr: number
+}
+
+interface DefectReport {
+	by_pr: ReadonlyMap<number, number>
+	by_kind: ReadonlyMap<string, number>
+	by_area: ReadonlyMap<string, number>
+	unknown: number
+	undeclared: number
+	added_within_week: ReadonlyMap<number, number>
+}
+
+function changed(files: ReadonlyArray<PrFile>): ReadonlyArray<PrFile> {
+	return files.filter((file) => !file.filename.startsWith(RUN_RECORD_ROOT))
+}
+
+// A pull request that brought in a new non-test file added a mechanism; one that took out more than it
+// put in removed; anything else changed what was there.
+function change_kind(files: ReadonlyArray<PrFile>): ChangeKind {
+	const source = changed(files).filter((file) => !TEST_FILE.test(file.filename))
+
+	if (source.some((file) => file.status === 'added')) return 'add'
+
+	const added = source.reduce((sum, file) => sum + file.additions, 0)
+	const removed = source.reduce((sum, file) => sum + file.deletions, 0)
+
+	return removed > added ? 'remove' : 'fix'
+}
+
+// `scripts/<dir>` for a script, the top-level directory otherwise, and one bucket for root files.
+function area_of(filename: string): string {
+	const segments = filename.split('/')
+
+	if (segments.length === 1) return ROOT_AREA
+
+	const is_script = segments[0] === SCRIPTS_ROOT && segments.length > SCRIPT_AREA_DEPTH
+	const depth = is_script ? SCRIPT_AREA_DEPTH : 1
+
+	return segments.slice(0, depth).join('/')
+}
+
+function areas(files: ReadonlyArray<PrFile>): ReadonlyArray<string> {
+	return [...new Set(changed(files).map((file) => area_of(file.filename)))]
+}
+
+function increment<K>(counts: Map<K, number>, key: K): void {
+	counts.set(key, (counts.get(key) ?? 0) + 1)
+}
+
+function count_by<K>(
+	items: ReadonlyArray<Attributed>,
+	keys: (item: Attributed) => ReadonlyArray<K>,
+): Map<K, number> {
+	const counts = new Map<K, number>()
+
+	for (const item of items) for (const key of keys(item)) increment(counts, key)
+
+	return counts
+}
+
+function within_week(issue: ReportIssue, origin: OriginPr): boolean {
+	const elapsed = Date.parse(issue.created_at) - Date.parse(origin.merged_at)
+
+	return elapsed >= 0 && elapsed <= WEEK_MS
+}
+
+function attribute(issue: ReportIssue): Attributed | undefined {
+	const origin = defect_origin_line.parse(issue.body)
+
+	return origin?.kind === 'pr' ? { issue, pr: origin.pr } : undefined
+}
+
+function attributed(issues: ReadonlyArray<ReportIssue>): ReadonlyArray<Attributed> {
+	return issues.map((issue) => attribute(issue)).filter((item) => item !== undefined)
+}
+
+// Every pull request an origin line names, once — what the report has to read.
+function origin_prs(issues: ReadonlyArray<ReportIssue>): ReadonlyArray<number> {
+	return [...new Set(attributed(issues).map(({ pr }) => pr))]
+}
+
+function soon_after_adding(
+	items: ReadonlyArray<Attributed>,
+	prs: ReadonlyMap<number, OriginPr>,
+): Map<number, number> {
+	return count_by(items, ({ issue, pr }) => {
+		const origin = prs.get(pr)
+
+		return origin?.kind === 'add' && within_week(issue, origin) ? [pr] : []
+	})
+}
+
+function count_origins(issues: ReadonlyArray<ReportIssue>, kind: 'unknown' | undefined): number {
+	return issues.filter((issue) => defect_origin_line.parse(issue.body)?.kind === kind).length
+}
+
+function aggregate(
+	issues: ReadonlyArray<ReportIssue>,
+	prs: ReadonlyMap<number, OriginPr>,
+): DefectReport {
+	const items = attributed(issues)
+
+	return {
+		by_pr: count_by(items, ({ pr }) => [pr]),
+		by_kind: count_by(items, ({ pr }) => [prs.get(pr)?.kind ?? UNREAD_AREA]),
+		by_area: count_by(items, ({ pr }) => prs.get(pr)?.areas ?? [UNREAD_AREA]),
+		unknown: count_origins(issues, 'unknown'),
+		undeclared: count_origins(issues, undefined),
+		added_within_week: soon_after_adding(items, prs),
+	}
+}
+
+const defect_report = { aggregate, area_of, areas, change_kind, origin_prs, WEEK_DAYS }
+
+export type { ChangeKind, DefectReport, OriginPr, PrFile, ReportIssue }
+export { defect_report }

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

@@ -53,6 +53,7 @@ const expected_effect_lint = {
 	DECLARATION_LINE,
 	HEADING,
 	ITEM_LABELS,
+	is_target,
 	problems,
 }
 

package/scripts/issue/issue-already-done-cli.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { issue_evidence_exit } from '#scripts/issue/issue-evidence-exit'
+import { ALREADY_DONE_LABEL } from '#scripts/issue/issue-labels'
+import { issue_sample_gate } from '#scripts/issue/issue-sample-gate'
+import { session_cite } from '#scripts/issue/session-cite'
+
+// `josh issue:already-done <N> --evidence-file <path>` — the exit for an Issue whose work is already
+// merged (`issue-comments.md` → "When the work turns out to be already merged"): the evidence
+// comment, the `already-done` label and the `run:release`, in that order (`issue-evidence-exit.ts`).
+//
+// The label is provisioned by `josh start`, so nothing here creates it.
+// **The Issue is never closed**: closing is a person's (Tier C), and the label is the run's exit.
+//
+// **A follow-up measurement is refused before anything is written** (joshuafolkken/kit#4504): its body
+// declares the sample wait (`issue_sample_gate.DECLARATION`, read as `not-before` reads it), and its
+// exit is `josh issue:measured`, which closes it — this one would leave it OPEN and the lane parked.
+
+const ARGV_OFFSET = 2
+
+function refusal_of(issue_number: string, body: string | undefined): string | undefined {
+	const cite = session_cite.issue(issue_number)
+	if (body === undefined) return `Issue ${cite} body not read; nothing written`
+	if (issue_sample_gate.cited_number(body) === undefined) return undefined
+
+	return `Issue ${cite} is a follow-up measurement (\`${issue_sample_gate.DECLARATION}\`): run \`josh issue:measured ${issue_number} --evidence-file <path>\` instead; nothing written`
+}
+
+async function admit(issue_number: string): Promise<boolean> {
+	const refusal = refusal_of(issue_number, await git_gh_command.issue_get_body(issue_number))
+
+	if (refusal !== undefined) console.error(refusal)
+
+	return refusal === undefined
+}
+
+async function apply_label(issue_number: string): Promise<boolean> {
+	const write = await git_gh_command.issue_apply_label(issue_number, ALREADY_DONE_LABEL)
+
+	if (!write.is_applied) console.error(`${ALREADY_DONE_LABEL} not applied: ${write.reason}`)
+
+	return write.is_applied
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	return await issue_evidence_exit.run(argv, {
+		command: 'issue:already-done',
+		finish: apply_label,
+		admit,
+	})
+}
+
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const issue_already_done_cli = { run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { issue_already_done_cli }

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

@@ -0,0 +1,40 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+
+// One text written to an issue: **into the body when the body is blank, as a comment otherwise.**
+// Two writers make this decision — `followup`'s completion notice and `issue:plan`'s plan — and a copy
+// per caller is how the two would come to disagree about what "blank" means.
+//
+// A body that could not be read is not blank: overwriting a body nobody saw could erase a person's
+// text, so an unreadable body falls to a comment, which loses nothing.
+
+type Destination = 'body' | 'comment'
+
+interface PostOutcome {
+	destination: Destination
+	url: string
+}
+
+function is_blank_body(body: string | undefined): boolean {
+	return body?.trim().length === 0
+}
+
+// `repo` (`owner/name`) addresses an issue in another repository; left out, the checkout's own.
+async function post(issue_number: string, text: string, repo?: string): Promise<PostOutcome> {
+	const current_body = await git_gh_command.issue_get_body(issue_number, repo)
+
+	if (is_blank_body(current_body)) {
+		const url = await git_gh_command.issue_edit_body(issue_number, text, repo)
+
+		return { destination: 'body', url }
+	}
+
+	return {
+		destination: 'comment',
+		url: await git_gh_command.issue_comment(issue_number, text, repo),
+	}
+}
+
+const issue_body_or_comment = { post }
+
+export { issue_body_or_comment }
+export type { Destination, PostOutcome }

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

@@ -1,5 +1,3 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
 import { git_gh_command } from '#scripts/gh/git-gh-command'
 import type { IssueRead } from '#scripts/gh/git-gh-issue-read'
 import { bounded_pool } from '#scripts/lib/bounded-pool'
@@ -24,7 +22,6 @@ import { issue_cite, type CiteTarget } from './issue-cite'
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
-const ARGV_OFFSET = 2
 // 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.
 const READ_CONCURRENCY = 8
@@ -160,10 +157,6 @@ async function run(args: ReadonlyArray<string>): Promise<number> {
 	return report(cited)
 }
 
-async function main(args: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(args)
-}
-
 const issue_cite_cli = {
 	USAGE,
 	cite,
@@ -171,6 +164,4 @@ const issue_cite_cli = {
 	run,
 }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
-
 export { issue_cite_cli }

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { issue_cite_cli } from './issue-cite-cli'
+
+// The `josh issue:cite` entry, kept apart from `issue-cite-cli.ts` because other modules import that
+// one: a bundle is one file, so a main guard there would fire for every command that carries it
+// (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await issue_cite_cli.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/issue/issue-classification.ts

@@ -1,3 +1,4 @@
+import { defect_origin_line } from './defect-origin-line'
 import { issue_bug_label } from './issue-bug-label'
 import { BREAKING_CHANGE_LABEL, BUG_LABEL, ENHANCEMENT_LABEL, has_label_name } from './issue-labels'
 import { markdown_section } from './markdown-section'
@@ -44,16 +45,20 @@ function bug_classification_problem(body: string): string | undefined {
 	return undefined
 }
 
-function problems(body: string): ReadonlyArray<string> {
-	const classification_problem = bug_classification_problem(body)
-	const found: Array<string> = []
-
-	if (classification_problem !== undefined) found.push(classification_problem)
+function label_conflict(body: string): string | undefined {
 	const labels = required_labels(body)
 
-	if (labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL)) found.push(CONFLICT)
+	return labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL) ? CONFLICT : undefined
+}
+
+function problems(body: string): ReadonlyArray<string> {
+	const found = [
+		bug_classification_problem(body),
+		label_conflict(body),
+		defect_origin_line.problem(body),
+	]
 
-	return found
+	return found.filter((problem) => problem !== undefined)
 }
 
 const issue_classification = {

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

@@ -1,5 +1,3 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
 import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
 import { cli_body } from '#scripts/josh/cli-body'
@@ -19,7 +17,6 @@ import { error_text } from '#scripts/lib/error-message'
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
-const ARGV_OFFSET = 2
 const BODY_FLAG = '--body'
 const BODY_FILE_FLAG = '--body-file'
 const USAGE = `Usage: josh issue:comment <issue-number> ${BODY_FLAG} <text> | ${BODY_FILE_FLAG} <path>`
@@ -33,23 +30,12 @@ interface CommentRequest {
 // ignored. `cli_body.resolve` owns the both-flags-at-once refusal and the file read.
 const OPTIONS = { body: { type: 'string' }, 'body-file': { type: 'string' } } as const
 
-// The number is the one positional, and it must be a real issue number: a missing, malformed or
-// second one refuses the whole call rather than posting to some other issue.
-function single_issue_number(positionals: ReadonlyArray<string>): string | undefined {
-	const [issue_number, ...rest] = positionals
-	const is_single = rest.length === 0 && issue_number !== undefined
-
-	return is_single && issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue_number)
-		? issue_number
-		: undefined
-}
-
 // `resolve` may throw when both body flags are given, which `run` reports — the message names the two
 // flags a caller must pick between.
 function parse_request(argv: ReadonlyArray<string>): CommentRequest | undefined {
 	const parsed = cli_flags.arguments_of(argv, OPTIONS)
 	if (parsed === undefined) return undefined
-	const issue_number = single_issue_number(parsed.positionals)
+	const issue_number = issue_number_shape.single_of(parsed.positionals)
 	if (issue_number === undefined) return undefined
 
 	const body = cli_body.resolve({
@@ -67,11 +53,16 @@ function parse_request(argv: ReadonlyArray<string>): CommentRequest | undefined
 // A both-flags refusal and a file-read failure both surface as an `Error` from `resolve`, and its
 // message already names the flags or the resolved path — so it is printed as-is and `USAGE` is
 // withheld. `undefined` is the other refusal: a bad number or an empty body, which `USAGE` explains.
-function resolve_request(argv: ReadonlyArray<string>): CommentRequest | undefined {
+// `usage` is the caller's: `run:park` parks with the same issue number and body, so it reads them here
+// and prints its own usage on a refusal.
+function resolve_request(
+	argv: ReadonlyArray<string>,
+	usage: string = USAGE,
+): CommentRequest | undefined {
 	try {
 		const request = parse_request(argv)
 
-		if (request === undefined) console.error(USAGE)
+		if (request === undefined) console.error(usage)
 
 		return request
 	} catch (error) {
@@ -93,12 +84,7 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 	return SUCCESS_EXIT_CODE
 }
 
-async function main(argv: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(argv)
-}
-
-const issue_comment_cli = { USAGE, run }
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+const issue_comment_cli = { USAGE, resolve_request, run }
 
+export type { CommentRequest }
 export { issue_comment_cli }

package/scripts/issue/issue-comment-main.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { issue_comment_cli } from './issue-comment-cli'
+
+// The `josh issue:comment` entry, kept apart from `issue-comment-cli.ts` because other modules import
+// that one: a bundle is one file, so a main guard there would fire for every command that carries it
+// (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const ARGV_OFFSET = 2
+
+	process.exitCode = await issue_comment_cli.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/issue/issue-evidence-exit.ts

@@ -0,0 +1,100 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { cli_body } from '#scripts/josh/cli-body'
+import { cli_flags } from '#scripts/lib/cli-flags'
+import { error_text } from '#scripts/lib/error-message'
+import { run_hold_cli } from '#scripts/run/hold/run-hold-cli'
+
+// The shape every evidence exit shares — `josh issue:already-done` and `josh issue:measured`: the
+// evidence comment, the exit's own finishing write, then the `run:release`, in that order.
+//
+// **The order is the point.** The finishing write without the comment is an uncited claim, so the
+// comment goes first and each step runs only once the one before it landed — a failure stops there
+// and names the step.
+
+const FAILURE_EXIT_CODE = 1
+const EVIDENCE_FILE_FLAG = '--evidence-file'
+const OPTIONS = { 'evidence-file': { type: 'string' } } as const
+
+interface EvidenceRequest {
+	issue_number: string
+	evidence: string
+}
+
+// `admit`, when given, runs once the request parsed and before the first write: an exit that does not
+// fit the Issue refuses there, with nothing written.
+interface EvidenceExit {
+	command: string
+	finish: (issue_number: string) => Promise<boolean>
+	admit?: (issue_number: string) => Promise<boolean>
+}
+
+// An evidence file that is empty or whitespace only is refused before anything is written: a comment
+// with no citations is not the finding an exit is for. The throw carries the reason to `run`.
+function parse_request(argv: ReadonlyArray<string>): EvidenceRequest | undefined {
+	const parsed = cli_flags.arguments_of(argv, OPTIONS)
+	if (parsed === undefined) return undefined
+	const issue_number = issue_number_shape.single_of(parsed.positionals)
+	const file_path = parsed.values['evidence-file']
+	if (issue_number === undefined || file_path === undefined) return undefined
+	const evidence = cli_body.read_file_or_stdin(file_path).trim()
+	if (evidence.length === 0) throw new Error(`Evidence file is empty: ${file_path}`)
+
+	return { issue_number, evidence }
+}
+
+// A file-read failure or an empty file is an `Error` naming the path, printed as-is; every other
+// refusal is `undefined`, which the usage line explains.
+function resolve_request(
+	argv: ReadonlyArray<string>,
+	command: string,
+): EvidenceRequest | undefined {
+	try {
+		const request = parse_request(argv)
+
+		if (request === undefined) {
+			console.error(`Usage: josh ${command} <issue-number> ${EVIDENCE_FILE_FLAG} <path>`)
+		}
+
+		return request
+	} catch (error) {
+		console.error(error_text.message_of(error))
+
+		return undefined
+	}
+}
+
+async function post_evidence(request: EvidenceRequest): Promise<boolean> {
+	try {
+		console.info(await git_gh_command.issue_comment(request.issue_number, request.evidence))
+
+		return true
+	} catch (error) {
+		console.error(`Evidence comment not posted: ${error_text.message_of(error)}`)
+
+		return false
+	}
+}
+
+// Each write runs only once the one before it landed: `&&` stops at the first that did not.
+async function write_exit(request: EvidenceRequest, exit: EvidenceExit): Promise<boolean> {
+	return (await post_evidence(request)) && (await exit.finish(request.issue_number))
+}
+
+async function is_admitted(request: EvidenceRequest, exit: EvidenceExit): Promise<boolean> {
+	return exit.admit === undefined || (await exit.admit(request.issue_number))
+}
+
+async function run(argv: ReadonlyArray<string>, exit: EvidenceExit): Promise<number> {
+	const request = resolve_request(argv, exit.command)
+	if (request === undefined || !(await is_admitted(request, exit))) return FAILURE_EXIT_CODE
+
+	return (await write_exit(request, exit))
+		? await run_hold_cli.run(['--release', request.issue_number])
+		: FAILURE_EXIT_CODE
+}
+
+const issue_evidence_exit = { run }
+
+export type { EvidenceExit }
+export { issue_evidence_exit }

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

@@ -14,20 +14,24 @@ import { repository_labels } from '#scripts/repo/repository-labels'
 import { run_event_filed } from '#scripts/run/event/run-event-filed'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
+import { run_hold_member } from '#scripts/run/hold/run-hold-member'
 import { issue_auto_ok } from './issue-auto-ok'
 import { issue_cite } from './issue-cite'
 import { issue_file, type FileArguments } from './issue-file'
 import { issue_file_fold } from './issue-file-fold'
 import { issue_lint_cli } from './issue-lint-cli'
+import { issue_priority } from './issue-priority'
 import { issue_release_cli } from './issue-release-cli'
+import { issue_sample_source } from './issue-sample-source'
 import { issue_scout_cli } from './issue-scout-cli'
 import { issue_wip } from './issue-wip'
 
-// `josh issue:file "<title>" --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>]…
+// `josh issue:file "<title>" --body-file <path> [--route <route>] [--label <name>]…
 // [--repo <owner/repo>] [--distinct <N,…>] [--over-cap] [--no-auto-ok] [--release]` — file an Issue
 // with every filing step run in order: the third-party refusal, the body
 // lint, the `## Origin` check for another repository, the `auto-ok` decision
-// with the run label it owes, the fold question against the run's earlier
+// with the run label it owes, the start condition read as a pull request, the fold question against
+// the run's earlier
 // filings, the WIP cap count, the
 // duplicate scout, the missing workflow labels created, the create call
 // carrying every label, the release link on `--release`, and `epic:bundle`.
@@ -37,7 +41,7 @@ const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const ARGV_OFFSET = 2
 const USAGE =
-	'Usage: josh issue:file "<title>" --body-file <path> --depth <0|1|2> [--route <tier-a|split|interrupt|review-cap>] [--label <name>]… [--repo <owner/repo>] [--distinct <N,…>] [--over-cap] [--no-auto-ok] [--release]'
+	'Usage: josh issue:file "<title>" --body-file <path> [--route <tier-a|split|interrupt|review-cap>] [--label <name>]… [--repo <owner/repo>] [--distinct <N,…>] [--over-cap] [--no-auto-ok] [--release]'
 const UNKNOWN_REPO_MESSAGE =
 	'Could not read this repository from `git remote`, so the filing has no repository to compare against — check `gh auth status`.'
 const THIRD_PARTY_MESSAGE =
@@ -77,6 +81,7 @@ function refusals_of(filing: Filing): ReadonlyArray<string> {
 	const problems = [
 		...issue_lint_cli.problems(filing.body),
 		issue_auto_ok.declaration_problem(filing.body),
+		issue_priority.problem(filing.body, filing.args.labels),
 		issue_file.origin_problem(filing.body, filing.target, filing.current),
 	]
 
@@ -223,8 +228,9 @@ async function place(url: string, target: string): Promise<void> {
 }
 
 // Every filing lands on the run's event stream: this is the one filing path, so
-// one append here reaches `run:board` from every route. A filing outside a run lands too and is left
-// out by the board's own scope to the invocation; the append is best-effort, as every emit is.
+// one append here reaches `run:board` from every route. A filing outside a run lands too, unmarked as
+// the run's (`run_hold_member`), and the board counts only the marked ones; the append is best-effort,
+// as every emit is.
 async function record(url: string, filing: Filing, labels: ReadonlyArray<string>): Promise<void> {
 	const number = String(issue_number_of(url))
 	const reference = issue_cite.plain(
@@ -233,7 +239,9 @@ async function record(url: string, filing: Filing, labels: ReadonlyArray<string>
 	)
 	const found_during = await issue_file_fold.finder()
 	const kind = run_event_filed.kind_of(labels)
-	const text = run_event_filed.text_of({ reference, kind, title: filing.args.title, found_during })
+	const is_run = await run_hold_member.is_run_member()
+	const { title } = filing.args
+	const text = run_event_filed.text_of({ reference, kind, title, found_during, is_run })
 
 	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.FILED, text)
 }
@@ -247,6 +255,20 @@ function is_admitted(filing: Filing): boolean {
 	return false
 }
 
+// The start condition's citation read against GitHub — after the local refusals, before any listing.
+async function is_source_clear(filing: Filing): Promise<boolean> {
+	const is_here = issue_file.is_same_repository(filing.target, filing.current)
+	const problem = await issue_sample_source.problem(
+		filing.body,
+		is_here ? undefined : filing.target,
+	)
+
+	if (problem === undefined) return true
+	console.error(`✖ ${problem}`)
+
+	return false
+}
+
 async function send(filing: Filing, labels: ReadonlyArray<string>): Promise<number> {
 	const url = await create(filing, labels)
 
@@ -270,7 +292,7 @@ async function is_clear(filing: Filing): Promise<boolean> {
 }
 
 async function file(filing: Filing): Promise<number> {
-	if (!is_admitted(filing)) return FAILURE_EXIT_CODE
+	if (!is_admitted(filing) || !(await is_source_clear(filing))) return FAILURE_EXIT_CODE
 	const labels = labels_of(filing)
 
 	if (labels === undefined || !(await is_clear(filing))) return FAILURE_EXIT_CODE