@joshuafolkken/kit 1.1455.0 → 1.1471.0

package/scripts/rules/third-party-write.ts

@@ -103,16 +103,11 @@ function writes_third_party(
 // to do instead. The command that computes the party is handed over, because the whole point of this
 // Issue is that the test is computed rather than judged.
 const THIRD_PARTY_WRITE_REASON =
-	'⛔ third-party write: this `gh api` call writes to a repository whose owner is not this session — ' +
-	'a tracker we do not own is Tier C, and every write there (Issue, comment, PR, Discussion, review) ' +
-	'needs explicit current-turn user instruction; typing the target, or holding a correct diagnosis, ' +
-	'is not that instruction (`CLAUDE.md` → "Third-party repositories are Tier C", ' +
-	'`prompts/collaboration-workflow/upstream-interrupt.md`). Confirm the party with ' +
-	'`pnpm josh repo:party <owner/repo>` — owner equality, computed not judged. A read (`-X GET`, or no ' +
-	'field flag) passes untouched; only a write (`-f`/`-F`/`--field`/`--raw-field`/`--input`, or ' +
-	'`-X POST|PATCH|PUT|DELETE`) is refused. Record the finding on our own Issue and draft the artifact ' +
-	'for a person to post — do not publish it yourself. **This rule fires on every occurrence, not once ' +
-	'per run.**'
+	'⛔ third-party write: this `gh api` call writes to a repository whose owner is not this session, ' +
+	'which is Tier C and needs explicit current-turn user instruction. Check with ' +
+	'`pnpm josh repo:party <owner/repo>`, then record the finding on our own Issue and draft the ' +
+	'artifact for a person to post. This rule fires on every occurrence ' +
+	'(`prompts/collaboration-workflow/upstream-interrupt.md`).'
 
 // `decide` returns true so it refuses every occurrence; it declares no `keeps` — not writing to
 // another owner's tracker is the absence of a call, not a call, so the row is reported unmeasured

package/scripts/rules/worktree-guard.ts

@@ -124,18 +124,11 @@ function is_unauthorized_worktree_change(command: string): boolean {
 // and — for a stash — the message form that is allowed. `pnpm josh git` and `pnpm josh stash:pop` are
 // invisible to this trigger, so a run that uses them is never refused.
 const WORKTREE_MUTATION_REASON =
-	'⛔ unauthorized working-tree change: `git checkout -- <path>`, `git restore <path>`, a forced ' +
-	'`git clean` and an unauthorized `git stash` discard work or mutate the repository-wide stash every work tree ' +
-	'shares, and none is on the `.claude/settings.json` deny list (`operating-rules.md`). Do not run ' +
-	'them on your own judgement. A commit goes through `pnpm josh git`; a stash pop goes through `pnpm ' +
-	'josh stash:pop "<message>"`, never a positional `git stash pop` a shared stack lets another lane ' +
-	'divert. A stash push is authorized only inside a documented flow and only with a findable message ' +
-	'— `git stash push -u -m "<message>"` — which this row allows; a bare `git stash`, a message-less ' +
-	'push, or `pop` / `apply` / `drop` is refused. A plan that restores a handed-over stash with `git ' +
-	'stash apply` / `git stash pop` is read as `pnpm josh stash:pop "<message>"`: apply it that way, ' +
-	'continue, and record the substitution on the Issue — Tier A, never a `needs-decision` park ' +
-	'unless the plan says why the owner keeps the stash: then stop and confirm (`operating-rules.md` ' +
-	'→ "no-self-staging"). **This rule fires on every occurrence, not once per run.**'
+	'⛔ unauthorized working-tree change: `git checkout --`, `git restore`, `git clean -f`, ' +
+	'`git stash`. A documented flow stashes with `git stash push -u -m "<message>"`; a handed-over ' +
+	'stash is `pnpm josh stash:pop "<message>"`; record the substitution on the Issue (Tier A) unless ' +
+	'the plan says why the owner keeps the stash: then stop and confirm. It fires on every occurrence ' +
+	'(`operating-rules.md`).'
 
 const ROW = {
 	id: 'worktree-mutation',

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

@@ -2,6 +2,7 @@ import { run_progress } from '#scripts/run/progress/run-progress'
 import { run_progress_cli } from '#scripts/run/progress/run-progress-cli'
 import type { ClosedAnswer } from './run-board-closed'
 import { run_board_fetch, type Fetch } from './run-board-fetch'
+import { run_board_idle } from './run-board-idle'
 import { run_board_layout, type BoardPlan } from './run-board-layout'
 import type { LocalRead } from './run-board-read'
 import { run_board_state, type BoardPorts, type BoardState, type Pace } from './run-board-state'
@@ -72,8 +73,15 @@ function fold_plan(state: BoardState): BoardState {
 	}
 }
 
-function statuses_for(plan: BoardPlan, local: LocalRead): ReadonlyMap<number, ItemStatus> {
-	return run_board_status.statuses_of(local.events, local.lanes, run_board_layout.numbers_of(plan))
+function statuses_for(
+	state: BoardState,
+	plan: BoardPlan,
+	local: LocalRead,
+): ReadonlyMap<number, ItemStatus> {
+	const in_run = run_board_layout.numbers_of(plan)
+	const stopped = run_board_idle.stopped_of(state.idle_since, state.read_ms)
+
+	return run_board_status.statuses_of(local.events, local.lanes, in_run, stopped)
 }
 
 // The children the run touched that the open listing no longer holds and the board has not read yet.
@@ -83,7 +91,7 @@ function unread_closed(state: BoardState, local: LocalRead): Array<number> {
 
 	if (open === undefined || state.plan === undefined) return []
 
-	const touched = [...statuses_for(state.plan, local).keys()]
+	const touched = [...statuses_for(state, state.plan, local).keys()]
 
 	return touched.filter((issue) => !open.has(issue) && !state.closed.has(issue))
 }

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

@@ -0,0 +1,31 @@
+import { lane_await } from '#scripts/lane/lane-await'
+
+// A lane is drawn stopped only once it has read idle for `lane_await.RECONFIRM_MS`: a boundary cut drops
+// the child's process for a moment before its resume takes over, and one bare probe cannot tell that
+// handoff from a child that died — `lane:await` re-confirms a disappearance over the same window. A live
+// board carries when each lane was first read idle across its reads; a single frame has no earlier read,
+// so it reads the lanes again after the window (`run-board-tick.ts`).
+
+/** When each lane the last read found idle was first read so. */
+type IdleSince = ReadonlyMap<string, number>
+
+const NO_IDLE: IdleSince = new Map()
+
+// The lanes read idle now, each keeping the moment it was first read so; a lane read working drops out.
+function since_of(before: IdleSince, idle: ReadonlyArray<string>, now_ms: number): IdleSince {
+	return new Map(idle.map((lane) => [lane, before.get(lane) ?? now_ms]))
+}
+
+// The lanes idle for the whole window as of the read at `read_ms`; none before any read.
+function stopped_of(since: IdleSince, read_ms: number | undefined): Array<string> {
+	if (read_ms === undefined) return []
+
+	const lasted = [...since].filter(([, at]) => read_ms - at >= lane_await.RECONFIRM_MS)
+
+	return lasted.map(([lane]) => lane)
+}
+
+const run_board_idle = { NO_IDLE, since_of, stopped_of }
+
+export type { IdleSince }
+export { run_board_idle }

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

@@ -1,7 +1,8 @@
 import type { NamedPlan } from '#scripts/backlog/backlog-plan'
+import { backlog_ready } from '#scripts/backlog/backlog-ready'
 import { backlogrun_launch } from '#scripts/backlog/backlogrun-launch'
-import { lane_capacity } from '#scripts/lane/lane-capacity'
 import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
+import { lane_spent } from '#scripts/lane/lane-spent'
 import { run_carry } from '#scripts/run/carry/run-carry'
 import { run_carry_ended } from '#scripts/run/carry/run-carry-ended'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
@@ -33,21 +34,16 @@ interface LocalRead {
 	is_stranded: boolean
 	// The newest operation of each session of the run, read off the end of its log.
 	operations?: SessionOperations | undefined
-	// How many more lanes the limit allows beside the live ones; `undefined` where the limit could not
-	// be read, so nothing is said about it.
+	// The open lanes no child is working in at this read (`lane-spent.ts`); one is drawn stopped once it
+	// has stayed so (`run-board-idle.ts`).
+	idle_lanes?: ReadonlyArray<string> | undefined
+	// How many more lanes the limit allows beside the live ones, as `lane:limit` counts them;
+	// `undefined` where the limit could not be read, so nothing is said about it.
 	free_lanes?: number | undefined
 	// How long each phase usually takes, from the repository's lane ledger.
 	usual?: UsualTimes | undefined
 }
 
-async function free_lanes_of(lanes: ReadonlyArray<LaneInfo>): Promise<number | undefined> {
-	const choice = await lane_capacity.lane_limit()
-
-	if (choice.kind !== 'limit') return undefined
-
-	return lane_capacity.free_lanes(choice.limit, lane_registry.live_count(lanes))
-}
-
 const NO_SPAN: SpanHere = { span: undefined, resume: undefined, transcript: undefined }
 
 interface SpanHere {
@@ -104,7 +100,8 @@ async function read_local(): Promise<LocalRead | undefined> {
 		resume,
 		is_stranded: run_stranded_detect.is_stranded_at(repository),
 		operations: run_board_operation_read.read(sources_of(repository, lanes, transcript)),
-		free_lanes: await free_lanes_of(lanes),
+		idle_lanes: lane_spent.idle_lanes(lanes),
+		free_lanes: await backlog_ready.free_lanes_beside(lanes),
 		usual: run_board_usual.read(repository),
 	}
 }

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

@@ -5,6 +5,7 @@ import { run_event_setup } from '#scripts/run/event/run-event-setup'
 import type { RunEvent } from '#scripts/run/event/run-event-stream'
 import { run_board_layout, type Overlay, type ReasonOf, type RowReason } from './run-board-layout'
 import { run_board_setup } from './run-board-setup'
+import type { ItemStatus } from './run-board-status'
 
 // Why each waiting row waits — pure, so the words are tested apart from the screen. A row whose lane is
 // being opened says the stage that lane is at; any other says what `backlog:next` would answer for it,
@@ -63,10 +64,13 @@ function is_untriaged_candidate(child: EpicChild, read: ReasonRead): boolean {
 	return !epic_triage.is_triaged(child) && !run_board_layout.is_blocked(child, read)
 }
 
+// A child whose lane stands with no one in it still holds the paths it declared, as its open lane does.
+function holds_paths(status: ItemStatus): boolean {
+	return status.state === 'running' || status.lane !== undefined
+}
+
 function running_of(read: ReasonRead): Array<number> {
-	return [...read.statuses]
-		.filter(([, status]) => status.state === 'running')
-		.map(([issue]) => issue)
+	return [...read.statuses].filter(([, status]) => holds_paths(status)).map(([issue]) => issue)
 }
 
 function pool_of(read: ReasonRead): Pool {

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 }