@joshuafolkken/kit 1.1784.0 → 1.2116.0

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

@@ -1,4 +1,11 @@
-import type { FrameParts, PlanLine, PlanSection, TerminalSize, YieldStage } from './run-board-fit'
+import {
+	run_board_fit,
+	type FrameParts,
+	type PlanLine,
+	type PlanSection,
+	type TerminalSize,
+	type YieldStage,
+} from './run-board-fit'
 import { run_board_fold, type FrameBounds } from './run-board-fold'
 import { run_board_fresh } from './run-board-fresh'
 import { run_board_header, type BoardHeader } from './run-board-header'
@@ -14,6 +21,7 @@ import { run_board_notes, type BoardNote } from './run-board-notes'
 import { run_board_priority } from './run-board-priority'
 import { run_board_render_condition } from './run-board-render-condition'
 import { run_board_render_foot } from './run-board-render-foot'
+import { run_board_render_found } from './run-board-render-found'
 import { run_board_render_icon } from './run-board-render-icon'
 import { run_board_render_lanes, type LaneCells } from './run-board-render-lanes'
 import { run_board_render_lead } from './run-board-render-lead'
@@ -38,14 +46,18 @@ const { time_of, time_width } = run_board_render_time
 const { state_icon } = run_board_render_icon
 const { NOTE_LIMIT } = run_board_render_notes
 const { lane_cells_of, lanes_section, number_text } = run_board_render_lanes
-const { LANE_INDENT, lead_of: lane_lead_of, running_fresh } = run_board_render_lead
-const { ELLIPSIS, TITLE_LIMIT, WHOLE, fitted, reason_text, row_overrun, title_of } =
+const { indent_of, lead_of: lane_lead_of, running_fresh } = run_board_render_lead
+const { ELLIPSIS, TITLE_LIMIT, WHOLE, columns_cut, fitted, reason_text, row_overrun, title_of } =
 	run_board_render_title
+const { width_of } = run_board_fit
 const { padded } = run_board_fresh
 const { condition_of, waits_of } = run_board_render_condition
 const { legend_lines, resume_lines, thanks_part } = run_board_render_foot
 const { ROW_INDENT, done_section, keyed, plan_section } = run_board_render_section
 const GAP = '  '
+// The fewest columns a done row's end is cut to before its title gives them up: its minutes and a cut
+// start of what follows.
+const FOUND_FLOOR = 8
 const FILED_LEAD = `${run_board_labels.FILED_RUN_MARK} `
 const BRANCH = `${ROW_INDENT}   ├ `
 const LAST_BRANCH = `${ROW_INDENT}   └ `
@@ -87,6 +99,8 @@ interface RowFrame {
 	// The lanes section draws each row's lead — progress, phase and times — before its cells
 	// (`run-board-render-lead.ts`).
 	is_lane_row?: boolean | undefined
+	// A done row whose title gives up the columns draws what was filed during it whole.
+	is_end_kept?: boolean | undefined
 }
 
 // A row drawn before the plan is read has no title yet, and says so.
@@ -159,40 +173,90 @@ function head_text(row: BoardRow, frame: RowFrame): string {
 	return joined([lead, time])
 }
 
+function same(reference: string): string {
+	return reference
+}
+
+// A row up to what was filed during it: its head, then its tail where it draws one.
+function tailed_head(row: BoardRow, frame: RowFrame): string {
+	return joined([head_text(row, frame), ...run_board_render_tail.tail_of(row, frame.header)])
+}
+
+// The columns the pane leaves after `head` and its gap, where the frame is kept within one and the
+// row's end is not kept whole.
+function room_after(indent: string, head: string, frame: RowFrame): number | undefined {
+	if (frame.columns === undefined || frame.is_end_kept === true) return undefined
+
+	return frame.columns - width_of(`${indent}${head}${GAP}`)
+}
+
+// What was filed during a done row, in `room`: a pane too narrow for it cuts its end on an ellipsis
+// rather than the title, so the time column stays where every other row has it
+// (joshuafolkken/kit#4922). The cut text's references are left unlinked, so no hyperlink escape is cut
+// in two.
+function found_fitted(room: number | undefined, row: BoardRow, header: BoardHeader): string {
+	const found = run_board_render_found.found_text(row, header)
+
+	if (found === '' || room === undefined || width_of(found) <= room) return found
+
+	const unlinked = run_board_render_found.found_text(row, { ...header, link: same })
+
+	return columns_cut(unlinked, Math.max(1, room))
+}
+
 // Every row carries its state's icon, or the icon of what it waits on; a running row ends on its tail
