@joshuafolkken/kit 1.3000.0 → 1.3044.0

package/scripts/run/board/run-board-roots.ts

@@ -1,7 +1,7 @@
 import { process_identity } from '#scripts/josh/process-identity'
 import { lane_process_table, type TableRead } from '#scripts/lane/lane-process-table'
 import type { CarryRead } from '#scripts/run/carry/run-carry'
-import { run_wake } from '#scripts/run/wake/run-wake'
+import { run_wake, type RunWake } from '#scripts/run/wake/run-wake'
 import type { ProcessRoots } from './run-board-process-groups'
 
 // The run's own processes the 💻 section names: the supervisor from its wake stamp and the parent
@@ -38,6 +38,29 @@ function roots_of(
 	return { supervisor: supervisor_of(repository, is_same), parent: parent_of(read, is_same) }
 }
 
+// A handed-back budget or the supervisor's own driver is no judgment session. Codex's pid-less
+// carry uses the launch pid already recorded by the wake supervisor instead.
+function is_session_owner(read: CarryRead): boolean {
+	return read.kind === 'carried' && read.carry.is_handed_off !== true
+}
+
+function live_session_pid(
+	pid: number | undefined,
+	start: string | undefined,
+	wake: RunWake | undefined,
+	is_same: SameProcess,
+): boolean {
+	return pid !== undefined && pid !== wake?.pid && is_same(pid, start) !== false
+}
+
+function session_is_active(repository: string, read: CarryRead, is_same: SameProcess): boolean {
+	if (read.kind !== 'carried' || !is_session_owner(read)) return false
+	const wake = run_wake.read_wake(run_wake.wake_path(repository))
+	const pid = read.carry.owner_pid ?? wake?.woke_pid
+
+	return live_session_pid(pid, read.carry.owner_start, wake, is_same)
+}
+
 // `is_same_process` with each start time answered from the redraw's own `ps` snapshot, so the board's
 // read runs no `ps` of its own per pid (joshuafolkken/kit#4263). Without a snapshot no start is known,
 // and a recorded start reads as "cannot tell".
@@ -48,7 +71,7 @@ async function same_in(table: TableRead | undefined): Promise<SameProcess> {
 	return (pid, start) => process_identity.is_same_process(pid, start, read)
 }
 
-const run_board_roots = { roots_of, same_in }
+const run_board_roots = { roots_of, same_in, session_is_active }
 
 export { run_board_roots }
 export type { SameProcess }

package/scripts/run/board/run-board-settle.ts

@@ -1,3 +1,4 @@
+import type { IssueOutcome } from '#scripts/issue/issue-outcome'
 import type { ItemState, ItemStatus } from './run-board-status'
 
 // What a child keeps of its run when it settles into a state other than running — shared by the
