@joshuafolkken/kit 1.957.0 → 1.972.0

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,

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

@@ -0,0 +1,167 @@
+import { run_cut, type CutState, type RunCut } from './run-cut'
+
+// The verdict tokens `josh run:cut` answers with and the reports that print them, split out of
+// `run-cut-cli.ts` so the CLI keeps to acting on the record. The contract is unchanged: **standard
+// output carries exactly one token** and every explanation goes to standard error.
+
+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'
+// The asking session is over the shared context-cut threshold, so an implementation cut was not
+// resumed into it (joshuafolkken/kit#2760) — the same refusal `run:carry` answers `over` with.
+const OVER_VERDICT = 'over'
+
+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)
+}
+
+// **An implementation cut is never resumed by a session over the threshold** (joshuafolkken/kit#2760).
+// The cut outside a lane leaves the session that took it open, so a person retyping `fullrun #N` there
+// would be answered `resume-impl`, keep implementing over the threshold, and be cut again on the next
+// edit — a loop that sheds no context. The record is left intact for a fresh session.
+function report_over(): number {
+	console.error(
+		'This session is over the shared context-cut threshold (`pnpm josh cost --cut` answers `over`), so the implementation cut was not resumed here and its record is kept. End this conversation and type the invocation again in a fresh session.',
+	)
+
+	return report(OVER_VERDICT, FAILURE_EXIT_CODE)
+}
+
+const run_cut_report = {
+	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,
+}
+
+export { run_cut_report }

package/scripts/run/run-cut.ts

@@ -9,7 +9,7 @@ import { stamp_file } from '#scripts/josh/stamp-file'
 import { lane_child_invocation } from '#scripts/lane/lane-child-invocation'
 import { z } from 'zod'
 import { run_cut_handoff, type Handoff } from './run-cut-handoff'
-import { run_hold } from './run-hold'
+import { run_hold, type RunHold } from './run-hold'
 
 // joshuafolkken/kit#1839: a lane child is a detached `fullrun #<N>` process, and the thinking it
 // accumulates while implementing rides on every later API call in the same session — measured at 176K
@@ -118,6 +118,8 @@ interface CutState {
 	branch: string
 	is_dirty: boolean
 	is_held: boolean
+	// The issue a `fullrun` hold names, absent when the tree is not held by one (joshuafolkken/kit#2760).
+	held_issue?: string | undefined
 }
 
 // The fields a cut is written from, bundled so `begin_cut` stays within the parameter limit. `phase`
@@ -432,22 +434,34 @@ function end_cut(target: string): void {
 	stamp_file.remove_stamp(target)
 }
 
-// Whether a run hold still stands over this tree — present as `held` or as an aged-out `stale`, but
+// The run hold still standing over this tree — present as `held` or as an aged-out `stale`, but
 // present. A tree with no hold at all is not the one a cut was taken in, so the resume refuses it.
-function tree_is_held(directory: string | undefined): boolean {
-	if (directory === undefined) return false
+function hold_of(directory: string | undefined): RunHold | undefined {
+	if (directory === undefined) return undefined
 
 	const read = run_hold.read_hold(run_hold.hold_path(directory))
 
-	return read.kind === 'held' || read.kind === 'stale'
+	return read.kind === 'held' || read.kind === 'stale' ? read.hold : undefined
+}
+
+// The issue a `fullrun` holds this tree for — what tells a `fullrun` held in its own checkout apart from
+// a person's tree (joshuafolkken/kit#2760). A `halfrun` or an in-session `backlogrun` child holds it
+// too, but its cut would be resumed as `fullrun #N`, so only a hold `run:entry` marked names an issue.
+function fullrun_issue(hold: RunHold | undefined): string | undefined {
+	return hold?.is_fullrun === true ? hold.issue : undefined
+}
+
+// The same read taken synchronously, for the `PreToolUse` implementation-cut guard.
+function held_issue_sync(): string | undefined {
+	return fullrun_issue(hold_of(worktree_git_directory_sync()))
 }
 
 async function current_state(): Promise<CutState> {
 	const branch = await git_command.branch()
 	const is_dirty = await run_hold.is_tree_dirty()
-	const directory = await worktree_directory()
+	const hold = hold_of(await worktree_directory())
 
-	return { branch, is_dirty, is_held: tree_is_held(directory) }
+	return { branch, is_dirty, is_held: hold !== undefined, held_issue: fullrun_issue(hold) }
 }
 
 function describe_cut(cut: RunCut): string {
@@ -508,8 +522,10 @@ const run_cut = {
 	describe_cut,
 	end_cut,
 	fresh_cut,
+	fullrun_issue,
 	handed_off_message,
 	has_required_handoff,
+	held_issue_sync,
 	incomplete_message,
 	invocation_for,
 	is_expired,

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

@@ -2,6 +2,7 @@
 import { fileURLToPath } from 'node:url'
 import { josh_command } from '#scripts/josh/josh-run'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import { run_cut_report } from './run-cut-report'
 import { run_entry, type EntryParts } from './run-entry'
 import { run_hold_cli } from './run-hold-cli'
 import { run_next } from './run-next'
@@ -50,9 +51,13 @@ function first_line(out: string): string {
 }
 
 // `run:hold <N>` prints one token — `hold`, `busy` or `unknown` — and forwards its explanation to
-// stderr, so the composite branches on the token and the reader still sees why.
+// stderr, so the composite branches on the token and the reader still sees why. `--fullrun` marks the
+// hold as this entry's, since `run:entry` is `fullrun #N`'s alone (joshuafolkken/kit#2760).
 async function claim_hold(issue_number: string): Promise<string> {
-	const held = await josh_command.josh_run(['run:hold', issue_number], should_forward_stderr)
+	const held = await josh_command.josh_run(
+		['run:hold', issue_number, '--fullrun'],
+		should_forward_stderr,
+	)
 
 	return first_line(held.out)
 }
@@ -96,7 +101,36 @@ function stop_report(issue_number: string, hold: string, cost: string, report: s
 	return emit({ issue_number, hold, cost, verdict: run_entry.NO_VERDICT, report })
 }
 
+interface Resume {
+	token: string
+	code: number
+}
+
+// **A resume is asked before the hold is claimed** (joshuafolkken/kit#2760). An implementation cut
+// outside a lane keeps its hold, so the fresh session's `fullrun #N` would be refused `busy` by its own
+// run's hold before it ever reached `run:cut --resume` — the hand-off the cut promised could not land.
+async function ask_resume(issue_number: string): Promise<Resume> {
+	const asked = await josh_command.josh_run(
+		['run:cut', '--resume', issue_number],
+		should_forward_stderr,
+	)
+
+	return { token: first_line(asked.out), code: asked.code }
+}
+
+// Anything but `fresh` is `run:cut --resume`'s answer to act on (`pre-gate-cut.md`), not a new run: the
+// token and its exit code are passed through, and nothing is claimed or read.
+function resume_report(issue_number: string, resume: Resume): number {
+	console.info(`entry #${issue_number} — resume: ${resume.token}`)
+
+	return resume.code
+}
+
 async function open_run(issue_number: string): Promise<number> {
+	const resume = await ask_resume(issue_number)
+
+	if (resume.token !== run_cut_report.FRESH_VERDICT) return resume_report(issue_number, resume)
+
 	const hold = await claim_hold(issue_number)
 
 	if (hold !== run_hold_cli.HOLD_VERDICT) {

package/scripts/run/run-headless.ts

@@ -99,6 +99,7 @@ const run_headless = {
 	environment,
 	is_backlog_parent,
 	is_headless,
+	is_owned_here,
 	must_keep_waiting,
 }