@joshuafolkken/kit 1.1455.0 → 1.1471.0

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

@@ -1,3 +1,5 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { session_cite } from '#scripts/issue/session-cite'
 import { run_cut, type CutState, type RunCut } from './run-cut'
 import { run_cut_handoff } from './run-cut-handoff'
 
@@ -136,6 +138,16 @@ function report_reviewer(): number {
 	return report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE)
 }
 
+// The cut outside a lane is taken, and nothing is relaunched: the session that took it is the one a
+// person is watching, so the run is handed on the way `fullrun`'s entry `over` stop hands it on.
+function report_held_cut(issue: string): number {
+	console.error(
+		`The cut is recorded for ${session_cite.issue(issue)} outside a lane, so nothing was relaunched. Keep the hold, send a \`confirmation\` Telegram whose body names the resume command \`fullrun ${issue_cite.plain(issue)}\`, and end the turn; the fresh session's \`pnpm josh run:cut --resume ${issue}\` answers \`resume-impl\` with the handoff.`,
+	)
+
+	return report(CUT_VERDICT, SUCCESS_EXIT_CODE)
+}
+
 // **An implementation cut is never resumed by a session over the threshold**.
 // The cut outside a lane leaves the session that took it open, so a person retyping `fullrun #N` there
 // would be answered `resume-impl`, keep implementing over the threshold, and be cut again on the next