-// (`run-board-render-tail.ts`), and a row with nothing after its padded columns ends where its text does.
-function row_text(row: BoardRow, frame: RowFrame): string {
+// (`run-board-render-tail.ts`), a done row on what was filed during it (`run-board-render-found.ts`),
+// and a row with nothing after its padded columns ends where its text does.
+function row_text(indent: string, row: BoardRow, frame: RowFrame): string {
 	const { header } = frame
-	const tail = run_board_render_tail.tail_of(row, header)
+	const head = tailed_head(row, frame)
+	const found = found_fitted(room_after(indent, head, frame), row, header)
 	const notes = [waits_of(row, header, frame.is_conditioned), reason_text(row, frame.reason_cut)]
 
-	return joined([head_text(row, frame), ...tail, ...notes]).trimEnd()
+	return `${indent}${joined([head, found, ...notes]).trimEnd()}`
 }
 
-// A row drawn whole or cut, after its indent.
-function row_draw(indent: string, row: BoardRow, frame: RowFrame): (cut: RowCut) => string {
-	return (cut) => `${indent}${row_text(row, { ...frame, ...cut })}`
+// A pane narrower than a done row's head leaves its end too few columns to say anything in, so there
+// the title gives up the columns instead, as before joshuafolkken/kit#4922.
+function is_found_squeezed(indent: string, row: BoardRow, frame: RowFrame): boolean {
+	if (run_board_render_found.found_text(row, frame.header) === '') return false
+
+	return (room_after(indent, tailed_head(row, frame), frame) ?? FOUND_FLOOR) < FOUND_FLOOR
+}
+
+// A row drawn whole or cut, after its indent; a row that keeps its line keeps its end whole too, its
+// title giving up the columns.
+function row_draw(
+	indent: string,
+	row: BoardRow,
+	frame: RowFrame,
+	fit: RowFit,
+): (cut: RowCut) => string {
+	const is_end_kept = fit.is_line_kept === true
+
+	return (cut) => row_text(indent, row, { ...frame, ...cut, is_end_kept })
 }
 
 // A row drawn with lane cells keeps its head on one line, its title giving up their columns where the
 // pane is narrow. A row that draws a tail keeps its whole line, giving up the columns its section's
-// rows give up together (joshuafolkken/kit#4226).
+// rows give up together (joshuafolkken/kit#4226). A done row keeps its title's width and cuts the end of
+// what was filed during it instead (`found_fitted`), unless that end is squeezed out.
 function row_fit(indent: string, row: BoardRow, frame: RowFrame): RowFit {
-	const is_line_kept = run_board_render_tail.tail_of(row, frame.header).length > 0
+	const is_tailed = run_board_render_tail.tail_of(row, frame.header).length > 0
 
 	return {
-		is_line_kept,
+		is_line_kept: is_tailed || is_found_squeezed(indent, row, frame),
 		lead: frame.filed.has(row.number) ? FILED_LEAD.length : 0,
 		head: (cut) => `${indent}${head_text(row, { ...frame, ...cut })}`,
 		is_head_kept: frame.cells !== undefined,
-		shared: is_line_kept ? frame.shared : undefined,
+		shared: is_tailed ? frame.shared : undefined,
 	}
 }
 
 // A plan line that draws one issue row, and one that draws none — a blank, a rule, an epic's own line.
 function row_line(indent: string, row: BoardRow, frame: RowFrame, stage?: YieldStage): PlanLine {
 	const fit = row_fit(indent, row, frame)
-	const text = fitted(row, frame.columns, row_draw(indent, row, frame), fit)
+	const text = fitted(row, frame.columns, row_draw(indent, row, frame, fit), fit)
 
 	return { text, row: run_board_row_yield.yield_of(row, stage) }
 }
@@ -201,10 +265,10 @@ function row_line(indent: string, row: BoardRow, frame: RowFrame, stage?: YieldS
 // their titles end in one column and the tails after them start in one.
 function shared_overrun(rows: ReadonlyArray<BoardRow>, frame: RowFrame): number {
 	const overruns = rows.map((row) => {
-		const fit = row_fit(LANE_INDENT, row, frame)
+		const fit = row_fit(indent_of(row), row, frame)
 
 		return fit.is_line_kept === true
-			? row_overrun(row, frame.columns, row_draw(LANE_INDENT, row, frame), fit)
+			? row_overrun(row, frame.columns, row_draw(indent_of(row), row, frame, fit), fit)
 			: 0
 	})
 
@@ -290,7 +354,7 @@ function active_sections(layout: BoardLayout, frame: RowFrame): Array<PlanSectio
 	const lane_frame = { ...frame, cells, is_lane_row: true }
 	const shared = shared_overrun(lead, lane_frame)
 	const lanes = lanes_section(
-		lead.map((row) => row_line(LANE_INDENT, row, { ...lane_frame, shared })),
+		lead.map((row) => row_line(indent_of(row), row, { ...lane_frame, shared })),
 		cells,
 	)
 

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

@@ -1,6 +1,4 @@
-import { stripVTControlCharacters } from 'node:util'
 import { MS_PER_SECOND } from '#scripts/lib/timeouts'
-import string_width from 'string-width'
 import { run_board_fit, type TerminalSize } from './run-board-fit'
 import { run_board_labels } from './run-board-labels'
 import type { BoardPorts } from './run-board-state'
@@ -38,7 +36,7 @@ type SpinPorts = Pick<BoardPorts, 'now' | 'sleep' | 'write'>
 // The spot of the placeholder at `index` in a line that starts `row` rows down the screen.
 function spot_at(line: string, index: number, row: number, columns: number): Spot {
 	const before = line.slice(0, index)
-	const width = string_width(stripVTControlCharacters(before))
+	const width = run_board_fit.width_of(before)
 	const style = (before.match(SGR) ?? []).join('')
 
 	return { row: row + Math.floor(width / columns), column: (width % columns) + 1, style }

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

@@ -88,6 +88,8 @@ interface RunActivity extends Partial<SetupRead> {
 const KIND = run_event_stream.EVENT_KIND
 const ENDING_STATES: Readonly<Partial<Record<string, ItemState>>> = {
 	[KIND.MERGE]: 'merged',
+	// A drive-closed measurement completes its issue as a merge does (`issue-merged.ts` → `is_measured`).
+	[KIND.MEASURED]: 'merged',
 	[KIND.PARK]: 'parked',
 	[KIND.SPLIT]: 'done',
 	[KIND.STOP]: 'done',

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

@@ -1,3 +1,4 @@
+import { lane_investigation_switch } from '#scripts/lane/lane-investigation-switch'
 import type { ClosedIssue } from './run-board-closed'
 import type { EarlierLanes } from './run-board-earlier'
 import type { FrameBounds } from './run-board-fold'
@@ -6,7 +7,7 @@ import { run_board_github } from './run-board-github'
 import { run_board_header, type BoardHeader } from './run-board-header'
 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'
+import { run_board_link, type Link } from './run-board-link'
 import { run_board_notes, type Titles } from './run-board-notes'
 import type { LocalRead } from './run-board-read'
 import { run_board_reason, type ReasonRead } from './run-board-reason'
@@ -93,15 +94,17 @@ function activity_here(local: LocalRead): RunActivity {
 
 type RoomRead = Pick<
 	ReasonRead,
-	'free_lanes' | 'occupied_count' | 'lane_limit' | 'is_memory_held' | 'gauges'
+	'free_lanes' | 'occupied_count' | 'lane_limit' | 'usage_reset_ms' | 'is_memory_held' | 'gauges'
 >
 
-// The room a waiting row is weighed against: the lanes under the limit, and the machine's memory.
+// The room a waiting row is weighed against: the lanes under the limit, the account's usage limit and
+// the machine's memory.
 function room_of(state: BoardState, local: LocalRead): RoomRead {
 	return {
 		free_lanes: local.free_lanes,
 		occupied_count: local.occupied_count,
 		lane_limit: local.lane_limit,
+		usage_reset_ms: local.usage_reset_ms,
 		is_memory_held: local.is_memory_held,
 		gauges: state.gauges,
 	}
@@ -131,7 +134,12 @@ function earlier_here(local: LocalRead): EarlierLanes {
 }
 
 // The plan laid under its statuses, each waiting row saying why it waits.
-function planned_layout(state: BoardState, plan: BoardPlan, local: LocalRead): BoardLayout {
+function planned_layout(
+	state: BoardState,
+	plan: BoardPlan,
+	local: LocalRead,
+	now_ms: number,
+): BoardLayout {
 	const statuses = planned_statuses(state, plan, local)
 	const reason_of = run_board_reason.reader({
 		plan,
@@ -140,6 +148,7 @@ function planned_layout(state: BoardState, plan: BoardPlan, local: LocalRead): B
 		...room_of(state, local),
 		carry: local.carry,
 		is_stopped: activity_here(local).is_stopped,
+		now_ms,
 	})
 
 	return run_board_layout.layout_of(
@@ -152,8 +161,8 @@ function planned_layout(state: BoardState, plan: BoardPlan, local: LocalRead): B
 
 // The statuses scoped to the run's plan, a running child GitHub read closed settled.
 // Before the plan is read, the run's own children alone, named and settled as the snapshot left them.
-function layout_for(state: BoardState, local: LocalRead): BoardLayout {
-	if (state.plan !== undefined) return planned_layout(state, state.plan, local)
+function layout_for(state: BoardState, local: LocalRead, now_ms: number): BoardLayout {
+	if (state.plan !== undefined) return planned_layout(state, state.plan, local, now_ms)
 
 	const read = open_read_of(state, undefined)
 	const statuses = run_board_status.settle_closed(statuses_for(state, local), read)
@@ -168,10 +177,18 @@ interface Redraw {
 	now_ms: number
 }
 
-// What the header reads off the local read.
+// What the header reads off the local read, and the investigation switch off this machine's
+// environment, `.env` loaded as for `run:merge`.
 type LocalHeader = Pick<
 	BoardHeader,
-	'started_ms' | 'ended_ms' | 'activity' | 'operations' | 'usual' | 'lane_limit'
+	| 'started_ms'
+	| 'ended_ms'
+	| 'activity'
+	| 'operations'
+	| 'usual'
+	| 'lane_limit'
+	| 'found'
+	| 'is_investigation_on'
 >
 
 function local_header(local: LocalRead): LocalHeader {
@@ -182,6 +199,18 @@ function local_header(local: LocalRead): LocalHeader {
 		operations: local.operations,
 		usual: local.usual,
 		lane_limit: local.lane_limit,
+		found: local.found,
+		is_investigation_on: lane_investigation_switch.is_on(),
+	}
+}
+
+// The issue references and pull request numbers linked into `repo`, plain before a plan is read.
+type Links = Pick<BoardHeader, 'link' | 'pull_link'>
+
+function links_of(repo: string | undefined, link: Link): Links {
+	return {
+		link: run_board_link.linker(repo, link),
+		pull_link: run_board_link.pull_linker(repo, link),
 	}
 }
 
@@ -207,7 +236,7 @@ function header_of(
 		form: redraw.ports.form,
 		repo: state.plan?.context.repo,
 		spinner: redraw.ports.is_tty ? SPOT : undefined,
-		link: run_board_link.linker(state.plan?.context.repo, redraw.ports.link),
+		...links_of(state.plan?.context.repo, redraw.ports.link),
 	}
 }
 
@@ -242,7 +271,7 @@ function draw(ports: BoardPorts, lines: ReadonlyArray<string>): void {
 // The first total the plan gives is the baseline every later arrival is counted against; the run's own
 // children before it are no total.
 function draw_run(state: BoardState, local: LocalRead, redraw: Redraw): BoardState {
-	const layout = layout_for(state, local)
+	const layout = layout_for(state, local, redraw.now_ms)
 	const first_total =
 		state.plan === undefined ? undefined : run_board_header.counts_of(layout).total
 	const settled = { ...state, baseline_total: state.baseline_total ?? first_total }

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

@@ -1,4 +1,5 @@
 import path from 'node:path'
+import { durable_state } from '#scripts/josh/durable-state'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { json_value } from '#scripts/lib/json-value'
 import { z } from 'zod'
@@ -17,7 +18,7 @@ import type { CarryRead } from './run-carry'
 // **One record, overwritten by the next `--end`**: the board keeps only the run before the next one, and
 // a run that begins replaces nothing here — its carry record is what the board reads while it runs.
 
-const ENDED_PREFIX = 'josh-run-ended-'
+const ENDED_PREFIX = durable_state.PREFIX.ENDED
 const TRANSCRIPT_SUFFIX = '.jsonl'
 
 const ended_run_schema = z.object({
@@ -32,7 +33,7 @@ type EndedRun = z.infer<typeof ended_run_schema>
 
 // Keyed on the common git directory, as the carry record is, so every lane reads the same one.
 function ended_path(git_directory: string): string {
-	return stamp_file.stamp_path(ENDED_PREFIX, git_directory)
+	return durable_state.path(ENDED_PREFIX, git_directory)
 }
 
 function session_of(transcript: string | undefined): string | undefined {

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

@@ -1,4 +1,5 @@
 import { git_command } from '#scripts/git/git-command'
+import { durable_state } from '#scripts/josh/durable-state'
 import { process_identity } from '#scripts/josh/process-identity'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { json_value } from '#scripts/lib/json-value'
@@ -35,7 +36,7 @@ import { run_carry_conversation } from './run-carry-conversation'
 // reaches, so only a cut the run itself took is carried without anyone deciding. Everything else is
 // an explicit carry-or-discard: `--resume` adopts the standing record, `--end` discards it.
 
-const CARRY_PREFIX = 'josh-run-carry-'
+const CARRY_PREFIX = durable_state.PREFIX.CARRY
 const REPOSITORY_DIRECTORY_INDEX = 1
 const NO_INCREMENT = 0
 
@@ -212,7 +213,7 @@ const run_carry_schema = z.object({
 })
 
 function carry_path(git_directory: string): string {
-	return stamp_file.stamp_path(CARRY_PREFIX, git_directory)
+	return durable_state.path(CARRY_PREFIX, git_directory)
 }
 
 // The common git directory: `.git` in the main work tree and the same `.git` from inside a lane, so

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

@@ -4,19 +4,22 @@ 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 { 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'
 import { lane_relaunch } from '#scripts/lane/lane-relaunch'
 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 RunCut } from './run-cut'
+import { split_resolution } from '#scripts/split/split-resolution'
+import { run_cut } from './run-cut'
 import { run_cut_args, type Request } from './run-cut-args'
 import { run_cut_decline } from './run-cut-decline'
+import { run_cut_digest } from './run-cut-digest'
 import { run_cut_handoff } from './run-cut-handoff'
 import { run_cut_ready } from './run-cut-ready'
 import { run_cut_report } from './run-cut-report'
+import { run_cut_resume } from './run-cut-resume'
+import { run_cut_review } from './run-cut-review'
 
 // `josh run:cut` — the record that lets a lane child end its process before the gate and a fresh one
 // resume from it. `run:cut <N>` writes the record and relaunches a fresh
@@ -40,15 +43,13 @@ const {
 	FAILED_VERDICT,
 	FAILURE_EXIT_CODE,
 	FRESH_VERDICT,
-	HANDED_OFF_VERDICT,
 	HANDOFF_MISSING_NOTE,
 	HANDOFF_OVERFLOW_NOTE,
-	INCOMPLETE_VERDICT,
 	NOT_A_LANE_VERDICT,
 	OVER_VERDICT,
 	RESUME_IMPL_VERDICT,
 	RESUME_VERDICT,
-	STALE_VERDICT,
+	SPLIT_UNRESOLVED_VERDICT,
 	SUCCESS_EXIT_CODE,
 	UNDER_THRESHOLD_VERDICT,
 	UNREADY_VERDICT,
@@ -57,27 +58,33 @@ const {
 	report_bad_handoff,
 	report_busy,
 	report_fault,
-	report_handed_off,
 	report_held_cut,
-	report_incomplete,
-	report_over,
+	report_missing_supervisor,
 	report_relaunched_cut,
 	report_reviewer,
-	report_stale,
+	report_split_unresolved,
 	report_under_threshold,
 	report_unknown,
-	report_unreadable,
 } = run_cut_report
 
 // **The pre-gate cut is conditional on the same statistic the implementation-phase cut reads**.
-// `cost_cli.session_verdict` prices the newest request against `CONTEXT_CUT_THRESHOLD`, so no second
+// `cost_cli.session_verdict` prices the newest request against the `--cut` break-even, so no second
 // threshold is introduced — an `under` session skips the cut, and an unmeasurable one still cuts as
 // the safety net. Only the pre-gate phase is checked here; the implementation-phase caller gates its own
 // `--impl` cut on `pnpm josh cost --cut` before it is ever issued.
-function skips_pre_gate_cut(phase: string): boolean {
-	if (phase !== run_cut.PRE_GATE_PHASE) return false
+//
+// **A noticed Issue answers the split notice first** (joshuafolkken/kit#4695): the pre-gate cut is the
+// boundary the notice names, so a lane that neither split nor recorded why is refused whether or not
+// the cut itself would be taken. Returns the answer given without cutting, or `undefined`.
+async function pre_gate_answer(issue: string, phase: string): Promise<number | undefined> {
+	if (phase !== run_cut.PRE_GATE_PHASE) return undefined
+	const split_note = await split_resolution.ledger_refusal(Number(issue))
+
+	if (split_note !== undefined) return report_split_unresolved(split_note)
 
 	return cost_cli.session_verdict() === cost_verdict.UNDER_VERDICT
+		? report_under_threshold()
+		: undefined
 }
 
 // The exclusive create lost, so a cut is already in flight for this tree — the double-cut guard. The
@@ -103,18 +110,11 @@ function report_relaunch_failure(target: string, note: string): number {
 	return report(FAILED_VERDICT, FAILURE_EXIT_CODE)
 }
 
-function report_missing_supervisor(issue: string): number {
-	console.error(
-		`The OpenAI supervisor for ${session_cite.issue(issue)} is not live, so this nested process was not cut and can continue. Re-dispatch the lane to recover the supervisor.`,
-	)
-
-	return report(FAILED_VERDICT, FAILURE_EXIT_CODE)
-}
-
 // **The relaunched child is started at the effort of the phase it is resuming into**.
 // A pre-gate resume drives the gate, commit, PR and merge — the mechanical
 // ship/bookkeeping region, lowered — while an implementation resume keeps the role default. The
-// phase-aware profile is `agent_argv.resume_argv`'s; a person's `JOSH_WORKER_EFFORT` still wins over it.
+// phase-aware profile is `agent_argv.resume_argv`'s; a person's `JOSH_WORKER_EFFORT` still wins over it,
+// and a pre-gate resume moves to `JOSH_WORKER_SHIP_MODEL` when that is set.
 function relaunch(target: string, lane: LaneInfo, phase: string): number {
 	const notes: Array<string> = []
 	const result = lane_relaunch.resume(lane, phase, (note) => {
@@ -177,14 +177,18 @@ async function write_cut(target: string, request: CutRequest): Promise<number |
 	const loaded = run_cut_handoff.load_handoff(request.handoff_path, run_cut.MAX_HANDOFF_BYTES)
 	if (loaded.kind === 'bad') return report_bad_handoff(loaded.note)
 
-	const spec = {
+	const base = {
 		issue: request.issue,
 		branch: request.branch,
 		phase: request.phase,
 		handoff: loaded.handoff,
 	}
+	// The checkout, not `target`: the record lives in the temp root, and the transcript is filed by checkout.
+	const checkout = await run_cut.worktree_directory()
+	const spec = run_cut.with_digest(base, () => run_cut_digest.own_digest(checkout))
 
-	const spec_note = spec_refusal(spec)
+	const spec_note =
+		spec_refusal(spec) ?? (await run_cut_review.unrecorded_refusal(request, loaded.handoff))
 
 	if (spec_note !== undefined) return report_bad_handoff(spec_note)
 	if (run_cut.begin_cut(target, spec) === undefined) return report_cut_exists(target)
@@ -247,7 +251,9 @@ async function cut(
 		return await declined({ issue, phase }, state, refuse_unready(state))
 	}
 
-	if (skips_pre_gate_cut(phase)) return report_under_threshold()
+	const answered = await pre_gate_answer(issue, phase)
+
+	if (answered !== undefined) return answered
 
 	clear_expired(target)
 	if (!has_matching_supervisor(lane, issue)) return report_missing_supervisor(issue)
@@ -255,111 +261,6 @@ async function cut(
 	return await finish_cut(target, lane, { issue, branch: state.branch, phase, handoff_path })
 }
 
-// **The adoption is the resume-uniqueness guarantee**: it removes and creates exclusively, so of two
-// racing resumes only one wins the create and the loser is answered `busy`.
-// An implementation cut resumes back into implementation; a pre-gate one into the gate. The resuming
-// child is told which by the verdict rather than reconstructing it from the record.
-function resume_verdict_for(cut_record: RunCut): string {
-	return run_cut.resumes_into_implementation(cut_record.phase)
-		? RESUME_IMPL_VERDICT
-		: RESUME_VERDICT
-}
-
-// **An implementation resume removes the record; a pre-gate one marks it handed off**.
-// The cuts have different multiplicities sharing one record: the pre-gate cut fires once per lane, so
-// its record must survive to answer a second resume `handed-off`; the implementation cut is guarded by the run's
-// event stream rather than the cut record, so its record is cleared on resume — a lingering record
-// would keep the pre-gate guard, which reads `carried_cut_sync`, silent for the rest of the run. A double
-// cut stays impossible either way: `begin_cut`'s exclusive create is what prevents it.
-function take_over(target: string, cut_record: RunCut): RunCut | undefined {
-	if (!run_cut.resumes_into_implementation(cut_record.phase)) {
-		return run_cut.adopt_cut(target, cut_record)
-	}
-
-	run_cut.end_cut(target)
-
-	return cut_record
-}
-
-// The carried instruction and work state, printed to standard error so the resumed session continues
-// on what the run was told to do rather than on the tree alone. The record is cleared
-// on adoption, so this is where it reaches the fresh process.
-function announce_handoff(cut_record: RunCut): void {
-	if (cut_record.handoff !== undefined) {
-		console.error(run_cut_handoff.describe_handoff(cut_record.handoff))
-	}
-}
-
-// **An implementation resume appends a `resume` event**. It clears the record
-// the `cut` event stood for, so the stream is what moves `run:step` back to implementation; a pre-gate
-// resume keeps its record and appends nothing. Best-effort, as the cut's own append is.
-async function emit_resume_event(issue: string, verdict: string): Promise<void> {
-	if (verdict !== RESUME_IMPL_VERDICT) return
-
-	await run_event_stream_emit.emit(
-		run_event_stream.EVENT_KIND.RESUME,
-		`${issue_cite.plain(issue)} resumed`,
-	)
-}
-
-async function adopt(target: string, cut_record: RunCut): Promise<number> {
-	const taken = take_over(target, cut_record)
-
-	if (taken === undefined) return report_busy(cut_record)
-
-	announce_handoff(cut_record)
-
-	const verdict = resume_verdict_for(cut_record)
-
-	await emit_resume_event(cut_record.issue, verdict)
-
-	return report(verdict, SUCCESS_EXIT_CODE)
-}
-
-// A relaunched lane child and a fresh session both measure `under`, so only the session that took an
-// implementation cut resumes over the threshold; unmeasurable is not refused.
-function is_over_threshold_resume(cut_record: RunCut): boolean {
-	if (!run_cut.resumes_into_implementation(cut_record.phase)) return false
-
-	return cost_cli.session_verdict() === cost_verdict.OVER_VERDICT
-}
-
-async function verify_and_adopt(
-	target: string,
-	cut_record: RunCut,
-	issue: string,
-): Promise<number> {
-	const state = await run_cut.current_state()
-	const verdict = run_cut.classify_resume(cut_record, {
-		issue,
-		current_branch: state.branch,
-		is_dirty: state.is_dirty,
-		is_held: state.is_held,
-	})
-
-	if (verdict === HANDED_OFF_VERDICT) return report_handed_off(cut_record)
-
-	if (verdict === 'stale') return report_stale(cut_record)
-
-	if (verdict === INCOMPLETE_VERDICT) return report_incomplete(cut_record)
-
-	if (is_over_threshold_resume(cut_record)) return report_over()
-
-	return await adopt(target, cut_record)
-}
-
-async function resume(target: string, issue: string): Promise<number> {
-	const read = run_cut.read_cut(target)
-
-	if (read.kind === 'none') return report(FRESH_VERDICT, SUCCESS_EXIT_CODE)
-
-	if (read.kind === 'unreadable') return report_unreadable()
-
-	if (read.kind === 'expired') return report_stale(read.cut)
-
-	return await verify_and_adopt(target, read.cut, issue)
-}
-
 function read_json(target: string): number {
 	const read = run_cut.read_cut(target)
 	const cut_record = read.kind === 'carried' || read.kind === 'expired' ? read.cut : undefined
@@ -395,7 +296,7 @@ async function take_cut(target: string, request: CutCommand): Promise<number> {
 async function act(target: string, request: Request): Promise<number> {
 	if (request.kind === 'cut') return await take_cut(target, request)
 
-	if (request.kind === 'resume') return await resume(target, request.issue)
+	if (request.kind === 'resume') return await run_cut_resume.resume(target, request.issue)
 
 	if (request.kind === 'read') return read_json(target)
 
@@ -447,12 +348,11 @@ const run_cut_cli = {
 	ENDED_VERDICT,
 	FAILED_VERDICT,
 	FRESH_VERDICT,
-	HANDED_OFF_VERDICT,
 	NOT_A_LANE_VERDICT,
 	OVER_VERDICT,
 	RESUME_IMPL_VERDICT,
 	RESUME_VERDICT,
-	STALE_VERDICT,
+	SPLIT_UNRESOLVED_VERDICT,
 	UNDER_THRESHOLD_VERDICT,
 	UNREADY_VERDICT,
 	run,