@joshuafolkken/kit 1.1050.0 → 1.1128.0

package/scripts/git/git-spawn-sync.ts

@@ -0,0 +1,65 @@
+import { read_spawn_stderr, read_spawn_stdout } from '#scripts/lib/spawn-exit'
+import { execaSync } from 'execa'
+import { git_utilities } from './constants'
+
+// The one place a synchronous git command is spawned from (joshuafolkken/kit#3065) — the sync
+// counterpart of `git-spawn.ts`. Every caller here wants an answer rather than an exception, so a
+// non-zero exit is returned as a result, and every call is bounded: a git that never answers is an
+// unknown the caller already handles, never a hang.
+
+const GIT_TIMEOUT_MS = 10_000
+const SUCCESS_EXIT_CODE = 0
+// git translates its messages, so a caller matching stderr would fail under any non-English locale.
+const C_LOCALE: Record<string, string> = { LC_ALL: 'C', LANGUAGE: 'C' }
+
+interface GitSyncOptions {
+	cwd?: string
+	timeout?: number
+	env?: Record<string, string | undefined>
+}
+
+interface GitSyncResult {
+	exit_code: number | undefined
+	stdout: string
+	stderr: string
+}
+
+function run(args: ReadonlyArray<string>, options: GitSyncOptions = {}): GitSyncResult {
+	// execa runs the binary directly with an argument array and no `shell` option; the git command and
+	// args are internally controlled, never untrusted input. tssecurity:S8705 is a false positive here.
+	const result = execaSync(git_utilities.get_git_command_for_spawn(), args, {
+		...options,
+		extendEnv: true,
+		reject: false,
+		timeout: options.timeout ?? GIT_TIMEOUT_MS,
+	}) // NOSONAR
+
+	return {
+		exit_code: result.exitCode,
+		stdout: read_spawn_stdout(result),
+		stderr: read_spawn_stderr(result),
+	}
+}
+
+// The trimmed output of a command that succeeded, or undefined for any failure.
+function read(args: ReadonlyArray<string>, options: GitSyncOptions = {}): string | undefined {
+	const result = run(args, options)
+
+	return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : undefined
+}
+
+// The configured `origin` URL, or undefined when the repository has none.
+function origin_url(cwd: string): string | undefined {
+	return read(['config', '--get', 'remote.origin.url'], { cwd })
+}
+
+// The absolute repository (or worktree) root, asked under the C locale so a caller can tell "not a
+// repository" apart from every other failure by its stderr.
+function toplevel(timeout: number = GIT_TIMEOUT_MS): GitSyncResult {
+	return run(['rev-parse', '--show-toplevel'], { env: C_LOCALE, timeout })
+}
+
+const git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run, read, origin_url, toplevel }
+
+export { git_spawn_sync }
+export type { GitSyncResult }

package/scripts/git/git-spawn.ts

@@ -18,10 +18,11 @@ import { git_ssh_keepalive } from './git-ssh-keepalive'
 // **`git-push-transport.ts` is the one deliberate exception among the command modules** and is not a
 // second helper of this kind: a push needs a transport-fault retry that no other command has, so it
 // spawns git itself. The timeout it carries is shared here by `read_remote` / `with_output_remote`. Those two files are the spawn sites of the ordinary command
