@joshuafolkken/kit 1.1455.0 → 1.1514.0

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

@@ -17,11 +17,17 @@ import { run_board_setup, type SetupRead } from './run-board-setup'
 // statuses are laid over is the slow GitHub half, and so is what a child that left the open listing
 // answers when read closed.
 
-type ItemState = 'running' | 'merged' | 'parked' | 'done' | 'waiting' | 'human' | 'stopped'
+type ItemState =
+	'running' | 'merged' | 'parked' | 'done' | 'waiting' | 'human' | 'stopped' | 'withdrawn'
 
 interface ItemStatus {
 	state: ItemState
+	// When the child first launched in this run — a re-dispatch or a restart does not move it, so the
+	// row's time is the lane's whole time.
 	started_ms?: number | undefined
+	// The child's newest launch, present only where it launched again after `started_ms` — what the
+	// GitHub read is weighed against.
+	launched_ms?: number | undefined
 	ended_ms?: number | undefined
 	// The seat-free lane label (`lane <N>`) of a running child, when it holds one — the running test reads
 	// it; the board does not draw it.
@@ -61,22 +67,40 @@ const ENDING_STATES: Readonly<Partial<Record<string, ItemState>>> = {
 	[KIND.PARK]: 'parked',
 	[KIND.SPLIT]: 'done',
 	[KIND.STOP]: 'done',
+	[KIND.WITHDRAW]: 'withdrawn',
 }
 // A cut or a resume says the child is still running, on whatever phase it had reached.
 const CONTINUING_KINDS: ReadonlySet<string> = new Set([KIND.CUT, KIND.RESUME])
-// A person's restart starts the child over in a fresh session, so its track starts over too.
+// A person's restart, and a re-dispatch after an outage, start the child over in a fresh session, so
+// its track starts over too; its time does not (`launched`).
 const LAUNCH_KINDS: ReadonlySet<string> = new Set([KIND.CHILD_LAUNCH, KIND.RESTART])
+// What the GitHub read may still settle: a running child, and one whose lane has no child left in it —
+// a child that merged and then died is drawn merged, not stopped.
+const UNSETTLED_STATES: ReadonlySet<ItemState> = new Set(['running', 'stopped'])
+// A parked child waits on a person, who may close its issue after the park; only a closed read settles
+// it again, so one still open stays parked whatever its labels say (joshuafolkken/kit#3958).
+const PARKED_STATE: ItemState = 'parked'
 
 function moment(event: RunEvent): number {
 	return Date.parse(event.at)
 }
 
-function launched(event: RunEvent): ItemStatus {
+// The newest launch carried on, where the child launched more than once.
+function relaunch_of(status: ItemStatus | undefined): Pick<ItemStatus, 'launched_ms'> {
+	const launched_ms = status?.launched_ms
+
+	return launched_ms === undefined ? {} : { launched_ms }
+}
+
+// joshuafolkken/kit#3971: a launch keeps the start of the child's first one in this run.
+function launched(previous: ItemStatus | undefined, event: RunEvent): ItemStatus {
 	const at_ms = moment(event)
+	const started_ms = previous?.started_ms ?? at_ms
 
 	return {
 		state: 'running',
-		started_ms: at_ms,
+		started_ms,
+		...(started_ms !== at_ms && { launched_ms: at_ms }),
 		track: [run_board_phase.LAUNCHED_PHASE],
 		phase_ms: at_ms,
 	}
@@ -95,7 +119,12 @@ function moved(previous: ItemStatus, track: ReadonlyArray<Phase>, event: RunEven
 function settled_as(previous: ItemStatus | undefined, state: ItemState): ItemStatus {
 	const track = previous?.track
 
-	return { state, started_ms: previous?.started_ms, ...(track !== undefined && { track }) }
+	return {
+		state,
+		started_ms: previous?.started_ms,
+		...relaunch_of(previous),
+		...(track !== undefined && { track }),
+	}
 }
 
 function ended(previous: ItemStatus | undefined, state: ItemState, event: RunEvent): ItemStatus {
@@ -105,7 +134,7 @@ function ended(previous: ItemStatus | undefined, state: ItemState, event: RunEve
 function continued(previous: ItemStatus | undefined): ItemStatus {
 	const { started_ms, track, phase_ms } = previous ?? {}
 
-	return { state: 'running', started_ms, track, phase_ms }
+	return { state: 'running', started_ms, ...relaunch_of(previous), track, phase_ms }
 }
 
 // A stage line carrying its attempt redraws the track of any child launched on this stream — a settled
@@ -140,7 +169,7 @@ function advanced(previous: ItemStatus | undefined, event: RunEvent): ItemStatus
 
 // One event folded into the status of the child it names; an event the board does not track keeps it.
 function next_status(previous: ItemStatus | undefined, event: RunEvent): ItemStatus | undefined {
-	if (LAUNCH_KINDS.has(event.kind)) return launched(event)
+	if (LAUNCH_KINDS.has(event.kind)) return launched(previous, event)
 
 	const ending = ENDING_STATES[event.kind]
 
@@ -162,8 +191,9 @@ function fold_events(events: ReadonlyArray<RunEvent>): Map<number, ItemStatus> {
 	return statuses
 }
 
-// A lane is this run's only when its issue is on the run's stream or in the run's plan, so a lane left
-// over from an earlier day is not drawn as this run's child.
+// A lane is this run's only when its issue is on the run's stream or in `in_run`, so a lane left over
+// from an earlier day is not drawn as this run's child. `in_run` leaves out a planned issue whose lane
+// an earlier run dispatched (`run-board-github.ts`).
 function is_running_lane(
 	issue: number,
 	status: ItemStatus | undefined,
@@ -175,13 +205,25 @@ function is_running_lane(
 	return in_run.has(issue) && !run_board_setup.is_lane_pending(events, issue)
 }
 
+// A lane no child is working in is stopped whatever the stream last said: a child that died writes no
+// ending, so its row would otherwise run — and its phase time grow — for as long as the lane stays.
+function lane_status(status: ItemStatus | undefined, lane: string, is_idle: boolean): ItemStatus {
+	const held = { lane: `lane ${lane}` }
+
+	return is_idle
+		? { ...settled_as(status, 'stopped'), ...held }
+		: { state: 'running', ...status, ...held }
+}
+
 // Every child the run has touched, with the lane each running child holds. A lane the stream never saw
 // launched — a run restored after the stream rolled — still reads as running while its issue is in the
-// run's plan (`in_run`); one the run is still setting up for stays waiting until its launch.
+// run's plan (`in_run`); one the run is still setting up for stays waiting until its launch. A lane in
+// `idle` has no child working in it (`lane-spent.ts`).
 function statuses_of(
 	events: ReadonlyArray<RunEvent>,
 	lanes: ReadonlyArray<string>,
 	in_run: ReadonlySet<number>,
+	idle: ReadonlyArray<string> = [],
 ): ReadonlyMap<number, ItemStatus> {
 	const statuses = fold_events(events)
 
@@ -190,7 +232,7 @@ function statuses_of(
 		const status = statuses.get(issue)
 
 		if (is_running_lane(issue, status, events, in_run)) {
-			statuses.set(issue, { state: 'running', ...status, lane: `lane ${lane}` })
+			statuses.set(issue, lane_status(status, lane, idle.includes(lane)))
 		}
 	}
 
@@ -212,9 +254,14 @@ function is_listed_closed(issue: number, read: OpenRead): boolean {
 	return read.open_numbers !== undefined && !read.open_numbers.has(issue)
 }
 
-// The listing was read after the child launched, so what it says about the child is this run's.
+// When the child last launched — what a GitHub read is weighed against.
+function launch_ms(status: ItemStatus): number | undefined {
+	return status.launched_ms ?? status.started_ms
+}
+
+// The listing was read after the child last launched, so what it says about the child is current.
 function is_read_after_launch(status: ItemStatus, read: OpenRead): boolean {
-	return read.read_ms !== undefined && (status.started_ms ?? 0) <= read.read_ms
+	return read.read_ms !== undefined && (launch_ms(status) ?? 0) <= read.read_ms
 }
 
 // A child launched before the listing was read and missing from it has closed since.
@@ -242,26 +289,30 @@ function labelled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus
 
 // A close dated before the launch is an earlier life of the issue, not how this run's child ended.
 function is_closed_before_launch(status: ItemStatus, closed: ClosedIssue): boolean {
-	if (closed.closed_ms === undefined || status.started_ms === undefined) return false
+	const launch = launch_ms(status)
+
+	if (launch === undefined || closed.closed_ms === undefined) return false
+
+	return closed.closed_ms < launch
+}
+
+function closed_state(closed: ClosedIssue): ItemState {
+	if (closed.is_merged) return 'merged'
 
-	return closed.closed_ms < status.started_ms
+	return closed.is_not_planned ? 'withdrawn' : 'done'
 }
 
-// A running child read closed ends when GitHub says it closed, merged or not.
+// A child read closed ends when GitHub says it closed — merged, withdrawn as not planned, or done.
 function closed_status(
 	status: ItemStatus,
 	closed: ClosedIssue | undefined,
 ): ItemStatus | undefined {
 	if (closed === undefined || is_closed_before_launch(status, closed)) return undefined
 
-	const state = closed.is_merged ? 'merged' : 'done'
-
-	return { ...settled_as(status, state), ended_ms: closed.closed_ms }
+	return { ...settled_as(status, closed_state(closed)), ended_ms: closed.closed_ms }
 }
 
-function settled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
-	if (status.state !== 'running') return status
-
+function unsettled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
 	const from_closed = closed_status(status, read.closed.get(issue))
 
 	if (from_closed !== undefined) return from_closed
@@ -271,11 +322,26 @@ function settled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus
 	return labelled(issue, status, read)
 }
 
+// The closed read is kept for the run, so a parked child a person reopened since is told apart by the
+// listing holding it again.
+function parked_settled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
+	if (read.open_numbers?.has(issue) === true) return status
+
+	return closed_status(status, read.closed.get(issue)) ?? status
+}
+
+function settled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
+	if (status.state === PARKED_STATE) return parked_settled(issue, status, read)
+
+	return UNSETTLED_STATES.has(status.state) ? unsettled(issue, status, read) : status
+}
+
 // **The stream stays the source of truth; the listing only unsticks it.** A child whose merge never
 // reached the stream would read as running forever, so a running child the plan's open listing no
 // longer holds is drawn finished instead — merged and timed once GitHub was read for it, finished
 // without a time while that read has not answered. One the listing still holds is drawn as its labels
-// say, so a child that stopped with no parent to record it does not read as running.
+// say, so a child that stopped with no parent to record it does not read as running. A parked child is
+// settled again only by a closed read.
 function settle_closed(
 	statuses: ReadonlyMap<number, ItemStatus>,
 	read: OpenRead,

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

@@ -17,8 +17,13 @@ type ThanksState = Pick<BoardState, 'thanks' | 'thanks_fetch' | 'thanks_attempte
 function launch_thanks(state: BoardState, ports: BoardPorts, now_ms: number): BoardState {
 	const { read_thanks } = ports
 
-	if (read_thanks === undefined || state.thanks_fetch !== undefined) return state
-	if (!is_due(state.thanks_attempted_ms, TTL_MS, now_ms)) return state
+	if (
+		read_thanks === undefined ||
+		state.thanks_fetch !== undefined ||
+		!is_due(state.thanks_attempted_ms, TTL_MS, now_ms)
+	) {
+		return state
+	}
 
 	const thanks_fetch: Fetch<Thanks> = run_board_fetch.launch(read_thanks, state.thanks)
 

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

@@ -1,7 +1,9 @@
+import { lane_await } from '#scripts/lane/lane-await'
 import { run_progress } from '#scripts/run/progress/run-progress'
 import type { ClosedIssue } from './run-board-closed'
 import { run_board_github } from './run-board-github'
 import { run_board_header, type BoardHeader } from './run-board-header'
+import { run_board_idle } from './run-board-idle'
 import { run_board_labels } from './run-board-labels'
 import { run_board_layout, type BoardLayout, type BoardPlan } from './run-board-layout'
 import { run_board_link } from './run-board-link'
@@ -34,10 +36,30 @@ const { FRESH_STATE, is_due } = run_board_state
 const { PLAN_RETRY_MS, gather_github, statuses_for } = run_board_github
 const { gather_thanks } = run_board_thanks
 
-async function reread(state: BoardState, ports: BoardPorts, now_ms: number): Promise<BoardState> {
+async function read_at(state: BoardState, ports: BoardPorts, now_ms: number): Promise<BoardState> {
+	const local = await ports.read_local()
+	const idle_since = run_board_idle.since_of(state.idle_since, local?.idle_lanes ?? [], now_ms)
+
+	return { ...state, local, read_ms: now_ms, idle_since }
+}
+
+// A single frame has no earlier read to confirm an idle lane against (`run-board-idle.ts`).
+function is_unconfirmed(before: BoardState, read: BoardState, pace: Pace): boolean {
+	return pace === 'settled' && before.read_ms === undefined && read.idle_since.size > 0
+}
+
+async function reread(state: BoardState, ports: BoardPorts, pace: Pace): Promise<BoardState> {
+	const now_ms = ports.now()
+
 	if (!is_due(state.read_ms, LOCAL_READ_MS, now_ms)) return state
 
-	return { ...state, local: await ports.read_local(), read_ms: now_ms }
+	const read = await read_at(state, ports, now_ms)
+
+	if (!is_unconfirmed(state, read, pace)) return read
+
+	await ports.sleep(lane_await.RECONFIRM_MS)
+
+	return await read_at(read, ports, ports.now())
 }
 
 // Each lane's usage, read on the machine's second; a reading that failed draws no column.
@@ -60,8 +82,10 @@ async function resample(state: BoardState, ports: BoardPorts, now_ms: number): P
 	const at_ms = ports.now()
 	const machine = { sample: await ports.read_machine(), at_ms }
 	const gauges = run_board_machine.gauges_of(state.machine, machine)
+	const budget_waits = ports.read_waits?.() ?? []
+	const usages = await read_usages(state, ports)
 
-	return { ...state, ...(await read_usages(state, ports)), machine, gauges, sampled_ms: now_ms }
+	return { ...state, ...usages, machine, gauges, budget_waits, sampled_ms: now_ms }
 }
 
 // The state of the run on screen; a different run starts its plan state from nothing, so no row, count
@@ -69,9 +93,9 @@ async function resample(state: BoardState, ports: BoardPorts, now_ms: number): P
 function state_for(state: BoardState, local: LocalRead): BoardState {
 	if (state.run_started_ms === local.started_ms) return state
 
-	const { local: kept, read_ms } = state
+	const { local: kept, read_ms, idle_since } = state
 
-	return { ...FRESH_STATE, local: kept, read_ms, run_started_ms: local.started_ms }
+	return { ...FRESH_STATE, local: kept, read_ms, idle_since, run_started_ms: local.started_ms }
 }
 
 // The plan with a closed child's title and labels under the listing's own.
@@ -108,12 +132,13 @@ function planned_layout(state: BoardState, plan: BoardPlan, local: LocalRead): B
 		closed,
 		labels: plan.labels,
 	}
-	const statuses = run_board_status.settle_closed(statuses_for(plan, local), read)
+	const statuses = run_board_status.settle_closed(statuses_for(state, plan, local), read)
 	const reason_of = run_board_reason.reader({
 		plan,
 		statuses,
 		events: local.events,
 		free_lanes: local.free_lanes,
+		occupied_lanes: local.occupied_lanes,
 		is_stopped: activity_here(local).is_stopped,
 	})
 
@@ -125,8 +150,10 @@ function planned_layout(state: BoardState, plan: BoardPlan, local: LocalRead): B
 function layout_for(state: BoardState, local: LocalRead): BoardLayout {
 	if (state.plan !== undefined) return planned_layout(state, state.plan, local)
 
+	const stopped = run_board_idle.stopped_of(state.idle_since, state.read_ms)
+
 	return run_board_layout.local_layout_of(
-		run_board_status.statuses_of(local.events, local.lanes, new Set()),
+		run_board_status.statuses_of(local.events, local.lanes, new Set(), stopped),
 	)
 }
 
@@ -168,6 +195,7 @@ function header_of(
 		is_plan_loading: state.plan_fetch !== undefined,
 		machine: state.gauges,
 		usages: state.usages,
+		budget_waits: state.budget_waits,
 		form: redraw.ports.form,
 		repo: state.plan?.context.repo,
 		spinner: redraw.ports.is_tty ? SPOT : undefined,
@@ -220,8 +248,9 @@ async function tick(
 	ports: BoardPorts,
 	pace: Pace = 'settled',
 ): Promise<BoardState> {
+	const read = await reread(state, ports, pace)
+	// Taken after the read, which a single frame may have waited on to confirm an idle lane.
 	const now_ms = ports.now()
-	const read = await reread(state, ports, now_ms)
 	const { local } = read
 
 	if (local === undefined) {

package/scripts/run/carry/run-carry-args.ts

@@ -269,9 +269,7 @@ function to_named_request(values: ParsedValues, owner: CarryOwner): Request | un
 }
 
 function to_request(values: ParsedValues): Request | undefined {
-	if (group_count(values) > ONE_GROUP) return undefined
-
-	if (!is_summary_paired(values)) return undefined
+	if (group_count(values) > ONE_GROUP || !is_summary_paired(values)) return undefined
 
 	const owner = to_owner(values.owner)
 

package/scripts/run/carry/run-carry-conversation.ts

@@ -76,8 +76,13 @@ function is_same_conversation(carry: RunCarry, owner: CarryOwner): boolean {
 // a new one, so the record goes on naming a live process once the conversation falls quiet. A record a
 // cut handed off is the successor's to take, never the cutting conversation's to take back.
 function reclaim_owner(carry: RunCarry, owner: CarryOwner): RunCarry {
-	if (carry.is_handed_off === true || !is_same_conversation(carry, owner)) return carry
-	if (owner.pid === carry.owner_pid) return carry
+	if (
+		carry.is_handed_off === true ||
+		!is_same_conversation(carry, owner) ||
+		owner.pid === carry.owner_pid
+	) {
+		return carry
+	}
 
 	return { ...carry, owner_pid: owner.pid, owner_start: owner.start }
 }

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

@@ -3,7 +3,6 @@ import { fileURLToPath } from 'node:url'
 import { agent_session_role } from '#scripts/agent/agent-session-role'
 import { cost_cli } from '#scripts/cost-runtime/cost-cli'
 import { cost_verdict } from '#scripts/cost-runtime/cost-verdict'
-import { git_command } from '#scripts/git/git-command'
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { session_cite } from '#scripts/issue/session-cite'
 import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
@@ -12,9 +11,11 @@ import { openai_lane_supervisor } from '#scripts/lane/openai-lane-supervisor'
 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_cli_fault } from '#scripts/run/run-cli-fault'
-import { run_cut, type CutState, type RunCut } from './run-cut'
+import { run_cut, type RunCut } from './run-cut'
 import { run_cut_args, type Request } from './run-cut-args'
+import { run_cut_decline } from './run-cut-decline'
 import { run_cut_handoff } from './run-cut-handoff'
+import { run_cut_ready } from './run-cut-ready'
 import { run_cut_report } from './run-cut-report'
 
 // `josh run:cut` — the record that lets a lane child end its process before the gate and a fresh one
@@ -57,8 +58,10 @@ const {
 	report_busy,
 	report_fault,
 	report_handed_off,
+	report_held_cut,
 	report_incomplete,
 	report_over,
+	report_relaunched_cut,
 	report_reviewer,
 	report_stale,
 	report_under_threshold,
@@ -122,14 +125,11 @@ function relaunch(target: string, lane: LaneInfo, phase: string): number {
 
 	if (notes.length > 0) console.error(notes.join('\n'))
 
-	return report(CUT_VERDICT, SUCCESS_EXIT_CODE)
+	return report_relaunched_cut()
 }
 
-async function is_lane_branch(state: CutState): Promise<boolean> {
-	const default_branch = await git_command.get_default_branch()
-
-	return state.branch !== default_branch && state.is_dirty
-}
+const { is_lane_branch } = run_cut_ready
+const { declined } = run_cut_decline
 
 // An expired record is a fresh process that never started; it is cleared so the next cut can begin
 // rather than being wedged behind a stale file the exclusive create would refuse forever.
@@ -200,20 +200,10 @@ async function finish_cut(target: string, lane: LaneInfo, request: CutRequest):
 	if (refused !== undefined) return refused
 
 	return lane_relaunch.is_openai_lane(lane)
-		? report(CUT_VERDICT, SUCCESS_EXIT_CODE)
+		? report_relaunched_cut()
 		: relaunch(target, lane, request.phase)
 }
 
-// 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)
-}
-
 // **A `fullrun` held in its own checkout takes the implementation cut too**, so a run a person started
 // has a bound on its context mid-implementation. The hold naming this issue is what marks the run — a
 // tree nobody holds for it, and the pre-gate phase (which a held run's gate reaches in the same
@@ -228,8 +218,11 @@ async function cut_outside_lane(
 
 	const state = await run_cut.current_state()
 
-	if (state.held_issue !== request.issue) return report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE)
-	if (!(await is_lane_branch(state))) return refuse_unready(state)
+	if (state.held_issue !== request.issue) {
+		return await declined(request, state, report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE))
+	}
+
+	if (!(await is_lane_branch(state))) return await declined(request, state, refuse_unready(state))
 
 	clear_expired(target)
 
@@ -250,7 +243,10 @@ async function cut(
 
 	const state = await run_cut.current_state()
 
-	if (!(await is_lane_branch(state))) return refuse_unready(state)
+	if (!(await is_lane_branch(state))) {
+		return await declined({ issue, phase }, state, refuse_unready(state))
+	}
+
 	if (skips_pre_gate_cut(phase)) return report_under_threshold()
 
 	clear_expired(target)

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

@@ -0,0 +1,72 @@
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { json_value } from '#scripts/lib/json-value'
+import { z } from 'zod'
+import { run_cut, type CutState } from './run-cut'
+
+// The implementation cut a run asked for and was refused — `not-a-lane` or `unready` — recorded so the
+// implementation-cut guard stops asking for it (joshuafolkken/kit#3881).
+//
+// **The reissue window alone re-asked every 90 seconds.** A run whose `run:cut --impl` can only answer
+// `unready` was refused edit after edit, each refusal a round trip that cut nothing. Neither answer
+// changes while the same hold stands over the tree, so the record names the issue and the hold it
+// answered, and the guard stays silent while both still match; a fresh hold — a new run — asks again.
+
+const DECLINE_PREFIX = 'josh-run-cut-decline-'
+
+const decline_schema = z.object({ issue: z.string(), hold_taken_at: z.string().optional() })
+
+type CutDecline = z.infer<typeof decline_schema>
+
+function decline_path(git_directory: string): string {
+	return stamp_file.stamp_path(DECLINE_PREFIX, git_directory)
+}
+
+function record(git_directory: string, decline: CutDecline): void {
+	stamp_file.replace_stamp(decline_path(git_directory), decline)
+}
+
+function read(git_directory: string): CutDecline | undefined {
+	const raw = stamp_file.read_stamp_text(decline_path(git_directory))
+
+	return raw === undefined ? undefined : json_value.parse_with(raw, decline_schema)
+}
+
+function matches(recorded: CutDecline | undefined, current: CutDecline): boolean {
+	return recorded?.issue === current.issue && recorded.hold_taken_at === current.hold_taken_at
+}
+
+// The same read taken synchronously, for the `PreToolUse` guard. A checkout git cannot describe has no
+// record, so the guard keeps speaking there.
+function is_declined_sync(
+	issue: string,
+	directory: string | undefined = run_cut.worktree_git_directory_sync(),
+): boolean {
+	if (directory === undefined) return false
+
+	const hold_taken_at = run_cut.hold_of(directory)?.taken_at
+
+	return matches(read(directory), { issue, hold_taken_at })
+}
+
+// **An implementation cut `run:cut` refuses is recorded for the guard that asked for it**, then its
+// exit code is passed back unchanged. The pre-gate phase has its own guard and records nothing.
+async function declined(
+	request: { issue: string; phase: string },
+	state: CutState,
+	code: number,
+): Promise<number> {
+	if (request.phase !== run_cut.IMPLEMENTATION_PHASE) return code
+
+	const directory = await run_cut.worktree_directory()
+
+	if (directory !== undefined) {
+		record(directory, { issue: request.issue, hold_taken_at: state.hold_taken_at })
+	}
+
+	return code
+}
+
+const run_cut_decline = { decline_path, declined, is_declined_sync, read, record }
+
+export type { CutDecline }
+export { run_cut_decline }

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

@@ -0,0 +1,74 @@
+import { UNTRACKED_FILES_FLAG } from '#scripts/git/constants'
+import { git_command } from '#scripts/git/git-command'
+import { git_diff_reads } from '#scripts/git/git-diff-reads'
+import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
+import type { CutState } from './run-cut'
+
+// Whether a cut can be taken on this tree — the one predicate `run:cut` refuses `unready` on and the
+// implementation-cut guard asks before it refuses an edit (joshuafolkken/kit#3881).
+//
+// **The guard and the command must not disagree.** The guard once fired on every over-threshold edit
+// of a run held on the default branch, where `run:cut --impl` can only ever answer `unready`; each
+// refusal cost a round trip that cut nothing. Reading the same predicate keeps the guard silent
+// exactly where the command would refuse.
+
+interface CutTree {
+	branch: string
+	default_branch: string
+	is_dirty: boolean
+}
+
+// A cut needs an uncommitted implementation on a branch other than the default one: the resume
+// verifies both, so a tree missing either has nothing a fresh process could resume.
+function is_ready(tree: CutTree): boolean {
+	return tree.branch !== tree.default_branch && tree.is_dirty
+}
+
+// The same predicate over the state `run:cut` reads, against the default branch asked asynchronously.
+async function is_lane_branch(state: CutState): Promise<boolean> {
+	const default_branch = await git_command.get_default_branch()
+
+	return is_ready({ branch: state.branch, default_branch, is_dirty: state.is_dirty })
+}
+
+// `--branch` puts the branch on a `# branch.head` header line, so one call answers both halves; every
+// other line is a change.
+const STATUS_ARGUMENTS = ['status', '--porcelain=v2', '--branch', UNTRACKED_FILES_FLAG] as const
+const HEADER_PREFIX = '#'
+const BRANCH_HEADER = '# branch.head '
+
+function tree_of(status: string, default_branch: string): CutTree | undefined {
+	const lines = status.split('\n').filter((line) => line !== '')
+	const header = lines.find((line) => line.startsWith(BRANCH_HEADER))
+
+	if (header === undefined) return undefined
+
+	const branch = header.slice(BRANCH_HEADER.length)
+	const is_dirty = lines.some((line) => !line.startsWith(HEADER_PREFIX))
+
+	return { branch, default_branch, is_dirty }
+}
+
+// The tree read synchronously, for the `PreToolUse` guard — `undefined` where git cannot answer.
+function read_tree_sync(): CutTree | undefined {
+	const status = git_spawn_sync.read(STATUS_ARGUMENTS)
+
+	if (status === undefined) return undefined
+
+	const reference = git_spawn_sync.read(git_diff_reads.DEFAULT_BRANCH_ARGUMENTS)
+
+	return tree_of(status, git_diff_reads.default_branch_of(reference))
+}
+
+// **A tree git cannot describe reads as ready**, so the guard keeps speaking rather than going quiet
+// on a read fault — the same direction `run_cut.carried_cut_sync` takes for an unreadable record.
+function is_ready_sync(read: () => CutTree | undefined = read_tree_sync): boolean {
+	const tree = read()
+
+	return tree === undefined || is_ready(tree)
+}
+
+const run_cut_ready = { is_lane_branch, is_ready, is_ready_sync, tree_of }
+
+export type { CutTree }
+export { run_cut_ready }