@@ -176,6 +188,7 @@ const run_cut_report = {
 	report_busy,
 	report_fault,
 	report_handed_off,
+	report_held_cut,
 	report_incomplete,
 	report_over,
 	report_reviewer,

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

@@ -106,6 +106,8 @@ interface CutState {
 	is_held: boolean
 	// The issue a `fullrun` hold names, absent when the tree is not held by one.
 	held_issue?: string | undefined
+	// When the hold standing over the tree was taken — what keys a declined cut to the run it answered.
+	hold_taken_at?: string | undefined
 }
 
 // The fields a cut is written from, bundled so `begin_cut` stays within the parameter limit. `phase`
@@ -402,7 +404,13 @@ async function current_state(): Promise<CutState> {
 	const is_dirty = await run_hold.is_tree_dirty()
 	const hold = hold_of(await worktree_directory())
 
-	return { branch, is_dirty, is_held: hold !== undefined, held_issue: fullrun_issue(hold) }
+	return {
+		branch,
+		is_dirty,
+		is_held: hold !== undefined,
+		held_issue: fullrun_issue(hold),
+		hold_taken_at: hold?.taken_at,
+	}
 }
 
 function describe_cut(cut: RunCut): string {
@@ -466,6 +474,7 @@ const run_cut = {
 	handed_off_message,
 	has_required_handoff,
 	held_issue_sync,
+	hold_of,
 	incomplete_message,
 	invocation_for,
 	is_expired,

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

@@ -176,14 +176,25 @@ function held_block(hold: RunHold, issue: string): string | undefined {
 	return run_hold.is_reentry(hold, issue) ? undefined : run_hold.held_message(hold)
 }
 
+// An expired record of the claimant's own issue that no stop marked is the earlier run of the same work —
+// a child killed and re-dispatched into its lane — so the claim adopts it with the work it left. A
+// stopped `halfrun` or `prrun` keeps its own adopt path.
+function is_own_unstopped(hold: RunHold, issue: string): boolean {
+	return run_hold.is_reentry(hold, issue) && !run_hold.is_stop_marked(hold)
+}
+
+async function stale_block(hold: RunHold, issue: string): Promise<string | undefined> {
+	if (is_own_unstopped(hold, issue)) return undefined
+
+	return (await run_hold.is_tree_dirty()) ? run_hold.uncommitted_message(hold) : undefined
+}
+
 async function blocking_message(read: HoldRead, issue: string): Promise<string | undefined> {
 	if (read.kind === 'held') return held_block(read.hold, issue)
 
 	if (read.kind === 'unreadable') return run_hold.unreadable_message()
 
-	const is_expired_over_work = read.kind === 'stale' && (await run_hold.is_tree_dirty())
-
-	return is_expired_over_work ? run_hold.uncommitted_message(read.hold) : undefined
+	return read.kind === 'stale' ? await stale_block(read.hold, issue) : undefined
 }
 
 // A record already here is never overwritten by a claim: overwriting is what the guard exists to

package/scripts/run/hold/run-hold.ts

@@ -129,10 +129,12 @@ function is_expired(hold: RunHold, now: Date): boolean {
 // nothing. Only a recorded session that is provably gone counts — no owner, or a live pid whose start
 // cannot be read, leaves the age as the whole test. **A stop-marked record is exempt**: a `halfrun` or
 // `prrun` stop is held across a person's latency on purpose, long after its session ends.
-function is_owner_gone(hold: RunHold): boolean {
-	const is_stop_mark = hold.is_halfrun_stop === true || hold.prrun_stop_head !== undefined
+function is_stop_marked(hold: RunHold): boolean {
+	return hold.is_halfrun_stop === true || hold.prrun_stop_head !== undefined
+}
 
-	if (is_stop_mark || hold.owner_pid === undefined) return false
+function is_owner_gone(hold: RunHold): boolean {
+	if (is_stop_marked(hold) || hold.owner_pid === undefined) return false
 
 	return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false
 }
@@ -317,6 +319,7 @@ function unknown_message(): string {
 }
 
 const run_hold = {
+	is_stop_marked,
 	FORCE_RELEASE_COMMAND,
 	HOLD_MAX_AGE_HOURS,
 	HOLD_MAX_AGE_MS,

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

@@ -10,11 +10,13 @@ import { lane_handoff } from '#scripts/lane/lane-handoff'
 import { lane_ledger } from '#scripts/lane/lane-ledger'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { run_carry, type CarryOwner, type RunCarry } from '#scripts/run/carry/run-carry'
+import { run_event_scope } from '#scripts/run/event/run-event-scope'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_ending } from '#scripts/run/run-ending'
 import { run_label } from '#scripts/run/run-label'
 import { run_merge, type ChildOutcome, type EndingSignals } from './run-merge'
+import { run_merge_ship } from './run-merge-ship'
 import { run_merge_steps, type FailedResult, type MergeContext } from './run-merge-steps'
 import { run_merge_token, type MergeToken } from './run-merge-token'
 
@@ -189,14 +191,34 @@ async function offered(ctx: MergeContext): Promise<OfferVerdict> {
 	return { token: await run_merge_steps.ask_next(ctx), code: SUCCESS_EXIT_CODE, is_offer: true }
 }
 
-// Whether the child's exit record shows it could not reach the API — read only when `--output` named
-// the transcript, off otherwise. The path is validated inside
-// `run_ending.read_exit`, which returns `undefined` for an unreadable or missing record, so a missing
-// output is simply "not an outage".
+// Whether the child's session ended through its environment — read only when `--output` named the
+// transcript, off otherwise: its exit record shows it could not reach the API, or the session was
+// killed inside a turn. The path is validated inside `run_ending`, so a missing output is "no".
 function read_is_outage(output: string | undefined): boolean {
 	if (output === undefined) return false
 
-	return api_outage.is_outage(run_ending.read_exit(output))
+	return api_outage.is_outage(run_ending.read_exit(output)) || run_ending.ended_mid_turn(output)
+}
+
+async function child_outages(child: string): Promise<number> {
+	const events = await run_event_stream_emit.current_events()
+
+	return events.filter(
+		(event) =>
+			event.kind === run_event_stream.EVENT_KIND.OUTAGE &&
+			run_event_scope.issue_named(event) === child,
+	).length
+}
+
+// An outage child is re-dispatched only so many times: one that ends the same way on every dispatch is
+// parked, since merges in other lanes reset the run-wide outage streak and would never stop it.
+async function read_is_retryable(child: string, output: string | undefined): Promise<boolean> {
+	const is_interrupted =
+		read_is_outage(output) || (await run_merge_ship.is_unanswered(child, output))
+
+	if (!is_interrupted) return false
+
+	return (await child_outages(child)) < run_merge.CONSECUTIVE_OUTAGE_LIMIT
 }
 
 type IssueRead = Awaited<ReturnType<typeof issue_state_cli.read_issue>>
@@ -211,12 +233,13 @@ async function read_merged_pr(child: string, read: IssueRead): Promise<string |
 }
 
 async function read_signals(ctx: MergeContext, read: IssueRead): Promise<EndingSignals> {
-	const [is_cut, merged_pr] = await Promise.all([
+	const [is_cut, merged_pr, is_outage] = await Promise.all([
 		run_merge_steps.has_resumable_cut(ctx.child),
 		read_merged_pr(ctx.child, read),
+		read_is_retryable(ctx.child, ctx.output),
 	])
 
-	return { is_outage: read_is_outage(ctx.output), is_cut, merged_pr }
+	return { is_outage, is_cut, merged_pr }
 }
 
 function outcome_of(read: IssueRead, signals: EndingSignals): ChildOutcome {

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

@@ -1,6 +1,9 @@
 import { git_common_directory } from '#scripts/git/git-common-directory'
+import { lane_registry } from '#scripts/lane/lane-registry'
+import { lane_relaunch } from '#scripts/lane/lane-relaunch'
 import { run_event_scope } from '#scripts/run/event/run-event-scope'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
+import { run_ending } from '#scripts/run/run-ending'
 import { run_ship_detach } from '#scripts/run/ship/run-ship-detach'
 
 // Why `run:merge` parks a child whose detached ship has already ended (joshuafolkken/kit#3808).
@@ -56,6 +59,61 @@ function cause(child: string, directory: string = process.cwd()): string | undef
 	return cause_of(run_ship_detach.read_result(repository, child), events, child)
 }
 
-const run_merge_ship = { cause, cause_of }
+// Whether the ended ship was never answered: a session relaunched to fix a stop writes to the
+// transcript after it, so a transcript last written before the newest stop means no fix-up ran — its
+// broker or relaunch could not start. A ship with no stop at all ended abnormally only when its supervisor
+// died before reaching a stage.
+function is_stop_unanswered(
+	ending: ShipEnding,
+	attempt: Events,
+	written_at: number | undefined,
+): boolean {
+	const stop = attempt.findLast((event) => event.kind === run_event_stream.EVENT_KIND.SHIP_STOP)
+
+	if (stop === undefined) return ending?.result === 'abnormal'
+
+	return written_at !== undefined && written_at < Date.parse(stop.at)
+}
+
+// Whether the child's ship ended through an interruption rather than its work, so the child is
+// re-dispatched instead of parked.
+function interrupted_of(
+	ending: ShipEnding,
+	events: Events,
+	child: string,
+	written_at: number | undefined,
+): boolean {
+	if (ending === undefined || !ENDED_RESULTS.has(ending.result)) return false
+
+	const attempt = since_ship_launch(events, child)
+
+	return attempt !== undefined && is_stop_unanswered(ending, attempt, written_at)
+}
+
+function is_interrupted(
+	child: string,
+	written_at: number | undefined,
+	directory: string = process.cwd(),
+): boolean {
+	const repository = git_common_directory.repository(directory)
+	if (repository === undefined) return false
+
+	const events = run_event_stream.read_events(run_event_stream.target_of(repository))
+
+	return interrupted_of(run_ship_detach.read_result(repository, child), events, child, written_at)
+}
+
+// Whether the child's ship stopped and the relaunch meant to fix it never ran, read against its
+// transcript at `output`. An OpenAI lane is never relaunched — its parent books every stop as an ended
+// child — and nothing relaunches a child whose lane is gone, so only an open non-OpenAI lane reads as one.
+async function is_unanswered(child: string, output: string | undefined): Promise<boolean> {
+	if (output === undefined || !is_interrupted(child, run_ending.written_at(output))) return false
+
+	const lane = await lane_registry.find_open_lane(child)
+
+	return lane !== undefined && !lane_relaunch.is_openai_lane(lane)
+}
+
+const run_merge_ship = { cause, cause_of, interrupted_of, is_unanswered }
 
 export { run_merge_ship }

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

@@ -23,8 +23,9 @@ const CLOSED_STATE = 'CLOSED'
 // 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.
 const CONSECUTIVE_FAILURE_LIMIT = 3
-// Three API outages in a row stop the run too — the same shape as the failure
-// guard, over its own streak. An outage is a child that could not reach the API, so a run of them is
+// 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,
+// its session was killed inside a turn, or its ship stopped with no relaunch — 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 merge or a genuine child failure resets it (`run-carry.ts` → `next_outages`).
 const CONSECUTIVE_OUTAGE_LIMIT = 3

package/scripts/run/run-ending.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs'
+import { readFileSync, statSync } from 'node:fs'
 import { agent_exit_record } from '#scripts/agent/agent-exit-record'
 import { api_outage } from '#scripts/agent/api-outage'
 import type { ClaudeResultEvent } from '#scripts/agent/claude-result-event'
@@ -179,7 +179,7 @@ async function read_cut_taken(issue: string): Promise<boolean> {
 	return read.kind === 'carried' && read.cut.invocation === run_cut.invocation_for(issue)
 }
 
-function read_exit(output_path: string): ClaudeResultEvent | undefined {
+function read_transcript(output_path: string): string | undefined {
 	const safe_path = run_liveness.to_safe_path(output_path)
 
 	if (safe_path === undefined) return undefined
@@ -188,12 +188,38 @@ function read_exit(output_path: string): ClaudeResultEvent | undefined {
 		// Validated by `run_liveness.to_safe_path` — normalized, required absolute, confined to the
 		// allowed roots — the same check `josh lane:output` gates a transcript path with, reused rather
 		// than re-spelled so the two cannot disagree.
-		return agent_exit_record.read_exit_record(readFileSync(safe_path, 'utf8')) // NOSONAR
+		return readFileSync(safe_path, 'utf8') // NOSONAR
+	} catch {
+		return undefined
+	}
+}
+
+function read_exit(output_path: string): ClaudeResultEvent | undefined {
+	const transcript = read_transcript(output_path)
+
+	return transcript === undefined ? undefined : agent_exit_record.read_exit_record(transcript)
+}
+
+// When the child's transcript was last written, in epoch milliseconds — `undefined` when unreadable.
+function written_at(output_path: string): number | undefined {
+	const safe_path = run_liveness.to_safe_path(output_path)
+
+	if (safe_path === undefined) return undefined
+
+	try {
+		return statSync(safe_path).mtimeMs // NOSONAR — validated as `read_transcript` validates it
 	} catch {
 		return undefined
 	}
 }
 
+// The child's session was killed inside a turn rather than finishing it.
+function ended_mid_turn(output_path: string): boolean {
+	const transcript = read_transcript(output_path)
+
+	return transcript !== undefined && agent_exit_record.is_mid_turn(transcript)
+}
+
 async function read_traces(request: EndingRequest): Promise<EndingTraces> {
 	const [is_child_closed, is_cut_taken, is_tree_dirty] = await Promise.all([
 		read_child_closed(request.issue, request.repo),
@@ -218,7 +244,9 @@ async function check(request: EndingRequest): Promise<EndingDecision> {
 const run_ending = {
 	check,
 	decide,
+	ended_mid_turn,
 	read_exit,
+	written_at,
 }
 
 export type { EndingDecision, EndingRequest, EndingTraces, EndingVerdict }

package/scripts/run/run-parent-cut-hook.ts

@@ -53,16 +53,11 @@ function current_state(): ParentCutState {
 const THRESHOLD_TEXT = `${cost_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-token`
 
 const PARENT_CUT_REASON =
-	'⛔ backlogrun parent hand-off: this session drives a `backlogrun` (it owns the live carry record) and ' +
-	`its recent-context cost has crossed the shared ${THRESHOLD_TEXT} threshold between merges, so every ` +
-	'later request re-reads the accumulated context (joshuafolkken/kit#2947). Take the hand-off now rather ' +
-	'than at the next merge: follow `.claude/skills/workflow-commands/backlogrun-progress.md` → "The ' +
-	'hand-off" from its `over` branch — open no new lane and take no new child, read `pnpm josh lane:list`, ' +
-	'make sure every lane in flight records an output path, then run `pnpm josh run:carry --cut --owner ' +
-	'"$PPID"` and, unless it answers `capped`, `pnpm josh run:wake`, post the progress comment and end the ' +
-	'turn. A lane nobody can poll means the cut does not happen; carry on and this asks again later. ' +
-	'Reissue this call when the hand-off is done or cannot be taken — the guard stays quiet for a while ' +
-	'after it refuses, so the hand-off calls themselves are not refused.'
+	'⛔ backlogrun parent hand-off: this session drives a `backlogrun` and its recent-context cost ' +
+	`crossed the ${THRESHOLD_TEXT} threshold between merges. Take the hand-off now: open no new lane, ` +
+	'follow `backlogrun-progress.md` → "The hand-off" (`pnpm josh run:carry --cut --owner "$PPID"`, then ' +
+	'`pnpm josh run:wake` unless `capped`) and end the turn. Reissue this call once done or if it ' +
+	'cannot be taken.'
 
 // Neither an uncapped parent's own record nor a measured `over` is optional: a capped record has no cut
 // left to take (`run:carry --cut` answers `capped`), and an unmeasurable session is left alone here —

package/scripts/run/run-preflight.ts

@@ -343,8 +343,7 @@ async function read_candidate(
 ): Promise<ChildState | undefined> {
 	const state = await read_pr_of_branch(name)
 
-	if (state.pr_state !== NO_PR) return state
-	if (await has_commits_beyond(context.base, references)) return state
+	if (state.pr_state !== NO_PR || (await has_commits_beyond(context.base, references))) return state
 
 	return (await is_held_dirty(name, context.lane)) ? state : undefined
 }

package/scripts/run/run-stop-notify.ts

@@ -27,8 +27,7 @@ const STOP_RECOVERY =
 // this type is for the run that halted needing a person. An `unreadable` record is not announced: with
 // nothing readable there is no run this can honestly say stopped.
 function plan(read: CarryRead, reason: string | undefined): StopNotice | undefined {
-	if (reason === undefined || reason.length === 0) return undefined
-	if (read.kind !== 'carried') return undefined
+	if (reason === undefined || reason.length === 0 || read.kind !== 'carried') return undefined
 
 	return { reason }
 }

package/scripts/run/run-watcher-guard.ts

@@ -49,9 +49,12 @@ async function owes_watcher(): Promise<boolean> {
 // `run_progress_clock.life_target_of(git_directory)`. Passed in rather than resolved here so the
 // caller can use whichever resolution fits its sync/async context.
 async function check(life_target: string): Promise<GuardResult> {
-	if (!(await owes_watcher())) return OK_RESULT
-
-	if (run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)) return OK_RESULT
+	if (
+		!(await owes_watcher()) ||
+		run_progress_clock.is_life_fresh(life_target, STALE_THRESHOLD_MS)
+	) {
+		return OK_RESULT
+	}
 
 	return { kind: 'stale', note: STALE_NOTE }
 }

package/scripts/run/ship/run-ship-review-steps.ts

@@ -59,7 +59,7 @@ const ROUND_ONE_RECORDED_NOTE =
 // single-sourced with the preflight and gate stages.
 const { run_phases, scoped_pair } = run_ship_scoped
 
-type PromptOf = (brief_path: string, findings_path: string) => string
+type PromptOf = (brief_path: string, findings_path: string, issue: string) => string
 
 function failure(out: string): JoshResult {
 	return { code: FAILURE_EXIT_CODE, out }
@@ -138,7 +138,12 @@ async function launch_reviewer(
 	stamp_file.write_text_stamp(target.brief, brief)
 	stamp_file.remove_stamp(target.findings)
 
-	return await run_session(prompt_of(target.brief, target.findings), target.log, issue, round)
+	return await run_session(
+		prompt_of(target.brief, target.findings, issue),
+		target.log,
+		issue,
+		round,
+	)
 }
 
 function current_verdict(): ReturnType<typeof run_ship_review.read_verdict> {
@@ -153,8 +158,12 @@ function current_verdict(): ReturnType<typeof run_ship_review.read_verdict> {
 async function join_gate(): Promise<JoshResult> {
 	const joined = await josh([RUN_REVIEW, '--join'])
 
-	if (joined.code === SUCCESS_EXIT_CODE) return joined
-	if (!run_ship_review.has_fixes(stamp_file.read_stamp_text(paths().findings))) return joined
+	if (
+		joined.code === SUCCESS_EXIT_CODE ||
+		!run_ship_review.has_fixes(stamp_file.read_stamp_text(paths().findings))
+	) {
+		return joined
+	}
 
 	note(FIXED_JOIN_NOTE)
 

package/scripts/run/ship/run-ship-review.ts

@@ -1,3 +1,4 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
 import { review_finding_ledger } from '#scripts/review/review-finding-ledger'
 import { review_record_cli } from '#scripts/review/review-record-cli'
 
@@ -83,12 +84,23 @@ function findings_instruction(findings_path: string, fixed_clause: string): stri
 	].join(' ')
 }
 
+// The rubric's requirement check sends the reviewer to the Issue, and a body-only read there is refused
+// by the issue-comments rule — so the prompt names the read that carries the comments with the body
+// (joshuafolkken/kit#3875).
+function issue_read_instruction(issue: string): string {
+	return [
+		`Read Issue ${issue_cite.plain(issue)} with \`pnpm josh issue:read ${issue}\`, which prints the body and every`,
+		`comment together — never a body-only \`gh api …/issues/${issue}\` read.`,
+	].join(' ')
+}
+
 // One line, because `detached_launch` refuses an argument carrying a control character: the multi-line
 // brief travels by path, never inline.
-function reviewer_prompt(brief_path: string, findings_path: string): string {
+function reviewer_prompt(brief_path: string, findings_path: string, issue: string): string {
 	return [
 		`Run a /code-review of this checkout: read the review brief at ${brief_path} and follow it exactly —`,
 		'the level on its first line, the rubric it names, the checkout it pins and its review:attest step.',
+		issue_read_instruction(issue),
 		'Apply a fix only for a Medium finding whose fix is small and local — a one-function refactor, an',
 		'added test, an added guard; never fix a High or a change that reaches beyond one place, and never',
 		'commit, stage or push. After any fix, run `pnpm josh lint:related && pnpm josh test:related` and',
@@ -98,11 +110,12 @@ function reviewer_prompt(brief_path: string, findings_path: string): string {
 }
 
 // The round-2 verification pass: a fresh session over the round-1 fix delta, reading only.
-function verification_prompt(brief_path: string, findings_path: string): string {
+function verification_prompt(brief_path: string, findings_path: string, issue: string): string {
 	return [
 		`Run a /code-review of this checkout — the round-2 verification pass over the round-1 fixes: read the`,
 		`review brief at ${brief_path} and follow it exactly — the level on its first line, the rubric it`,
 		'names, the checkout it pins and its review:attest step. Do not edit any file.',
+		issue_read_instruction(issue),
 		findings_instruction(findings_path, ''),
 	].join(' ')
 }

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

@@ -33,12 +33,12 @@ function memoized(read: IsMerged): IsMerged {
 
 async function sweep(): Promise<void> {
 	try {
-		const read_merged = memoized(issue_merged.read_merged)
+		const is_merged = memoized(issue_merged.read_merged)
 		const in_flight = backlog_drive_restore.active_issues(
 			await run_event_stream_emit.current_events(),
 		)
-		const lanes = await run_tidy_lanes.tidy_lanes(read_merged, in_flight)
-		const stashes = await run_tidy_stashes.tidy_stashes(read_merged)
+		const lanes = await run_tidy_lanes.tidy_lanes(is_merged, in_flight)
+		const stashes = await run_tidy_stashes.tidy_stashes(is_merged)
 		const report = run_tidy.format_report([...lanes, ...stashes])
 
 		if (report !== undefined) console.error(report)

package/scripts/run/tidy/run-tidy-lanes.ts

@@ -95,8 +95,9 @@ async function tidy_lane(
 	is_merged: IsMerged,
 	in_flight: ReadonlySet<string>,
 ): Promise<Outcome | undefined> {
-	if (in_flight.has(lane.issue)) return undefined
-	if (lane.is_stranded || !(await is_merged(lane.issue))) return undefined
+	if (in_flight.has(lane.issue) || lane.is_stranded || !(await is_merged(lane.issue))) {
+		return undefined
+	}
 
 	return { target: `lane ${session_cite.issue(lane.issue)}`, verdict: await settle(lane) }
 }

package/scripts/safe-chain/project-config.ts

@@ -126,8 +126,13 @@ function merge_project_config(existing: string, workspace: string): string {
 	const aikido = yaml_document.parse_yaml(existing)
 	const safe_chain = read_mapping(aikido['safe-chain'], 'safe-chain')
 	const merged = merge_age(merge_exclusions(safe_chain, exclusions), workspace)
-	if (JSON.stringify(merged) === JSON.stringify(safe_chain)) return existing
-	if (has_nothing_to_write(existing, exclusions, workspace)) return existing
+
+	if (
+		JSON.stringify(merged) === JSON.stringify(safe_chain) ||
+		has_nothing_to_write(existing, exclusions, workspace)
+	) {
+		return existing
+	}
 
 	return replace_safe_chain_block(existing, merged)
 }

package/scripts/sync/sync-hook-safety.ts

@@ -65,8 +65,14 @@ function hook_write_warning(
 	filename: string,
 ): string | undefined {
 	const installed_version = installed_consumer_version(project_root)
-	if (writing_version === undefined || installed_version === undefined) return undefined
-	if (is_safe_to_write_hooks(writing_version, installed_version)) return undefined
+
+	if (
+		writing_version === undefined ||
+		installed_version === undefined ||
+		is_safe_to_write_hooks(writing_version, installed_version)
+	) {
+		return undefined
+	}
 
 	return outdated_install_warning(writing_version, installed_version, filename)
 }

package/scripts/test/unit-worker-share.ts

@@ -186,8 +186,9 @@ function worker_arguments(
 	vitest_arguments: ReadonlyArray<string>,
 	share: number | undefined,
 ): Array<string> {
-	if (share === undefined) return []
-	if (vitest_arguments.some((argument) => is_worker_flag(argument))) return []
+	if (share === undefined || vitest_arguments.some((argument) => is_worker_flag(argument))) {
+		return []
+	}
 
 	return [`${WORKER_FLAG}=${String(share)}`]
 }

package/scripts/time-runtime/time-batch-guard.ts

@@ -51,12 +51,12 @@ type NamedCall = Pick<Span, 'is_bundleable' | 'is_writing' | 'label' | 'targets'
 const RULE_POINTER = '`prompts/collaboration-workflow/turn-batching.md`'
 const STREAK = `${String(CONSECUTIVE_LIMIT)} single-call turns in a row`
 
-// Includes what to do when the turn was already batching — the guard cannot see the turn it interrupted.
+// Includes what to do when there is nothing to pair — the guard cannot see the turn it interrupted.
 const REASON =
 	`⛔ batching: ${STREAK}. Reissue this with the calls that do not need its result — the test is ` +
 	`whether a call's input needs another call's result, not what kind of call it is (edits are covered ` +
-	`exactly as reads), and it never authorizes weakening a verification gate or a review. Already ` +
-	`batching, or nothing to pair? Reissue it unchanged; this fires once per streak. ${RULE_POINTER}`
+	`exactly as reads); it never authorizes weakening a verification gate or a review. Nothing to ` +
+	`pair? Reissue it unchanged. ${RULE_POINTER}`
 
 // A whole-file write earns a notice, not a refusal: a `Write` cannot be refused safely.
 const NOTICE =

package/scripts/time-runtime/time-hook-transcript.ts

@@ -68,8 +68,9 @@ function fork_path(transcript_path: string, agent_id: string): string {
 // **A path that is not a transcript is answered with itself**, since nothing can be derived from it and
 // guessing would name a file in some other layout entirely.
 function transcript_of(transcript_path: string, agent_id: string | null | undefined): string {
-	if (!is_agent_id(agent_id)) return transcript_path
-	if (!transcript_path.endsWith(TRANSCRIPT_EXTENSION)) return transcript_path
+	if (!is_agent_id(agent_id) || !transcript_path.endsWith(TRANSCRIPT_EXTENSION)) {
+		return transcript_path
+	}
 
 	return fork_path(transcript_path, agent_id)
 }

package/scripts/time-runtime/time-shell.ts

@@ -189,6 +189,15 @@ function unquoted(command: string): string {
 	return without_heredoc_bodies(command).replaceAll(QUOTED_SPAN_PATTERN, ' ')
 }
 
+// Quoted text replaced by spaces of its own length, so an offset found here is the same offset in the
+// command — what a caller cutting the command where the unquoted reading says to needs. `undefined`
+// for a line carrying a heredoc, whose body lines a cut would read as commands of their own.
+function blanked(command: string): string | undefined {
+	if (HEREDOC_MARKER.test(command)) return undefined
+
+	return command.replaceAll(QUOTED_SPAN_PATTERN, (span) => ' '.repeat(span.length))
+}
+
 function discarded_commands(command: string): Array<string> {
 	const plain = unquoted(command)
 
@@ -308,6 +317,7 @@ const time_shell = {
 	JOSH_PREFIX,
 	bash_command,
 	bash_label,
+	blanked,
 	command_segment,
 	discarded_commands,
 	josh_arguments,

package/scripts/version/effective-upstream.ts

@@ -23,8 +23,7 @@ function read_matching_version(manifest_path: string, package_name: string): str
 	const parsed = package_named_version_schema.safeParse(
 		json_value.parse_or_undefined(readFileSync(manifest_path, 'utf8')),
 	)
-	if (!parsed.success) return undefined
-	if (parsed.data.name !== package_name) return undefined
+	if (!parsed.success || parsed.data.name !== package_name) return undefined
 
 	return parsed.data.version
 }
@@ -45,10 +44,10 @@ function walk_up_for_version(start_directory: string, package_name: string): str
 function resolve_from_base(
 	base_url: string,
 	package_name: string,
-	resolve_marker: string | undefined,
+	resolve_marker = package_name,
 ): string | undefined {
 	try {
-		return createRequire(base_url).resolve(resolve_marker ?? package_name)
+		return createRequire(base_url).resolve(resolve_marker)
 	} catch {
 		return undefined
 	}