@joshuafolkken/kit 1.1514.0 → 1.2114.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

@@ -7,19 +7,19 @@ import { issue_backlinks } from './issue-backlinks'
 import { issue_classification } from './issue-classification'
 import {
 	AUTO_OK_LABEL,
-	DEPTH_LABEL_ORDER,
 	FILING_ROUTE_LABELS,
 	has_label_name,
 	RUN_LANE_LABEL,
 	RUN_SOLO_LABEL,
 } from './issue-labels'
+import { issue_not_before_label } from './issue-not-before-label'
+import { issue_priority } from './issue-priority'
 import { markdown_section } from './markdown-section'
 
 // The decisions behind `josh issue:file`, kept apart from the command that
 // reads the network so each one is a pure answer a test can pin. The filing steps are the command's
 // arguments: a label the filing owes is a required option rather than a line to remember.
 
-const DEPTH_PREFIX = 'depth:'
 const ROUTE_PREFIX = 'route:'
 const LIST_SEPARATOR = ','
 const WORD_SEPARATOR = /\s+/u
@@ -32,11 +32,14 @@ const DIGIT = /\d/u
 interface FileArguments {
 	title: string
 	body_file: string
-	depth: string
 	route: string | undefined
 	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`).
@@ -44,22 +47,26 @@ 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 = {
 	'body-file': { type: 'string' },
-	depth: { type: 'string' },
 	route: { type: 'string' },
 	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 `--depth` / `--route` value names, or `undefined` when it names none — read against the
-// label sets `issue-labels.ts` defines, so the command cannot apply a depth or route nobody provisions.
+// The label a `--route` value names, or `undefined` when it names none — read against the route
+// labels `issue-labels.ts` defines, so the command cannot apply a route nobody provisions.
 function label_of(
 	prefix: string,
 	value: string | undefined,
@@ -97,18 +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 depth, route or `--distinct` entry is not
-// one the command knows.
-function labelled_of(
-	values: ParsedValues,
-): Pick<FileArguments, 'depth' | 'route' | 'distinct'> | undefined {
-	const depth = label_of(DEPTH_PREFIX, values.depth, DEPTH_LABEL_ORDER)
+// `--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 || depth === undefined || distinct === undefined) return undefined
+	if (route === false || distinct === undefined || found_during === false) return undefined
 
-	return { depth, route, distinct }
+	return { route, distinct, found_during }
 }
 
 function arguments_of(values: ParsedValues, title: string | undefined): FileArguments | undefined {
@@ -126,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,
 	}
 }
 
@@ -144,14 +161,19 @@ function is_undeclared_classification(label: string, body: string): boolean {
 	return is_classification && !has_label_name(issue_classification.required_labels(body), label)
 }
 
-// Every label the filing carries: the depth, the route when there is one, the classification labels
+// Every label the filing carries: the route when there is one, the classification labels
 // 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. One request applies them all, so no label is a separate step to forget.
+// already named it, `not-before` while the body's start time is ahead (`issue-not-before-label.ts`), and
+// 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))
-	const declared = [args.depth, ...(args.route === undefined ? [] : [args.route]), ...extra]
-	const labels = issue_classification.labels_for(body, declared)
+	const declared = [...(args.route === undefined ? [] : [args.route]), ...extra]
+	const labels = issue_priority.with_label(
+		issue_not_before_label.with_label(issue_classification.labels_for(body, declared), body),
+		body,
+	)
 
 	if (!is_auto_ok || has_label_name(labels, AUTO_OK_LABEL)) return labels
 
