@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/scripts/run/merge/run-merge.ts

@@ -2,6 +2,7 @@ import {
 	EPIC_LABEL,
 	has_label_name,
 	has_parked_label,
+	NEEDS_HUMAN_MERGE_LABEL,
 	RUN_STALLED_LABEL,
 } from '#scripts/issue/issue-labels'
 import type { IssueState } from '#scripts/issue/issue-state'
@@ -20,17 +21,21 @@ import type { ChildOutcome } from './run-merge-outcome'
 // unit-tested without a network — `merged`, `parked`, `failed`, `human-review`, `unresolved`.
 
 const CLOSED_STATE = 'CLOSED'
-// Three failures in a row stop the run — the figure `backlogrun-progress.md` states in prose. A merge
-// resets the streak (`run-carry.ts` → `next_failures`), so the guard trips only on an environment
-// failing every child it is handed rather than on failures scattered across a long run.
+// Every third failure in a row asks whether `main` itself is broken (`run-merge-health.ts`) — the
+// figure `backlogrun-progress.md` states in prose. Nothing stops the run: each failed child is already
+// parked on its own (joshuafolkken/kit#7078). A merge resets the streak (`run-carry.ts` →
+// `next_failures`), so the check runs only on an environment failing every child it is handed.
 const CONSECUTIVE_FAILURE_LIMIT = 3
-// Three outages in a row stop the run too — the same shape as the failure
-// guard, over its own streak. An outage is a child its environment ended — it could not reach the API
-// or its session was killed inside a turn — so a run of them is the environment being down; stopping is
-// what keeps the run from re-dispatching into a dead API forever. A ship that stopped with no relaunch
-// is re-dispatched too but not counted: its child reached the API (joshuafolkken/kit#3974). A merge or
-// a genuine child failure resets it (`run-carry.ts` → `next_outages`).
+// Three outages in a row hold launches — the same shape as the failure guard, over its own streak. An
+// outage is a child its environment ended — it could not reach the API or its session was killed inside
+// a turn — so a run of them is the environment being down; the hold keeps the run from re-dispatching
+// into a dead API, and every further outage doubles it up to `OUTAGE_WAIT_CAP_MS` (`outage_wait_ms`).
+// A ship that stopped with no relaunch is re-dispatched too but not counted: its child reached the API
+// (joshuafolkken/kit#3974). A merge or a genuine child failure resets it (`run-carry.ts` → `next_outages`).
 const CONSECUTIVE_OUTAGE_LIMIT = 3
+const OUTAGE_WAIT_BASE_MS = 300_000
+const OUTAGE_WAIT_CAP_MS = 3_600_000
+const DOUBLING = 2
 const ONE = 1
 
 // What a returned child turned out to be, decided from its GitHub state and — for the failed case
@@ -38,7 +43,7 @@ const ONE = 1
 // - `merged`      — CLOSED by a merge; the child finished and its pull request merged. Also an OPEN, unparked
 //                   child a merged pull request's `closes #N` names — GitHub merged it without closing
 //                   the issue.
-// - `human-review` — OPEN and carrying `needs-human-review`; the run's own ending (needs-human-review.md).
+// - `human-review` — OPEN and carrying `needs-human-review`; only this child stops (needs-human-review.md).
 // - `parked`      — OPEN and carrying a park label (`PARKED_LABELS`); a person still owns it.
 // - `split`       — OPEN and carrying `epic`; its work was divided into new children.
 // - `outage`      — OPEN and carrying neither, but the exit record shows it could not reach the API, a
@@ -48,8 +53,8 @@ const ONE = 1
 //                   the child ended its session on purpose, so it is resumed rather than parked and
 //                   counts nothing.
 // - `unauthenticated` — OPEN and carrying neither, but the exit record shows the session could not
-//                   authenticate; no child can run until a person runs `/login`, so the run stops with
-//                   the child left `in-progress` and nothing counted (joshuafolkken/kit#4216).
+//                   authenticate; no child can run until a person runs `/login`, so launches are held
+//                   with the child released and nothing counted (joshuafolkken/kit#4216, #7078).
 // - `usage-limit` — OPEN and carrying neither, but the exit record shows a Claude usage limit stopped
 //                   it; nothing is counted or parked, and the run dispatches again once the limit
 //                   resets (joshuafolkken/kit#4745).
