@joshuafolkken/kit 1.1166.0 → 1.1178.0

package/scripts/backlog/backlog-plan-cli.ts

@@ -10,6 +10,7 @@ import { run_invocation } from '#scripts/run/run-invocation'
 import { backlog_named } from './backlog-named'
 import { backlog_next, type OptedIn } from './backlog-next'
 import { backlog_plan, type NamedPlan, type PlanContext } from './backlog-plan'
+import type { GateScope } from './backlog-rank'
 import { backlog_scope } from './backlog-scope'
 import { backlog_waves } from './backlog-waves'
 
@@ -104,9 +105,9 @@ interface Plan {
 	// past the listing cap. Carrying the *whole* index here instead would move that misreport rather
 	// than remove it: the sentence would name an epic that is withholding nothing.
 	tracked: ReadonlyMap<number, number>
-	// The rows the offer's cap bounds, so `--waves` cuts each wave where `backlog:next` does
-	// (joshuafolkken/kit#2928).
-	standalone: ReadonlySet<string>
+	// The rows the offer's cap bounds and the paths each issue restructures, so `--waves` cuts each
+	// wave where `backlog:next` does (joshuafolkken/kit#2928, joshuafolkken/kit#3221).
+	scope: GateScope
 }
 
 // The listing plus whether it was cut. Carried together because the rows alone cannot say whether
@@ -141,7 +142,7 @@ async function classify(
 		repo: context.repo,
 		exclude,
 		tracked: epic_index.withheld_children(context.tracking.index, context.opted_in.issues),
-		standalone: backlog_next.standalone_keys(context),
+		scope: backlog_next.gate_scope(context),
 	}
 }
 
