@joshuafolkken/kit 1.1453.0 → 1.1471.0

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

@@ -4,6 +4,7 @@ import type { ClosedAnswer, ClosedIssue } from './run-board-closed'
 import type { Fetch } from './run-board-fetch'
 import type { TerminalSize } from './run-board-fit'
 import type { BoardForm } from './run-board-header'
+import { run_board_idle, type IdleSince } from './run-board-idle'
 import type { BoardPlan } from './run-board-layout'
 import type { Link } from './run-board-link'
 import type { MachineGauges, MachineMark } from './run-board-machine'
@@ -56,6 +57,8 @@ interface BoardState {
 	// The last local read, drawn until the next is due; `undefined` when no run had started.
 	local: LocalRead | undefined
 	read_ms: number | undefined
+	// When each lane the reads found idle was first read so (`run-board-idle.ts`).
+	idle_since: IdleSince
 	// The start of the run the plan state was built for, so a run that begins draws nothing of the last.
 	run_started_ms: number | undefined
 	plan: BoardPlan | undefined
@@ -91,6 +94,7 @@ interface BoardState {
 const FRESH_STATE: BoardState = {
 	local: undefined,
 	read_ms: undefined,
+	idle_since: run_board_idle.NO_IDLE,
 	run_started_ms: undefined,
 	plan: undefined,
 	plan_fetch: undefined,

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

@@ -66,6 +66,9 @@ const ENDING_STATES: Readonly<Partial<Record<string, ItemState>>> = {
 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.
 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'])
 
 function moment(event: RunEvent): number {
 	return Date.parse(event.at)
@@ -175,13 +178,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 +205,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)))
 		}
 	}
 
@@ -260,7 +275,7 @@ function closed_status(
 }
 
 function settled(issue: number, status: ItemStatus, read: OpenRead): ItemStatus {
-	if (status.state !== 'running') return status
+	if (!UNSETTLED_STATES.has(status.state)) return status
 
 	const from_closed = closed_status(status, read.closed.get(issue))
 

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.
@@ -69,9 +91,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,7 +130,7 @@ 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,
@@ -125,8 +147,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),
 	)
 }
 
@@ -220,8 +244,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,6 +58,7 @@ const {
 	report_busy,
 	report_fault,
 	report_handed_off,
+	report_held_cut,
 	report_incomplete,
 	report_over,
 	report_reviewer,
@@ -125,11 +127,8 @@ function relaunch(target: string, lane: LaneInfo, phase: string): number {
 	return report(CUT_VERDICT, SUCCESS_EXIT_CODE)
 }
 
-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.
@@ -204,16 +203,6 @@ async function finish_cut(target: string, lane: LaneInfo, request: CutRequest):
 		: 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 +217,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 +242,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 }

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

@@ -1,3 +1,5 @@
+import { issue_cite } from '#scripts/issue/issue-cite'
+import { session_cite } from '#scripts/issue/session-cite'
 import { run_cut, type CutState, type RunCut } from './run-cut'
 import { run_cut_handoff } from './run-cut-handoff'
 
@@ -136,6 +138,16 @@ function report_reviewer(): number {
 	return report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE)
 }
 
+// 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)
+}
+
 // **An implementation cut is never resumed by a session over the threshold**.
 // 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