@@ -127,7 +132,9 @@ function unfinished_outcome(signals: EndingSignals): ChildOutcome {
 }
 
 function open_outcome(state: IssueState, signals: EndingSignals): ChildOutcome {
-	if (state.is_human_review) return 'human-review'
+	if (state.is_human_review || has_label_name(state.labels, NEEDS_HUMAN_MERGE_LABEL)) {
+		return 'human-review'
+	}
 
 	if (has_label_name(state.labels, EPIC_LABEL)) return 'split'
 
@@ -171,16 +178,26 @@ function change_of(outcome: ChildOutcome): CarryChange | undefined {
 	return undefined
 }
 
+// Every `CONSECUTIVE_FAILURE_LIMIT`-th failure in a row, so a streak `main`'s check found green asks
+// again only after as many more failures.
 function is_guard_tripped(failures: number): boolean {
-	return failures >= CONSECUTIVE_FAILURE_LIMIT
+	return failures > 0 && failures % CONSECUTIVE_FAILURE_LIMIT === 0
 }
 
-// The outage guard, over its own streak. Same shape as the failure guard: a
-// run of consecutive outages is the environment being down, so the run stops rather than re-dispatching.
+// The outage guard, over its own streak: a run of consecutive outages is the environment being down,
+// so launches are held rather than re-dispatched.
 function is_outage_guard_tripped(outages: number): boolean {
 	return outages >= CONSECUTIVE_OUTAGE_LIMIT
 }
 
+// How long a tripped outage guard holds launches: `OUTAGE_WAIT_BASE_MS` at the limit, doubled for every
+// outage past it, never past `OUTAGE_WAIT_CAP_MS`.
+function outage_wait_ms(outages: number): number {
+	const doublings = Math.max(0, outages - CONSECUTIVE_OUTAGE_LIMIT)
+
+	return Math.min(OUTAGE_WAIT_BASE_MS * DOUBLING ** doublings, OUTAGE_WAIT_CAP_MS)
+}
+
 // The progress comment, generated from the single-source carry record so the counters live in one
 // place and this text is derived rather than a second copy kept alongside it.
 // It is script-emitted, so it stays English while the run's session-facing prose follows
@@ -210,7 +227,7 @@ interface ParkReason {
 function streak_line(carry: RunCarry | undefined): string {
 	if (carry === undefined) return '- Consecutive failures: not recorded (no carry record).'
 
-	return `- Consecutive failures: ${String(carry.failures)} of ${String(CONSECUTIVE_FAILURE_LIMIT)} (the run stops at ${String(CONSECUTIVE_FAILURE_LIMIT)}).`
+	return `- Consecutive failures: ${String(carry.failures)} of ${String(CONSECUTIVE_FAILURE_LIMIT)} (every ${String(CONSECUTIVE_FAILURE_LIMIT)} in a row checks \`main\`).`
 }
 
 function park_comment(reason: ParkReason): string {
@@ -221,7 +238,7 @@ function park_comment(reason: ParkReason): string {
 		`- Why: ${reason.cause}`,
 		'- Read: the issue is OPEN, carries no park label, `needs-human-review` or `epic`, no merged pull request’s `closes #N` names it, and it declares no open blocker, start date still ahead or sample condition not yet met.',
 		streak_line(reason.carry),
-		`- Next: read the child’s transcript${transcript}, ${run_stalled.next_step(reason.child)}.`,
+		`- Next: read the child’s transcript${transcript}, ${run_stalled.next_step(reason.child, reason.cause)}.`,
 	].join('\n')
 }
 
@@ -246,6 +263,7 @@ const run_merge = {
 	waiting_comment,
 	is_guard_tripped,
 	is_outage_guard_tripped,
+	outage_wait_ms,
 }
 
 export type { EndingSignals, ParkReason }

package/scripts/run/park/run-park-answered.ts

@@ -0,0 +1,84 @@
+import { answer_judge } from '#scripts/agent/answer-judge'
+import type { AnswerVerdict, Evidence } from '#scripts/agent/answer-verdict'
+import { issue_sources, type SourcesRead } from '#scripts/issue/issue-sources'
+import { session_cite } from '#scripts/issue/session-cite'
+
+// **A park asks a person only what the Issue has not already decided** (joshuafolkken/kit#6531).
+// Before any write, `answer_judge` reads the question against the Issue's trusted sources: an answered
+// question is refused with the quotes that answer it, an unanswered one parks as before, and a read or
+// judgment that failed refuses too — a park is never written on a verdict nobody could read.
+
+const FAILURE_EXIT_CODE = 1
+const NO_WRITE = 'Nothing was labelled, commented, recorded or released.'
+
+type Answered = Extract<AnswerVerdict, { kind: 'answered' }>
+
+function park_command(issue_number: string): string {
+	return `pnpm josh run:park ${issue_number} --body-file <path>`
+}
+
+function refused(lines: ReadonlyArray<string>): number {
+	console.error(lines.join('\n'))
+
+	return FAILURE_EXIT_CODE
+}
+
+function evidence_line(evidence: Evidence): string {
+	const { source, quote } = evidence
+	const origin = source.author === undefined ? '' : ` (${source.author} ${source.created_at ?? ''})`
+
+	return `- ${source.id}${origin}: "${quote}"`
+}
+
+function answered(issue_number: string, verdict: Answered): number {
+	return refused([
+		`Park refused: ${session_cite.issue(issue_number)} already answers this question — ${verdict.decision} (${verdict.decision_kind}).`,
+		...verdict.evidence.map((evidence) => evidence_line(evidence)),
+		`Follow that decision: record \`Auto-decided: <choice> over <alt> because <reason>\` on the Issue with \`pnpm josh issue:comment ${issue_number} --body-file <path>\`, then continue the run. ${NO_WRITE}`,
+	])
+}
+
+function failed(issue_number: string, cause: string, retry: string): number {
+	return refused([
+		`Park failed: ${cause}. ${NO_WRITE}`,
+		`Retry: ${retry} (\`${park_command(issue_number)}\`)`,
+	])
+}
+
+function read_failure(
+	issue_number: string,
+	read: Exclude<SourcesRead, { kind: 'sources' }>,
+): number {
+	const hint = read.hint === undefined ? '' : ` — ${read.hint}`
+	const retry = read.is_retryable
+		? 're-run once the Issue reads again'
+		: `check the number: ${session_cite.issue(issue_number)} does not exist`
+
+	return failed(issue_number, `the Issue's sources could not be read (${read.kind}${hint})`, retry)
+}
+
+function outcome(issue_number: string, verdict: AnswerVerdict): number | undefined {
+	if (verdict.kind === 'unanswered') return undefined
+	if (verdict.kind === 'failed') return failed(issue_number, verdict.cause, verdict.retry)
+
+	return answered(issue_number, verdict)
+}
+
+// `undefined` lets the park go on; a number is the exit code of a park that stopped before any write.
+async function refusal_of(
+	issue_number: string,
+	question: string,
+	directory: string,
+): Promise<number | undefined> {
+	const read = await issue_sources.read_sources(issue_number)
+
+	if (read.kind !== 'sources') return read_failure(issue_number, read)
+
+	const verdict = await answer_judge.judge({ question, sources: read.sources, directory })
+
+	return outcome(issue_number, verdict)
+}
+
+const run_park_answered = { refusal_of }
+
+export { run_park_answered }

package/scripts/run/park/run-park-body.ts

@@ -0,0 +1,346 @@
+import { markdown_section } from '#scripts/issue/markdown-section'
+
+// The `run:park` body schema (joshuafolkken/kit#6669): numbered options under the options heading,
+// each with its tier and the permission taking it needs, and one recommendation line naming the
+// option the child recommends, or no recommendation with why. A child parks because it lacks the
+// permission to take its own recommendation, so the parent reads it instead of rebuilding the choice.
+//
+// **The one parser of the schema**: `run:park` refuses a body `problem_of` names, and a reader of a
+// park comment summarizes it through `summary_of` — `run:board`'s park rows (joshuafolkken/kit#6688).
+//
+// An option that is a size approval carries its range in three more lines (joshuafolkken/kit#6776) —
+// the paths and both axes of `lane-plan-approval.ts`'s json, which `backlog:triage --adopt` writes.
+
+interface ParkBound {
+	declared: number
+	max: number
+}
+
+interface ParkApproval {
+	paths?: ReadonlyArray<string>
+	lines?: ParkBound
+	files?: ParkBound
+}
+
+type ApprovalRange = Required<ParkApproval>
+
+interface ParkOption {
+	number: number
+	tier?: string | undefined
+	permission?: string | undefined
+	approval?: ParkApproval | undefined
+}
+
+interface ParkPick {
+	number?: number
+}
+
+interface ParkBody {
+	options: ReadonlyArray<ParkOption>
+	pick: ParkPick | undefined
+}
+
+const OPTIONS_HEADING = '### 選択肢'
+const PICK_HEADING = '### 推奨'
+const NO_PICK_WORD = '推奨なし'
+const TIER_LINE = '   - 層: A|B|C'
+const ANY_HEADING = /^#{1,6} /u
+const ITEM = /^(\d+)\. +\S/u
+const TIER = /^- 層: ?([ABC])$/u
+const PERMISSION = /^- 必要な権限: ?(\S.*)$/u
+const APPROVAL_PATHS = /^- 規模承認のパス: ?(\S.*)$/u
+const APPROVAL_LINES = /^- 規模承認の行数: ?([1-9]\d*) *\/ *([1-9]\d*)$/u
+const APPROVAL_FILES = /^- 規模承認のファイル数: ?([1-9]\d*) *\/ *([1-9]\d*)$/u
+const PATH_SEPARATOR = /[\s,、]+/u
+const APPROVAL_PARTS = [
+	['paths', '- 規模承認のパス: <path> …'],
+	['lines', '- 規模承認の行数: <declared> / <max>'],
+	['files', '- 規模承認のファイル数: <declared> / <max>'],
+] as const
+const PICK = /^(\d+)[\s:：.、]+\S/u
+const NO_PICK = /^推奨なし[\s:：—-]+\S/u
+const AUTO_TIER = 'A'
+// The tier no parent takes, even on a person's behalf: trust settings, third parties, destructive acts.
+const PERSON_TIER = 'C'
+// The permission a parent adopts with no person and no action of its own.
+const AUTO_PERMISSION = 'なし'
+// An option needing the parent's own action (filing, closing, editing an Issue): adopting it is not
+// taking it, so the lane must not resume before the parent has (joshuafolkken/kit#7001).
+const PARENT_PERMISSION = '親'
+const PARENT_ACTION_NOTE = ' · 親の操作'
+
+const FORMAT = [
+	'Park body schema:',
+	OPTIONS_HEADING,
+	'1. <option>',
+	TIER_LINE,
+	'   - 必要な権限: なし | 親 | owner コメント | epic 編集 | 信頼設定 | 人',
+	'2. <option>',
+	TIER_LINE,
+	'   - 必要な権限: …',
+	'   (a size-approval option adds all three:)',
+	...APPROVAL_PARTS.map(([, line]) => `   ${line}`),
+	PICK_HEADING,
+	`<option number> <reason>   (or: ${NO_PICK_WORD} <reason>)`,
+].join('\n')
+
+function section_of(lines: ReadonlyArray<string>, heading: string): ReadonlyArray<string> {
+	const start = lines.findIndex((line) => line.trim() === heading)
+
+	if (start === -1) return []
+	const rest = lines.slice(start + 1)
+	const end = rest.findIndex((line) => ANY_HEADING.test(line))
+
+	return end === -1 ? rest : rest.slice(0, end)
+}
+
+function tier_of(option: ParkOption, line: string): string | undefined {
+	return option.tier ?? TIER.exec(line)?.[1]
+}
+
+function permission_of(option: ParkOption, line: string): string | undefined {
+	return option.permission ?? PERMISSION.exec(line)?.[1]?.trim()
+}
+
+function bound_of(pattern: RegExp, line: string): ParkBound | undefined {
+	const [, declared, max] = pattern.exec(line) ?? []
+
+	return max === undefined ? undefined : { declared: Number(declared), max: Number(max) }
+}
+
+function paths_of(line: string): ReadonlyArray<string> | undefined {
+	const text = APPROVAL_PATHS.exec(line)?.[1]
+	const paths = text
+		?.split(PATH_SEPARATOR)
+		.map((path) => path.replaceAll('`', ''))
+		.filter(Boolean)
+
+	return paths?.length === 0 ? undefined : paths
+}
+
+function approval_of(approval: ParkApproval | undefined, line: string): ParkApproval | undefined {
+	const paths = paths_of(line)
+
+	if (paths !== undefined) return { ...approval, paths }
+	const lines = bound_of(APPROVAL_LINES, line)
+
+	if (lines !== undefined) return { ...approval, lines }
+	const files = bound_of(APPROVAL_FILES, line)
+
+	return files === undefined ? approval : { ...approval, files }
+}
+
+function with_detail(option: ParkOption, raw_line: string): ParkOption {
+	const line = raw_line.trim()
+	const approval = approval_of(option.approval, line)
+
+	return {
+		...option,
+		tier: tier_of(option, line),
+		permission: permission_of(option, line),
+		approval,
+	}
+}
+
+// Each numbered item opens an option; the lines under it fill in its tier and permission.
+function next_options(options: ReadonlyArray<ParkOption>, line: string): ReadonlyArray<ParkOption> {
+	const number = ITEM.exec(line)?.[1]
+
+	if (number !== undefined) return [...options, { number: Number(number) }]
+	const last = options.at(-1)
+
+	return last === undefined ? options : [...options.slice(0, -1), with_detail(last, line)]
+}
+
+function options_of(lines: ReadonlyArray<string>): ReadonlyArray<ParkOption> {
+	let options: ReadonlyArray<ParkOption> = []
+
+	for (const line of lines) options = next_options(options, line)
+
+	return options
+}
+
+function first_line(lines: ReadonlyArray<string>): string {
+	return lines.find((candidate) => candidate.trim() !== '')?.trim() ?? ''
+}
+
+function pick_of(lines: ReadonlyArray<string>): ParkPick | undefined {
+	const line = first_line(lines)
+
+	if (NO_PICK.test(line)) return {}
+	const number = PICK.exec(line)?.[1]
+
+	return number === undefined ? undefined : { number: Number(number) }
+}
+
+function parse(body: string): ParkBody {
+	const lines = markdown_section.fence_free_lines(body)
+
+	return {
+		options: options_of(section_of(lines, OPTIONS_HEADING)),
+		pick: pick_of(section_of(lines, PICK_HEADING)),
+	}
+}
+
+// A size-approval option missing one line of its range: the json it becomes needs every one.
+function approval_problem(approval: ParkApproval | undefined, name: string): string | undefined {
+	if (approval === undefined) return undefined
+	const missing = APPROVAL_PARTS.find(([key]) => approval[key] === undefined)
+
+	return missing === undefined ? undefined : `${name} has no "${missing[1]}" line`
+}
+
+function option_problem(option: ParkOption): string | undefined {
+	const name = `option ${String(option.number)}`
+
+	if (option.tier === undefined) return `${name} has no "- 層: A|B|C" line`
+	if (option.permission === undefined) return `${name} has no "- 必要な権限: …" line`
+
+	return approval_problem(option.approval, name)
+}
+
+function is_listed(park: ParkBody, number: number | undefined): boolean {
+	return number === undefined || park.options.some((option) => option.number === number)
+}
+
+function pick_problem(park: ParkBody): string | undefined {
+	if (park.pick === undefined) {
+		return `${PICK_HEADING} needs one line: "<option number> <reason>" or "${NO_PICK_WORD} <reason>"`
+	}
+
+	if (is_listed(park, park.pick.number)) return undefined
+
+	return `${PICK_HEADING} names option ${String(park.pick.number)}, which ${OPTIONS_HEADING} does not list`
+}
+
+// The first missing piece of the schema, in one line; `undefined` for a body that meets it.
+function problem_of(body: string): string | undefined {
+	const park = parse(body)
+
+	if (park.options.length === 0) return `${OPTIONS_HEADING} lists no numbered option`
+
+	return park.options.map((option) => option_problem(option)).find(Boolean) ?? pick_problem(park)
+}
+
+// The option the recommendation names; `undefined` for no recommendation or a body off the schema.
+function picked_option(body: string): ParkOption | undefined {
+	const park = parse(body)
+	const number = park.pick?.number
+
+	return park.options.find((candidate) => candidate.number === number)
+}
+
+function is_parent_action(option: ParkOption | undefined): boolean {
+	return option?.permission?.startsWith(PARENT_PERMISSION) === true
+}
+
+// The recommended option and its tier, or no recommendation; `undefined` for a body off the schema.
+function summary_of(body: string): string | undefined {
+	if (problem_of(body) !== undefined) return undefined
+	const option = picked_option(body)
+
+	if (option === undefined) return NO_PICK_WORD
+	const note = is_parent_action(option) ? PARENT_ACTION_NOTE : ''
+
+	return `推奨: ${String(option.number)}（層 ${option.tier ?? ''}${note}）`
+}
+
+// Whether option `number` needs the parent's own action before the lane may resume.
+function parent_action(body: string, number: number): boolean {
+	return is_parent_action(parse(body).options.find((candidate) => candidate.number === number))
+}
+
+function is_parents(option: ParkOption): boolean {
+	return option.tier === AUTO_TIER && option.permission === AUTO_PERMISSION
+}
+
+// The recommended option a parent with no person takes itself (joshuafolkken/kit#6738): tier A, needing
+// no permission at all. An option needing the parent's own action is not taken by adopting it, so it
+// waits for `backlog:triage --adopt --done` (joshuafolkken/kit#7001). `undefined` for any other park.
+function auto_pick(body: string): number | undefined {
+	if (problem_of(body) !== undefined) return undefined
+	const option = picked_option(body)
+
+	return option !== undefined && is_parents(option) ? option.number : undefined
+}
+
+// Why a parent may not adopt option `number` of a schema-conforming park (joshuafolkken/kit#6670):
+// a park with no recommendation stays a person's, an unlisted option is no answer, and a tier C option
+// stays a person's. `undefined` when the parent may adopt it.
+function adopt_problem(body: string, number: number): string | undefined {
+	const park = parse(body)
+
+	if (park.pick?.number === undefined) return `the park says ${NO_PICK_WORD}, so a person decides`
+	const option = park.options.find((candidate) => candidate.number === number)
+
+	if (option === undefined) return `${OPTIONS_HEADING} lists no option ${String(number)}`
+
+	return option.tier === PERSON_TIER
+		? `option ${String(number)} is tier C, a person's to take`
+		: undefined
+}
+
+// The recommended option a parent may adopt (`adopt_problem` passes it) — what `backlog:triage --pass`
+// prints an `--adopt` line for (joshuafolkken/kit#6777). `undefined` for no pick or a tier C pick.
+function adoptable_pick(body: string): number | undefined {
+	const number = picked_option(body)?.number
+
+	return number !== undefined && adopt_problem(body, number) === undefined ? number : undefined
+}
+
+interface DefaultPick {
+	number: number
+	over: ReadonlyArray<number>
+}
+
+// Reversible and the narrowest change: no tier C, no permission, no size approval widening the lane.
+function is_narrowest(option: ParkOption): boolean {
+	const { tier, permission, approval } = option
+
+	return tier !== PERSON_TIER && permission === AUTO_PERMISSION && approval === undefined
+}
+
+// The options of a park with no recommendation; none for a recommended park or a body off the schema.
+function unpicked_options(body: string): ReadonlyArray<ParkOption> {
+	const park = parse(body)
+
+	return problem_of(body) === undefined && park.pick?.number === undefined ? park.options : []
+}
+
+// The option a parent takes for a park with no recommendation (joshuafolkken/kit#7077): the first
+// listed reversible option with the smallest change, and the options it was taken over. `undefined`
+// for a recommended park, a body off the schema, or one whose every option a person must take.
+function default_pick(body: string): DefaultPick | undefined {
+	const options = unpicked_options(body)
+	const number = options.find((option) => is_narrowest(option))?.number
+	const over = options.map((option) => option.number).filter((other) => other !== number)
+
+	return number === undefined ? undefined : { number, over }
+}
+
+function is_complete(approval: ParkApproval | undefined): approval is ApprovalRange {
+	return APPROVAL_PARTS.every(([key]) => approval?.[key] !== undefined)
+}
+
+// The size-approval range option `number` carries; `undefined` for an option that is no size approval.
+function approval_range(body: string, number: number): ApprovalRange | undefined {
+	const option = parse(body).options.find((candidate) => candidate.number === number)
+
+	return is_complete(option?.approval) ? option.approval : undefined
+}
+
+const run_park_body = {
+	FORMAT,
+	HEADINGS: [OPTIONS_HEADING, PICK_HEADING],
+	adopt_problem,
+	adoptable_pick,
+	approval_range,
+	auto_pick,
+	default_pick,
+	parent_action,
+	problem_of,
+	summary_of,
+}
+
+export type { ApprovalRange, DefaultPick }
+export { run_park_body }

package/scripts/run/park/run-park-cli.ts

@@ -4,10 +4,14 @@ import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
 import { issue_comment_cli, type CommentRequest } from '#scripts/issue/issue-comment-cli'
 import { NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
 import { issue_number_shape } from '#scripts/issue/issue-number-shape'
-import { issue_park } from '#scripts/issue/issue-park'
 import { session_cite } from '#scripts/issue/session-cite'
 import { cli_flags } from '#scripts/lib/cli-flags'
+import { run_step_section } from '#scripts/run/run-step-section'
 import { run_park } from './run-park'
+import { run_park_answered } from './run-park-answered'
+import { run_park_body } from './run-park-body'
+import { run_park_release } from './run-park-release'
+import { run_park_write } from './run-park-write'
 
 // `josh run:park <N> --body-file <path>` — park a lane child for a person's decision in one call: the
 // question as a comment, `needs-decision`, and the local record the `lane-park` guard reads.
@@ -17,14 +21,21 @@ import { run_park } from './run-park'
 // (joshuafolkken/kit#4132). One call writes both, and only a park that has both is recorded, so the
 // guard falls silent on exactly the child that left a question behind.
 //
-// **`in-progress` and the hold are not this command's.** A parked child keeps `in-progress`, and every
-// parked ending still owes `pnpm josh run:release <N>` (`backlogrun-park.md` → "park and continue").
+// **Every parked ending owes the release, so the park runs it** (joshuafolkken/kit#5737): once the
+// label and the comment are on, `run_park_release` drops the hold and `in-progress`. A failed release
+// keeps the park.
+//
+// **A park from inside a lane names the lane it keeps** (joshuafolkken/kit#5840): `run_park_lane`
+// appends the lane directory, the held seat and the `lane:close` hint to the comment.
+//
+// **A released park prints the section it follows** (joshuafolkken/kit#5842), through
+// `run_step_section.print_once`: "park and continue" for the parent, the park-then-stop for a lane child.
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const ARGV_OFFSET = 2
 const CLEAR_FLAG = '--clear'
-const USAGE = `Usage: josh run:park <issue-number> --body-file <path> | <issue-number> ${CLEAR_FLAG}`
+const USAGE = `Usage: josh run:park <issue-number> --body-file <path> | <issue-number> ${CLEAR_FLAG}\n\n${run_park_body.FORMAT}`
 const CLEAR_OPTIONS = { clear: { type: 'boolean' } } as const
 
 function clear_issue(argv: ReadonlyArray<string>): string | undefined {
@@ -35,17 +46,31 @@ function clear_issue(argv: ReadonlyArray<string>): string | undefined {
 	return issue_number_shape.single_of(parsed.positionals)
 }
 
+// A released park prints what its caller does next, once per session.
+async function release(issue_number: string, directory: string): Promise<number> {
+	const exit_code = await run_park_release.release(issue_number)
+
+	if (exit_code !== SUCCESS_EXIT_CODE) return exit_code
+
+	return run_step_section.print_once(run_step_section.PARK, directory)
+}
+
+// **A park asks only what the Issue has not answered** (joshuafolkken/kit#6531): after the schema,
+// `run_park_answered` judges the question against the Issue before any write.
+async function stop_of(request: CommentRequest, directory: string): Promise<number | undefined> {
+	if (run_park_write.is_refused(request.body)) return FAILURE_EXIT_CODE
+
+	return await run_park_answered.refusal_of(request.issue_number, request.body, directory)
+}
+
 async function park(request: CommentRequest, directory: string): Promise<number> {
-	const { issue_number, body } = request
-	const write = await issue_park.apply(issue_number, NEEDS_DECISION_LABEL, body)
-	const is_parked = write.is_labelled && write.is_commented
-	const is_recorded = is_parked && run_park.record(issue_number, directory)
+	const stop = await stop_of(request, directory)
+
+	if (stop !== undefined) return stop
 
-	console.info(
-		`park ${session_cite.issue(issue_number)} — label: ${String(write.is_labelled)} · comment: ${String(write.is_commented)} · recorded: ${String(is_recorded)}`,
-	)
+	const is_parked = await run_park_write.write(request, directory)
 
-	return is_parked ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
+	return is_parked ? await release(request.issue_number, directory) : FAILURE_EXIT_CODE
 }
 
 // **The record goes whatever the label answers**: the decision is a person's and already made, so a