@@ -172,7 +173,7 @@ function print_plan(plan: Plan, listing: OpenListing, view: PlanView): void {
 	const context = context_of(plan, listing)
 
 	if (view.is_waves) {
-		console.info(backlog_waves.format_waves(plan.result, context, plan.standalone))
+		console.info(backlog_waves.format_waves(plan.result, context, plan.scope))
 
 		return
 	}

package/scripts/backlog/backlog-rank.ts

@@ -4,6 +4,7 @@ import { epic_rank } from '#scripts/epic/epic-rank'
 import type { EpicNextResult } from '#scripts/epic/epic-report'
 import { epic_solo, type SoloGate, type SoloSelection } from '#scripts/epic/epic-solo'
 import { git_next_issues } from '#scripts/issue/git-next-issues'
+import { backlog_restructure, type Declared } from './backlog-restructure'
 
 // What the backlog offers, in the order it is decided (joshuafolkken/kit#2928): rank, then the
 // `run:solo` gate, then the cap. `backlog:next` and `backlog:plan --waves` both call `select`, so the
@@ -78,29 +79,37 @@ interface OfferInput {
 	repo: string
 	// The keys of the standalone rows — the ones the cap bounds.
 	standalone: ReadonlySet<string>
+	// The paths each issue restructures; two candidates claiming one are not offered together
+	// (joshuafolkken/kit#3221). Absent, nothing is separated.
+	declared?: Declared
 }
 
+// The restructure separation runs before the cap, for the reason the gate does: the cap only ever
+// removes what would otherwise be offered.
 function select(input: OfferInput): SoloSelection {
 	const ranked = rank(input.candidates, input.pool)
+	const { read, repo } = input
+	const gated = epic_solo.select(ranked, read, repo)
+	const separated = backlog_restructure.separate(gated, input.declared ?? new Map(), { read, repo })
 
-	return cap(epic_solo.select(ranked, input.read, input.repo), input.standalone)
+	return cap(separated, input.standalone)
+}
+
+interface GateScope {
+	standalone: ReadonlySet<string>
+	declared: Declared
 }
 
 // `backlog:next`'s gate: `epic_solo.gate` with this selection in place of its bare one.
-function gate(
-	result: EpicNextResult,
-	read: BusyRead,
-	repo: string,
-	standalone: ReadonlySet<string>,
-): SoloGate {
+function gate(result: EpicNextResult, read: BusyRead, repo: string, scope: GateScope): SoloGate {
 	const pool = everything_in(result)
 
 	return epic_solo.gate(result, read, repo, (candidates) =>
-		select({ candidates, pool, read, repo, standalone }),
+		select({ candidates, pool, read, repo, ...scope }),
 	)
 }
 
 const backlog_rank = { everything_in, gate, rank_result, select }
 
 export { backlog_rank }
-export type { OfferInput }
+export type { GateScope, OfferInput }

package/scripts/backlog/backlog-restructure.ts

@@ -0,0 +1,152 @@
+import type { BusyRead } from '#scripts/epic/epic-busy'
+import type { EpicChild } from '#scripts/epic/epic-graph'
+import type { SoloSelection } from '#scripts/epic/epic-solo'
+
+// Which candidates may not run side by side because both restructure the same file
+// (joshuafolkken/kit#3221). The condition is deliberately narrow: plain overlap is not serialized,
+// because every resume record of the 2026-10-05 backlog run was resolved mechanically by merging
+// main. What git cannot resolve on its own is a rename or modify/delete conflict — two lanes that
+// each move, split, rename or delete the same file — so only a path both bodies name on a line with
+// such a verb holds the second one back. `remove` is left out: issue bodies use it for lines and
+// options far more often than for files.
+const RESTRUCTURE_WORDS: ReadonlySet<string> = new Set([
+	'move',
+	'moved',
+	'moves',
+	'moving',
+	'rename',
+	'renamed',
+	'renames',
+	'renaming',
+	'split',
+	'splits',
+	'splitting',
+	'delete',
+	'deleted',
+	'deletes',
+	'deleting',
+])
+const RESTRUCTURE_PHRASES: ReadonlyArray<string> = ['移動', '分割', '削除', 'リネーム', '改名']
+const WORD = /[a-z]+/giu
+const CODE_SPAN = /`([^`\s]+)`/gu
+const LINE_SUFFIX = /:\d+(?::\d+)?$/u
+const FILE_EXTENSION = /\.[a-z]\w*$/iu
+
+// The restructured paths each issue declares, by issue number.
+type Declared = ReadonlyMap<number, ReadonlySet<string>>
+
+interface DeclaringIssue {
+	number: number
+	body?: string | undefined
+}
+
+function is_path(token: string): boolean {
+	return token.includes('/') || FILE_EXTENSION.test(token)
+}
+
+function paths_on(line: string): Array<string> {
+	return [...line.matchAll(CODE_SPAN)]
+		.map((match) => (match[1] ?? '').replace(LINE_SUFFIX, ''))
+		.filter((token) => is_path(token))
+}
+
+function is_restructuring(line: string): boolean {
+	const words = line.match(WORD) ?? []
+
+	if (words.some((word) => RESTRUCTURE_WORDS.has(word.toLowerCase()))) return true
+
+	return RESTRUCTURE_PHRASES.some((phrase) => line.includes(phrase))
+}
+
+// The backticked paths on the lines of `body` that carry a restructuring verb.
+function restructured_paths(body: string): ReadonlySet<string> {
+	const lines = body.split('\n').filter((line) => is_restructuring(line))
+
+	return new Set(lines.flatMap((line) => paths_on(line)))
+}
+
+function declared_of(issues: ReadonlyArray<DeclaringIssue>): Declared {
+	return new Map(issues.map((issue) => [issue.number, restructured_paths(issue.body ?? '')]))
+}
+
+interface SeparateContext {
+	read: BusyRead
+	repo: string
+}
+
+// The path each running lane restructures, mapped to the issue that holds it.
+function running_claims(declared: Declared, read: BusyRead): Map<string, number> {
+	const holders = read.kind === 'busy' ? read.issues.map((issue) => issue.number) : []
+	const pairs = holders.flatMap((number) =>
+		[...(declared.get(number) ?? [])].map((path): [string, number] => [path, number]),
+	)
+
+	return new Map(pairs)
+}
+
+function paths_of(child: EpicChild, declared: Declared, repo: string): ReadonlySet<string> {
+	if (child.repo !== repo) return new Set()
+
+	return declared.get(child.number) ?? new Set()
+}
+
+function clash_note(child: EpicChild, path: string, holder: number): string {
+	return `#${String(child.number)} waits: it and #${String(holder)} both restructure \`${path}\`.`
+}
+
+interface Walk {
+	claims: Map<string, number>
+	offered: Array<EpicChild>
+	withheld: Array<EpicChild>
+	notes: Array<string>
+}
+
+function visit(walk: Walk, child: EpicChild, paths: ReadonlySet<string>): void {
+	const clash = [...paths].find((path) => walk.claims.has(path))
+
+	if (clash === undefined) {
+		walk.offered.push(child)
+		for (const path of paths) walk.claims.set(path, child.number)
+
+		return
+	}
+
+	walk.withheld.push(child)
+	walk.notes.push(clash_note(child, clash, walk.claims.get(clash) ?? child.number))
+}
+
+function merged_notice(
+	notice: string | undefined,
+	notes: ReadonlyArray<string>,
+): string | undefined {
+	const parts = notice === undefined ? notes : [notice, ...notes]
+
+	return parts.length === 0 ? undefined : parts.join('\n')
+}
+
+// `selection` with every offered candidate that restructures a path a running lane or an earlier
+// candidate already restructures moved to `withheld`, in offer order.
+function separate(
+	selection: SoloSelection,
+	declared: Declared,
+	context: SeparateContext,
+): SoloSelection {
+	const walk: Walk = {
+		claims: running_claims(declared, context.read),
+		offered: [],
+		withheld: [],
+		notes: [],
+	}
+
+	for (const child of selection.offered) visit(walk, child, paths_of(child, declared, context.repo))
+
+	const notice = merged_notice(selection.notice, walk.notes)
+	const withheld = [...walk.withheld, ...selection.withheld]
+
+	return { offered: walk.offered, withheld, ...(notice !== undefined && { notice }) }
+}
+
+const backlog_restructure = { declared_of, restructured_paths, separate }
+
+export { backlog_restructure }
+export type { Declared }

