@joshuafolkken/kit 1.1050.0 → 1.1094.0

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

@@ -238,13 +238,10 @@ const run_event_stream = {
 	EVENT_CAP,
 	EVENT_KIND,
 	EVENT_KINDS,
-	EVENT_PREFIX,
-	EVENT_SUFFIX,
 	TRACE_KINDS,
 	append,
 	format_event,
 	has_since,
-	is_event_kind,
 	read_events,
 	read_from,
 	read_last,

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

@@ -22,6 +22,7 @@ async function watch(ports: WatchPorts, position: number): Promise<number> {
 	let next = position
 
 	while (ports.should_continue()) {
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		const read = await ports.pass(next)
 
 		for (const event of read.events) ports.write(ports.render(event))

package/scripts/run/run-halfrun-resume.ts

@@ -1,4 +1,4 @@
-import { run_hold, type HoldRead, type RunHold } from './run-hold'
+import { run_hold, type HoldRead, type RunHold, type StopMarkFields } from './run-hold'
 
 // joshuafolkken/kit#2796: a `halfrun` stops before its commit and **keeps** its hold, because the
 // uncommitted, hand-verified work is exactly what a second run would trample. The person then types
@@ -38,7 +38,13 @@ function is_own_record(read: HoldRead, issue: string): boolean {
 	return hold === undefined || hold.issue === issue || hold.issue === run_hold.UNNUMBERED_ISSUE
 }
 
-function mark_stop_at(target: string, issue: string): StopMark {
+// `mark` is the `halfrun` stop's by default; a `prrun` stop passes its own (joshuafolkken/kit#3023), so
+// the own-record check is one check whichever run is stopping.
+function mark_stop_at(
+	target: string,
+	issue: string,
+	mark: StopMarkFields = run_hold.HALFRUN_STOP_FIELDS,
+): StopMark {
 	const read = run_hold.read_hold(target)
 
 	if (read.kind === 'unreadable') return UNREADABLE
@@ -47,7 +53,14 @@ function mark_stop_at(target: string, issue: string): StopMark {
 
 	run_hold.release_hold(target)
 
-	return run_hold.create_halfrun_stop_hold(target, issue) ? MARKED : FOREIGN
+	return run_hold.create_stop_hold(target, issue, mark) ? MARKED : FOREIGN
+}
+
+// The stopped run's record is replaced by this `fullrun`'s, shared with the `prrun` resume.
+function take_over(target: string, issue: string): boolean {
+	run_hold.release_hold(target)
+
+	return run_hold.create_hold(target, issue, new Date(), true)
 }
 
 // `false` leaves the record untouched, so the ordinary claim that follows decides the tree exactly as
@@ -55,9 +68,7 @@ function mark_stop_at(target: string, issue: string): StopMark {
 function adopt_at(target: string, issue: string, is_dirty: boolean): boolean {
 	if (!is_halfrun_stop(run_hold.read_hold(target), issue, is_dirty)) return false
 
-	run_hold.release_hold(target)
-
-	return run_hold.create_hold(target, issue, new Date(), true)
+	return take_over(target, issue)
 }
 
 // **An unreadable git directory is no resume**, never a crash: `run:entry` must still print its one
@@ -95,9 +106,11 @@ const run_halfrun_resume = {
 	UNREADABLE,
 	adopt,
 	adopt_at,
-	is_halfrun_stop,
+	hold_of,
+	hold_target,
 	is_pending,
 	mark_stop_at,
+	take_over,
 }
 
 export type { StopMark }

package/scripts/run/run-headless.ts

@@ -1,7 +1,7 @@
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
 import { lane_reap } from '#scripts/lane/lane-reap'
+import { lane_registry } from '#scripts/lane/lane-registry'
 import { run_carry, type CarryRead, type RunCarry } from './run-carry'
-import { run_watcher_guard } from './run-watcher-guard'
 
 // The headless `backlogrun` parent (joshuafolkken/kit#2437). `run:wake` starts a cut's successor as
 // `claude -p`, and there a turn that ends is the process that ends: its background `lane:await` and
@@ -51,7 +51,7 @@ async function read_carry_here(): Promise<CarryRead | undefined> {
 async function must_keep_waiting(source: EnvironmentSource = process.env): Promise<boolean> {
 	const is_candidate = is_headless(source) && lane_child_marker.marked_issue(source) === undefined
 
-	if (!is_candidate || !(await run_watcher_guard.has_lanes_in_flight())) return false
+	if (!is_candidate || !(await lane_registry.has_lanes_in_flight())) return false
 
 	return is_driving(await read_carry_here())
 }

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

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'node:url'
 import { run_halfrun_resume } from './run-halfrun-resume'
 import { run_hold, type HoldRead, type RunHold } from './run-hold'
 import { run_preflight, type PreflightDecision } from './run-preflight'
+import { run_prrun_resume } from './run-prrun-resume'
 import { run_tidy_cli } from './run-tidy-cli'
 
 // `josh run:hold [<N>]` and `josh run:release [<N> | --force]` — the working-tree guard the typed
@@ -48,11 +49,13 @@ const FORCE_FLAG = '--force'
 // implementation cut outside a lane resumes as `fullrun #N` (joshuafolkken/kit#2760).
 const FULLRUN_FLAG = '--fullrun'
 const HALFRUN_STOP_FLAG = '--halfrun-stop'
+// A `prrun`'s stop before merge (joshuafolkken/kit#3023): its record keeps the commit it stopped on.
+const PRRUN_STOP_FLAG = '--prrun-stop'
 // The most a claim reads: the issue number and the one flag after it.
 const MAX_CLAIM_ARGUMENTS = 2
 const ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u
 const USAGE =
-	'Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop]] | josh run:release [<issue-number> | --force]'
+	'Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --prrun-stop]] | josh run:release [<issue-number> | --force]'
 
 const HOLD_VERDICT = 'hold'
 const BUSY_VERDICT = 'busy'
@@ -65,6 +68,7 @@ const HELD_VERDICT = 'held'
 
 const FORCE_RELEASE_KIND = 'force-release'
 const HALFRUN_STOP_KIND = 'halfrun-stop'
+const PRRUN_STOP_KIND = 'prrun-stop'
 
 interface ClaimRequest {
 	kind: 'claim'
@@ -72,11 +76,20 @@ interface ClaimRequest {
 	is_fullrun?: boolean
 }
 
+interface StopRequest {
+	kind: typeof HALFRUN_STOP_KIND | typeof PRRUN_STOP_KIND
+	issue: string
+}
+
 type HoldRequest =
 	| ClaimRequest
+	| StopRequest
 	| { kind: 'release'; claimant: string }
 	| { kind: typeof FORCE_RELEASE_KIND }
-	| { kind: typeof HALFRUN_STOP_KIND; issue: string }
+
+function is_stop_request(request: HoldRequest): request is StopRequest {
+	return request.kind === HALFRUN_STOP_KIND || request.kind === PRRUN_STOP_KIND
+}
 
 const FORCE_RELEASE_REQUEST: HoldRequest = { kind: FORCE_RELEASE_KIND }
 
@@ -84,12 +97,20 @@ function release_request(claimant: string): HoldRequest {
 	return { kind: 'release', claimant }
 }
 
-// The flag after a numbered claim: absent, `--fullrun` or `--halfrun-stop`. Anything else is a usage
-// error.
+const STOP_KIND_BY_FLAG: ReadonlyMap<string, typeof HALFRUN_STOP_KIND | typeof PRRUN_STOP_KIND> =
+	new Map([
+		[HALFRUN_STOP_FLAG, HALFRUN_STOP_KIND],
+		[PRRUN_STOP_FLAG, PRRUN_STOP_KIND],
+	])
+
+// The flag after a numbered claim: absent, `--fullrun`, `--halfrun-stop` or `--prrun-stop`. Anything
+// else is a usage error.
 function numbered_claim(issue: string, flag: string | undefined): HoldRequest | undefined {
 	if (flag === undefined) return { kind: 'claim', issue }
 
-	if (flag === HALFRUN_STOP_FLAG) return { kind: HALFRUN_STOP_KIND, issue }
+	const stop_kind = STOP_KIND_BY_FLAG.get(flag)
+
+	if (stop_kind !== undefined) return { kind: stop_kind, issue }
 
 	return flag === FULLRUN_FLAG ? { kind: 'claim', issue, is_fullrun: true } : undefined
 }
@@ -293,8 +314,12 @@ async function read_worktree(): Promise<string | undefined> {
 
 // **A `halfrun` stop marks its own record** (joshuafolkken/kit#2796) — the positive "this run has ended
 // over its verified diff" that `run:entry` adopts on `fullrun #N`. Another run's record is left alone.
-function mark_halfrun_stop(target: string, issue: string): number {
-	const mark = run_halfrun_resume.mark_stop_at(target, issue)
+// A `prrun` stop marks its record the same way, with the commit it stopped on (joshuafolkken/kit#3023).
+async function mark_stop(target: string, request: StopRequest): Promise<number> {
+	const mark =
+		request.kind === PRRUN_STOP_KIND
+			? await run_prrun_resume.mark_stop_at(target, request.issue)
+			: run_halfrun_resume.mark_stop_at(target, request.issue)
 
 	if (mark === run_halfrun_resume.MARKED) return report_hold()
 
@@ -306,7 +331,7 @@ function mark_halfrun_stop(target: string, issue: string): number {
 async function dispatch(request: HoldRequest, target: string, is_linked: boolean): Promise<number> {
 	if (request.kind === 'claim') return await claim(target, request, is_linked)
 
-	if (request.kind === HALFRUN_STOP_KIND) return mark_halfrun_stop(target, request.issue)
+	if (is_stop_request(request)) return await mark_stop(target, request)
 
 	if (request.kind === FORCE_RELEASE_KIND) return force_release(target)
 
@@ -351,8 +376,6 @@ const run_hold_cli = {
 	RELEASED_VERDICT,
 	UNKNOWN_VERDICT,
 	USAGE,
-	blocking_message,
-	main,
 	parse_request,
 	run,
 }

package/scripts/run/run-hold.ts

@@ -52,6 +52,10 @@ interface RunHold {
 	// the positive record that the run has *ended* over its verified diff, which is what lets
 	// `fullrun #N` adopt the hold. A running `halfrun` or a `backlogrun` child never carries it.
 	is_halfrun_stop?: boolean | undefined
+	// Set only at a `prrun`'s stop before merge (`run:hold <N> --prrun-stop`, joshuafolkken/kit#3023): the
+	// commit the green pull request stood on, so `fullrun #N` can tell an untouched branch — merge it —
+	// from one that moved since and has to pass the gate and the review again.
+	prrun_stop_head?: string | undefined
 }
 
 type HoldRead =
@@ -92,6 +96,7 @@ const run_hold_schema = z.object({
 	pid: z.number(),
 	is_fullrun: z.boolean().optional(),
 	is_halfrun_stop: z.boolean().optional(),
+	prrun_stop_head: z.string().optional(),
 })
 
 // `undefined` for anything that is not a well-formed record, so the caller decides what a broken one
@@ -161,9 +166,24 @@ function create_hold(
 	return stamp_file.create_stamp(target, build_hold(issue, now, is_fullrun))
 }
 
-// The claim a `halfrun` stop leaves behind: the same exclusive create, carrying the stop mark.
+// What a stopped run's record carries on top of the claim: the `halfrun` stop's flag, or the commit a
+// `prrun` stop stood on (joshuafolkken/kit#3023).
+type StopMarkFields = Pick<RunHold, 'is_halfrun_stop' | 'prrun_stop_head'>
+
+const HALFRUN_STOP_FIELDS: StopMarkFields = { is_halfrun_stop: true }
+
+// The claim a stop leaves behind: the same exclusive create, carrying the stop mark.
+function create_stop_hold(
+	target: string,
+	issue: string,
+	mark: StopMarkFields,
+	now: Date = new Date(),
+): boolean {
+	return stamp_file.create_stamp(target, { ...build_hold(issue, now), ...mark })
+}
+
 function create_halfrun_stop_hold(target: string, issue: string, now: Date = new Date()): boolean {
-	return stamp_file.create_stamp(target, { ...build_hold(issue, now), is_halfrun_stop: true })
+	return create_stop_hold(target, issue, HALFRUN_STOP_FIELDS, now)
 }
 
 // **A tree with uncommitted work in it is never handed over, however old its record is.** No age can
@@ -260,8 +280,9 @@ const run_hold = {
 	UNNUMBERED_ISSUE,
 	classify,
 	create_halfrun_stop_hold,
+	create_stop_hold,
+	HALFRUN_STOP_FIELDS,
 	create_hold,
-	describe_holder,
 	foreign_release_message,
 	forced_release_message,
 	held_message,
@@ -270,7 +291,6 @@ const run_hold = {
 	is_own_hold,
 	is_tree_dirty,
 	own_release_command,
-	parse_hold,
 	race_message,
 	read_hold,
 	release_hold,
@@ -282,5 +302,5 @@ const run_hold = {
 	write_hold,
 }
 
-export type { HoldRead, RunHold }
+export type { HoldRead, RunHold, StopMarkFields }
 export { run_hold }

package/scripts/run/run-issue-number.ts

@@ -14,6 +14,6 @@ function require_issue_number(issue: string): void {
 	if (!ISSUE_NUMBER_PATTERN.test(issue)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue}`)
 }
 
-const run_issue_number = { BAD_ISSUE_MESSAGE, ISSUE_NUMBER_PATTERN, require_issue_number }
+const run_issue_number = { ISSUE_NUMBER_PATTERN, require_issue_number }
 
 export { run_issue_number }

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

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

package/scripts/run/run-liveness.ts

@@ -3,8 +3,8 @@ import { homedir, tmpdir } from 'node:os'
 import path from 'node:path'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { agent_event, type AgentEventState } from '#scripts/agent/agent-event'
-import { git_gh_issue_read } from '#scripts/git/git-gh-issue-read'
-import { ALREADY_DONE_LABEL, NEEDS_DECISION_LABEL } from '#scripts/git/issue-labels'
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
+import { ALREADY_DONE_LABEL, NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
 import { issue_state } from '#scripts/issue/issue-state'
 import { PLATFORM_TEMP_ROOT } from '#scripts/josh/platform-temporary'
 import { run_hold } from './run-hold'
@@ -401,7 +401,6 @@ const run_liveness = {
 	decide,
 	describe_agent_state,
 	read_child_settled,
-	read_agent_state,
 	read_output_frozen,
 	sample_output,
 	to_safe_path,

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

@@ -5,6 +5,7 @@ import { api_outage } from '#scripts/agent/api-outage'
 import { CONTEXT_CUT_THRESHOLD } from '#scripts/cost-runtime/context-cut-threshold'
 import { issue_closing_pr } from '#scripts/issue/issue-closing-pr'
 import { issue_state_cli } from '#scripts/issue/issue-state-cli'
+import { lane_handoff } from '#scripts/lane/lane-handoff'
 import { run_carry, type CarryOwner, type RunCarry } from './run-carry'
 import { run_ending } from './run-ending'
 import { run_event_stream } from './run-event-stream'
@@ -12,8 +13,6 @@ import { run_event_stream_emit } from './run-event-stream-emit'
 import { run_issue_number } from './run-issue-number'
 import { run_merge, type ChildOutcome, type EndingSignals } from './run-merge'
 import { run_merge_steps, type MergeContext } from './run-merge-steps'
-import { run_ship_detach } from './run-ship-detach'
-import { run_ship_probe } from './run-ship-probe'
 
 // `josh run:merge <N>` — one composite command for a `backlogrun` merge event (joshuafolkken/kit#2024).
 // The parent's context is the largest and its per-turn cost the highest, and the event was two turns:
@@ -316,7 +315,10 @@ async function on_cut(ctx: MergeContext): Promise<MergeVerdict> {
 
 // A child that parked itself: nothing is counted, but the park is written to the stream as a failed
 // child's is, so a reader restoring the run from its events sees the child settled (joshuafolkken/kit#2508).
+// Its `in-progress` is dropped as a failed child's is: left on, it outlived the `needs-decision` a
+// person later lifted, and a `run:solo` child then held the whole backlog (joshuafolkken/kit#3017).
 async function on_parked(ctx: MergeContext): Promise<MergeVerdict> {
+	await run_merge_steps.remove_in_progress(ctx.child)
 	await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.PARK, `#${ctx.child} parked`)
 
 	return emit(await run_merge_steps.ask_next(ctx), SUCCESS_EXIT_CODE)
@@ -355,18 +357,10 @@ const HANDLERS: Readonly<Record<ChildOutcome, (ctx: MergeContext) => Promise<Mer
 	shipping: on_shipping,
 }
 
-async function is_ship_running(child: string): Promise<boolean> {
-	const repository = await run_ship_probe.repository_directory()
-
-	return (
-		repository !== undefined && run_ship_detach.read_result(repository, child)?.result === 'running'
-	)
-}
-
 // The whole merge event for one returned child, in-process: read its state, classify it, and run the
 // handler. The CLI prints the token; `backlog:drive` branches on the outcome (joshuafolkken/kit#2508).
 async function merge_child(ctx: MergeContext): Promise<MergeResult> {
-	if (await is_ship_running(ctx.child)) {
+	if (lane_handoff.is_ship_running(ctx.child, process.cwd())) {
 		return { outcome: 'shipping', ...(await on_shipping()) }
 	}
 
@@ -405,8 +399,6 @@ const run_merge_cli = {
 	RESUMED_TOKEN,
 	RETRY_TOKEN,
 	STOP_TOKEN,
-	USAGE,
-	main,
 	merge_child,
 	parse,
 	run,

package/scripts/run/run-merge-steps.ts

@@ -1,9 +1,9 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
-import { git_followup_issue_close } from '#scripts/git/git-followup-issue-close'
-import { git_gh_issue_write } from '#scripts/git/git-gh-issue-write'
-import { git_stash } from '#scripts/git/git-stash'
-import { IN_PROGRESS_LABEL, NEEDS_DECISION_LABEL } from '#scripts/git/issue-labels'
+import { git_followup_issue_close } from '#scripts/followup/git-followup-issue-close'
+import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
+import { git_stash } from '#scripts/git/stash/git-stash'
+import { IN_PROGRESS_LABEL, NEEDS_DECISION_LABEL } from '#scripts/issue/issue-labels'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { lane_close } from '#scripts/lane/lane-close'
 import { lane_reap } from '#scripts/lane/lane-reap'
@@ -347,7 +347,6 @@ async function ask_next(ctx: MergeContext): Promise<string> {
 
 const run_merge_steps = {
 	CUT_RELAUNCH_CAUSE,
-	apply_carry,
 	ask_next,
 	do_failed,
 	do_merged,
@@ -355,6 +354,7 @@ const run_merge_steps = {
 	has_resumable_cut,
 	is_over_budget,
 	refused_carry,
+	remove_in_progress,
 	resume_cut,
 }
 

package/scripts/run/run-merge.ts

@@ -3,7 +3,7 @@ import {
 	EPIC_LABEL,
 	has_label_name,
 	NEEDS_DECISION_LABEL,
-} from '#scripts/git/issue-labels'
+} from '#scripts/issue/issue-labels'
 import type { IssueState } from '#scripts/issue/issue-state'
 import type { CarryChange, RunCarry } from './run-carry'
 

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

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

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

@@ -135,7 +135,6 @@ async function parent_cut_reason(
 const run_parent_cut_hook = {
 	PARENT_CUT_REASON,
 	QUIET_WINDOW_MS,
-	STAMP_PREFIX,
 	SWITCH_ENV_KEY,
 	parent_cut_reason,
 }

package/scripts/run/run-preflight.ts

@@ -1,5 +1,5 @@
+import { git_gh_pr_read } from '#scripts/gh/git-gh-pr-read'
 import { git_command } from '#scripts/git/git-command'
-import { git_gh_pr_read } from '#scripts/git/git-gh-pr-read'
 import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
 import { z } from 'zod'
 import { run_hold } from './run-hold'
@@ -89,7 +89,7 @@ const STASH_LABEL_PREFIX = 'run:hold reclaimed before #'
 // so the shape it may take is pinned beside the interpolation rather than only in the CLI that
 // happens to be today's single caller. `run:liveness` interpolates it the same way, so the pattern
 // and the refusal live in one module both read (joshuafolkken/kit#1485).
-const { ISSUE_NUMBER_PATTERN, require_issue_number } = run_issue_number
+const { require_issue_number } = run_issue_number
 const UNREADABLE_PR_MESSAGE = 'The pull request could not be read for branch '
 
 function needs_reclaim(tree: TreeState): boolean {
@@ -385,15 +385,8 @@ async function check(issue: string): Promise<PreflightDecision> {
 }
 
 const run_preflight = {
-	CLEAN_ADVICE,
-	CLEAN_REASON,
 	CLEAN_VERDICT,
-	ISSUE_NUMBER_PATTERN,
-	PARK_ADVICE,
-	PARK_VERDICT,
-	RECLAIM_VERDICT,
 	RESUME_ADVICE,
-	RESUME_VERDICT,
 	MERGED_PR,
 	STASH_LABEL_PREFIX,
 	check,

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { git_stash } from '#scripts/git/git-stash'
+import { git_stash } from '#scripts/git/stash/git-stash'
 import { issue_read_cli, type BlockRead } from '#scripts/issue/issue-read-cli'
 import { issue_state_cli, type StateRead } from '#scripts/issue/issue-state-cli'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
@@ -150,7 +150,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 // `gather` and `to_parts` are exported so `run:next` reads the same state from the same three reads
 // rather than growing a second copy of the gather (joshuafolkken/kit#2188) — `run:next` is the
 // consumer of `run:prep` the epic #2166 wanted.
-const run_prep_cli = { USAGE, gather, main, parse_number, run, to_parts }
+const run_prep_cli = { gather, parse_number, run, to_parts }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 

package/scripts/run/run-prep-locate.ts

@@ -159,7 +159,7 @@ async function locate(text: string): Promise<string> {
 	return format_locations(located)
 }
 
-const run_prep_locate = { extract_targets, format_locations, locate, parse_hits }
+const run_prep_locate = { extract_targets, locate, parse_hits }
 
 export type { Hit, Located }
 export { run_prep_locate }

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

@@ -28,7 +28,7 @@ import { run_progress_read, type ObservationRead } from './run-progress-read'
 // `backlogrun` parent — `ready #N · free lanes N` — which is itself something the parent acts on.
 //
 // **It cannot send a Telegram.** That is structural rather than a promise — nothing here imports
-// `scripts/git/telegram-notify`, which is the only egress there is. A heartbeat every twenty minutes on
+// `scripts/notify/telegram-notify`, which is the only egress there is. A heartbeat every twenty minutes on
 // a phone is notification fatigue, and it would cheapen the `confirmation` and `completion` messages
 // that do need to interrupt someone.
 
@@ -347,10 +347,13 @@ async function run_ticks(
 	let loop = seed_loop(target, started_ms)
 
 	while (Date.now() - started_ms < options.max_ms && !run_progress_clock.is_life_ended(life)) {
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await sleep(options.tick_ms)
 		run_progress_clock.ping_life(life)
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		loop = await step(options, target, loop)
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		const exit = await wait_exit(loop, wait)
 
 		if (exit !== undefined) return exit
@@ -491,27 +494,21 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 }
 
 const run_progress_cli = {
-	DECLINE_RETRY_SECONDS,
 	DEFAULT_MAX_HOURS,
 	DISABLED_NOTICE,
 	FAILED_TICK_PREFIX,
 	FRESH_LOOP,
 	IDLE_NOTICE,
 	LANE_CHILD_NOTICE,
-	MARKED_NOTICE,
 	REPO_UNRESOLVED_NOTICE,
-	TICK_SECONDS,
 	UNREADABLE_NOTICE,
 	USAGE,
 	WAIT_EXPIRED_NOTICE,
-	main,
 	read_arguments: run_progress_args.read_arguments,
-	report_decline,
 	run,
 	step,
 	to_interval_ms: run_progress_args.to_interval_ms,
 	to_max_ms: run_progress_args.to_max_ms,
-	to_options,
 	wait_once,
 }
 

package/scripts/run/run-progress-clock.ts

@@ -1,6 +1,5 @@
-import { git_utilities } from '#scripts/git/constants'
+import { git_common_directory } from '#scripts/git/git-common-directory'
 import { stamp_file } from '#scripts/josh/stamp-file'
-import { execaSync } from 'execa'
 import { z } from 'zod'
 
 // The report clock `josh run:progress` keeps, in the one form both of its readers can use
@@ -16,9 +15,10 @@ import { z } from 'zod'
 //
 // **The key is the work tree's own git directory**, the way `run_hold` keys its record: two lanes of
 // one repository are two runs, and one lane's report must not silence the other's clock. The
-// synchronous twin asks `git rev-parse --absolute-git-dir`, which is the first of the two lines
-// `git_command.git_directories` reads and the one the asynchronous path already takes — so the two
-// spellings cannot name different files.
+// synchronous twin is `git_common_directory.own()`, which asks the same two lines
+// `git_command.git_directories` reads and takes the first — so the two spellings cannot name different
+// files. A git read that fails or times out answers `undefined`, which reads as "no clock here" and
+// lets the call through.
 
 const PROGRESS_PREFIX = 'josh-run-progress-'
 // The watcher's own liveness record, kept apart from the report clock above: that one says *when* the
@@ -55,14 +55,6 @@ const MS_PER_MINUTE = 60_000
 const LOG_STALE_MINUTES = 90
 const LOG_STALE_MS = LOG_STALE_MINUTES * MS_PER_MINUTE
 const BLOCK_SEPARATOR = '\n\n'
-// The lookup only ever decides whether a rule speaks, so a git call that hangs must not hold the hook
-// that is holding the user's call. A timeout answers `undefined`, which reads as "no clock here" and
-// lets the call through — the direction every other failure in this path already takes.
-const GIT_TIMEOUT_MS = 5000
-// The first of the two lines `git_command.git_directories` reads, asked on its own because that is the
-// one the record is keyed on. Asking git rather than assuming a directory named `.git` is what makes a
-// linked work tree, a bare repository and a `--separate-git-dir` clone all answer correctly.
-const GIT_DIRECTORY_ARGUMENTS: ReadonlyArray<string> = ['rev-parse', '--absolute-git-dir']
 
 // `line` is the last heartbeat the watcher printed, kept verbatim beside the clock so a reader that
 // cannot see the watcher's transcript — a person checking a woken headless `backlogrun` through
@@ -259,25 +251,8 @@ function end_life(target: string): void {
 	stamp_file.remove_stamp(target)
 }
 
-// execa runs the binary directly with an argument array and no `shell` option, so CLI args cannot
-// break out of a shell sandbox; the git command and args are internally controlled, never untrusted
-// input. tssecurity:S8705 is a false positive here.
-function git_directory_sync(): string | undefined {
-	const git_binary = git_utilities.get_git_command_for_spawn()
-	const result = execaSync(git_binary, GIT_DIRECTORY_ARGUMENTS, {
-		reject: false,
-		timeout: GIT_TIMEOUT_MS,
-	}) // NOSONAR
-
-	if (result.exitCode !== 0) return undefined
-
-	const output = result.stdout.trim()
-
-	return output === '' ? undefined : output
-}
-
 function stamp_target_sync(): string | undefined {
-	const directory = git_directory_sync()
+	const directory = git_common_directory.own()
 
 	return directory === undefined ? undefined : stamp_target_of(directory)
 }
@@ -299,8 +274,6 @@ const run_progress_clock = {
 	LIFE_PREFIX,
 	LOG_KEEP,
 	LOG_STALE_MS,
-	PROGRESS_PREFIX,
-	append_line,
 	begin_life,
 	end_life,
 	is_life_ended,
@@ -314,7 +287,6 @@ const run_progress_clock = {
 	read_last_report,
 	read_last_report_sync,
 	stamp_target_of,
-	stamp_target_sync,
 }
 
 export { run_progress_clock }

package/scripts/run/run-progress-config.ts

@@ -27,8 +27,6 @@ import { run_progress } from './run-progress'
 // watcher it guards kept the default, which is the one state this module exists to prevent.
 
 const PACKAGE_FILE = 'package.json'
-const CONFIG_FIELD = 'josh'
-const INTERVAL_FIELD = 'progress_interval_minutes'
 
 // Deep enough to cross a workspace package and its root, and bounded so a path that never reaches a
 // root — a broken mount, a mocked `dirname` — cannot spin.
@@ -108,8 +106,6 @@ function configured_interval_ms(directory: string = process.cwd()): number {
 }
 
 const run_progress_config = {
-	CONFIG_FIELD,
-	INTERVAL_FIELD,
 	PACKAGE_FILE,
 	configured_interval_ms,
 	read_package_minutes,