@@ -168,7 +190,7 @@ function triage_problem(labels: ReadonlyArray<string>): string | undefined {
 
 	if (!is_owed) return undefined
 
-	return `an \`${AUTO_OK_LABEL}\` filing needs \`--label ${RUN_LANE_LABEL}\` or \`--label ${RUN_SOLO_LABEL}\` — \`${RUN_SOLO_LABEL}\` only for a defect in kit's own verification that makes unrelated PRs answer wrongly on main now (\`backlogrun-lanes.md\`), else \`${RUN_LANE_LABEL}\``
+	return `an \`${AUTO_OK_LABEL}\` filing needs \`--label ${RUN_LANE_LABEL}\` or \`--label ${RUN_SOLO_LABEL}\` — \`${RUN_SOLO_LABEL}\` only for a defect in kit's own verification that makes unrelated PRs answer wrongly on main on every run (\`backlogrun-lanes.md\`), else \`${RUN_LANE_LABEL}\` — a flaky one takes \`${RUN_LANE_LABEL}\` and \`priority:critical\``
 }
 
 function is_same_repository(target: string, current: string): boolean {
@@ -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-fold-cli.ts

@@ -1,9 +1,7 @@
-#!/usr/bin/env tsx
-import { fileURLToPath } from 'node:url'
-import { git_command } from '#scripts/git/git-command'
 import { path_decision } from '#scripts/josh/path-decision'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { split_assess, type SplitVerdict } from '#scripts/split/split-assess'
+import { split_measure } from '#scripts/split/split-measure'
 import { issue_fold, type FoldVerdict } from './issue-fold'
 
 // `josh issue:fold "<title>" "<title>" …` — before a run files a second finding, answer whether the
@@ -15,7 +13,6 @@ import { issue_fold, type FoldVerdict } from './issue-fold'
 // `--not-separable` when the findings are really one deliverable. The verdict logic is in
 // `issue-fold.ts`; everything here is the invocation.
 
-const ARGV_OFFSET = 2
 const USAGE = 'Usage: josh issue:fold "<title>" "<title>" … [--not-separable] [--json]'
 const JSON_KEY = 'fold'
 const FAILURE_EXIT_CODE = 1
@@ -58,7 +55,7 @@ function read_arguments(argv: ReadonlyArray<string>): FoldArguments | undefined
 // rather than folding on no evidence. `issue:file` asks it too.
 async function size_verdict(): Promise<SplitVerdict | undefined> {
 	try {
-		const measurement = split_assess.assess(await git_command.diff_main_numstat())
+		const measurement = await split_measure.read_branch()
 
 		return measurement.files === 0 ? undefined : measurement.verdict
 	} catch {
@@ -91,12 +88,6 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 	return 0
 }
 
-async function main(argv: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(argv)
-}
-
 const issue_fold_cli = { REASONS, read_arguments, size_verdict, run }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
-
 export { issue_fold_cli }

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { issue_fold_cli } from './issue-fold-cli'
+
+// The `josh issue:fold` entry, kept apart from `issue-fold-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_fold_cli.run(process.argv.slice(ARGV_OFFSET))
+}

package/scripts/issue/issue-labels.ts

@@ -1,6 +1,12 @@
 // The workflow label names, defined once. The epic auto-close, the epic validator, the issue-prep
 // labeler and the next-issues display all key on these exact strings, and a drifted copy would
 // fail silently — an epic filtered on the wrong name is simply never closed or never excluded.
+//
+// **A new label is defined here and added to `REPOSITORY_LABELS`**, so `josh start` and `josh sync`
+// create it; a label deliberately not provisioned goes into `EXEMPT_FROM_PROVISIONING` with its
+// reason. Every other module imports the constant rather than spelling the name —
+// `issue-label-scan.test.ts` fails on a `*_LABEL` constant missing from `ALL_LABELS`, on a label name
+// spelled outside this module, and on a label call naming a label `ALL_LABELS` does not hold.
 const EPIC_LABEL = 'epic'
 const BUG_LABEL = 'bug'
 const ENHANCEMENT_LABEL = 'enhancement'
@@ -15,6 +21,11 @@ const PLANNED_LABEL = 'run:planned'
 // it: a parked child is why a run reports "nothing left that time will fix" rather than waiting
 // forever.
 const NEEDS_DECISION_LABEL = 'needs-decision'
+// Parks a child the `backlogrun` driver could not finish mechanically — its session ended unfinished, or
+// its ship hit the relaunch cap. **Not `needs-decision`**: nothing is asked of a person beyond fixing the
+// cause and removing it, so the board and the idle report keep it out of the decisions they list. Parked
+// all the same, so a child failing on one cause is not handed straight back until the cause is fixed.
+const RUN_STALLED_LABEL = 'run:stalled'
 // Marks an issue whose defect reaches the verification path, so it runs with nothing beside it.
 // A run applies it from the verification-path enumeration in `backlogrun-lanes.md`;
 // `backlog:next` enforces it (`backlog-solo.ts`), so the rule no longer rests on a judgement at
@@ -24,11 +35,15 @@ const RUN_SOLO_LABEL = 'run:solo'
 // 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. 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.
+// Puts an issue at the head of the backlog's ranking, below `priority:critical`. `issue:file` applies
+// it from the body's priority declaration at its high level (`issue-priority.ts`), a person may apply it by
+// hand, 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'
+// Ranks above `priority:high` — an urgent defect (one of the interrupt-filing conditions) or a lane
+// speed-up worth at least a tenth of a merge's median lane time. Applied from the urgent declaration;
+// it never interrupts a running lane, only takes the next free one. Only a person removes it.
+const PRIORITY_CRITICAL_LABEL = 'priority:critical'
 // Opts one issue outside any epic into unattended execution. **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
@@ -64,6 +79,13 @@ const NEEDS_HUMAN_REVIEW_LABEL = 'needs-human-review'
 // takes it off, because taking it off asserts the work is *not* done, which is the same claim in
 // reverse and is no more a run's to make.
 const ALREADY_DONE_LABEL = 'already-done'
+// The mark of a measurement-only Issue a run closed itself (`josh issue:measured`). No pull request
+// 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
@@ -71,16 +93,28 @@ const ALREADY_DONE_LABEL = 'already-done'
 // and only a person opts it into unattended execution.
 const RELEASE_LABEL = 'release'
 // A person's mark for work set aside for now; `issue-auto-ok.ts` reads it as an exclusion. Applied by
-// hand and never provisioned, so it is not in `REPOSITORY_LABELS`.
+// hand, so it is provisioned: a person cannot apply a label the repository does not have.
 const DEFERRED_LABEL = 'deferred'
-// Applied to an Issue whose second review round was skipped, so the condition stays auditable
-// (`prompts/review.md` → "When round 2 is skipped entirely, and when it is not").
-const REVIEW_ROUND2_SKIPPED_LABEL = 'review-round2-skipped'
+// A copy of the body's start-time declaration while that time is still ahead (`issue-not-before.ts`), so a
+// listing tells an issue that waits on the clock from one that can start. The body stays the source:
+// `issue-not-before-label.ts` applies and removes it. Only `run:merge` reads it as a reason to wait,
+// and only where the body itself could not be read (`run-merge-steps.ts`).
+const NOT_BEFORE_LABEL = 'not-before'
+
+// The labels that park an open issue: a run never starts or restarts it, and only a person lifts
+// them — `needs-decision` waits for an answer, `run:stalled` for a mechanical cause to be fixed, and
+// `already-done` for the close. The run that applied any of them committed nothing, so the checkout
+// is clean. Held once because the merge, the board, the pool, the classification and the liveness
+// read all ask "is this child parked", and a copy that missed a label would answer differently.
+const PARKED_LABELS: ReadonlySet<string> = new Set([
+	NEEDS_DECISION_LABEL,
+	RUN_STALLED_LABEL,
+	ALREADY_DONE_LABEL,
+])
 
-// The four labels that mean an open issue must not be handed to a run as it stands: an `epic`
+// The labels that mean an open issue must not be handed to a run as it stands: an `epic`
 // tracks a batch and is never run directly (its children are), `in-progress` is already claimed by
-// a running workflow, `needs-decision` was parked precisely because it cannot advance without a
-// person, and `already-done` names work that is already merged. Held here rather than in either
+// a running workflow, and a parked issue (`PARKED_LABELS`) waits on a person. Held here rather than in either
 // caller because both the next-issues display and the `auto-ok` pickup ask the same question, and
 // two copies would answer it differently the first time one of them gained another label.
 //
@@ -91,8 +125,7 @@ const REVIEW_ROUND2_SKIPPED_LABEL = 'review-round2-skipped'
 const NOT_DIRECTLY_RUNNABLE_LABELS: ReadonlySet<string> = new Set([
 	EPIC_LABEL,
 	IN_PROGRESS_LABEL,
-	NEEDS_DECISION_LABEL,
-	ALREADY_DONE_LABEL,
+	...PARKED_LABELS,
 ])
 
 // Filing-route labels, applied at filing time so the backlog's composition — a review-cap
@@ -149,61 +182,6 @@ const FILING_ROUTE_LABELS: ReadonlyArray<{
 	},
 ]
 