@@ -25,9 +26,22 @@ function kept_of(
 // The status a child settles into: its start and the track it had reached, so a settled row still
 // draws how it got there.
 function settled_as(previous: ItemStatus | undefined, state: ItemState): ItemStatus {
-	return { state, started_ms: previous?.started_ms, ...kept_of(previous) }
+	return {
+		state,
+		started_ms: previous?.started_ms,
+		...kept_of(previous),
+		...(previous?.outcome !== undefined && { outcome: previous.outcome }),
+	}
+}
+
+const OUTCOME_STATES: ReadonlySet<ItemState> = new Set(['done', 'already_done', 'withdrawn'])
+
+function with_outcome(status: ItemStatus, outcome: IssueOutcome | undefined): ItemStatus {
+	return outcome === undefined || !OUTCOME_STATES.has(status.state)
+		? status
+		: { ...status, outcome }
 }
 
-const run_board_settle = { relaunch_of, settled_as }
+const run_board_settle = { relaunch_of, settled_as, with_outcome }
 
 export { run_board_settle }

package/scripts/run/board/run-board-setup.ts

@@ -21,19 +21,25 @@ interface SetupRead {
 
 const NO_SETUP: SetupRead = { setup: undefined, setup_ms: undefined }
 
+// Only these stages depend on the judgment session owning the carry.
+const SESSION_STAGES: ReadonlySet<string> = new Set([STAGE.JUDGING, STAGE.SESSION])
+
 // The stages of a hand-back to a session, and of the retrospective unit the driver waits on at a drain
 // (joshuafolkken/kit#6745). Only the run's next stage ends one, whatever the session or the unit writes
 // to the stream meanwhile.
-const SESSION_STAGES: ReadonlySet<string> = new Set([
-	STAGE.JUDGING,
-	STAGE.SESSION,
-	STAGE.RETROSPECTIVE,
-])
+const RETAINED_STAGES: ReadonlySet<string> = new Set([...SESSION_STAGES, STAGE.RETROSPECTIVE])
 
 function is_setup(event: RunEvent): boolean {
 	return event.kind === KIND.SETUP
 }
 
+// Session stages describe the last hand-off even after its owner has returned the budget.
+function is_working(setup: string | undefined, is_session_active: boolean | undefined): boolean {
+	if (setup === undefined) return false
+
+	return !SESSION_STAGES.has(setup) || is_session_active !== false
+}
+
 // A launch that returned without a child (`run_event_setup.no_child`): it ends its own lane's stage,
 // and prepares nothing a person waits on.
 function is_refusal(event: RunEvent): boolean {
@@ -65,7 +71,7 @@ function is_opening(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
 // Whether the run is at `stage` now: at any stage while it is starting; after that only at one it is
 // itself working through.
 function is_standing(events: ReadonlyArray<RunEvent>, stage: RunEvent): boolean {
-	if (!has_started(events) || SESSION_STAGES.has(stage.text)) return true
+	if (!has_started(events) || RETAINED_STAGES.has(stage.text)) return true
 
 	return is_opening(events, stage)
 }
@@ -119,7 +125,7 @@ function lane_stage(events: ReadonlyArray<RunEvent>, issue: number): LaneStage |
 	return { text: step.text, at_ms: Date.parse(step.at) }
 }
 
-const run_board_setup = { is_refusal, lane_stage, read }
+const run_board_setup = { is_refusal, is_working, lane_stage, read }
 
 export { run_board_setup }
 export type { LaneStage, SetupRead }

package/scripts/run/board/run-board-snapshot.ts

@@ -1,4 +1,5 @@
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
+import { issue_outcome } from '#scripts/issue/issue-outcome'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { z } from 'zod'
 import type { ClosedIssue } from './run-board-closed'
@@ -38,6 +39,9 @@ const label_names_schema = z.array(z.string())
 // A close time JSON dropped is read back as unknown.
 const closed_issue_schema = z
 	.object({
+		outcome: z
+			.object({ summary: issue_outcome.summary_schema, url: issue_outcome.url_schema })
+			.optional(),
 		title: z.string(),
 		labels: label_names_schema,
 		closed_ms: z.number().optional(),

package/scripts/run/board/run-board-status.ts

@@ -1,4 +1,5 @@
 import type { AgentResult } from '#scripts/agent/agent-event'
+import type { IssueOutcome } from '#scripts/issue/issue-outcome'
 import type { Span } from '#scripts/lane/lane-spans'
 import type { PrChecks } from '#scripts/run/event/run-event-checks'
 import { run_event_retry } from '#scripts/run/event/run-event-retry'
@@ -40,6 +41,7 @@ type ItemState =
 	| 'unknown'
 
 interface ItemStatus {
+	outcome?: IssueOutcome | undefined
 	state: ItemState
 	// When the child first launched in this run — a re-dispatch or a restart does not move it.
 	started_ms?: number | undefined
@@ -80,6 +82,8 @@ interface LatestEvent {
 // The run as a whole, read off the same stream. The setup half is `run-board-setup.ts`'s, absent
 // where a stream carries no stage.
 interface RunActivity extends Partial<SetupRead> {
+	// Runtime evidence for the stage, independent of its retained description.
+	is_setup_working?: boolean | undefined
 	last_event_ms: number | undefined
 	// The newest thing the run did — its newest position, or its newest event where it has none yet —
 	// in the event's own words, and when.
@@ -395,7 +399,15 @@ function settle_closed(
 	statuses: ReadonlyMap<number, ItemStatus>,
 	read: OpenRead,
 ): ReadonlyMap<number, ItemStatus> {
-	return new Map([...statuses].map(([issue, status]) => [issue, settled(issue, status, read)]))
+	return new Map(
+		[...statuses].map(([issue, status]) => {
+			const closed = read.closed.get(issue)
+			const outcome =
+				closed === undefined || is_closed_before_launch(status, closed) ? undefined : closed.outcome
+
+			return [issue, run_board_settle.with_outcome(settled(issue, status, read), outcome)]
+		}),
+	)
 }
 
 function is_run_stop(event: RunEvent | undefined): boolean {

package/scripts/run/board/run-board-tick.ts

@@ -14,6 +14,7 @@ import { run_board_reason, type ReasonRead } from './run-board-reason'
 import { run_board_released } from './run-board-released'
 import { run_board_render } from './run-board-render'
 import { run_board_seat, type SeatRead } from './run-board-seat'
+import { run_board_setup } from './run-board-setup'
 import type { Known } from './run-board-snapshot'
 import { run_board_spin, type Spun } from './run-board-spin'
 import { run_board_state, type BoardPorts, type BoardState, type Pace } from './run-board-state'
@@ -82,10 +83,15 @@ function titles_of(state: BoardState): Titles {
 
 // A run `run:carry --end` closed and one nobody drives any more are both drawn as stopped.
 function activity_here(local: LocalRead): RunActivity {
-	return run_board_status.activity_of(
+	const activity = run_board_status.activity_of(
 		local.events,
 		local.ended_ms !== undefined || local.is_stranded,
 	)
+
+	return {
+		...activity,
+		is_setup_working: run_board_setup.is_working(activity.setup, local.is_session_active),
+	}
 }
 
 // The already-read supervisor or parent drives retries until the run stops or becomes stranded.

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

@@ -129,7 +129,8 @@ function report_relaunch_failure(target: string, note: string): number {
 // A pre-gate resume drives the gate, commit, PR and merge — the mechanical
 // ship/bookkeeping region, lowered — while an implementation resume keeps the role default. The
 // phase-aware profile is `agent_argv.resume_argv`'s; a person's `JOSH_WORKER_EFFORT` still wins over it,
-// and a pre-gate resume moves to the ship model — Sonnet, or `JOSH_WORKER_SHIP_MODEL` when that is set.
+// and a pre-gate resume moves to the ship model — Sonnet, or `JOSH_WORKER_SHIP_MODEL` when that is set,
+// never above the Issue's `josh.worker` profile (`agent-ship-cap.ts`).
 async function relaunch(target: string, lane: LaneInfo, phase: string): Promise<number> {
 	const notes: Array<string> = []
 	const result = await lane_relaunch.resume(lane, phase, (note) => {

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

@@ -10,12 +10,15 @@ 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_escalate } from './run-park-escalate'
 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.
 // `josh run:park <N> --clear` takes the park back off once the decision is recorded.
+// `josh run:park <N> --escalate "<reason>"` parks a worker that needs a stronger profile
+// (`run-park-escalate.ts`).
 //
 // **The park was two hand-typed commands, and a child could stop after either one**
 // (joshuafolkken/kit#4132). One call writes both, and only a park that has both is recorded, so the
@@ -35,7 +38,7 @@ 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}\n\n${run_park_body.FORMAT}`
+const USAGE = `Usage: josh run:park <issue-number> --body-file <path> | <issue-number> ${CLEAR_FLAG} | <issue-number> ${run_park_escalate.ESCALATE_FLAG} "<reason>"\n\n${run_park_body.FORMAT}`
 const CLEAR_OPTIONS = { clear: { type: 'boolean' } } as const
 
 function clear_issue(argv: ReadonlyArray<string>): string | undefined {
@@ -94,11 +97,20 @@ async function run_clear(argv: ReadonlyArray<string>, directory: string): Promis
 	return FAILURE_EXIT_CODE
 }
 
+// **A worker's escalation is a mechanical stop, not a question** (joshuafolkken/kit#7356): no
+// decision schema, the same release.
+async function run_escalate(argv: ReadonlyArray<string>, directory: string): Promise<number> {
+	const issue_number = await run_park_escalate.park(argv, directory, USAGE)
+
+	return issue_number === undefined ? FAILURE_EXIT_CODE : await release(issue_number, directory)
+}
+
 async function run(
 	argv: ReadonlyArray<string>,
 	directory: string = process.cwd(),
 ): Promise<number> {
 	if (argv.includes(CLEAR_FLAG)) return await run_clear(argv, directory)
+	if (run_park_escalate.is_requested(argv)) return await run_escalate(argv, directory)
 
 	const request = issue_comment_cli.resolve_request(argv, USAGE)
 

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

@@ -0,0 +1,102 @@
+import { agent_worker_profile } from '#scripts/agent/agent-worker-profile'
+import { RUN_STALLED_LABEL } from '#scripts/issue/issue-labels'
+import { issue_number_shape } from '#scripts/issue/issue-number-shape'
+import { session_cite } from '#scripts/issue/session-cite'
+import { cli_flags } from '#scripts/lib/cli-flags'
+import { run_stalled } from './run-stalled'
+import { run_stalled_park } from './run-stalled-park'
+
+// `josh run:park <N> --escalate "<reason>"` (joshuafolkken/kit#7356): a worker declares that its Issue
+// needs a stronger `josh.worker` profile and stops. Only a repository with `josh.worker.escalate: true`
+// accepts it. The park is a `run:stalled` one whose cause has no retry check, so the drive never
+// re-offers it on the same profile: it resumes the lane one profile up (joshuafolkken/kit#7357).
+
+const ESCALATE_FLAG = '--escalate'
+const OPTIONS = { escalate: { type: 'string' } } as const
+const DISABLED_NOTE = `run:park ${ESCALATE_FLAG}: refused — this repository's package.json does not set josh.worker.escalate to true.`
+
+interface Escalation {
+	issue: string
+	reason: string
+}
+
+function is_requested(argv: ReadonlyArray<string>): boolean {
+	return argv.some((token) => token === ESCALATE_FLAG || token.startsWith(`${ESCALATE_FLAG}=`))
+}
+
+// Whether the repository lets a worker declare an escalation at all.
+function is_enabled(directory: string): boolean {
+	const result = agent_worker_profile.read(directory)
+
+	return result.kind === 'settings' && result.settings.escalate
+}
+
+function reason_of(value: string | undefined): string {
+	return value?.trim() ?? ''
+}
+
+// The Issue and a non-blank reason, or `undefined` when either is missing.
+function escalation_of(argv: ReadonlyArray<string>): Escalation | undefined {
+	const parsed = cli_flags.arguments_of(argv, OPTIONS)
+	if (parsed === undefined) return undefined
+
+	const issue = issue_number_shape.single_of(parsed.positionals)
+	const reason = reason_of(parsed.values.escalate)
+
+	return issue === undefined || reason === '' ? undefined : { issue, reason }
+}
+
+// The note a declaration is refused with, or `undefined` once it is accepted.
+function refusal_of(
+	escalation: Escalation | undefined,
+	directory: string,
+	usage: string,
+): string | undefined {
+	if (escalation === undefined) return usage
+
+	return is_enabled(directory) ? undefined : DISABLED_NOTE
+}
+
+function accepted(
+	argv: ReadonlyArray<string>,
+	directory: string,
+	usage: string,
+): Escalation | undefined {
+	const escalation = escalation_of(argv)
+	const refusal = refusal_of(escalation, directory, usage)
+
+	if (refusal !== undefined) console.error(refusal)
+
+	return refusal === undefined ? escalation : undefined
+}
+
+function comment_of(escalation: Escalation): string {
+	const { issue, reason } = escalation
+
+	return [
+		`Parked with \`${RUN_STALLED_LABEL}\`: ${run_stalled.ESCALATION_REQUESTED.why}`,
+		`- Reason: ${reason}`,
+		`- Next: the backlogrun drive resumes it one \`worker:<name>\` profile up, or hands it to a person at the top profile; without a drive, give it a stronger profile, ${run_stalled.next_step(issue)}.`,
+	].join('\n')
+}
+
+// The parked Issue, or `undefined` when the declaration is refused or the park could not be written.
+async function park(
+	argv: ReadonlyArray<string>,
+	directory: string,
+	usage: string,
+): Promise<string | undefined> {
+	const escalation = accepted(argv, directory, usage)
+	if (escalation === undefined) return undefined
+
+	const { short } = run_stalled.escalation_requested(escalation.reason)
+	const is_parked = await run_stalled_park.apply(escalation.issue, comment_of(escalation), short)
+
+	console.info(`escalate ${session_cite.issue(escalation.issue)} — parked: ${String(is_parked)}`)
+
+	return is_parked ? escalation.issue : undefined
+}
+
+const run_park_escalate = { ESCALATE_FLAG, is_enabled, is_requested, park }
+
+export { run_park_escalate }

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

@@ -55,20 +55,40 @@ function next_step(child: number | string, cause = ''): string {
 	return `${recovery}, then use \`${resume_of(child, true)}\` in the live backlogrun or resume it with \`${resume_of(child, false)}\``
 }
 
-const SESSION_UNFINISHED_LEAD = `${SESSION_UNFINISHED.short}: `
+// The worker's own declaration that its Issue needs a stronger `josh.worker` profile
+// (joshuafolkken/kit#7356). No retry check reads it, so `run:stalled`'s auto-retry never re-offers it
+// on the same profile; the drive resumes it one profile up (joshuafolkken/kit#7357).
+const ESCALATION_REQUESTED: StallCause = {
+	short: 'escalation requested',
+	why: 'the worker declared that its Issue needs a stronger josh.worker profile.',
+}
 
-// The child's first message line rides behind its class, so a reader keyed on the class still finds it.
-function session_unfinished(message: string): StallCause {
+const CARRYING_CLASSES = [SESSION_UNFINISHED, ESCALATION_REQUESTED]
+
+function lead_of(cause: StallCause): string {
+	return `${cause.short}: `
+}
+
+// The message's first line rides behind its class, so a reader keyed on the class still finds it.
+function carrying(cause: StallCause, message: string): StallCause {
 	const first = message.split(/\r?\n/u, 1)[0]?.trim() ?? ''
 
-	return first === ''
-		? SESSION_UNFINISHED
-		: { short: `${SESSION_UNFINISHED_LEAD}${first}`, why: first }
+	return first === '' ? cause : { short: `${lead_of(cause)}${first}`, why: first }
+}
+
+function session_unfinished(message: string): StallCause {
+	return carrying(SESSION_UNFINISHED, message)
+}
+
+function escalation_requested(reason: string): StallCause {
+	return carrying(ESCALATION_REQUESTED, reason)
 }
 
 // The class a park's cause names: `session unfinished` for one carrying the child's message too.
 function class_of(cause: string): string {
-	return cause.startsWith(SESSION_UNFINISHED_LEAD) ? SESSION_UNFINISHED.short : cause
+	const carried = CARRYING_CLASSES.find((known) => cause.startsWith(lead_of(known)))
+
+	return carried?.short ?? cause
 }
 
 function park_event(child: number | string, cause: string): string {
@@ -113,11 +133,13 @@ function waiting_text(waits: ReadonlyArray<string>): string {
 
 const run_stalled = {
 	CUT_NOT_RELAUNCHED,
+	ESCALATION_REQUESTED,
 	SESSION_UNFINISHED,
 	STALE_HANDOFF,
 	cause_in,
 	cause_of,
 	class_of,
+	escalation_requested,
 	next_step,
 	park_event,
 	resume_of,

package/scripts/run/review/run-review-early-push.ts

@@ -20,8 +20,8 @@ import { run_review_steps } from './run-review-steps'
 // already moved, pushes nothing and the ship's commit stage pushes as before. A round recorded once
 // the branch is pushed goes to the issue (`review-record-comment.ts`).
 //
-// Only a lane child's own open, briefing code alone: the ship's `--code-only` open commits through its
-// own sync stage, and an interaction review is still to come.
+// Only a lane child's own open, after every due brief is written: the ship's `--code-only` open
+// commits through its own sync stage. All due slots still have to attest before the ship can merge.
 
 const PUSH_FLAG = '--push'
 const RUN_REVIEW_COMMAND = 'run:review'
@@ -43,10 +43,10 @@ interface EarlyPushPlan {
 
 type Environment = Readonly<Record<string, string | undefined>>
 
-function is_code_alone(plan: EarlyPushPlan): boolean {
+function is_full_open(plan: EarlyPushPlan): boolean {
 	if (plan.is_code_only) return false
 
-	return plan.slots.length === 1 && plan.slots[0] === review_attest.REVIEW_SLOT.CODE
+	return plan.slots.includes(review_attest.REVIEW_SLOT.CODE)
 }
 
 // The mark counts only in the checkout of the issue it names: a leaked one pushes nothing.
@@ -55,7 +55,7 @@ function is_due(
 	environment: Environment = process.env,
 	directory = PROJECT_ROOT,
 ): boolean {
-	return lane_child_marker.is_child_of(directory, environment) && is_code_alone(plan)
+	return lane_child_marker.is_child_of(directory, environment) && is_full_open(plan)
 }
 
 // A clean tree is already committed; a refused commit says why and leaves the round to the ship.
@@ -77,7 +77,7 @@ function preparation_skip(
 	if (!lane_child_marker.is_child_of(directory, environment)) return 'not-lane-child'
 	if (plan.is_code_only) return 'code-only'
 
-	return is_code_alone(plan) ? undefined : 'multiple-slots'
+	return is_full_open(plan) ? undefined : 'multiple-slots'
 }
 
 // Whether this open pushes early: due here, and the tree committed for the brief to attest.

package/scripts/run/ship/run-ship-stop-cause.ts

@@ -3,6 +3,7 @@ import { RERUNS_SPENT_MESSAGE } from '#scripts/followup/followup-job-rerun'
 import { UNREADABLE_COMMENTS_STOP } from '#scripts/gh/git-gh-comments-unreadable'
 import { gh_retry } from '#scripts/gh/git-gh-retry'
 import { PR_CHECKS_TIMEOUT_MESSAGE } from '#scripts/gh/git-pr-checks'
+import { git_pr_checks_failed } from '#scripts/gh/git-pr-checks-failed'
 import { is_blocked_cause } from '#scripts/gh/git-pr-checks-missing'
 import { NO_CHECKS_MESSAGE } from '#scripts/gh/git-pr-checks-watch'
 import { git_error } from '#scripts/git/git-error'
@@ -176,6 +177,13 @@ function findings_of(stage: Stage, cause: Cause, body: string): ReadonlyArray<st
 	return is_finding_stop(stage, cause) ? run_ship_review.blocking_kinds(body) : []
 }
 
+// The CI checks a followup `check` stop's wait reported failed (joshuafolkken/kit#7333).
+function checks_of(stage: Stage, cause: Cause, body: string): ReadonlyArray<string> {
+	return stage === STAGE.FOLLOWUP && cause === CAUSE.CHECK
+		? git_pr_checks_failed.names_of(body)
+		: []
+}
+
 // Each finding that decided a review stop, whole, for the durable stop log (joshuafolkken/kit#4519).
 function details_of(stage: Stage, failed: StoppedOutput = NO_OUTPUT): ReadonlyArray<StopFinding> {
 	if (!is_finding_stop(stage, cause_of(stage, failed))) return []
@@ -185,11 +193,13 @@ function details_of(stage: Stage, failed: StoppedOutput = NO_OUTPUT): ReadonlyAr
 
 // The lane ledger's record of one stop — the stage, its cause and, for a preflight, which
 // preconditions were unmet, so `lane:stats` counts the one worth meeting before a ship
-// (joshuafolkken/kit#4166); for a review, which kinds of finding stopped it (joshuafolkken/kit#4426).
+// (joshuafolkken/kit#4166); for a review, which kinds of finding stopped it (joshuafolkken/kit#4426);
+// for a followup red on a check, which checks failed (joshuafolkken/kit#7333).
 function record_of(issue: number, stage: Stage, failed: StoppedOutput = NO_OUTPUT): StopRecord {
 	const { body, conflicts, preconditions } = failed
 	const cause = cause_of(stage, failed)
 	const findings = findings_of(stage, cause, body)
+	const checks = checks_of(stage, cause, body)
 
 	return {
 		issue,
@@ -197,6 +207,7 @@ function record_of(issue: number, stage: Stage, failed: StoppedOutput = NO_OUTPU
 		cause,
 		...(preconditions !== undefined && { preconditions: [...preconditions] }),
 		...(findings.length > 0 && { findings: [...findings] }),
+		...(checks.length > 0 && { checks: [...checks] }),
 	}
 }
 

package/scripts/split/split-assess.ts

@@ -1,3 +1,4 @@
+import { codex_hooks } from '#scripts/agent/codex-hooks'
 import { git_path_quoting } from '#scripts/git/git-path-quoting'
 import { issue_body_keys } from '#scripts/issue/issue-body-keys'
 import { run_record_path } from '#scripts/josh/run-record-path'
@@ -160,15 +161,21 @@ function partners_of(
 
 // The files grouped into what splits as one, each group at its first file: a new scripts module and an
 // importer of its directory count as one (joshuafolkken/kit#6635), for `lane:plan` and the split notice
-// alike (joshuafolkken/kit#6724). With no `added` file, every file stands alone.
+// alike (joshuafolkken/kit#6724). A registered generated artifact also stays with its source (#7381);
+// the two files' changed lines still count in full. Other files stand alone when none is added.
 function units_of(files: ReadonlyArray<string>, added: ReadonlySet<string>): Array<Array<string>> {
-	const partners = partners_of(files, added)
+	const artifacts = codex_hooks.GENERATED_SOURCES
+	const sources = files.filter((file) => !files.includes(artifacts.get(file) ?? ''))
+	const partners = partners_of(sources, added)
 
-	return files.flatMap((file) => {
+	return sources.flatMap((file) => {
 		const partner = partners.get(file)
-		if (partner === undefined) return [[file]]
+		const unit = partner === undefined ? [file] : [file, partner]
+		const generated = files.filter((path) => unit.includes(artifacts.get(path) ?? ''))
 
-		return files.indexOf(partner) < files.indexOf(file) ? [] : [[file, partner]]
+		return partner !== undefined && sources.indexOf(partner) < sources.indexOf(file)
+			? []
+			: [[...unit, ...generated]]
 	})
 }
 
@@ -315,8 +322,10 @@ const split_assess = {
 	SINGLE_VERDICT,
 	assess,
 	guide_for,
+	is_deliverable,
 	is_over_cap,
 	notice,
+	measure,
 	parse_numstat,
 	policy_text,
 	reason,

package/scripts/test/test-related-touched.ts

@@ -1,5 +1,6 @@
 import { readdirSync } from 'node:fs'
 import path from 'node:path'
+import { direct_importers } from './direct-importers'
 import { test_related_pins } from './test-related-pins'
 import { related_scope, type RelatedScope } from './test-related-scope'
 
@@ -7,7 +8,7 @@ import { related_scope, type RelatedScope } from './test-related-scope'
 // near a hub reaches hundreds of test files, and paying that reach after every small edit repeats it
 // minutes apart. **The touched scope reads no test-read map and no import graph**: it is the diff's own
 // test files and, for each changed module `foo.ts`, its colocated `foo.test.ts` and `foo.*.test.ts`,
-// plus the tests the change pins (`test-related-pins.ts`).
+// plus the tests the change pins (`test-related-pins.ts`) and its modules' direct test importers.
 // The full-reach run checks further away. A touched green admits review round 2, and the lane ledger
 // records it under its own kind.
 
@@ -15,8 +16,8 @@ const TOUCHED_FLAG = '--touched'
 const TOUCHED_KIND = 'touched'
 const TEST_SUFFIX = '.test.ts'
 const TOUCHED_REASON =
-	'the diff test files, the tests named after its modules and the tests it pins'
-const NOTHING_TOUCHED_REASON = 'no test file is in the diff or named after a changed module'
+	"the diff test files, their modules' same-named tests, direct test importers and pinned tests"
+const NOTHING_TOUCHED_REASON = 'no changed file reaches a touched test'
 
 type ListDirectory = (directory: string) => ReadonlyArray<string>
 
@@ -76,11 +77,28 @@ function touched_scope(
 	return { mode: 'related', files, reason: TOUCHED_REASON }
 }
 
+// A shared fixture often has no same-named test. Reuse the direct-import scan, without building
+// a transitive graph, so its consuming suites run before the shipping checks (joshuafolkken/kit#7380).
+async function read_scope(
+	root: string,
+	changed: ReadonlyArray<string> | undefined,
+): Promise<RelatedScope> {
+	if (changed === undefined) return touched_scope(root, changed)
+
+	const importers = await direct_importers.importers_of(
+		root,
+		changed.filter((file) => related_scope.is_relatable(file)),
+	)
+
+	return touched_scope(root, [...changed, ...[...importers.values()].flat()])
+}
+
 const test_related_touched = {
 	NOTHING_TOUCHED_REASON,
 	TOUCHED_FLAG,
 	TOUCHED_KIND,
 	TOUCHED_REASON,
+	read_scope,
 	touched_scope,
 	touched_tests,
 }

package/scripts/test/test-related.ts

@@ -369,7 +369,7 @@ async function run_touched(given: ReadonlyArray<string>): Promise<number> {
 	const root = await changed_file_scope.repository_root_or_cwd()
 	const explicit = explicit_files(root, command_arguments)
 	const changed = explicit.length > 0 ? explicit : await branch_change()
-	const scope = test_related_touched.touched_scope(root, changed)
+	const scope = await test_related_touched.read_scope(root, changed)
 	const input = { scope, root, changed, synced: [], since_map: [], kind: TOUCHED_KIND }
 
 	return await test_related_run.run_and_record(input, command_arguments)

package/dist/commands/chunk-6WEVLIZE.js

@@ -1,29 +0,0 @@
-import {
-  issue_park
-} from "./chunk-T33QDAWD.js";
-import {
-  run_stalled
-} from "./chunk-B33BTNB4.js";
-import {
-  run_event_stream_emit
-} from "./chunk-34LAULSC.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  RUN_STALLED_LABEL
-} from "./chunk-QQBMVC5W.js";
-
-// scripts/run/park/run-stalled-park.ts
-var { PARK } = run_event_stream.EVENT_KIND;
-async function apply(issue, comment, cause, fields = {}) {
-  const park_write = await issue_park.apply(issue, RUN_STALLED_LABEL, comment);
-  if (!park_write.is_labelled) return false;
-  await run_event_stream_emit.emit(PARK, run_stalled.park_event(issue, cause), /* @__PURE__ */ new Date(), fields);
-  return true;
-}
-var run_stalled_park = { apply };
-
-export {
-  run_stalled_park
-};