-// modules — the claim stops there. Other parts of this package spawn git for their own purposes
-// (`scripts/run/run-progress-clock.ts`, `scripts/propagate/propagate-git.ts`,
-// `scripts/doctor/doctor-io.ts`, `scripts/git/git-fixture-workspace.ts`), and an audit of how the git
-// binary is resolved has to read those too.
+// modules — the claim stops there. A synchronous caller goes through `git-spawn-sync.ts`, the same
+// binary resolution with a result instead of an exception (joshuafolkken/kit#3065). Other parts of
+// this package spawn git for their own purposes (`scripts/run/run-progress-clock.ts`,
+// `scripts/git/git-fixture-workspace.ts`), and an audit of how the git binary is resolved has to read
+// those too.
 
 async function read(arguments_: Array<string>): Promise<string> {
 	const git_cmd = git_utilities.get_git_command_for_spawn()

package/scripts/git/git-staging.ts

@@ -62,6 +62,7 @@ async function stage_untracked_files(files: ReadonlyArray<string>): Promise<void
 	if (files.length === 0) return
 
 	for (const file of files) {
+		// eslint-disable-next-line no-await-in-loop -- git add holds the index lock, so two at once fail
 		await git_command.add_path(file)
 	}
 

package/scripts/git/git-status.ts

@@ -1,4 +1,4 @@
-import { animation_helpers, type AnimationOptions } from './animation-helpers'
+import { animation_helpers, type AnimationOptions } from '#scripts/lib/animation-helpers'
 import { REQUIRED_STATUS_LENGTH, STAGED_STATUS_INDEX, UNTRACKED_FILE_PREFIX } from './constants'
 import { git_command } from './git-command'
 

package/scripts/git/git-workflow.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env tsx
 import { parseArgs } from 'node:util'
+import { git_pr } from '#scripts/gh/git-pr'
 import { cli_body } from '#scripts/josh/cli-body'
 import { test_red_commit } from '#scripts/test/test-red-commit'
 import { git_branch } from './git-branch'
 import { git_commit } from './git-commit'
 import { git_error } from './git-error'
 import { git_issue, type IssueInfo } from './git-issue'
-import { git_pr } from './git-pr'
 import { git_preflight } from './git-preflight'
 import { git_prompt, type WorkflowConfirmations } from './git-prompt'
 import { git_push } from './git-push'

package/scripts/git/gone-branch.ts

@@ -89,6 +89,7 @@ async function delete_each(names: ReadonlyArray<string>): Promise<PruneResult> {
 
 	for (const name of names) {
 		try {
+			// eslint-disable-next-line no-await-in-loop -- branch deletions write the same refs, one at a time
 			await git_spawn.read(['branch', '-d', name])
 			result.deleted.push(name)
 		} catch {

package/scripts/git/listing-cutoff.ts

@@ -1,4 +1,4 @@
-import { MAX_SCANNED } from './git-gh-issue-list'
+import { MAX_SCANNED } from '#scripts/gh/git-gh-issue-list'
 
 // Why an open-issue listing stopped short of the end of the backlog, or that it did not
 // (joshuafolkken/kit#1067).

package/scripts/git/main-merge.ts

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

package/scripts/git/main-sync.ts

@@ -70,9 +70,27 @@ async function prune_quietly(default_branch: string): Promise<void> {
 	}
 }
 
+// **The local default branch is fast-forwarded before it is checked out** (joshuafolkken/kit#2979).
+// A run's ledger file is committed on its feature branch and merged; a line appended afterwards leaves
+// it dirty, and git refuses to check out a stale default branch that lacks the file — so `run:tail`'s
+// sync failed exactly when the flush after it had work. Once fast-forwarded, the default branch holds
+// the committed file and the checkout carries the dirty lines over (the same step the flush takes,
+// joshuafolkken/kit#2462). Skipped on the default branch, where `fetch` refuses to update the checked-out
+// ref; a refusal elsewhere — a local default ahead of origin — is left to the checkout and pull to judge.
+async function fast_forward_quietly(default_branch: string): Promise<void> {
+	if ((await git_command.branch()) === default_branch) return
+
+	try {
+		await git_command.fast_forward_local(default_branch)
+	} catch {
+		// The checkout and `pull --ff-only` below decide, exactly as before this step existed.
+	}
+}
+
 async function synchronize(): Promise<number> {
 	const default_branch = await git_command.get_default_branch()
 
+	await fast_forward_quietly(default_branch)
 	await git_command.checkout(default_branch)
 	await git_command.pull_fast_forward()
 	await prune_quietly(default_branch)
@@ -115,7 +133,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const main_sync = { COMMAND_NAME, LANE_REFUSAL, main, run }
+const main_sync = { run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/git/parse-json-array.ts

@@ -87,10 +87,7 @@ function parse_json_object_safe<T>(raw_json: string, schema: z.ZodType<T>): T |
 }
 
 const parse_json = {
-	parse_json_array_safe,
-	parse_json_array_or_undefined,
 	parse_json_object_safe,
-	read_json_listing,
 }
 
 export {

package/scripts/git/repository-lock.ts

@@ -2,7 +2,9 @@ import { randomUUID } from 'node:crypto'
 import { linkSync, renameSync, rmSync } from 'node:fs'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { process_identity } from '#scripts/josh/process-identity'
+import { process_owner_schema, type ProcessOwner } from '#scripts/josh/process-owner'
 import { stamp_file } from '#scripts/josh/stamp-file'
+import { json_value } from '#scripts/lib/json-value'
 import { git_common_directory } from './git-common-directory'
 
 // One holder at a time per repository, for work that every work tree of that repository shares
@@ -14,32 +16,29 @@ import { git_common_directory } from './git-common-directory'
 
 const POLL_INTERVAL_MS = 200
 
-interface LockOwner {
-	pid: number
-	process_start?: string
-}
-
-type IsGone = (owner: LockOwner) => boolean
+type IsGone = (owner: ProcessOwner) => boolean
 
-function lock_path(prefix: string, cwd: string = process.cwd()): string {
-	return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd)
+// Without a `cwd` the read keeps the inherited git location variables, as every other git call of the
+// running process does; an explicit `cwd` clears them so that directory is the one answered for.
+function lock_path(prefix: string, cwd?: string): string {
+	return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd())
 }
 
-function parse_owner(raw: string | undefined): LockOwner | undefined {
+// A record that is not JSON, or is JSON of any other shape — `null`, an array, an object with no
+// numeric `pid` — is unreadable rather than an owner, so it is never judged and never cleared.
+function parse_owner(raw: string | undefined): ProcessOwner | undefined {
 	if (raw === undefined) return undefined
 
-	try {
-		return JSON.parse(raw) as LockOwner
-	} catch {
-		return undefined
-	}
+	const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw))
+
+	return parsed.success ? parsed.data : undefined
 }
 
-function read_owner(target: string): LockOwner | undefined {
+function read_owner(target: string): ProcessOwner | undefined {
 	return parse_owner(stamp_file.read_stamp_text(target))
 }
 
-function is_owner_gone(owner: LockOwner): boolean {
+function is_owner_gone(owner: ProcessOwner): boolean {
 	return process_identity.is_same_process(owner.pid, owner.process_start) === false
 }
 
@@ -111,6 +110,7 @@ async function acquire(target: string, max_wait_ms: number): Promise<boolean> {
 
 	while (!claim(target)) {
 		if (Date.now() >= deadline) return false
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await sleep(POLL_INTERVAL_MS)
 	}
 

package/scripts/git/{git-stash.ts → stash/git-stash.ts}

@@ -1,4 +1,4 @@
-import { git_spawn } from './git-spawn'
+import { git_spawn } from '#scripts/git/git-spawn'
 
 // The one place a sanctioned `git stash pop` is targeted by its message rather than its stack
 // position (joshuafolkken/kit#2050). The stash is a single repository-wide stack shared by every

package/scripts/git/{stash-pop-args.ts → stash/stash-pop-args.ts}

@@ -21,12 +21,7 @@ interface Request {
 }
 
 function read_arguments(argv: ReadonlyArray<string>): ParsedValues | undefined {
-	return cli_flags.parse_or_undefined({
-		args: [...argv],
-		options: OPTIONS,
-		strict: true,
-		allowPositionals: true,
-	})
+	return cli_flags.arguments_of(argv, OPTIONS)
 }
 
 // The message is the sole positional and must be a non-empty string: an empty message matches every
@@ -47,7 +42,7 @@ function to_request(parsed: ParsedValues): Request | undefined {
 	return { message, dir: parsed.values.dir }
 }
 
-const stash_pop_args = { USAGE, message_of, read_arguments, to_request }
+const stash_pop_args = { USAGE, read_arguments, to_request }
 
 export type { Request }
 export { stash_pop_args }

package/scripts/git/{stash-pop-cli.ts → stash/stash-pop-cli.ts}

@@ -97,7 +97,6 @@ const stash_pop_cli = {
 	CONFLICTED_VERDICT,
 	NO_MATCH_VERDICT,
 	POPPED_VERDICT,
-	main,
 	run,
 }
 

package/scripts/git/{stash-sweep-lock.ts → stash/stash-sweep-lock.ts}

@@ -1,4 +1,4 @@
-import { repository_lock } from './repository-lock'
+import { repository_lock } from '#scripts/git/repository-lock'
 
 // One stash sweep at a time per repository (joshuafolkken/kit#2701). The stash is a single stack every
 // work tree shares, and a `backlogrun` runs one sweep per lane seat at once: two sweeps that each
@@ -11,7 +11,7 @@ const LOCK_PREFIX = 'josh-stash-sweep-lock-'
 // wait; the cap only bounds a holder that hung, and a sweep that gives up keeps its entries.
 const MAX_WAIT_MS = 30_000
 
-function lock_path(cwd: string = process.cwd()): string {
+function lock_path(cwd?: string): string {
 	return repository_lock.lock_path(LOCK_PREFIX, cwd)
 }
 
@@ -25,6 +25,6 @@ async function with_lock<T>(
 	return await repository_lock.with_lock(work, target, max_wait_ms)
 }
 
-const stash_sweep_lock = { clear_stale: repository_lock.clear_stale, lock_path, with_lock }
+const stash_sweep_lock = { clear_stale: repository_lock.clear_stale, with_lock }
 
 export { stash_sweep_lock }

package/scripts/hooks/codex-hook-adapter.ts

@@ -146,7 +146,6 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 
 const codex_hook_adapter = {
 	format_posttool_payloads,
-	patch_paths,
 	posttool_payloads,
 	pretool_outcome,
 	pretool_payload,

package/scripts/hooks/edited-cspell.ts

@@ -122,7 +122,7 @@ async function spelling_diagnostics(
 	}
 }
 
-const edited_cspell = { format_unknown_words, is_checkable, spelling_diagnostics }
+const edited_cspell = { format_unknown_words, spelling_diagnostics }
 
 export type { CspellRunner }
 export { edited_cspell, MAX_DIAGNOSTIC_CHARS }

package/scripts/hooks/format-edited-file.ts

@@ -327,6 +327,7 @@ async function run_command(command: FormatCommand, project_root: string): Promis
 	let outcome: CommandOutcome = { exit_code: 0, stdout: '' }
 
 	for (const invocation of resolve_invocations(command, project_root)) {
+		// eslint-disable-next-line no-await-in-loop -- a fallback route runs only when the previous one failed to start
 		outcome = await spawn_invocation(invocation, project_root)
 		if (!is_start_failure(outcome)) return outcome
 	}
@@ -374,6 +375,7 @@ async function collect_unfixed(
 
 	for (const command of plan) {
 		try {
+			// eslint-disable-next-line no-await-in-loop -- formatters rewrite the same file, in plan order
 			unfixed = eslint_unfixed(command, await runner(command, project_root)) ?? unfixed
 		} catch {
 			// One formatter failing to start is not a reason to skip the next: prettier runs last, and

package/scripts/hooks/pre-push-unit.ts

@@ -136,10 +136,6 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 
 const pre_push_unit = {
 	FORCE_ENV,
-	format_skip,
-	forwarded_arguments,
-	read_push_tree,
-	reusable_green_push,
 	run_pre_push_unit,
 }
 

package/scripts/hooks/pretool-guard.ts

@@ -5,6 +5,7 @@ import { delivered_rules } from '#scripts/rules/delivered-rules'
 import { run_parent_cut_hook } from '#scripts/run/run-parent-cut-hook'
 import { run_watcher_hook } from '#scripts/run/run-watcher-hook'
 import { batch_outcome } from './batch-guard'
+import { step_zero_notice } from './step-zero-notice'
 
 // One PreToolUse process for the three guards that used to be three (joshuafolkken/kit#1930). A Bash
 // call used to spawn `batch:guard`, `investigation:guard` and `rule:guard` separately — three pnpm
@@ -49,10 +50,20 @@ function with_duplicate_notice(combined: GuardOutcome, notice: string | undefine
 	return { reason: undefined, notice, fault: undefined }
 }
 
+// The Step 0 reminder is the last word (joshuafolkken/kit#2994): asked only where every guard stayed
+// clear, so a refusal or another notice never spends its once-per-session stamp unseen.
+function with_step_zero_notice(outcome: GuardOutcome, raw_payload: string): GuardOutcome {
+	if (!is_clear(outcome)) return outcome
+
+	const notice = step_zero_notice.notice(raw_payload)
+
+	return notice === undefined ? outcome : { reason: undefined, notice, fault: undefined }
+}
+
 // All guards run unconditionally, exactly as the separate PreToolUse entries did: each records its own
 // once-per-run stamp, so short-circuiting on the first refusal would change which guard is allowed to
 // fire on a later call.
-function pretool_outcome(raw_payload: string): GuardOutcome {
+function guard_outcome(raw_payload: string): GuardOutcome {
 	const batch = batch_outcome(raw_payload)
 	const investigation = investigation_refusal(raw_payload)
 	const duplicate = duplicate_read_outcome(raw_payload)
@@ -63,6 +74,11 @@ function pretool_outcome(raw_payload: string): GuardOutcome {
 	return with_duplicate_notice(combined, duplicate.notice)
 }
 
+// The synchronous verdict the Codex adapter asks for, with the Step 0 reminder as its last layer.
+function pretool_outcome(raw_payload: string): GuardOutcome {
+	return with_step_zero_notice(guard_outcome(raw_payload), raw_payload)
+}
+
 // The watcher guard is the one composed rule that cannot answer synchronously — it reads the lane
 // registry and the watcher's life record off disk (joshuafolkken/kit#2353). So it is asked after the
 // synchronous guards and only where they stayed clear: a refusal from any of them wins first, exactly
@@ -81,15 +97,17 @@ async function async_reason(raw_payload: string): Promise<string | undefined> {
 }
 
 async function pretool_outcome_async(raw_payload: string): Promise<GuardOutcome> {
-	const base = pretool_outcome(raw_payload)
+	const base = guard_outcome(raw_payload)
 
 	if (!is_clear(base)) return base
 
 	const reason = await async_reason(raw_payload)
 
-	return reason === undefined ? base : { reason, notice: undefined, fault: undefined }
+	if (reason !== undefined) return { reason, notice: undefined, fault: undefined }
+
+	return with_step_zero_notice(base, raw_payload)
 }
 
-const pretool_guard = { combine_outcomes, pretool_outcome, pretool_outcome_async }
+const pretool_guard = { combine_outcomes, pretool_outcome }
 
 export { pretool_guard, pretool_outcome, pretool_outcome_async }

package/scripts/hooks/reserved-run.ts

@@ -85,6 +85,6 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 	process.exitCode = await run_reserved(process.argv.slice(FIRST_ARGUMENT_INDEX))
 }
 
-const reserved_run = { parse_arguments, run_command, run_reserved }
+const reserved_run = { parse_arguments, run_reserved }
 
 export { reserved_run }

package/scripts/hooks/step-zero-notice.ts

@@ -0,0 +1,76 @@
+import path from 'node:path'
+import { hook_decision } from '#scripts/josh/hook-decision'
+import { json_value } from '#scripts/lib/json-value'
+import { test_declared_logic } from '#scripts/test/test-declared-logic'
+
+// The Code Change Rules Step 0 reminder, delivered at the moment implementation code is about to be
+// written rather than on every prompt (joshuafolkken/kit#2994). As a `UserPromptSubmit` echo it was
+// injected into every turn — a question that writes nothing included — and re-read as accumulated
+// context on each turn after it. The trigger the rule names is "before writing any implementation
+// code", so the hook that delivers it is the one that sees that write: the first `Edit` / `Write` of a
+// runtime file in the session.
+//
+// **A runtime file only.** What counts is `test_declared_logic.is_exempt`, the same classification
+// `pnpm josh test:declared` answers at the commit, so a doc or prompt edit neither shows the notice nor
+// spends it. A path outside the working tree (a memory file, a scratchpad) is not this project's code.
+//
+// **Once per session**, on a stamp keyed by the transcript like every other guard record here. A stamp
+// that cannot be written stays silent rather than repeating the notice on every edit.
+const STAMP_PREFIX = 'josh-step-zero-notice-'
+const EDIT_TOOLS: ReadonlySet<string> = new Set(['Edit', 'Write'])
+const PARENT_PREFIX = '..'
+
+const NOTICE =
+	'Before writing any implementation code: present the two-layer work summary (Now / Change / Check, then every change with its test) once per Issue. Full rule: Code Change Rules Step 0 in CLAUDE.md.'
+
+const STAMP = hook_decision.create_refusal_stamp(STAMP_PREFIX)
+
+// A Codex `apply_patch` arrives translated with its first file as `file_path` and every file in
+// `file_paths`, so a patch that leads with a doc and also writes code is still a runtime write.
+function edited_paths(tool_input: unknown): Array<string> {
+	if (!json_value.is_record(tool_input)) return []
+
+	const { file_path, file_paths } = tool_input
+	const listed: ReadonlyArray<unknown> = Array.isArray(file_paths) ? file_paths : []
+
+	return [file_path, ...listed].filter(
+		(entry): entry is string => typeof entry === 'string' && entry.length > 0,
+	)
+}
+
+function is_runtime_file(file_path: string, root: string): boolean {
+	const relative = path.relative(root, path.resolve(root, file_path))
+
+	if (relative.startsWith(PARENT_PREFIX) || path.isAbsolute(relative)) return false
+
+	return !test_declared_logic.is_exempt(relative.split(path.sep).join('/'))
+}
+
+function is_candidate(raw_payload: string, root: string): string | undefined {
+	const payload = hook_decision.parse_hook_payload(raw_payload)
+
+	if (payload === undefined || !EDIT_TOOLS.has(payload.tool_name)) return undefined
+
+	const has_runtime_file = edited_paths(payload.tool_input).some((file_path) =>
+		is_runtime_file(file_path, root),
+	)
+
+	return has_runtime_file ? payload.transcript_path : undefined
+}
+
+function notice(raw_payload: string, root: string = process.cwd()): string | undefined {
+	const transcript = is_candidate(raw_payload, root)
+
+	if (transcript === undefined) return undefined
+
+	const target = STAMP.path(transcript)
+
+	if (STAMP.last_ms(target) !== hook_decision.NEVER_MS) return undefined
+	if (!STAMP.record(target, Date.now())) return undefined
+
+	return NOTICE
+}
+
+const step_zero_notice = { NOTICE, notice, stamp_path: STAMP.path }
+
+export { step_zero_notice }

package/scripts/hooks/stop-guard.ts

@@ -7,12 +7,15 @@ import { repo_party } from '#scripts/discovery/repo-party'
 import { hook_decision } from '#scripts/josh/hook-decision'
 import { session_language } from '#scripts/josh/session-language'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import { lane_handoff } from '#scripts/lane/lane-handoff'
 import { filing_cap } from '#scripts/rules/filing-cap'
 import { lane_background } from '#scripts/rules/lane-background'
 import { lane_park } from '#scripts/rules/lane-park'
 import { last_prompt } from '#scripts/rules/last-prompt'
 import { stop_rules, type StopContext, type StopOutcome } from '#scripts/rules/stop-rules'
+import { run_carry } from '#scripts/run/run-carry'
 import { run_cut } from '#scripts/run/run-cut'
+import { run_halfrun_resume } from '#scripts/run/run-halfrun-resume'
 import { run_headless } from '#scripts/run/run-headless'
 import { run_hold } from '#scripts/run/run-hold'
 import { run_stranded_detect } from '#scripts/run/run-stranded-detect'
@@ -29,16 +32,17 @@ import { time_hook_transcript } from '#scripts/time-runtime/time-hook-transcript
 // resolving (send the notify, release the hold) and `stop_hook_active` is the backstop, so failing
 // open here costs at most a missed nudge, never a stuck run.
 
-// The hold record for this working tree is still in place. `unreadable` reads as absent: the safe
-// direction for a stop guard is not to block, and an unreadable record is not proof a run is holding.
-async function is_hold_present(): Promise<boolean> {
+// The hold record for this working tree is still in place, and whether it is a `prrun` stop's
+// (joshuafolkken/kit#3023). `unreadable` reads as absent: the safe direction for a stop guard is not to
+// block, and an unreadable record is not proof a run is holding.
+async function hold_facts(): Promise<Pick<StopContext, 'hold_present' | 'prrun_stopped'>> {
 	const directory = await run_hold.worktree_directory()
+	const hold =
+		directory === undefined
+			? undefined
+			: run_halfrun_resume.hold_of(run_hold.read_hold(run_hold.hold_path(directory)))
 
-	if (directory === undefined) return false
-
-	const read = run_hold.read_hold(run_hold.hold_path(directory))
-
-	return read.kind === 'held' || read.kind === 'stale'
+	return { hold_present: hold !== undefined, prrun_stopped: hold?.prrun_stop_head !== undefined }
 }
 
 // A `confirmation` notify sits on this run's transcript tail. The tail is derived exactly as the
@@ -67,7 +71,7 @@ async function build_context(
 	const tail = transcript_tail(transcript_path)
 
 	return {
-		hold_present: await is_hold_present(),
+		...(await hold_facts()),
 		tree_clean: !(await run_hold.is_tree_dirty()),
 		notified: lane_park.mentions_confirmation_notify(tail),
 		message: payload_tail.message,
@@ -81,6 +85,7 @@ async function build_context(
 		lane_child: lane_child_marker.is_child_of(process.cwd()),
 		background_pending: lane_background.pending_background_ids(tail).length > 0,
 		agent_pending: lane_background.pending_agent_ids(tail).length > 0,
+		handed_off: lane_handoff.is_handed_off(process.cwd()),
 		session_lang: session_lang(),
 	}
 }
@@ -106,22 +111,43 @@ async function outcome_of(raw_payload: string): Promise<StopOutcome> {
 	}
 }
 
+// A live carry record is in place — `carried` alone reads as a run. Both report checks below are about
+// a carried run: the strand judge reads this very record and returns on anything but `carried`, and a
+// stall needs a backlog driver, which begins one before its plan. A spent (`expired`) or `unreadable`
+// record a crashed run left behind is no run either, so it does not re-arm the stall's backlog probe
+// on every stop (joshuafolkken/kit#2995).
+// A failed git read — outside a repository, `git rev-parse` exits non-zero — reads as no run, since this
+// gate sits ahead of the checks' own swallowing and must not throw into the stop decision either.
+async function has_run_record(): Promise<boolean> {
+	try {
+		const directory = await run_carry.repository_directory()
+
+		if (directory === undefined) return false
+
+		return run_carry.read_carry(run_carry.carry_path(directory)).kind === 'carried'
+	} catch {
+		return false
+	}
+}
+
+// The stall check rides the Stop hook because the stop *is* the loop boundary: a run alive but not
+// advancing ends turns without dispatching (joshuafolkken/kit#2359). The strand check rides the same
+// boundary and is the step before the stall (joshuafolkken/kit#2375): it fires when the driver is gone
+// — the budget handed off, the owner dead, no supervisor watching. Both only report and swallow their
+// own failures, so neither can change the stop decision. An ordinary stop with no run record skips
+// both, so it pays one directory read rather than their reads and a stale stream's backlog probe.
+async function run_report_checks(): Promise<void> {
+	if (!(await has_run_record())) return
+
+	await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS)
+	await run_stranded_detect.run_stranded_check()
+}
+
 // Nothing reaches stdout on an ordinary stop, so what the harness parses stays empty unless the stop
 // is being held — all three rules block, so a bare `#N` is reported the same way (joshuafolkken/kit#2247).
 async function write_stop_decision(raw_payload: string): Promise<void> {
 	hook_decision.load_environment_file()
-
-	// The stall check rides the Stop hook because the stop *is* the loop boundary: a run alive but not
-	// advancing ends turns without dispatching (joshuafolkken/kit#2359). It only reports — leaves a
-	// marker, sends a notification — and swallows its own failures, so it can never change the decision
-	// below or hold the stop.
-	await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS)
-
-	// The strand check rides the same boundary for the same reason, and is the step before the stall
-	// (joshuafolkken/kit#2375): the stall detector needs a live driver that could dispatch, and this one
-	// fires when that driver is gone — the budget handed off, the owner dead, no supervisor watching. It
-	// too only reports and swallows its own failures, so it never touches the stop decision below.
-	await run_stranded_detect.run_stranded_check()
+	await run_report_checks()
 
 	const { reason } = await outcome_of(raw_payload)