package/scripts/backlog/backlog-waves.ts

@@ -10,7 +10,7 @@ import {
 	NEEDS_DECISION_LABEL,
 } from '#scripts/issue/issue-labels'
 import { backlog_plan, type PlanContext } from './backlog-plan'
-import { backlog_rank } from './backlog-rank'
+import { backlog_rank, type GateScope } from './backlog-rank'
 
 // The order a `backlogrun` takes, wave by wave, before it starts (joshuafolkken/kit#2778).
 //
@@ -18,7 +18,8 @@ import { backlog_rank } from './backlog-rank'
 // made from, so the order past the first answer was left for a person to work out by hand. This plays
 // the asks forward under one assumption: **every issue of a wave merges before the next wave starts**.
 //
-// **No rule is written twice.** The first wave is `backlog_rank.select` — rank, `run:solo` gate, cap —
+// **No rule is written twice.** The first wave is `backlog_rank.select` — rank, `run:solo` gate,
+// restructure separation, cap —
 // over the very candidates `backlog:next` resolves, asked of an idle repository — so it is what
 // `backlog:next` prints when nothing is running (joshuafolkken/kit#2928). Each later wave marks the earlier waves closed and re-classifies the same pool
 // through `epic_classify.classify_children` with the resolver `epic:next` sorted it with the first
@@ -28,6 +29,7 @@ import { backlog_rank } from './backlog-rank'
 
 const IDLE: BusyRead = { kind: 'idle' }
 const CLOSED = 'CLOSED'
+const EMPTY_SCOPE: GateScope = { standalone: new Set(), declared: new Map() }
 
 const HEADING_ASSUMPTION =
 	'Assumes every issue in a wave merges before the next wave starts. Issues a run already has are left out, and only issues of this repository are planned.'
@@ -59,17 +61,17 @@ interface WavePool {
 	children: ReadonlyArray<EpicChild>
 	running: ReadonlySet<string>
 	repo: string
-	standalone: ReadonlySet<string>
+	scope: GateScope
 }
 
