@joshuafolkken/kit 1.953.0 → 1.972.0

package/scripts/rules/implementation-cut.ts

@@ -63,6 +63,9 @@ interface LaneCostState {
 	directory: string
 	source: MarkerSource
 	carried: (now?: Date) => RunCut | undefined
+	// The issue whose run hold stands over this checkout (joshuafolkken/kit#2760) — how a `fullrun`
+	// held outside a lane is told apart from a person's tree.
+	held_issue: () => string | undefined
 	verdict: () => CostVerdict
 }
 
@@ -71,6 +74,7 @@ function current_state(): LaneCostState {
 		directory: process.cwd(),
 		source: process.env,
 		carried: run_cut.carried_cut_sync,
+		held_issue: run_cut.held_issue_sync,
 		// **Read through the short reuse window** (joshuafolkken/kit#2385). The row now fires per
 		// threshold crossing rather than once per run, so this predicate is a candidate on every edit;
 		// the window collapses one turn's burst of edits to a single whole-transcript price.
@@ -79,22 +83,49 @@ function current_state(): LaneCostState {
 	}
 }
 
-// A dispatched lane child for this checkout with no cut already carried. The dispatch mark is what
-// tells a child apart from a person (joshuafolkken/kit#1904), read from the environment against this
-// lane's own issue so a leaked mark for another issue reads as a person. **The carried-cut half keeps
-// the guard silent between a cut and its resume**, exactly as `pre-gate-cut.ts`'s does: a record naming
-// this issue means a cut is already in flight, and `begin_cut`'s exclusive create would refuse a second
-// one anyway.
-function uncut_lane_child_issue(state: LaneCostState): string | undefined {
+// A dispatched lane child's issue for this checkout. The dispatch mark is what tells a child apart from
+// a person (joshuafolkken/kit#1904), read from the environment against this lane's own issue so a
+// leaked mark for another issue reads as a person.
+function lane_child_issue(state: LaneCostState): string | undefined {
 	if (!lane_child_marker.is_child_of(state.directory, state.source)) return undefined
 
-	const issue = lane_paths.lane_issue_of(state.directory, { ...state.source })
+	return lane_paths.lane_issue_of(state.directory, { ...state.source })
+}
+
+// The issue a run holds this checkout for, read only outside a lane: a lane's hold is its dispatched
+// child's, so a person finishing that lane's work carries no mark and still sees no refusal.
+function held_run_issue(state: LaneCostState): string | undefined {
+	if (lane_paths.lane_issue_of(state.directory, { ...state.source }) !== undefined) return undefined
+
+	return state.held_issue()
+}
+
+// The run this checkout's edits belong to, with no cut already carried — a dispatched lane child, or
+// **a `fullrun` held in its own checkout** (joshuafolkken/kit#2760): the cut was lane-only, so a run a
+// person started grew without a bound mid-implementation. The run hold naming an issue is what marks
+// such a run, and a person's tree holds nothing, so it still sees no refusal. **The carried-cut half
+// keeps the guard silent between a cut and its resume**, exactly as `pre-gate-cut.ts`'s does: a record
+// naming this issue means a cut is already in flight, and `begin_cut`'s exclusive create would refuse
+// a second one anyway.
+function uncut_run_issue(state: LaneCostState): string | undefined {
+	const issue = lane_child_issue(state) ?? held_run_issue(state)
 
 	if (issue === undefined) return undefined
 
 	return state.carried()?.issue === issue ? undefined : issue
 }
 
+// **An unmeasurable session is cut in a lane and left alone outside one.** A lane child's safety net is
+// the pre-gate direction below; a held run outside a lane is a person's own session, so only a measured
+// `over` interrupts it — a provider with no transcript would otherwise refuse every edit it makes.
+function warrants_the_cut(state: LaneCostState): boolean {
+	const verdict = state.verdict()
+
+	if (lane_child_issue(state) === undefined) return verdict === cost_verdict.OVER_VERDICT
+
+	return verdict !== cost_verdict.UNDER_VERDICT
+}
+
 // **The tool-name test comes first and the world is consulted second, the cost measurement last.** This
 // predicate is asked of every call in the run, so the `Edit` / `Write` string match keeps the lane read
 // off all but the edits, and the lane read keeps the transcript-priced verdict off every edit but those
@@ -109,9 +140,9 @@ function is_over_threshold_edit(
 	call: GuardedCall,
 	state: LaneCostState = current_state(),
 ): boolean {
-	if (!is_edit_tool(call.name) || uncut_lane_child_issue(state) === undefined) return false
+	if (!is_edit_tool(call.name) || uncut_run_issue(state) === undefined) return false
 
-	return state.verdict() !== cost_verdict.UNDER_VERDICT
+	return warrants_the_cut(state)
 }
 
 // **The threshold in the refusal text is assembled from the constant, never spelled** (joshuafolkken/kit#2385).
@@ -125,7 +156,8 @@ const THRESHOLD_TEXT = `${cost_format.format_tokens(CONTEXT_CUT_THRESHOLD)}-toke
 // because `cut` is the only one that ends the turn and a run told merely to "take the cut" would have to
 // read which of the others leave it implementing — the same reason `pre-gate-cut.ts` spells them out.
 const IMPLEMENTATION_CUT_REASON =
-	'⛔ implementation-phase cut: this checkout is a lane dispatched for this issue and its recent-context ' +
+	'⛔ implementation-phase cut: this checkout is a lane dispatched for this issue, or a run holds it for ' +
+	'this issue (joshuafolkken/kit#2760), and its recent-context ' +
 	`cost has crossed the shared ${THRESHOLD_TEXT} threshold mid-implementation, so the thinking accumulated ` +
 	'so far is now re-read on every later request. Take the cut before this edit. ' +
 	'First write a handoff file with the Write tool — the user’s instruction verbatim, what you have ' +
@@ -139,11 +171,12 @@ const IMPLEMENTATION_CUT_REASON =
 	'because the verdict was only ever read at session entry, where the context has not yet grown. The ' +
 	"verdict is `pnpm josh cost --cut`'s exactly — the same per-request billed-input statistic against the " +
 	'same threshold, never a second measurement. Issue `pnpm josh run:cut --impl <N> --handoff <path>` now and read the ' +
-	'verdict: on `cut`, **end the turn immediately** — the fresh process owns the run and continues ' +
-	'implementing, so it must not be waited for; on `not-a-lane`, `unready`, `busy`, `failed` or ' +
+	'verdict: on `cut`, **end the turn immediately** — in a lane the fresh process owns the run and ' +
+	'continues implementing, so it must not be waited for; outside a lane nothing is relaunched, so first ' +
+	'send the `confirmation` Telegram naming the resume command `fullrun #<N>` and keep the hold; on `not-a-lane`, `unready`, `busy`, `failed` or ' +
 	'`unknown`, this process carries the run on and the edit is simply the next call. Never relaunch a ' +
-	'second process after `busy`. This fired because the dispatch mark names this lane; a person working ' +
-	'here carries no mark and sees no refusal, so there is no human-or-child judgement left to make. The ' +
+	'second process after `busy`. This fired because the dispatch mark names this lane or the run hold ' +
+	'names this issue; a person working here carries no mark and holds no run, so sees no refusal, so there is no human-or-child judgement left to make. The ' +
 	'procedure is `.claude/skills/workflow-commands/pre-gate-cut.md`. Reissue this edit once the cut has ' +
 	'answered — an edit reissued right after this refusal passes, so `busy` / `failed` cannot wedge the ' +
 	'run edit after edit; this fires again on the next threshold crossing rather than once per run.'
@@ -195,7 +228,7 @@ const implementation_cut = {
 	is_over_threshold_edit,
 	is_reissued_refusal,
 	takes_the_impl_cut,
-	uncut_lane_child_issue,
+	uncut_run_issue,
 }
 
 export type { LaneCostState }

package/scripts/rules/lane-background.ts

@@ -3,7 +3,10 @@ import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { json_value } from '#scripts/lib/json-value'
 import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 import { time_shell } from '#scripts/time-runtime/time-shell'
-import { time_transcript_line } from '#scripts/time-runtime/time-transcript-line'
+import {
+	time_transcript_line,
+	type Block as TranscriptBlock,
+} from '#scripts/time-runtime/time-transcript-line'
 import { run_tail } from './run-tail'
 
 // A dispatched lane child is stopped from backgrounding a long-running josh command (joshuafolkken/kit#2704).
@@ -60,16 +63,32 @@ function is_background_long_run(
 	return is_candidate(call) && is_lane_child()
 }
 
-// The background tasks the transcript tail launched and never saw finish. A launch is read off its own
-// tool result and a finish off the harness notice, both by `time_transcript_line`.
-function pending_background_ids(tail: string): ReadonlyArray<string> {
+// The launches `launched_ids` reads off the transcript tail that never saw their finish. A launch is
+// read off its own tool result and a finish off the harness notice, both by `time_transcript_line`.
+function unfinished_ids(
+	tail: string,
+	launched_ids: (block: TranscriptBlock) => ReadonlyArray<string>,
+): ReadonlyArray<string> {
 	const lines = tail.split('\n').map((line) => time_transcript_line.parse_line(line))
 	const finished = new Set(lines.map((line) => line?.finished_background ?? ''))
-	const launched = lines.flatMap((line) => line?.blocks.map((block) => block.background_id) ?? [])
+	const blocks = lines.flatMap((line) => line?.blocks ?? [])
+	const launched = blocks.flatMap((block) => launched_ids(block))
 
 	return launched.filter((id) => id !== '' && !finished.has(id))
 }
 
+// The background tasks the tail launched and never saw finish — commands and subagents alike
+// (joshuafolkken/kit#2774), since a lane child's turn-end kills either.
+function pending_background_ids(tail: string): ReadonlyArray<string> {
+	return unfinished_ids(tail, (block) => [block.background_id, block.agent_id])
+}
+
+// The backgrounded subagents alone. A subagent always ends and its notice re-invokes the session; a
+// command may be a server that never exits, so only this set says the run is certain to resume.
+function pending_agent_ids(tail: string): ReadonlyArray<string> {
+	return unfinished_ids(tail, (block) => [block.agent_id])
+}
+
 const LANE_BACKGROUND_REASON =
 	'⛔ lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless ' +
 	'`claude -p` process whose background Bash tasks are killed when the turn ends — so a backgrounded ' +
@@ -105,6 +124,7 @@ const lane_background = {
 	LANE_BACKGROUND_STOP_REASON,
 	ROW,
 	is_background_long_run,
+	pending_agent_ids,
 	pending_background_ids,
 }
 

package/scripts/rules/stop-rules.ts

@@ -67,9 +67,12 @@ interface StopContext {
 	headless_refusals: number
 	// This session is a dispatched lane child for this checkout — `lane_child_marker.is_child_of`.
 	lane_child: boolean
-	// A background task this run launched has not finished — `lane_background.pending_background_ids`
-	// over the transcript tail (joshuafolkken/kit#2704).
+	// A background task this run launched — a command or a subagent — has not finished —
+	// `lane_background.pending_background_ids` over the transcript tail (joshuafolkken/kit#2704).
 	background_pending: boolean
+	// A backgrounded subagent this run launched has not finished — `lane_background.pending_agent_ids`
+	// (joshuafolkken/kit#2774). Apart from `background_pending`, since only a subagent is sure to end.
+	agent_pending: boolean
 	// The resolved `JOSH_SESSION_LANG` — `session_language.resolve_session_lang` (joshuafolkken/kit#2470).
 	session_lang: string
 }
@@ -221,12 +224,21 @@ function needs_filing(context: StopContext): boolean {
 	return filing_offer.is_first_party_target(context.message, context.session_owner)
 }
 
+// **A running background subagent stands both hold rules down** (joshuafolkken/kit#2774). Its completion
+// notice re-invokes the session, so the turn-end is a wait on the run's own work, not on a person — a
+// notify there says "nothing needed" and dilutes the ones that do. A backgrounded command does not
+// count: a dev server never ends, and a stop behind it would leave a person silently waiting. A lane
+// child never reaches this with a task running: `needs_background_wait` answers it first.
+function is_held_idle(context: StopContext): boolean {
+	return context.hold_present && !context.agent_pending
+}
+
 function needs_notify(context: StopContext): boolean {
-	return context.hold_present && !context.notified
+	return is_held_idle(context) && !context.notified
 }
 
 function needs_release(context: StopContext): boolean {
-	return context.hold_present && context.tree_clean
+	return is_held_idle(context) && context.tree_clean
 }
 
 function citation_reason(message: string): string | undefined {

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

@@ -1,5 +1,7 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { cost_cli } from '#scripts/cost-runtime/cost-cli'
+import { cost_verdict } from '#scripts/cost-runtime/cost-verdict'
 import {
 	run_carry,
 	type CarryClaim,
@@ -44,6 +46,9 @@ const UNKNOWN_VERDICT = 'unknown'
 // the run carries on uncut rather than paying a cold preamble the accumulation it would shed no longer
 // covers, exactly as an under-threshold pre-gate cut carries on to the gate.
 const CAPPED_VERDICT = 'capped'
+// The asking session is over the shared context-cut threshold, so nothing was claimed
+// (joshuafolkken/kit#2760).
+const OVER_VERDICT = 'over'
 const NO_CUTS = 0
 
 const CLAIM_VERDICTS: Record<CarryClaim, string> = {
@@ -235,7 +240,22 @@ function adopt(target: string, request: CarryClaimRequest, is_json: boolean): nu
 	return report_claim(target, read.carry, request, is_json)
 }
 
+// **A session already over the shared cut threshold claims nothing** (joshuafolkken/kit#2760). A claim
+// assumed the asking session was fresh, so a `backlogrun` parent that had taken its cut at 233k could
+// retype the keyword in the same conversation and be answered `resumed` by its own hand-off — measured
+// twice, at 232k and 258k. The verdict is `pnpm josh cost --cut`'s, so no second threshold exists; only a
+// measured `over` refuses, because a provider with no transcript cannot be priced at all.
+function report_over(is_json: boolean): number {
+	console.error(
+		'This session is over the shared context-cut threshold (`pnpm josh cost --cut` answers `over`), so no run was begun or resumed here. End this conversation and type the invocation again in a fresh session.',
+	)
+
+	return report(OVER_VERDICT, undefined, is_json, FAILURE_EXIT_CODE)
+}
+
 function claim_record(target: string, request: CarryClaimRequest, is_json: boolean): number {
+	if (cost_cli.session_verdict() === cost_verdict.OVER_VERDICT) return report_over(is_json)
+
 	return request.is_adoption ? adopt(target, request, is_json) : begin(target, request, is_json)
 }
 
@@ -425,6 +445,7 @@ const run_carry_cli = {
 	EXPIRED_VERDICT,
 	MISMATCH_VERDICT,
 	NONE_VERDICT,
+	OVER_VERDICT,
 	RESUMED_VERDICT,
 	STANDING_VERDICT,
 	UNKNOWN_VERDICT,

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

@@ -9,6 +9,7 @@ import { openai_lane_supervisor } from '#scripts/lane/openai-lane-supervisor'
 import { run_cut, type CutState, type RunCut } from './run-cut'
 import { run_cut_args, type Request } from './run-cut-args'
 import { run_cut_handoff } from './run-cut-handoff'
+import { run_cut_report } from './run-cut-report'
 import { run_event_stream } from './run-event-stream'
 import { run_event_stream_emit } from './run-event-stream-emit'
 
@@ -24,115 +25,41 @@ import { run_event_stream_emit } from './run-event-stream-emit'
 // session.
 
 const ARGV_OFFSET = 2
-const SUCCESS_EXIT_CODE = 0
-const FAILURE_EXIT_CODE = 1
-
-const CUT_VERDICT = 'cut'
-const RESUME_VERDICT = 'resume'
-// An implementation-phase resume: the fresh process continues implementing rather than going to the
-// gate (joshuafolkken/kit#1933). It is a distinct token so the resuming child branches on it without
-// re-reading the record.
-const RESUME_IMPL_VERDICT = 'resume-impl'
-const FRESH_VERDICT = 'fresh'
-// The recent-window context is under the shared cut threshold, so the pre-gate cut was not worth its
-// resume and nothing was cut (joshuafolkken/kit#2312). A benign, non-failing answer: the run carries
-// on to the gate itself, exactly as `not-a-lane` does.
-const UNDER_THRESHOLD_VERDICT = 'under-threshold'
-const STALE_VERDICT = 'stale'
-// The record matched the tree but carried no instruction to resume on, so the run was refused rather
-// than continued blind to what it was told to do (joshuafolkken/kit#2354).
-const INCOMPLETE_VERDICT = 'incomplete'
-// The `--handoff` path was given but could not be read as a handoff, or was too large for the record;
-// the cut is refused rather than taken without the instruction it was meant to carry.
-const BAD_HANDOFF_VERDICT = 'bad-handoff'
-const HANDED_OFF_VERDICT = 'handed-off'
-const BUSY_VERDICT = 'busy'
-const NOT_A_LANE_VERDICT = 'not-a-lane'
-const UNREADY_VERDICT = 'unready'
-const FAILED_VERDICT = 'failed'
-const ENDED_VERDICT = 'ended'
-const UNREADABLE_VERDICT = 'unreadable'
-const UNKNOWN_VERDICT = 'unknown'
-
-function report(verdict: string, code: number): number {
-	console.info(verdict)
-
-	return code
-}
-
-function report_stale(cut_record: RunCut): number {
-	console.error(run_cut.stale_message(cut_record))
-
-	return report(STALE_VERDICT, FAILURE_EXIT_CODE)
-}
-
-function report_busy(cut_record: RunCut): number {
-	console.error(run_cut.busy_message(cut_record))
 
-	return report(BUSY_VERDICT, FAILURE_EXIT_CODE)
-}
-
-// The record matched the tree but carried no instruction; the run is refused rather than continued
-// without what it was told to do (joshuafolkken/kit#2354).
-function report_incomplete(cut_record: RunCut): number {
-	console.error(run_cut.incomplete_message(cut_record))
-
-	return report(INCOMPLETE_VERDICT, FAILURE_EXIT_CODE)
-}
-
-// The `--handoff` file parsed but the assembled record would not fit the byte bound — the scalar fields
-// carry a handoff that fit alone past the cap (joshuafolkken/kit#2354).
-const HANDOFF_OVERFLOW_NOTE = '--handoff <path> would grow the cut record past its byte bound'
-// An implementation cut resumes into implementation, and that resume refuses a record with no
-// instruction (`incomplete`) — so the cut is refused here instead of relaunching a successor that can
-// only stop (joshuafolkken/kit#2484).
-const HANDOFF_MISSING_NOTE = 'this cut resumes into implementation and needs --handoff <path>'
-
-function report_bad_handoff(note: string): number {
-	console.error(`${note}. Nothing was cut; write the handoff file and reissue.`)
-
-	return report(BAD_HANDOFF_VERDICT, FAILURE_EXIT_CODE)
-}
-
-// A successor already resumed this cut; a process woken after its own hand-off is told to stop rather
-// than to investigate (joshuafolkken/kit#1935). It is a benign, non-failing stop.
-function report_handed_off(cut_record: RunCut): number {
-	console.error(run_cut.handed_off_message(cut_record))
-
-	return report(HANDED_OFF_VERDICT, SUCCESS_EXIT_CODE)
-}
-
-function report_unreadable(): number {
-	console.error(run_cut.unreadable_message())
-
-	return report(UNREADABLE_VERDICT, FAILURE_EXIT_CODE)
-}
-
-function report_unknown(): number {
-	console.error(run_cut.unknown_message())
-
-	return report(UNKNOWN_VERDICT, FAILURE_EXIT_CODE)
-}
-
-// A cut is only meaningful on a lane branch whose implementation is uncommitted. On the default
-// branch, or with a clean tree, there is nothing to carry across the boundary.
-function refuse_unready(state: CutState): number {
-	console.error(
-		`Not ready to cut on ${state.branch} (dirty: ${String(state.is_dirty)}); a cut needs an uncommitted lane branch. Nothing was cut.`,
-	)
-
-	return report(UNREADY_VERDICT, FAILURE_EXIT_CODE)
-}
-
-// Below the shared context threshold there is no accumulation a cut would drop, so the resume it would
-// relaunch costs more than it saves; the current process carries the run on to the gate uncut.
-function report_under_threshold(): number {
-	console.error(
-		'The recent-window context is under the shared cut threshold, so nothing was cut; a resume would cost more than the accumulation it would drop. Continue to the gate.',
-	)
-
-	return report(UNDER_THRESHOLD_VERDICT, SUCCESS_EXIT_CODE)
-}
+const {
+	BAD_HANDOFF_VERDICT,
+	BUSY_VERDICT,
+	CUT_VERDICT,
+	ENDED_VERDICT,
+	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,
+	SUCCESS_EXIT_CODE,
+	UNDER_THRESHOLD_VERDICT,
+	UNKNOWN_VERDICT,
+	UNREADABLE_VERDICT,
+	UNREADY_VERDICT,
+	refuse_unready,
+	report,
+	report_bad_handoff,
+	report_busy,
+	report_handed_off,
+	report_incomplete,
+	report_over,
+	report_stale,
+	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**
 // (joshuafolkken/kit#2312). `cost_cli.session_verdict` prices the recent `RECENT_REQUEST_WINDOW`
@@ -240,7 +167,9 @@ function spec_refusal(spec: Parameters<typeof run_cut.begin_cut>[1]): string | u
 	return undefined
 }
 
-async function finish_cut(target: string, lane: LaneInfo, request: CutRequest): Promise<number> {
+// Writes the record and appends the `cut` event, or answers the refusal that stopped it — the half of a
+// cut every checkout shares; what follows the write (a relaunch or a stop) is the caller's.
+async function write_cut(target: string, request: CutRequest): Promise<number | undefined> {
 	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)
 
@@ -258,11 +187,53 @@ async function finish_cut(target: string, lane: LaneInfo, request: CutRequest):
 
 	await emit_cut_event(request)
 
+	return undefined
+}
+
+async function finish_cut(target: string, lane: LaneInfo, request: CutRequest): Promise<number> {
+	const refused = await write_cut(target, request)
+
+	if (refused !== undefined) return refused
+
 	return lane_relaunch.is_openai_lane(lane)
 		? report(CUT_VERDICT, SUCCESS_EXIT_CODE)
 		: 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 #${issue} outside a lane, so nothing was relaunched. Keep the hold, send a \`confirmation\` Telegram whose body names the resume command \`fullrun #${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** (joshuafolkken/kit#2760).
+// The cut was lane-only, so a run a person started had no 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 session), stay `not-a-lane` exactly as before.
+async function cut_outside_lane(
+	target: string,
+	request: Omit<CutRequest, 'branch'>,
+): Promise<number> {
+	if (request.phase !== run_cut.IMPLEMENTATION_PHASE) {
+		return report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE)
+	}
+
+	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)
+
+	clear_expired(target)
+
+	const refused = await write_cut(target, { ...request, branch: state.branch })
+
+	return refused ?? report_held_cut(request.issue)
+}
+
 async function cut(
 	target: string,
 	issue: string,
@@ -271,7 +242,7 @@ async function cut(
 ): Promise<number> {
 	const lane = await lane_registry.find_open_lane(issue)
 
-	if (lane === undefined) return report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE)
+	if (lane === undefined) return await cut_outside_lane(target, { issue, phase, handoff_path })
 
 	const state = await run_cut.current_state()
 
@@ -331,6 +302,14 @@ function adopt(target: string, cut_record: RunCut): number {
 	return report(resume_verdict_for(cut_record), 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 (joshuafolkken/kit#2760); 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,
@@ -350,6 +329,8 @@ async function verify_and_adopt(
 
 	if (verdict === INCOMPLETE_VERDICT) return report_incomplete(cut_record)
 
+	if (is_over_threshold_resume(cut_record)) return report_over()
+
 	return adopt(target, cut_record)
 }
 
@@ -444,6 +425,7 @@ const run_cut_cli = {
 	HANDED_OFF_VERDICT,
 	INCOMPLETE_VERDICT,
 	NOT_A_LANE_VERDICT,
+	OVER_VERDICT,
 	RESUME_IMPL_VERDICT,
 	RESUME_VERDICT,
 	STALE_VERDICT,