-// The depth of an issue's subject, recorded as a label at filing time.
-//
-// **The definition is not here.** `.claude/skills/workflow-commands/observation-filing.md` → "The depth test",
-// is the single source: depth 0 is what a consumer of this package touches, depth 1 the run
-// orchestration that executes an Issue, depth 2 what measures a run. These constants are the
-// recording of that table, never a second copy of it — a label whose description restated the rule
-// would be the clone `CLAUDE.md` prohibits, and the descriptions below therefore name the section
-// rather than paraphrase it.
-//
-// **Why a label at all.** The share of open issues at depth 0 is a measured target, and without a
-// recorded depth it could only be obtained by reading every open issue's body by hand — hand counts
-// disagree on the denominator and are not comparable, which is the failure a recorded label removes.
-//
-// **The depth is read off the subject, so a run applies it.** Unlike `auto-ok` and
-// `needs-human-review` this is not a person's judgement about authorization; it is the same reading
-// `observation-filing.md` already asks a run to make before it files, and none of the three withholds or widens anything
-// a run may do.
-const DEPTH_0_LABEL = 'depth:0'
-const DEPTH_1_LABEL = 'depth:1'
-const DEPTH_2_LABEL = 'depth:2'
-
-// Ordered shallowest first, which is what makes `depth_label_of` deterministic: an issue carrying
-// more than one depth label counts as the **lowest** depth present, the one closest to the consumer.
-// Without a fixed tie-break the same listing measured twice could answer differently.
-const DEPTH_LABEL_ORDER: ReadonlyArray<string> = [DEPTH_0_LABEL, DEPTH_1_LABEL, DEPTH_2_LABEL]
-
-// The metadata `gh api ... labels` needs, in the shape `FILING_ROUTE_LABELS` above uses and for the
-// same reason: applying a label at issue-creation auto-creates it with a generated color and no
-// description, so provisioning from here is what gives each one a stable color a reader can scan by.
-// Green, amber and pale blue, so the consumer-facing depth is the one that stands out in a listing.
-//
-// **`josh issue:file` provisions them** through `repository_labels.ensure_labels` before its create
-// call, so no document carries a creation command to keep in step.
-const DEPTH_LABELS: ReadonlyArray<{
-	name: string
-	color: string
-	description: string
-}> = [
-	{
-		name: DEPTH_0_LABEL,
-		color: '0e8a16',
-		description: 'Depth 0 — what a consumer of this package touches (observation-filing.md)',
-	},
-	{
-		name: DEPTH_1_LABEL,
-		color: 'fbc02d',
-		description: 'Depth 1 — the run orchestration that executes an Issue (observation-filing.md)',
-	},
-	{
-		name: DEPTH_2_LABEL,
-		color: 'c5def5',
-		description: 'Depth 2 — what measures a run (observation-filing.md)',
-	},
-]
-
 interface LabelDefinition {
 	name: string
 	color: string
@@ -234,6 +212,11 @@ const WORKFLOW_LABELS: ReadonlyArray<LabelDefinition> = [
 		color: '0e8a16',
 		description: 'Judged safe to run beside others in a backlogrun',
 	},
+	{
+		name: PRIORITY_CRITICAL_LABEL,
+		color: 'b60205',
+		description: 'Offered before priority:high in a backlogrun; only a person removes it',
+	},
 	{
 		name: PRIORITY_HIGH_LABEL,
 		color: 'e99695',
@@ -254,6 +237,12 @@ const WORKFLOW_LABELS: ReadonlyArray<LabelDefinition> = [
 		color: 'd93f0b',
 		description: 'Parked: needs a decision before it can run',
 	},
+	{
+		name: RUN_STALLED_LABEL,
+		color: 'e99d42',
+		description:
+			'Parked: the driver could not finish it mechanically — no decision; fix the cause and remove',
+	},
 	{
 		name: NEEDS_HUMAN_REVIEW_LABEL,
 		color: 'd93f0b',
@@ -265,13 +254,28 @@ const WORKFLOW_LABELS: ReadonlyArray<LabelDefinition> = [
 		description: 'Verified already merged — a person closes it',
 	},
 	{
-		name: REVIEW_ROUND2_SKIPPED_LABEL,
-		color: 'c5def5',
-		description: 'Review round 2 was skipped under the condition in prompts/review.md',
+		name: MEASURED_LABEL,
+		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',
+		description: 'Set aside for now; never opted in to unattended execution',
+	},
+	{
+		name: NOT_BEFORE_LABEL,
+		color: 'bfd4f2',
+		description: "Waiting: the body's 実施可能日 has not arrived yet",
 	},
 	{ name: BUG_LABEL, color: 'd73a4a', description: "Something isn't working" },
 	...FILING_ROUTE_LABELS,
-	...DEPTH_LABELS,
 ]
 
 // The pull request release classifications `pr-classification.yml` requires exactly one of.
@@ -350,13 +354,14 @@ function has_label_name(labels: ReadonlyArray<string>, wanted: string): boolean
 	return label_name_of(labels, wanted) !== undefined
 }
 
-// The depth recorded on one listing row, or `undefined` where none is — the reading every share
-// measurement makes. Lowercased through the same comparison as every other membership test above,
-// because GitHub keeps the casing a label was created with and `Depth:0` is the same label.
-function depth_label_of(labels: ReadonlyArray<LabelReference> | undefined): string | undefined {
-	const names = new Set((labels ?? []).map((label) => label.name.toLowerCase()))
+// 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))
+}
 
-	return DEPTH_LABEL_ORDER.find((name) => names.has(name))
+// Whether label names carry any park label (`PARKED_LABELS`).
+function has_parked_label(labels: ReadonlyArray<string>): boolean {
+	return parked_label_of(labels) !== undefined
 }
 
 // Every workflow label this package manages. The label-reference scan
@@ -372,21 +377,23 @@ const ALL_LABELS: ReadonlySet<string> = new Set([
 	IN_PROGRESS_LABEL,
 	PLANNED_LABEL,
 	NEEDS_DECISION_LABEL,
+	RUN_STALLED_LABEL,
 	AUTO_OK_LABEL,
 	NEEDS_HUMAN_REVIEW_LABEL,
 	ALREADY_DONE_LABEL,
+	MEASURED_LABEL,
+	MEASURED_UNMET_LABEL,
+	DEFERRED_LABEL,
+	PRIORITY_CRITICAL_LABEL,
 	PRIORITY_HIGH_LABEL,
 	RELEASE_LABEL,
+	NOT_BEFORE_LABEL,
 	INTERRUPT_ROUTE_LABEL,
 	REVIEW_CAP_ROUTE_LABEL,
-	REVIEW_ROUND2_SKIPPED_LABEL,
 	RUN_LANE_LABEL,
 	RUN_SOLO_LABEL,
 	SPLIT_ROUTE_LABEL,
 	TIER_A_ROUTE_LABEL,
-	DEPTH_0_LABEL,
-	DEPTH_1_LABEL,
-	DEPTH_2_LABEL,
 	BUGFIX_LABEL,
 	OTHER_CHANGE_LABEL,
 	IGNORE_FOR_RELEASE_LABEL,
@@ -406,36 +413,37 @@ export {
 	BUGFIX_LABEL,
 	BREAKING_CHANGE_LABEL,
 	DEFERRED_LABEL,
-	depth_label_of,
-	DEPTH_0_LABEL,
-	DEPTH_1_LABEL,
-	DEPTH_2_LABEL,
-	DEPTH_LABEL_ORDER,
-	DEPTH_LABELS,
 	ENHANCEMENT_LABEL,
 	EPIC_LABEL,
 	EXEMPT_FROM_PROVISIONING,
 	FILING_ROUTE_LABELS,
 	has_any_label,
 	has_label_name,
+	has_parked_label,
 	IGNORE_FOR_RELEASE_LABEL,
 	IN_PROGRESS_LABEL,
 	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,
 	PRIORITY_HIGH_LABEL,
 	RELEASE_CLASSIFICATION_LABELS,
 	RELEASE_CLASSIFICATION_NAMES,
 	RELEASE_LABEL,
 	REPOSITORY_LABELS,
 	REVIEW_CAP_ROUTE_LABEL,
-	REVIEW_ROUND2_SKIPPED_LABEL,
 	RUN_LANE_LABEL,
 	RUN_SOLO_LABEL,
+	RUN_STALLED_LABEL,
 	SPLIT_ROUTE_LABEL,
 	TIER_A_ROUTE_LABEL,
 	WORKFLOW_LABELS,

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

@@ -1,16 +1,21 @@
-#!/usr/bin/env tsx
 import { readFile } from 'node:fs/promises'
-import { fileURLToPath } from 'node:url'
+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
@@ -18,17 +23,37 @@ 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,
 		...behavior_change_lint.problems(body),
 		...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 {
@@ -56,14 +81,6 @@ async function run(body_path: string | undefined): Promise<number> {
 	return report(problems(body), body)
 }
 
-async function main(argv: ReadonlyArray<string>): Promise<void> {
-	process.exitCode = await run(argv[0])
-}
-
 const issue_lint_cli = { problems, run }
 
-const ARGV_OFFSET = 2
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
-
 export { issue_lint_cli }