-function pool_of(result: EpicNextResult, repo: string, standalone: ReadonlySet<string>): WavePool {
+function pool_of(result: EpicNextResult, repo: string, scope: GateScope): WavePool {
 	const all = backlog_rank.everything_in(result)
 
 	return {
 		children: all.filter((child) => !is_running(child)),
 		running: epic_outside_blocker.running_keys(all),
 		repo,
-		standalone,
+		scope,
 	}
 }
 
@@ -78,9 +80,9 @@ function offer(
 	children: ReadonlyArray<EpicChild>,
 	pool: WavePool,
 ): ReadonlyArray<EpicChild> {
-	const { repo, standalone } = pool
+	const { repo, scope } = pool
 
-	return backlog_rank.select({ candidates, pool: children, read: IDLE, repo, standalone }).offered
+	return backlog_rank.select({ candidates, pool: children, read: IDLE, repo, ...scope }).offered
 }
 
 // Ranked against the whole result, exactly as `backlog:next` ranks it, so the two agree.
@@ -106,14 +108,10 @@ function next_wave(pool: WavePool, done: ReadonlySet<string>): ReadonlyArray<Epi
 }
 
 // Each wave is closed before the next is asked for; a wave that offers nothing ends the plan, which
-// the pool's size bounds because every wave closes at least one child. `standalone` names the rows the
-// offer's cap bounds; left empty, no wave is capped.
-function build(
-	result: EpicNextResult,
-	repo: string,
-	standalone: ReadonlySet<string> = new Set(),
-): WavePlan {
-	const pool = pool_of(result, repo, standalone)
+// the pool's size bounds because every wave closes at least one child. `scope` names the rows the
+// offer's cap bounds and the paths each issue restructures; left empty, no wave is capped or separated.
+function build(result: EpicNextResult, repo: string, scope: GateScope = EMPTY_SCOPE): WavePlan {
+	const pool = pool_of(result, repo, scope)
 	const done = new Set<string>()
 	const waves: Array<ReadonlyArray<EpicChild>> = []
 
@@ -155,11 +153,11 @@ function unreached_lines(plan: WavePlan, context: PlanContext): Array<string> {
 function format_waves(
 	result: EpicNextResult,
 	context: PlanContext,
-	standalone: ReadonlySet<string> = new Set(),
+	scope: GateScope = EMPTY_SCOPE,
 ): string {
 	if (result.verdict === 'error') return backlog_plan.format_unusable(result)
 
-	const plan = build(result, context.repo, standalone)
+	const plan = build(result, context.repo, scope)
 	const waves = plan.waves.map((wave, index) => wave_line(wave, index, context.repo))
 
 	return [

package/scripts/cost-runtime/context-cut-threshold.ts

@@ -10,12 +10,4 @@ import { context_cut_payback } from './context-cut-payback'
 // from the cache-price multipliers and the horizon rather than restated, so it moves with the model.
 const CONTEXT_CUT_THRESHOLD = context_cut_payback.break_even_context()
 
-// The hand-off prices the average billed input of the most recent requests, not the whole session
-// (joshuafolkken/kit#2295). A long parent session's whole-session average lags its current context by
-// dozens of requests — measured at 85 requests (~4 hours) behind on the 2026-09-21 parent — so it
-// keeps supervising an already-oversized context long after a cut was due. Ten requests is enough to
-// smooth a single outlier without reaching back into the cheap early context; it sits beside the
-// threshold so the window and the limit are read from one place and cannot drift.
-const RECENT_REQUEST_WINDOW = 10
-
-export { CONTEXT_CUT_THRESHOLD, RECENT_REQUEST_WINDOW }
+export { CONTEXT_CUT_THRESHOLD }

package/scripts/cost-runtime/cost-verdict.ts

@@ -3,42 +3,31 @@
 // of a session will cost, and takes only the figures its verdict needs — an over measurement — never
 // a whole report. The `--cap` counterfactual it once sat beside was retired in #2016 as readerless.
 
-import { RECENT_REQUEST_WINDOW } from './context-cut-threshold'
-
 const FAILURE_EXIT_CODE = 1
 const OVER_VERDICT = 'over'
 const UNDER_VERDICT = 'under'
 
-// What `--over` reads of a session: the billed input each request paid, oldest first. The whole
-// per-request sequence is carried rather than a single sum because the hand-off prices the recent
-// tail alone (joshuafolkken/kit#2295) — a long session's whole-session average lags its current
-// context by dozens of requests, so a sum could not answer what the recent window actually cost.
+// What `--over` reads of a session: the billed input each request paid, oldest first. The sequence
+// is carried rather than a single sum because the hand-off prices the newest request alone
+// (joshuafolkken/kit#3224) — a sum could not answer what the session's current context costs.
 interface OverMeasurement {
 	billed_input_per_request: ReadonlyArray<number>
 }
 
-// The most recent requests the hand-off prices, oldest first — the whole sequence when it is shorter
-// than the window, so a session with fewer than `RECENT_REQUEST_WINDOW` requests is priced on what it
-// has rather than padded.
-function recent_requests(measurement: OverMeasurement): ReadonlyArray<number> {
-	return measurement.billed_input_per_request.slice(-RECENT_REQUEST_WINDOW)
-}
-
 // What a turn costs is decided by the accumulated preamble, not by what the turn does, so the
-// marginal cost of a session is the billed input its recent requests paid. Measured across one
+// marginal cost of a session is the billed input its newest request paid. Measured across one
 // `epicrun` that ran six children in one context: 222k per request during the first child, 645k
 // during the sixth — the same work at 2.9x the price (joshuafolkken/kit#968).
 //
-// The recent window rather than the whole session, because a long parent's whole-session average
-// lags its current context by dozens of requests (joshuafolkken/kit#2295); the recent average says
-// what the *next* turn will cost, which is the thing a hand-off decision turns on.
+// **The newest request, not an average.** joshuafolkken/kit#2295 replaced the whole-session average,
+// which lagged a long parent by dozens of requests, with the average of the last ten; that still
+// lagged. A session's billed input only grows between compactions (a unit writes its own transcript),
+// so an average smooths no outlier — it only trails the context it averages. On 2026-10-05 wake
+// session 03367124 crossed the threshold at request 65 and its ten-request average at request 70
+// (joshuafolkken/kit#3224). The threshold is a break-even on the *current* context
+// (`context-cut-payback.ts`), so the current context is what it is compared against.
 function per_request_cost(measurement: OverMeasurement): number {
-	const window = recent_requests(measurement)
-	if (window.length === 0) return 0
-
-	const total = window.reduce((sum, billed) => sum + billed, 0)
-
-	return Math.round(total / window.length)
+	return measurement.billed_input_per_request.at(-1) ?? 0
 }
 
 // The bare over/under decision, without a report: `run:status` reads this same verdict read-only
@@ -51,14 +40,12 @@ function classify(
 	return per_request_cost(measurement) > limit ? OVER_VERDICT : UNDER_VERDICT
 }
 
-// The stderr line names the window the average covers, so the reader can tell a recent-tail average
-// from a whole-session one (joshuafolkken/kit#2295): "the last W of T request(s)" reads W when the
-// session is longer than the window and the whole count when it is shorter.
+// The stderr line names which request was priced, so the reader can tell the newest request's cost
+// from an average over the session (joshuafolkken/kit#3224).
 function over_summary(measurement: OverMeasurement, limit: number): string {
 	const total = measurement.billed_input_per_request.length
-	const window = recent_requests(measurement).length
 
-	return `${String(per_request_cost(measurement))} billed input tokens per request over the last ${String(window)} of ${String(total)} request(s); limit ${String(limit)}`
+	return `${String(per_request_cost(measurement))} billed input tokens per request, on the newest of ${String(total)} request(s); limit ${String(limit)}`
 }
 
 // A verdict, not a table: the point of the flag is that the hand-off is decided by a number rather

package/scripts/followup/git-followup-stages.ts

@@ -1,3 +1,4 @@
+import { PrConflictError } from '#scripts/gh/git-pr-checks-eval'
 import { time_format } from '#scripts/time-runtime/time-format'
 
 // Where `pnpm josh followup` spends its own wall clock (joshuafolkken/kit#1349).
@@ -73,8 +74,15 @@ const STAGE = {
 	// blocker and on a red check, and those are the runs whose wait is longest — reporting nothing for
 	// them would leave the measurement blind to exactly the invocations worth measuring.
 	interrupted: 'interrupted',
+	// The interrupted lap when the wait failed on a merge conflict (joshuafolkken/kit#3221), so the
+	// stage block names the cause a resumed session used to look up with `gh pr view`.
+	conflict: 'conflict',
 } as const
 
+function stopped_lap(error: unknown): string {
+	return error instanceof PrConflictError ? STAGE.conflict : STAGE.interrupted
+}
+
 interface FollowupStage {
 	name: string
 	duration_ms: number
@@ -143,6 +151,7 @@ const git_followup_stages = {
 	total_ms,
 	format_stages,
 	print_stages,
+	stopped_lap,
 }
 
 export type { FollowupStage, StageLog }

package/scripts/followup/git-pr-followup.ts

@@ -437,7 +437,7 @@ async function run(input: FollowupInput): Promise<string | undefined> {
 	try {
 		return await run_stages(input, log)
 	} catch (error) {
-		lap(log, STAGE.interrupted)
+		lap(log, git_followup_stages.stopped_lap(error))
 
 		throw error
 	} finally {

package/scripts/gh/git-gh-issue.ts

@@ -26,8 +26,10 @@ const SUMMARY_FIELDS = 'number,title,labels,createdAt'
 // `SUMMARY_FIELDS` on purpose: a listing carries no `blockedBy`, so the field is answered from each
 // row's own dependencies endpoint, and asking for it on the shared list would put that request
 // behind the next-issues display too — where a refused one becomes a failure with no message at all,
-// since the listing swallows the error (joshuafolkken/kit#996, joshuafolkken/kit#1025).
-const PICKUP_FIELDS = `${SUMMARY_FIELDS},blockedBy`
+// since the listing swallows the error (joshuafolkken/kit#996, joshuafolkken/kit#1025). `body` costs
+// no request — the REST listing row already carries it — and is what the backlog offer reads for
+// the restructures each issue declares (joshuafolkken/kit#3221).
+const PICKUP_FIELDS = `${SUMMARY_FIELDS},blockedBy,body`
 
 // Every listing below goes through the one REST invocation in `git-gh-issue-list.ts`. It kept the
 // `json_fields` / `limit` contract it had as a `gh issue list` wrapper, so these callers changed
@@ -111,7 +113,7 @@ async function issue_list_by_label(label: string, limit: number): Promise<IssueL
 }
 
 // The same filter with the fields the `auto-ok` pickup needs (joshuafolkken/kit#906): it orders by
-// `createdAt` and re-checks `labels` client-side, so bodies would be fetched and thrown away. A
+// `createdAt`, re-checks `labels` client-side and reads each body for its declared restructures. A
 // label that does not exist in the repository is not an error — the listing comes back empty, which
 // is exactly "nobody has opted anything in".
 // `json_fields` overrides the pickup's list. Its only caller is the probe that runs *after* a failed

package/scripts/gh/git-gh-pr-read.ts

@@ -2,6 +2,7 @@ import { FULL_PAGE_QUERY, git_gh_api_path } from './git-gh-api-path'
 import { git_gh_exec } from './git-gh-exec'
 import { git_gh_helpers } from './git-gh-helpers'
 import { git_gh_pr_rest, type RestPull } from './git-gh-pr-rest'
+import { to_gh_state } from './git-gh-rest-state'
 
 // Reading pull requests through REST, in the answers `gh pr view` used to give.
 //
@@ -81,6 +82,8 @@ interface PullMergeState {
 	is_merged: boolean
 	merged_at: string | undefined
 	head_sha: string | undefined
+	// `josh ship` reads `DIRTY` here to re-merge a conflicting pull request (joshuafolkken/kit#3221).
+	merge_state_status: string | undefined
 }
 
 type PullNumberRead =
@@ -234,6 +237,7 @@ async function pr_get_merge_state(branch_name: string): Promise<PullMergeState |
 		is_merged: git_gh_pr_rest.is_merged(pull),
 		merged_at: pull.merged_at ?? undefined,
 		head_sha: pull.head?.sha,
+		merge_state_status: to_gh_state(pull.mergeable_state),
 	}
 }
 

package/scripts/gh/git-pr-checks-eval.ts

@@ -240,7 +240,14 @@ function is_auto_merge_blocked(snapshot: PrStateSnapshot): boolean {
 	)
 }
 
+// A failed wait whose cause is a merge conflict (joshuafolkken/kit#3221), so `followup` names its last
+// lap `conflict` rather than `interrupted` and the cause is read from the stage block, not looked up.
+class PrConflictError extends Error {
+	override name = 'PrConflictError'
+}
+
 export {
+	PrConflictError,
 	evaluate_pr_state,
 	is_auto_merge_blocked,
 	is_review_decision_decisive,
@@ -251,5 +258,6 @@ export {
 	REQUIRED_CHECKS,
 	CODERABBIT_CHECK_NAME,
 	is_required_check,
+	is_merge_conflict,
 }
 export type { PrEvaluation }

package/scripts/gh/git-pr-checks.ts

@@ -6,7 +6,9 @@ import {
 	describe_pr_failure,
 	evaluate_pr_state,
 	is_auto_merge_blocked,
+	is_merge_conflict,
 	is_review_decision_decisive,
+	PrConflictError,
 	type PrEvaluation,
 } from './git-pr-checks-eval'
 import { parse_pr_state_snapshot, read_string, type PrStateSnapshot } from './git-pr-checks-parse'
@@ -142,6 +144,12 @@ function advance_stable_count(previous: number, state: PrEvaluation): number {
 	return state === 'success' ? previous + 1 : 0
 }
 
+function failure_error(message: string, snapshot: PrStateSnapshot): Error {
+	return is_merge_conflict(snapshot.merge_state_status)
+		? new PrConflictError(message)
+		: new Error(message)
+}
+
 function classify_poll_result(input: {
 	snapshot: PrStateSnapshot
 	stable_count: number
@@ -150,7 +158,9 @@ function classify_poll_result(input: {
 }): { is_done: boolean; next_stable_count: number } {
 	const state = input.evaluator.evaluate(input.snapshot)
 
-	if (state === 'failure') throw new Error(input.evaluator.describe(input.snapshot))
+	if (state === 'failure') {
+		throw failure_error(input.evaluator.describe(input.snapshot), input.snapshot)
+	}
 
 	const next_stable_count = advance_stable_count(input.stable_count, state)
 

package/scripts/git/constants.ts

@@ -12,6 +12,11 @@ const PORCELAIN_FLAG = '--porcelain'
 // The untracked-files mode every porcelain status reading passes (`git-command.ts` carries why it is
 // passed and why it is `all`), shared so another module's own reading cannot drift from it.
 const UNTRACKED_FILES_FLAG = '--untracked-files=all'
+// The git binary a spawn runs in place of the platform's own (joshuafolkken/kit#3234). The spawn path
+// is absolute, so a `git` placed in front on `PATH` never stands in for it: the unit suite's network
+// guard shimmed `git` that way, and `josh ship`'s tests fetched and merged the default branch into the
+// checkout they ran in without the guard ever seeing the call. The guard names its shim here instead.
+const GIT_BINARY_KEY = 'JOSH_GIT_BINARY'
 
 function get_git_command(): string {
 	if (platform() === 'win32') {
@@ -22,6 +27,10 @@ function get_git_command(): string {
 }
 
 function get_git_command_for_spawn(): string {
+	const binary = process.env[GIT_BINARY_KEY]
+
+	if (binary !== undefined && binary !== '') return binary
+
 	if (platform() === 'win32') {
 		return String.raw`C:\Program Files\Git\cmd\git.exe`
 	}
@@ -35,6 +44,7 @@ const git_utilities = {
 }
 
 export {
+	GIT_BINARY_KEY,
 	REQUIRED_STATUS_LENGTH,
 	STAGED_STATUS_INDEX,
 	UNTRACKED_FILE_PREFIX,