@@ -176,6 +188,7 @@ const run_cut_report = {
 	report_busy,
 	report_fault,
 	report_handed_off,
+	report_held_cut,
 	report_incomplete,
 	report_over,
 	report_reviewer,

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

@@ -106,6 +106,8 @@ interface CutState {
 	is_held: boolean
 	// The issue a `fullrun` hold names, absent when the tree is not held by one.
 	held_issue?: string | undefined
+	// When the hold standing over the tree was taken — what keys a declined cut to the run it answered.
+	hold_taken_at?: string | undefined
 }
 
 // The fields a cut is written from, bundled so `begin_cut` stays within the parameter limit. `phase`
@@ -402,7 +404,13 @@ async function current_state(): Promise<CutState> {
 	const is_dirty = await run_hold.is_tree_dirty()
 	const hold = hold_of(await worktree_directory())
 
-	return { branch, is_dirty, is_held: hold !== undefined, held_issue: fullrun_issue(hold) }
+	return {
+		branch,
+		is_dirty,
+		is_held: hold !== undefined,
+		held_issue: fullrun_issue(hold),
+		hold_taken_at: hold?.taken_at,
+	}
 }
 
 function describe_cut(cut: RunCut): string {
@@ -466,6 +474,7 @@ const run_cut = {
 	handed_off_message,
 	has_required_handoff,
 	held_issue_sync,
+	hold_of,
 	incomplete_message,
 	invocation_for,
 	is_expired,

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

@@ -1,6 +1,6 @@
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { josh_command } from '#scripts/josh/josh-run'
-import { telegram_notify } from '#scripts/notify/telegram-notify'
+import { telegram_notify, type ConfirmInput } from '#scripts/notify/telegram-notify'
 import { lane_park } from '#scripts/rules/lane-park'
 
 // What `run:entry` does on the way out of a stop it decided itself.
@@ -26,14 +26,15 @@ interface StopNotice {
 }
 
 interface StopPorts {
-	notify: (input: { issue_title: string; body: string; recovery: string }) => Promise<boolean>
+	notify: (input: ConfirmInput) => Promise<boolean>
 	release: (issue_number: string) => Promise<boolean>
 	is_parking_child: () => boolean
 }
 
 const RECOVERY = 'If this did not arrive, the run:entry output in the session names the stop.'
+const LATER_ALTERNATIVE = 'Leave the Issue for a later session — nothing was changed'
 const NOTIFY_FAILED_NOTE =
-	'(the confirmation Telegram could not be sent — send it with `pnpm josh notify --task-type confirmation` before stopping)'
+	'(the confirmation Telegram could not be sent — send it with `pnpm josh notify --task-type confirmation --recommended "<choice>"` before stopping)'
 const RELEASED_NOTE = '(hold released by run:entry — the tree is free for the resume)'
 const RELEASE_FAILED_NOTE =
 	'(the hold could not be released — run `pnpm josh run:release` before stopping)'
@@ -78,6 +79,8 @@ async function notify_stop(notice: StopNotice, ports: StopPorts): Promise<void>
 		issue_title: `${notice.command} ${issue_cite.plain(notice.issue_number)} stopped`,
 		body: body_of(notice),
 		recovery: RECOVERY,
+		recommended: `Run \`${notice.command} ${issue_cite.plain(notice.issue_number)}\` again in a fresh session`,
+		alternatives: [LATER_ALTERNATIVE],
 	})
 
 	console.info(is_sent ? lane_park.COMMAND_NOTIFY_MARKER : NOTIFY_FAILED_NOTE)

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

@@ -176,14 +176,25 @@ function held_block(hold: RunHold, issue: string): string | undefined {
 	return run_hold.is_reentry(hold, issue) ? undefined : run_hold.held_message(hold)
 }
 
+// An expired record of the claimant's own issue that no stop marked is the earlier run of the same work —
+// a child killed and re-dispatched into its lane — so the claim adopts it with the work it left. A
+// stopped `halfrun` or `prrun` keeps its own adopt path.
+function is_own_unstopped(hold: RunHold, issue: string): boolean {
+	return run_hold.is_reentry(hold, issue) && !run_hold.is_stop_marked(hold)
+}
+
+async function stale_block(hold: RunHold, issue: string): Promise<string | undefined> {
+	if (is_own_unstopped(hold, issue)) return undefined
+
+	return (await run_hold.is_tree_dirty()) ? run_hold.uncommitted_message(hold) : undefined
+}
+
 async function blocking_message(read: HoldRead, issue: string): Promise<string | undefined> {
 	if (read.kind === 'held') return held_block(read.hold, issue)
 
 	if (read.kind === 'unreadable') return run_hold.unreadable_message()
 
-	const is_expired_over_work = read.kind === 'stale' && (await run_hold.is_tree_dirty())
-
-	return is_expired_over_work ? run_hold.uncommitted_message(read.hold) : undefined
+	return read.kind === 'stale' ? await stale_block(read.hold, issue) : undefined
 }
 
 // A record already here is never overwritten by a claim: overwriting is what the guard exists to

package/scripts/run/hold/run-hold.ts

@@ -129,10 +129,12 @@ function is_expired(hold: RunHold, now: Date): boolean {
 // nothing. Only a recorded session that is provably gone counts — no owner, or a live pid whose start
 // cannot be read, leaves the age as the whole test. **A stop-marked record is exempt**: a `halfrun` or
 // `prrun` stop is held across a person's latency on purpose, long after its session ends.
-function is_owner_gone(hold: RunHold): boolean {
-	const is_stop_mark = hold.is_halfrun_stop === true || hold.prrun_stop_head !== undefined
+function is_stop_marked(hold: RunHold): boolean {
+	return hold.is_halfrun_stop === true || hold.prrun_stop_head !== undefined
+}
 
-	if (is_stop_mark || hold.owner_pid === undefined) return false
+function is_owner_gone(hold: RunHold): boolean {
+	if (is_stop_marked(hold) || hold.owner_pid === undefined) return false
 
 	return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false
 }
@@ -317,6 +319,7 @@ function unknown_message(): string {
 }
 
 const run_hold = {
+	is_stop_marked,
 	FORCE_RELEASE_COMMAND,
 	HOLD_MAX_AGE_HOURS,
 	HOLD_MAX_AGE_MS,