@joshuafolkken/kit 1.1050.0 → 1.1094.0

package/scripts/rules/stop-rules.ts

@@ -45,6 +45,9 @@ interface StopContext {
 	hold_present: boolean
 	// `git status --porcelain` came back empty.
 	tree_clean: boolean
+	// That record carries a `prrun` stop mark (joshuafolkken/kit#3023): the run stopped at a green pull
+	// request and keeps the hold over a clean tree on purpose, so a person can look before it merges.
+	prrun_stopped: boolean
 	// A `confirmation` notify is on this run's transcript tail.
 	notified: boolean
 	// The turn's session-facing reply text.
@@ -75,6 +78,9 @@ interface StopContext {
 	// 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
+	// This lane child handed its region to a running detached ship — `lane_handoff.is_handed_off`
+	// (joshuafolkken/kit#2962). The supervisor notifies on its own outcome, so nobody waits on this stop.
+	handed_off: boolean
 	// The resolved `JOSH_SESSION_LANG` — `session_language.resolve_session_lang` (joshuafolkken/kit#2470).
 	session_lang: string
 }
@@ -105,8 +111,8 @@ const HOLD_RELEASE_REASON =
 	'place, so the next run here runs `git switch main && git pull` believing the tree is free while ' +
 	'you hold it. `.claude/skills/workflow-commands/SKILL.md` → §2f: a stop that leaves the tree clean ' +
 	'releases the hold with `pnpm josh run:release <N>` (bare for a `new` entry). A `halfrun` ' +
-	'pre-commit stop and a `needs-human-review` stop keep the hold because their tree is dirty — this ' +
-	'row is silent there. Release it, then end with a one-line confirmation that it was released — do ' +
+	'pre-commit stop and a `needs-human-review` stop keep the hold because their tree is dirty, and a ' +
+	'`prrun` stop keeps it by its stop mark — this row is silent there. Release it, then end with a one-line confirmation that it was released — do ' +
 	'not repeat your previous reply.'
 
 // **A refusal that corrects rather than advises** (joshuafolkken/kit#2247). The bare `#N` is already
@@ -232,8 +238,11 @@ function needs_filing(context: StopContext): boolean {
 // 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.
+//
+// **A lane handed to the detached ship stands them down too** (joshuafolkken/kit#2962): the hold now
+// belongs to the supervisor driving the merge, and the person hears from that supervisor's own notify.
 function is_held_idle(context: StopContext): boolean {
-	return context.hold_present && !context.agent_pending
+	return context.hold_present && !context.agent_pending && !context.handed_off
 }
 
 function needs_notify(context: StopContext): boolean {
@@ -241,7 +250,7 @@ function needs_notify(context: StopContext): boolean {
 }
 
 function needs_release(context: StopContext): boolean {
-	return is_held_idle(context) && context.tree_clean
+	return is_held_idle(context) && context.tree_clean && !context.prrun_stopped
 }
 
 function citation_reason(context: StopContext): string | undefined {
@@ -345,7 +354,6 @@ const stop_rules = {
 	STOP_NOTIFY_REASON,
 	SWITCH_ENV_KEY,
 	block_envelope,
-	block_reason,
 	build_language_reason,
 	count_headless_refusals,
 	is_enabled,

package/scripts/rules/tail-commands.ts

@@ -30,6 +30,6 @@ function prior_bash_commands(tail: string): ReadonlyArray<string> {
 	return tail.split('\n').flatMap((line) => bash_commands_of(line))
 }
 
-const tail_commands = { bash_commands_of, is_bash_use, prior_bash_commands }
+const tail_commands = { is_bash_use, prior_bash_commands }
 
 export { tail_commands }

package/scripts/rules/test-declared-commit.ts

@@ -46,6 +46,6 @@ const REASON =
 // reason above.
 const ROW = { id: 'test-declared', is_trigger: is_untested_commit, reason: REASON }
 
-const test_declared_commit = { REASON, ROW, is_untested_commit }
+const test_declared_commit = { REASON, ROW }
 
 export { test_declared_commit }

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

@@ -83,7 +83,6 @@ const ROW = {
 const third_party_write = {
 	ROW,
 	THIRD_PARTY_WRITE_REASON,
-	is_third_party_write_segment,
 	writes_third_party,
 }
 

package/scripts/rules/worktree-guard.ts

@@ -36,8 +36,8 @@ function is_worktree_checkout(args: ReadonlyArray<string>): boolean {
 }
 
 // `git restore <path>` discards working-tree changes. `--staged` / `-S` alone is an index restore —
-// that is the deny list's territory (`git restore --staged*` / `-S*`), so a pure index restore is not
-// refused twice. Anything touching the worktree (the default, or an explicit `--worktree` / `-W`) is.
+// that is the `index-mutation` row's (`index-guard.ts`), so a pure index restore is not claimed by two
+// rows. Anything touching the worktree (the default, or an explicit `--worktree` / `-W`) is this row's.
 const STAGED_LONG = '--staged'
 const STAGED_LETTER = 'S'
 const WORKTREE_LONG = '--worktree'
@@ -83,14 +83,33 @@ function is_unauthorized_stash(args: ReadonlyArray<string>): boolean {
 	return true
 }
 
+// `git clean` deletes untracked files, which no commit can bring back (joshuafolkken/kit#2983). It
+// refuses to act without a force (`clean.requireForce`), so a force — `--force`, or a cluster carrying
+// `f` — is what marks the destructive call; `git clean -n` is a dry run and passes.
+const CLEAN_SUBCOMMAND = 'clean'
+const FORCE_LONG = '--force'
+const FORCE_LETTER = 'f'
+
+function is_forced_clean(args: ReadonlyArray<string>): boolean {
+	return args.some(
+		(argument) => argument === FORCE_LONG || git_argv.short_cluster_has(argument, FORCE_LETTER),
+	)
+}
+
+// Each subcommand this row judges, with the predicate that reads its arguments.
+const JUDGED_SUBCOMMANDS: ReadonlyMap<string, (args: ReadonlyArray<string>) => boolean> = new Map([
+	[CHECKOUT_SUBCOMMAND, is_worktree_checkout],
+	[RESTORE_SUBCOMMAND, touches_worktree],
+	[CLEAN_SUBCOMMAND, is_forced_clean],
+	[STASH_SUBCOMMAND, is_unauthorized_stash],
+])
+
 function is_unauthorized_segment(segment: string): boolean {
 	const call = git_argv.parse(segment)
 
 	if (call === undefined) return false
-	if (call.subcommand === CHECKOUT_SUBCOMMAND) return is_worktree_checkout(call.args)
-	if (call.subcommand === RESTORE_SUBCOMMAND) return touches_worktree(call.args)
 
-	return call.subcommand === STASH_SUBCOMMAND && is_unauthorized_stash(call.args)
+	return JUDGED_SUBCOMMANDS.get(call.subcommand ?? '')?.(call.args) === true
 }
 
 function is_unauthorized_worktree_change(command: string): boolean {
@@ -101,8 +120,8 @@ 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>` and an ' +
-	'unauthorized `git stash` mutate the working tree or the repository-wide stash every work tree ' +
+	'⛔ 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 ' +
@@ -121,9 +140,7 @@ const ROW = {
 const worktree_guard = {
 	ROW,
 	WORKTREE_MUTATION_REASON,
-	is_unauthorized_stash,
 	is_unauthorized_worktree_change,
-	is_worktree_checkout,
 	touches_worktree,
 }
 

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

@@ -447,11 +447,9 @@ const run_carry_cli = {
 	RESUMED_VERDICT,
 	STANDING_VERDICT,
 	UNKNOWN_VERDICT,
-	UNREADABLE_VERDICT,
 	// Re-exported rather than restated: the usage line belongs to the half that parses, and a second
 	// copy of it here would drift from the flags it describes.
 	USAGE: run_carry_args.USAGE,
-	main,
 	run,
 }
 

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

@@ -1,5 +1,5 @@
-import { git_stash } from '#scripts/git/git-stash'
-import { stash_orphans } from '#scripts/git/stash-orphans'
+import { git_stash } from '#scripts/git/stash/git-stash'
+import { stash_orphans } from '#scripts/git/stash/stash-orphans'
 import { issue_state_cli } from '#scripts/issue/issue-state-cli'
 import { bounded_pool } from '#scripts/lib/bounded-pool'
 

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

@@ -107,7 +107,7 @@ function next_state(carry: StreakCarry, change: StreakChange, now: Date): Streak
 	}
 }
 
-const run_carry_streak = { OUTAGE_FOLD_WINDOW_MS, next_state }
+const run_carry_streak = { next_state }
 
 export type { StreakCarry, StreakChange, StreakState }
 export { run_carry_streak }

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

@@ -45,8 +45,6 @@ const {
 	STALE_VERDICT,
 	SUCCESS_EXIT_CODE,
 	UNDER_THRESHOLD_VERDICT,
-	UNKNOWN_VERDICT,
-	UNREADABLE_VERDICT,
 	UNREADY_VERDICT,
 	refuse_unready,
 	report,
@@ -423,18 +421,13 @@ const run_cut_cli = {
 	FAILED_VERDICT,
 	FRESH_VERDICT,
 	HANDED_OFF_VERDICT,
-	INCOMPLETE_VERDICT,
 	NOT_A_LANE_VERDICT,
 	OVER_VERDICT,
 	RESUME_IMPL_VERDICT,
 	RESUME_VERDICT,
 	STALE_VERDICT,
 	UNDER_THRESHOLD_VERDICT,
-	UNKNOWN_VERDICT,
-	UNREADABLE_VERDICT,
 	UNREADY_VERDICT,
-	USAGE: run_cut_args.USAGE,
-	main,
 	run,
 }
 

package/scripts/run/run-cut.ts

@@ -1,10 +1,8 @@
-import { execFileSync } from 'node:child_process'
 import { agent_role_profile } from '#scripts/agent/agent-role-profile'
 import { backlog_budget } from '#scripts/backlog/backlog-budget'
 import { CONTEXT_CUT_THRESHOLD } from '#scripts/cost-runtime/context-cut-threshold'
-import { git_utilities } from '#scripts/git/constants'
 import { git_command } from '#scripts/git/git-command'
-import { git_location_environment } from '#scripts/git/git-location-environment'
+import { git_common_directory } from '#scripts/git/git-common-directory'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { lane_child_invocation } from '#scripts/lane/lane-child-invocation'
 import { z } from 'zod'
@@ -60,14 +58,6 @@ const IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD
 const CUT_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS
 const CUT_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS
 
-// The synchronous git read runs inside a `PreToolUse` hook, which holds the tool call for as long as
-// it takes; `rev-parse` takes no lock, so anything past a second is a fault rather than slow work.
-const GIT_READ_TIMEOUT_MS = 5000
-
-// The two lines `GIT_DIRECTORY_ARGUMENTS` prints, in order: the work tree's own git directory, then the
-// common one every lane of a repository shares. `git_directories` reads the same two asynchronously.
-const WORKTREE_DIRECTORY_INDEX = 0
-
 const END_COMMAND = 'pnpm josh run:cut --end'
 const READ_COMMAND = 'pnpm josh run:cut --json'
 
@@ -224,10 +214,10 @@ function read_cut(target: string, now: Date = new Date()): CutRead {
 
 // **The same read as `read_cut(cut_path(await worktree_directory()))`, taken synchronously**
 // (joshuafolkken/kit#1864). The pre-gate cut is enforced from a `PreToolUse` guard, and a guard
-// answers synchronously or not at all — so the one git call the path derivation needs is made here
-// with `git_command.GIT_DIRECTORY_ARGUMENTS`, the same argument list the asynchronous reader uses,
-// rather than a second spelling of it. Everything after the path is already shared: `cut_path` keys
-// the record and `classify` parses and expires it.
+// answers synchronously or not at all — so the one git call the path derivation needs is
+// `git_common_directory.own()`, the synchronous twin of the asynchronous reader, rather than a second
+// spelling of it. Everything after the path is already shared: `cut_path` keys the record and
+// `classify` parses and expires it.
 //
 // **A fault reads as "no cut was taken", and that direction is deliberate rather than fail-open.** A
 // checkout git cannot describe, a record that will not parse and an expired one all come back
@@ -235,47 +225,11 @@ function read_cut(target: string, now: Date = new Date()): CutRead {
 // The alternative errs the other way: a read fault would be taken for "already cut" and the guard
 // would go quiet on exactly the run it exists for. The cost of this direction is one refusal a lane
 // can answer by reissuing, since that row is delivered once per run.
-function git_directories_sync(cwd?: string): ReadonlyArray<string> {
-	try {
-		// The binary is resolved through `git_utilities` exactly as `git-spawn.ts` resolves it, so this
-		// call does not answer to whatever `PATH` happens to hold. It runs the binary directly with an
-		// argument array and no `shell` option, and both are internally controlled, never untrusted
-		// input.
-		const output = execFileSync(
-			git_utilities.get_git_command_for_spawn(),
-			[...git_command.GIT_DIRECTORY_ARGUMENTS],
-			// git's own diagnostics are discarded: a checkout it cannot describe is already the
-			// `undefined` below, and a hook that let `fatal: not a git repository` through would print it
-			// in front of a tool call that is about to be allowed.
-			// A `PreToolUse` hook holds the tool call while it runs, so the read is bounded rather than
-			// left to whatever git does.
-			// `cwd` is set only by `lane_cut_sync`, which reads another lane's record from the parent.
-			// With a `cwd`, the git location variables are cleared so it is what git answers for: a hook
-			// exports `GIT_DIR`, which beats `cwd` and would name the hook's checkout instead
-			// (joshuafolkken/kit#2515). Without one the environment is kept, so this read resolves the same
-			// checkout as the asynchronous `git_directories` that writes the record.
-			{
-				cwd,
-				env:
-					cwd === undefined
-						? process.env
-						: { ...process.env, ...git_location_environment.location_free_environment() },
-				encoding: 'utf8',
-				stdio: ['ignore', 'pipe', 'ignore'],
-				timeout: GIT_READ_TIMEOUT_MS,
-			},
-		) // NOSONAR
-
-		return output.split('\n').filter((line) => line !== '')
-	} catch {
-		return []
-	}
-}
-
+//
 // The work tree's own git directory (index 0), the same read `git_directories` makes asynchronously —
 // the record and the pre-gate guard both key on it.
 function worktree_git_directory_sync(): string | undefined {
-	return git_directories_sync()[WORKTREE_DIRECTORY_INDEX]
+	return git_common_directory.own()
 }
 
 // **The directory is injectable so a test never has to write to the live record.** Keyed to the work
@@ -297,7 +251,7 @@ function carried_cut_sync(
 // lane's own git directory, so the parent — standing in the main checkout — resolves that directory
 // from the lane's path rather than its own, and gets the record path back to mark it.
 function lane_cut_sync(lane_directory: string): { target: string; cut: RunCut } | undefined {
-	const directory = git_directories_sync(lane_directory)[WORKTREE_DIRECTORY_INDEX]
+	const directory = git_common_directory.own(lane_directory)
 
 	if (directory === undefined) return undefined
 

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

@@ -101,7 +101,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const run_ending_cli = { USAGE, main, parse_request, run }
+const run_ending_cli = { USAGE, parse_request, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/run/run-ending.ts

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs'
 import { agent_exit_record } from '#scripts/agent/agent-exit-record'
 import { api_outage } from '#scripts/agent/api-outage'
 import type { ClaudeResultEvent } from '#scripts/agent/claude-result-event'
-import { git_gh_issue_read } from '#scripts/git/git-gh-issue-read'
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
 import { issue_state } from '#scripts/issue/issue-state'
 import { run_cut } from './run-cut'
 import { run_hold } from './run-hold'
@@ -222,9 +222,6 @@ async function check(request: EndingRequest): Promise<EndingDecision> {
 const run_ending = {
 	check,
 	decide,
-	describe_exit,
-	read_child_closed,
-	read_cut_taken,
 	read_exit,
 }
 

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

@@ -9,6 +9,9 @@ import { run_hold_cli } from './run-hold-cli'
 import { run_next } from './run-next'
 import { run_prep } from './run-prep'
 import { run_prep_cli } from './run-prep-cli'
+import { run_prrun_resume } from './run-prrun-resume'
+import { run_stage, type StageCommand, type StageDecision } from './run-stage'
+import { run_stage_read, type StageRead } from './run-stage-read'
 import { run_step } from './run-step'
 
 // `josh run:entry <N>` — one call for the fixed entry sequence a lane opens on (joshuafolkken/kit#2372).
@@ -27,7 +30,10 @@ const ARGV_OFFSET = 2
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u
-const USAGE = 'Usage: josh run:entry <issue-number>'
+const USAGE = 'Usage: josh run:entry <issue-number> [--to kickoff|halfrun|prrun|fullrun]'
+const TO_FLAG = '--to'
+// The flag and its command.
+const TO_ARGUMENT_COUNT = 2
 const should_forward_stderr = true
 const NEWLINE = '\n'
 
@@ -48,16 +54,42 @@ function parse_number(argv: ReadonlyArray<string>): string | undefined {
 	return first
 }
 
+interface EntryRequest {
+	issue_number: string
+	command: StageCommand
+}
+
+// `--to <command>` names how far the run goes (joshuafolkken/kit#3042); absent, it is `fullrun`.
+// Anything else is refused.
+function parse_command(rest: ReadonlyArray<string>): StageCommand | undefined {
+	if (rest.length === 0) return run_stage.DEFAULT_COMMAND
+
+	const [flag, value] = rest
+
+	if (flag !== TO_FLAG || rest.length !== TO_ARGUMENT_COUNT) return undefined
+
+	return run_stage.to_command(value)
+}
+
+function parse_request(argv: ReadonlyArray<string>): EntryRequest | undefined {
+	const issue_number = parse_number(argv.slice(0, 1))
+	const command = parse_command(argv.slice(1))
+
+	return issue_number === undefined || command === undefined ? undefined : { issue_number, command }
+}
+
 function first_line(out: string): string {
 	return out.split(NEWLINE)[0] ?? ''
 }
 
 // `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. `--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> {
+// hold as a run whose implementation cut resumes as `fullrun #N` (joshuafolkken/kit#2760) — a
+// `fullrun`'s, and a `prrun`'s, which runs `fullrun`'s steps; a `halfrun`'s hold is never marked.
+async function claim_hold(issue_number: string, command: StageCommand): Promise<string> {
+	const mark = command === run_stage.HALFRUN ? [] : ['--fullrun']
 	const held = await josh_command.josh_run(
-		['run:hold', issue_number, '--fullrun'],
+		['run:hold', issue_number, ...mark],
 		should_forward_stderr,
 	)
 
@@ -131,31 +163,51 @@ function resume_report(issue_number: string, resume: Resume): number {
 // **A `halfrun` stopped before its commit is resumed, not claimed** (joshuafolkken/kit#2796): its hold
 // is kept over the verified diff, so the claim below would answer `busy` against it. The budget is asked
 // first, as for any run; then the hold is adopted and the run goes to the gate, skipping everything up
-// to and including implementation.
-async function resume_halfrun(issue_number: string): Promise<number> {
+// to and including implementation. **A `prrun` stopped before its merge is resumed the same way**
+// (joshuafolkken/kit#3023), under the token that says what is left of it.
+async function resume_stopped(
+	issue_number: string,
+	token: string,
+	stopped_run: { adopt: (issue: string) => Promise<boolean> },
+): Promise<number> {
 	const cost = await check_cost()
 
-	if (cost === run_entry.COST_OVER) {
-		return stop_report(issue_number, HALFRUN_RESUME_TOKEN, cost, COST_STOP_NOTE)
-	}
+	if (cost === run_entry.COST_OVER) return stop_report(issue_number, token, cost, COST_STOP_NOTE)
 
-	if (!(await run_halfrun_resume.adopt(issue_number))) {
+	if (!(await stopped_run.adopt(issue_number))) {
 		return stop_report(issue_number, run_hold_cli.BUSY_VERDICT, cost, HOLD_STOP_NOTE)
 	}
 
-	console.info(`entry #${issue_number} — resume: ${HALFRUN_RESUME_TOKEN}`)
+	console.info(`entry #${issue_number} — resume: ${token}`)
 
 	return SUCCESS_EXIT_CODE
 }
 
-async function open_run(issue_number: string): Promise<number> {
-	const resume = await ask_resume(issue_number)
+// The stopped run a decision picks up: a `halfrun` stop resumes at the gate, a `prrun` stop at
+// `followup` under its own token. `undefined` for any other start, so the ordinary claim decides.
+async function resume_any(
+	issue_number: string,
+	decision: StageDecision,
+	stage: StageRead,
+): Promise<number | undefined> {
+	if (decision.state === run_stage.HALFRUN_STOPPED) {
+		return await resume_stopped(issue_number, HALFRUN_RESUME_TOKEN, run_halfrun_resume)
+	}
 
-	if (resume.token !== run_cut_report.FRESH_VERDICT) return resume_report(issue_number, resume)
+	return stage.prrun_token === undefined
+		? undefined
+		: await resume_stopped(issue_number, stage.prrun_token, run_prrun_resume)
+}
 
-	if (await run_halfrun_resume.is_pending(issue_number)) return await resume_halfrun(issue_number)
+// **A command whose stopping point the issue has already reached redoes nothing** (joshuafolkken/kit#3042)
+// — the stage line is the whole report. A merged issue is the exception: the ordinary entry already
+// answers it (`already-done`, or `keep-work` over a lane's uncommitted work), so it is left to that.
+function is_settled(decision: StageDecision): boolean {
+	return decision.is_reached && decision.state !== run_stage.MERGED
+}
 
-	const hold = await claim_hold(issue_number)
+async function claim_run({ issue_number, command }: EntryRequest): Promise<number> {
+	const hold = await claim_hold(issue_number, command)
 
 	if (hold !== run_hold_cli.HOLD_VERDICT) {
 		return stop_report(issue_number, hold, run_entry.COST_SKIPPED, HOLD_STOP_NOTE)
@@ -170,16 +222,45 @@ async function open_run(issue_number: string): Promise<number> {
 	return emit({ issue_number, hold, cost, verdict: reads.verdict, report: reads.report })
 }
 
+// A carried cut is asked first, before anything is read (`run:cut --resume`); `kickoff` claims and cuts
+// nothing, so it never asks. `undefined` when no cut is waiting.
+async function resume_cut(request: EntryRequest): Promise<number | undefined> {
+	if (request.command === run_stage.KICKOFF) return undefined
+
+	const resume = await ask_resume(request.issue_number)
+
+	return resume.token === run_cut_report.FRESH_VERDICT
+		? undefined
+		: resume_report(request.issue_number, resume)
+}
+
+// `kickoff` stops at the stage line whatever it says — it plans, and claims nothing.
+async function open_run(request: EntryRequest): Promise<number> {
+	const { issue_number, command } = request
+	const cut = await resume_cut(request)
+
+	if (cut !== undefined) return cut
+
+	const stage = await run_stage_read.read_stage(issue_number)
+	const decision = run_stage.decide(stage.state, command)
+
+	console.info(run_stage.format_decision(issue_number, decision))
+
+	if (command === run_stage.KICKOFF || is_settled(decision)) return SUCCESS_EXIT_CODE
+
+	return (await resume_any(issue_number, decision, stage)) ?? (await claim_run(request))
+}
+
 async function run(argv: ReadonlyArray<string>): Promise<number> {
-	const issue_number = parse_number(argv)
+	const request = parse_request(argv)
 
-	if (issue_number === undefined) {
+	if (request === undefined) {
 		console.error(USAGE)
 
 		return FAILURE_EXIT_CODE
 	}
 
-	return await open_run(issue_number)
+	return await open_run(request)
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {
@@ -188,12 +269,8 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 
 const run_entry_cli = {
 	HALFRUN_RESUME_TOKEN,
-	SUCCESS_EXIT_CODE,
-	USAGE,
-	check_cost,
-	claim_hold,
-	main,
 	parse_number,
+	parse_request,
 	run,
 }
 

package/scripts/run/run-entry.ts

@@ -84,7 +84,6 @@ const run_entry = {
 	COST_SKIPPED,
 	COST_UNDER,
 	NO_VERDICT,
-	SUMMARY_PREFIX,
 	exit_code,
 	format_report,
 	can_proceed,

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

@@ -193,8 +193,6 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 }
 
 const run_event_cli = {
-	USAGE,
-	main,
 	run,
 	watch_start,
 }

package/scripts/run/run-event-follow.ts

@@ -52,6 +52,7 @@ async function follow(
 	let read = ports.read(position)
 
 	while (read.events.length === 0 && ports.now() < deadline) {
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await ports.sleep(options.tick_ms)
 		read = ports.read(position)
 	}

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

@@ -69,7 +69,7 @@ function render(event: RunEvent, lang: string): string {
 	return [clock_of(event.at), label_of(event.kind, lang), event.text].join(FIELD_SEPARATOR)
 }
 
-const run_event_render = { KIND_LABELS, clock_of, label_of, render }
+const run_event_render = { clock_of, label_of, render }
 
 export type { KindLabel }
 export { run_event_render }

package/scripts/run/run-event-scope.ts

@@ -91,6 +91,22 @@ const SHIP_POSITION_KINDS: ReadonlySet<string> = new Set([
 	run_event_stream.EVENT_KIND.SHIP_STOP,
 ])
 
+const KIND = run_event_stream.EVENT_KIND
+
+// The parent's record of the batch around a child — its dispatch, park and split, the retrospective
+// whose summary may name an issue it filed, and the strand whose text carries the whole invocation
+// (`backlogrun #<N1> #<N2> …`). Each can name the child, yet none is a position the child itself is at,
+// so a lane child never reads one as its own.
+const BATCH_RECORD_KINDS: ReadonlySet<string> = new Set([
+	KIND.CHILD_LAUNCH,
+	KIND.PARK,
+	KIND.SPLIT,
+	KIND.RETROSPECTIVE,
+	KIND.STRANDED,
+])
+
+const ISSUE_REFERENCE = /#(\d+)/u
+
 function is_foreign_ship_event(event: RunEvent, issue: string): boolean {
 	return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`#${issue} `)
 }
@@ -99,16 +115,49 @@ function is_own_ship_event(event: RunEvent, issue: string): boolean {
 	return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue)
 }
 
+// **A lane child's position is read only from events that name its own issue** (joshuafolkken/kit#3039).
+// The parent and every lane append to one stream under one carry scope, so anything else on it is another
+// run's: another lane's merge told a planned child to stop, the parent's stall (which names no issue)
+// pointed it at `backlog:next`, and another lane's cut at `run:cut --resume`. The child's own merge and
+// outage stay, so the parent-only stop in `run-step.ts` still holds; the parent keeps reading everything.
+function names_issue(event: RunEvent, issue: string): boolean {
+	return ISSUE_REFERENCE.exec(event.text)?.[1] === issue
+}
+
+function is_lane_position(event: RunEvent, issue: string): boolean {
+	return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue)
+}
+
+// A lane child's attempt begins at its own newest launch. A child re-dispatched after an outage — or
+// relaunched after a cut, whose resume `run:cut --resume` answers at the entry — shares the scope with
+// its previous attempt, and that attempt's outage would otherwise stop the new one at its entry `run:step`.
+function since_own_launch(events: ReadonlyArray<RunEvent>, issue: string): ReadonlyArray<RunEvent> {
+	const launch = events.findLastIndex(
+		(event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue),
+	)
+
+	return events.slice(launch + 1)
+}
+
+function is_foreign_event(event: RunEvent, issue: string, is_lane_child: boolean): boolean {
+	if (is_lane_child) return !is_lane_position(event, issue)
+
+	return is_foreign_ship_event(event, issue)
+}
+
 // The newest position for one issue's run: the scoped last event with other issues' ship positions left
-// out, and — where no scope applies, as in an interactive `fullrun` with no carry record — the issue's own
-// newest ship position, which its issue number already scopes. A determined scope with nothing in it yet
-// reads nothing: an earlier invocation's stop for the same issue is not this invocation's position.
+// out — and, for a lane child, every event not naming its issue — and, where no scope applies, as in
+// an interactive `fullrun` with no carry record, the issue's own newest ship position, which its issue
+// number already scopes. A determined scope with nothing in it yet reads nothing: an earlier invocation's
+// stop for the same issue is not this invocation's position.
 function last_issue_event(
 	events: ReadonlyArray<RunEvent>,
 	scope: EventScope,
 	issue: string,
+	is_lane_child: boolean,
 ): RunEvent | undefined {
-	const own = events.filter((event) => !is_foreign_ship_event(event, issue))
+	const attempt = is_lane_child ? since_own_launch(events, issue) : events
+	const own = attempt.filter((event) => !is_foreign_event(event, issue, is_lane_child))
 
 	if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope)