@joshuafolkken/kit 1.3000.0 → 1.3041.0

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
-};