@joshuafolkken/kit 1.1050.0 → 1.1128.0

package/scripts/lane/lane-handoff.ts

@@ -0,0 +1,38 @@
+import { git_common_directory } from '#scripts/git/git-common-directory'
+import { run_ship_detach } from '#scripts/run/run-ship-detach'
+import { lane_child_marker, type MarkerSource } from './lane-child-marker'
+
+// Whether a lane has handed its post-implementation region to the detached ship (joshuafolkken/kit#2962).
+//
+// **A child that ran `pnpm josh ship --detach` waits on nobody when it ends.** The supervisor drives the
+// gate, the review and the merge, and notifies on its own outcome, so the `Stop` hook's demand for a
+// `confirmation` notify and `lane-park`'s refusal of that notify only bought a "nothing needed"
+// Telegram and a wasted turn — measured on 2026-10-02 as 43 demands, 21 refusals and ~94 extra turns.
+// Both hooks read this one predicate, so they cannot disagree about whether the lane was handed off.
+//
+// **Running, never merely recorded.** A ship that failed hands its region back to the child, whose
+// record then reads `failed`; that child is waiting again and owes the notify, so only a live
+// supervisor counts as a hand-off.
+
+// A detached ship for `issue` is live in the repository `directory` belongs to — the single reading
+// `lane:await`, `run:merge` and the two stop hooks share.
+function is_ship_running(issue: string, directory: string): boolean {
+	const repository = git_common_directory.repository(directory)
+
+	return (
+		repository !== undefined && run_ship_detach.read_result(repository, issue)?.result === 'running'
+	)
+}
+
+// This session is the dispatched lane child for `directory` and its own ship is running.
+function is_handed_off(directory: string, source: MarkerSource = process.env): boolean {
+	const issue = lane_child_marker.marked_issue(source)
+
+	if (issue === undefined || !lane_child_marker.is_child_of(directory, source)) return false
+
+	return is_ship_running(issue, directory)
+}
+
+const lane_handoff = { is_handed_off, is_ship_running }
+
+export { lane_handoff }

package/scripts/lane/lane-launch-cli.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { parseArgs } from 'node:util'
 import { josh_command } from '#scripts/josh/josh-run'
+import { cli_flags } from '#scripts/lib/cli-flags'
+import { INSTALL_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import { execa } from 'execa'
 
 // `josh lane:launch <issue> [--stash <message>]` — one composite command for a `backlogrun` lane-start
@@ -34,21 +35,15 @@ interface LaunchContext {
 }
 
 function read_context(argv: ReadonlyArray<string>): LaunchContext | undefined {
-	try {
-		const parsed = parseArgs({
-			args: [...argv],
-			options: OPTIONS,
-			strict: true,
-			allowPositionals: true,
-		})
-		const [issue, ...rest] = parsed.positionals
-
-		if (issue === undefined || rest.length > 0 || !ISSUE_PATTERN.test(issue)) return undefined
-
-		return { issue, stash: parsed.values.stash }
-	} catch {
-		return undefined
-	}
+	const parsed = cli_flags.arguments_of(argv, OPTIONS)
+
+	if (parsed === undefined) return undefined
+
+	const [issue, ...rest] = parsed.positionals
+
+	if (issue === undefined || rest.length > 0 || !ISSUE_PATTERN.test(issue)) return undefined
+
+	return { issue, stash: parsed.values.stash }
 }
 
 // The pop brought in the `pnpm-lock.yaml` `josh latest` rewrote, so this one lane installs a second
@@ -57,6 +52,7 @@ function read_context(argv: ReadonlyArray<string>): LaunchContext | undefined {
 async function install(directory: string): Promise<boolean> {
 	const result = await execa(PNPM, ['--dir', directory, 'install', '--frozen-lockfile'], {
 		reject: false,
+		timeout: INSTALL_TIMEOUT_MS,
 	})
 
 	if ((result.exitCode ?? FAILURE_EXIT_CODE) === SUCCESS_EXIT_CODE) return true
@@ -82,29 +78,37 @@ async function prepare(stash: string | undefined, directory: string): Promise<bo
 	return await install(directory)
 }
 
-// The launch chain in-process: the dispatched child's pid, or `undefined` when a step refused. The CLI
-// prints the pid; `backlog:drive` launches through this same chain (joshuafolkken/kit#2508).
-async function launch_lane(context: LaunchContext): Promise<string | undefined> {
+// Where the chain ended. `unopened` is a `lane:open` refusal — no lane was taken; `failed` is a step
+// after it, which leaves the opened lane holding a seat, so a caller cannot read the two alike
+// (joshuafolkken/kit#3027).
+type LaunchOutcome = { kind: 'launched'; pid: string } | { kind: 'unopened' } | { kind: 'failed' }
+
+const UNOPENED: LaunchOutcome = { kind: 'unopened' }
+const FAILED: LaunchOutcome = { kind: 'failed' }
+
+// The launch chain in-process. The CLI prints the pid; `backlog:drive` launches through this same
+// chain (joshuafolkken/kit#2508).
+async function launch_lane(context: LaunchContext): Promise<LaunchOutcome> {
 	const opened = await josh_command.josh_run(['lane:open', context.issue], should_forward_stderr)
 
-	if (opened.code !== SUCCESS_EXIT_CODE) return undefined
+	if (opened.code !== SUCCESS_EXIT_CODE) return UNOPENED
 
-	if (!(await prepare(context.stash, opened.out))) return undefined
+	if (!(await prepare(context.stash, opened.out))) return FAILED
 
 	const dispatched = await josh_command.josh_run(
 		['lane:dispatch', context.issue],
 		should_forward_stderr,
 	)
 
-	return dispatched.code === SUCCESS_EXIT_CODE ? dispatched.out : undefined
+	return dispatched.code === SUCCESS_EXIT_CODE ? { kind: 'launched', pid: dispatched.out } : FAILED
 }
 
 async function launch(context: LaunchContext): Promise<number> {
-	const pid = await launch_lane(context)
+	const outcome = await launch_lane(context)
 
-	if (pid === undefined) return FAILURE_EXIT_CODE
+	if (outcome.kind !== 'launched') return FAILURE_EXIT_CODE
 
-	console.info(pid)
+	console.info(outcome.pid)
 
 	return SUCCESS_EXIT_CODE
 }
@@ -125,9 +129,9 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const lane_launch_cli = { USAGE, install, launch, launch_lane, prepare, read_context, run }
+const lane_launch_cli = { launch_lane, read_context, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 
-export type { LaunchContext }
+export type { LaunchContext, LaunchOutcome }
 export { lane_launch_cli }

package/scripts/lane/lane-open.ts

@@ -279,10 +279,7 @@ async function open_lane(issue: string): Promise<OpenOutcome> {
 }
 
 const lane_open = {
-	build_plan,
-	guard_unreadable,
 	open_lane,
-	read_root_environment,
 }
 
 export type { OpenOutcome }

package/scripts/lane/lane-output.ts

@@ -115,7 +115,6 @@ function describe_refusal(refusal: Refusal, issue: string): string {
 const lane_output = {
 	NO_OUTPUT,
 	describe_refusal,
-	invalid_reason,
 	read_output,
 	record_output,
 }

package/scripts/lane/lane-registry.ts

@@ -217,6 +217,14 @@ async function list_lanes(): Promise<Array<LaneInfo>> {
 	return lanes.toSorted((left, right) => Number(left.issue) - Number(right.issue))
 }
 
+// The lanes a parent is still waiting on. A stranded lane has no child working in it, so it is not
+// in-flight — the one definition the watcher guard and the headless stop rule both read.
+async function has_lanes_in_flight(): Promise<boolean> {
+	const lanes = await list_lanes()
+
+	return lanes.some((lane) => !lane.is_stranded)
+}
+
 /** The seats live lanes hold — what a new lane's seat has to avoid. */
 function used_seats(lanes: ReadonlyArray<LaneInfo>): Array<number> {
 	return lanes.map((lane) => lane.seat).filter((seat): seat is number => seat !== undefined)
@@ -246,6 +254,7 @@ async function find_open_lane(issue: string): Promise<LaneInfo | undefined> {
 const lane_registry = {
 	find_lane,
 	find_open_lane,
+	has_lanes_in_flight,
 	list_lanes,
 	main_repository_root,
 	parse_block,

package/scripts/lane/openai-lane-ship.ts

@@ -17,7 +17,9 @@ async function wait_for_ship(issue: string, prior_launch: string | undefined): P
 	if (read === undefined || read.launch_id === prior_launch) return 'none'
 
 	while (read.result === 'running') {
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await sleep(POLL_MS)
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		read = await current(issue)
 		if (read === undefined) return 'abnormal'
 	}

package/scripts/lane/openai-lane-supervisor-decision.ts

@@ -48,6 +48,7 @@ async function is_approved(lane_directory: string, nonce: string): Promise<boole
 		const decision = read(lane_directory, nonce)?.decision
 		if (decision !== undefined) return decision === 'approved'
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await new Promise((resolve) => setTimeout(resolve, APPROVAL_POLL_MS))
 	}
 
@@ -58,6 +59,6 @@ function remove(lane_directory: string, nonce: string): void {
 	stamp_file.remove_stamp(target(lane_directory, nonce))
 }
 
-const openai_lane_supervisor_decision = { approve, cancel, is_approved, remove, target }
+const openai_lane_supervisor_decision = { approve, cancel, is_approved, remove }
 
 export { openai_lane_supervisor_decision }

package/scripts/lane/openai-lane-supervisor.ts

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url'
 import { agent_argv } from '#scripts/agent/agent-argv'
 import type { AgentProfile } from '#scripts/agent/agent-role-profile'
 import { process_identity } from '#scripts/josh/process-identity'
+import { process_owner_schema } from '#scripts/josh/process-owner'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { detached_launch, type LaunchArgv } from '#scripts/run/detached-launch'
 import { run_cut, type RunCut } from '#scripts/run/run-cut'
@@ -22,11 +23,12 @@ const CHILD_POLL_MS = 250
 const CLAIM_POLL_MS = 50
 const CLAIM_POLL_LIMIT = 40
 const SUPERVISOR_SCRIPT = fileURLToPath(new URL('openai-lane-supervisor-cli.ts', import.meta.url))
-const owner_schema = z.object({
+// The shared owner pair, with the pid narrowed: this record is written only by a live supervisor, so a
+// pid that is not a real one marks it as corrupt rather than as a dead owner.
+const owner_schema = process_owner_schema.extend({
 	issue: z.string(),
 	nonce: z.string(),
 	pid: z.number().int().positive(),
-	process_start: z.string().optional(),
 })
 const state_schema = z.object({
 	owner_nonce: z.string(),
@@ -81,6 +83,7 @@ async function wait_for_active(lane_directory: string): Promise<SupervisorOwner
 	for (let attempt = 0; attempt < CLAIM_POLL_LIMIT; attempt += 1) {
 		const owner = active(lane_directory)
 		if (owner !== undefined) return owner
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await new Promise((resolve) => setTimeout(resolve, CLAIM_POLL_MS))
 	}
 
@@ -298,6 +301,7 @@ async function wait_for_inherited_child(
 	child_process_start: string | undefined,
 ): Promise<void> {
 	while (process_identity.is_same_process(child_pid, child_process_start) !== false) {
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await new Promise((resolve) => setTimeout(resolve, CHILD_POLL_MS))
 	}
 }
@@ -350,10 +354,8 @@ const openai_lane_supervisor = {
 	approve: openai_lane_supervisor_decision.approve,
 	cancel: openai_lane_supervisor_decision.cancel,
 	claim,
-	decision_path: openai_lane_supervisor_decision.target,
 	marker_path,
 	new_nonce: randomUUID,
-	read,
 	release,
 	state_path,
 	supervise,

package/scripts/lane/openai-review-broker.ts

@@ -6,6 +6,7 @@ import { agent_argv } from '#scripts/agent/agent-argv'
 import { agent_role_profile } from '#scripts/agent/agent-role-profile'
 import { git_common_directory } from '#scripts/git/git-common-directory'
 import { stamp_file } from '#scripts/josh/stamp-file'
+import { error_text } from '#scripts/lib/error-message'
 import { detached_launch } from '#scripts/run/detached-launch'
 import { run_ship_review } from '#scripts/run/run-ship-review'
 import { z } from 'zod'
@@ -102,7 +103,9 @@ function write_response(target: string, body: z.infer<typeof response_schema>):
 async function launched(lane: LaneInfo, round: ReviewRound): Promise<boolean> {
 	try {
 		return await launch_review(lane, round)
-	} catch {
+	} catch (error) {
+		error_text.trace_swallowed('openai_review_broker.launched', error)
+
 		return false
 	}
 }
@@ -138,9 +141,11 @@ async function serve(
 
 		if (received?.session === session && received.nonce !== last_nonce) {
 			last_nonce = received.nonce
+			// eslint-disable-next-line no-await-in-loop -- requests are served one at a time, in arrival order
 			await process_request(lane, response, received, state)
 		}
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await sleep(POLL_MS)
 	}
 }
@@ -232,6 +237,7 @@ async function wait_response(target: string, session: string, nonce: string): Pr
 		const verdict = response_verdict(read_record(target, response_schema), session, nonce)
 		if (verdict !== 'wait') return verdict === 'success'
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await sleep(POLL_MS)
 	}
 

package/scripts/lib/bounded-pool.ts

@@ -70,6 +70,7 @@ async function drain<Item, Result>(
 		const [index, item] = entry
 
 		try {
+			// eslint-disable-next-line no-await-in-loop -- one consumer runs one task at a time; the pool's width is the concurrency
 			pool.results.push({ index, value: await worker(item, index) })
 		} catch (error) {
 			pool.failures.push(error)

package/scripts/lib/cli-flags.ts

@@ -1,4 +1,4 @@
-import { parseArgs, type ParseArgsConfig } from 'node:util'
+import { parseArgs, type ParseArgsConfig, type ParseArgsOptionsConfig } from 'node:util'
 
 // Argument reading for the commands under `scripts/`.
 //
@@ -32,6 +32,35 @@ function parse_or_undefined<T extends ParseArgsConfig>(
 	}
 }
 
-const cli_flags = { refuse_unknown_flags, parse_or_undefined }
+// The two shapes every command reads `argv` in: flags alone, or flags beside positionals. Both are
+// strict, so an unknown flag is `undefined` rather than a silently ignored typo; the commands had each
+// carried a one-line wrapper spelling these out (joshuafolkken/kit#3072).
+type FlagsOnly<T extends ParseArgsOptionsConfig> = ReturnType<
+	typeof parseArgs<{ args: Array<string>; options: T }>
+>
+type WithPositionals<T extends ParseArgsOptionsConfig> = ReturnType<
+	typeof parseArgs<{ args: Array<string>; options: T; allowPositionals: true }>
+>
+
+function values_of<T extends ParseArgsOptionsConfig>(
+	argv: ReadonlyArray<string>,
+	options: T,
+): FlagsOnly<T>['values'] | undefined {
+	return parse_or_undefined({ args: [...argv], options })?.values
+}
+
+function arguments_of<T extends ParseArgsOptionsConfig>(
+	argv: ReadonlyArray<string>,
+	options: T,
+): WithPositionals<T> | undefined {
+	return parse_or_undefined({ args: [...argv], options, allowPositionals: true })
+}
+
+// A string option's value, or `undefined` where the flag was absent or parsed as anything else.
+function string_of(value: unknown): string | undefined {
+	return typeof value === 'string' ? value : undefined
+}
+
+const cli_flags = { refuse_unknown_flags, parse_or_undefined, values_of, arguments_of, string_of }
 
 export { cli_flags }

package/scripts/lib/error-message.ts

@@ -4,6 +4,17 @@ function message_of(error: unknown): string {
 	return error instanceof Error ? error.message : String(error)
 }
 
-const error_text = { message_of }
+const DEBUG_ENV_KEY = 'JOSH_DEBUG'
+
+// A catch that folds a failure into a state verdict — "dirty", "not merged", "not written" — leaves no
+// trace of why by default, so a wrong verdict cannot be followed back to its cause (joshuafolkken/kit#3067).
+// `JOSH_DEBUG` set to any non-blank value writes the swallowed reason to stderr; unset, nothing changes.
+function trace_swallowed(where: string, error: unknown): void {
+	if ((process.env[DEBUG_ENV_KEY] ?? '').trim() === '') return
+
+	process.stderr.write(`josh debug: ${where}: ${message_of(error)}\n`)
+}
+
+const error_text = { message_of, trace_swallowed }
 
 export { error_text }

package/scripts/lib/json-value.ts

@@ -1,9 +1,10 @@
 // Reading JSON that may not be JSON (joshuafolkken/kit#1151).
 //
-// Four readers under `scripts/` parse text that a defect, a truncated write or an older format can
-// make unparseable — a transcript line, a settings file, an MCP declaration — and every one of them
-// answers "could not read this" rather than throwing, because a single bad line must not fail a
-// whole report. They had begun to carry a copy of the same try/catch each; this is the one copy.
+// Readers under `scripts/` parse text that a defect, a truncated write or an older format can make
+// unparseable — a transcript line, a settings file, an MCP declaration, a lock record, CLI output —
+// and every one of them answers "could not read this" rather than throwing, because a single bad line
+// must not fail a whole report. They had begun to carry a copy of the same try/catch each; this is the
+// one copy, and `is_record` beside it is the one object test (joshuafolkken/kit#2986).
 
 function parse_or_undefined(text: string): unknown {
 	try {

package/scripts/lib/poll.ts

@@ -1,6 +1,6 @@
 // One bounded polling loop and one sleep, in one place.
 //
-// **Three modules had already written the same three-line `sleep`** — `git/git-pr-checks.ts`,
+// **Three modules had already written the same three-line `sleep`** — `gh/git-pr-checks.ts`,
 // `eval/eval-run.ts` and `propagate/propagate-publish.ts` — and the release command's tag watch
 // (joshuafolkken/kit#1169) would have been the fourth. `CLAUDE.md` → "No clones — single-source"
 // reads an existing duplication as the signal to single-source it rather than as a license to add to
@@ -43,8 +43,10 @@ async function poll_until(is_done: () => Promise<boolean>, options: PollOptions)
 	const wait = options.sleeper ?? sleep
 
 	for (let attempt = 0; attempt < options.attempts; attempt += 1) {
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		if (await is_done()) return true
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await wait_between(wait, options.interval_ms, attempt, options.attempts)
 	}
 

package/scripts/lib/timed-fetch.ts

@@ -0,0 +1,15 @@
+import { FETCH_TIMEOUT_MS } from './timeouts'
+
+// **The one place in `scripts/` that calls the global `fetch`** (joshuafolkken/kit#2981). Every request
+// carries a time limit, so a stalled connection rejects instead of holding an unattended run forever;
+// `timed-fetch-usage.test.ts` refuses a direct `fetch` call anywhere else. The signal also bounds the
+// body read, because the response stream aborts with it.
+async function timed_fetch(
+	url: string,
+	init: Omit<RequestInit, 'signal'> = {},
+	timeout_ms: number = FETCH_TIMEOUT_MS,
+): Promise<Response> {
+	return await fetch(url, { ...init, signal: AbortSignal.timeout(timeout_ms) })
+}
+
+export { timed_fetch }

package/scripts/lib/timeouts.ts

@@ -0,0 +1,13 @@
+// Shared time limits for the calls that leave the process — a network request or a spawned command.
+// An unattended run (a lane, `followup`, a backlog drain) that waits on a request or a command with no
+// limit stays stuck where it stopped and never comes back (joshuafolkken/kit#2981), so every such
+// call takes one of these, and a value used in more than one place is named once here.
+
+// One HTTP request to a registry, an API or a webhook.
+const FETCH_TIMEOUT_MS = 10_000
+// A short command that only answers a question (`gh --version`, `pnpm config get`).
+const COMMAND_TIMEOUT_MS = 30_000
+// A `pnpm install`, which can download the whole dependency tree on a cold store.
+const INSTALL_TIMEOUT_MS = 600_000
+
+export { COMMAND_TIMEOUT_MS, FETCH_TIMEOUT_MS, INSTALL_TIMEOUT_MS }

package/scripts/{yaml → lib}/yaml-document.ts

@@ -1,3 +1,4 @@
+import { json_value } from '#scripts/lib/json-value'
 import { json_object_schema } from '#scripts/lib/schemas'
 import { load, loadAll, YAMLException } from 'js-yaml'
 
@@ -25,8 +26,9 @@ function parse_yaml(content: string): Record<string, unknown> {
 	return json_object_schema.parse(raw)
 }
 
+// A YAML mapping parses to the same plain object a JSON object does, so the test is `json_value`'s.
 function is_mapping_document(value: unknown): value is Record<string, unknown> {
-	return typeof value === 'object' && value !== null && !Array.isArray(value)
+	return json_value.is_record(value)
 }
 
 // pnpm 11 writes pnpm-lock.yaml as a multi-document stream (the package-manager document, then the

package/scripts/{bytes → lines}/bytes-command.ts

@@ -170,10 +170,8 @@ const bytes_command = {
 	entry_row,
 	entry_rows,
 	near_ceiling_statuses,
-	run_bytes,
 	scan_lines,
 	status_row,
-	NONE_NEAR,
 	NOT_A_FILE,
 	NOT_BUDGETED,
 }

package/scripts/lines/line-targets.ts

@@ -40,10 +40,6 @@ const LS_FILES_FLAGS: ReadonlyArray<string> = [
 	'-z',
 ]
 const NUL = '\0'
-// `--show-toplevel` prints the absolute repository (or worktree) root from anywhere inside it, so the
-// root-relative names `--full-name` returns resolve to the right absolute paths wherever the command
-// was invoked.
-const SHOW_TOPLEVEL: ReadonlyArray<string> = ['rev-parse', '--show-toplevel']
 
 function is_lint_target(relative_path: string): boolean {
 	return LINT_EXTENSIONS.has(path.extname(relative_path))
@@ -53,12 +49,6 @@ function split_names(output: string): ReadonlyArray<string> {
 	return output.split(NUL).filter((name) => name.length > 0)
 }
 
-// `git_spawn.read` is the one place ordinary git commands are spawned from, so this reuses it rather
-// than growing a second spawn site (joshuafolkken/kit#1640).
-async function repo_root(): Promise<string> {
-	return await git_spawn.read([...SHOW_TOPLEVEL])
-}
-
 // The names resolve against the repository `root`, never the process cwd: `--full-name` prints them
 // relative to the root wherever the command runs, so resolving against cwd would double the prefix
 // and drop every file when the command is invoked from a subdirectory.
@@ -73,7 +63,6 @@ async function lint_target_files(root: string): Promise<ReadonlyArray<string>> {
 const line_targets = {
 	is_lint_target,
 	lint_target_files,
-	repo_root,
 	split_names,
 }
 

package/scripts/lines/lines-command.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env tsx
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { git_command } from '#scripts/git/git-command'
 import { line_budget, type FileBudget, type LineBudget } from './line-budget'
 import { line_targets } from './line-targets'
 
@@ -122,10 +123,11 @@ function render(budgets: ReadonlyArray<FileBudget>, project_root: string): strin
 	return [header(budgets), ...rows_for(budgets, project_root)].join('\n')
 }
 
-// The scan resolves the repository root first — `budgets_for` and the row display both key off it — so
-// a run started from a subdirectory reports the same files as one started from the root.
+// The scan resolves the repository root first — `budgets_for` and the row display both key off it, and
+// `git ls-files --full-name` names files relative to it — so a run started from a subdirectory reports
+// the same files as one started from the root.
 async function run_scan(): Promise<number> {
-	const root = await line_targets.repo_root()
+	const root = await git_command.repository_root()
 	const budgets = await scan_budgets(root)
 
 	process.stdout.write(`${render(budgets, root)}\n`)
@@ -161,7 +163,6 @@ const lines_command = {
 	header,
 	near_limit_budgets,
 	not_counted_reason,
-	render,
 	row,
 	rows_for,
 	run_lines,

package/scripts/lint/lint-related-scope.ts

@@ -116,7 +116,6 @@ function eslint_arguments(files: ReadonlyArray<string>): ReadonlyArray<string> {
 
 const lint_related_scope = {
 	COMMAND_LABEL,
-	COMMAND_NAME,
 	NOTHING_LINTABLE_REASON,
 	describe_scope,
 	eslint_arguments,

package/scripts/lint/lint-related.ts

@@ -99,6 +99,6 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 	process.exitCode = await run_related_lint(process.argv.slice(changed_file_scope.ARGV_START))
 }
 
-const lint_related = { report_ignored_flags, run_related_lint }
+const lint_related = { run_related_lint }
 
 export { lint_related }

package/scripts/{git → notify}/telegram-notify.ts

@@ -1,4 +1,5 @@
 import { gh_spawn } from '#scripts/gh/gh-spawn'
+import { timed_fetch } from '#scripts/lib/timed-fetch'
 import { z } from 'zod'
 
 const TELEGRAM_API_BASE = 'https://api.telegram.org'
@@ -193,7 +194,7 @@ function build_text(input: TelegramSendInput): string {
 
 async function post_message(config: TelegramConfig, text: string): Promise<void> {
 	const url = `${TELEGRAM_API_BASE}/bot${config.bot_token}/sendMessage`
-	const response = await fetch(url, {
+	const response = await timed_fetch(url, {
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },
 		body: JSON.stringify({ chat_id: config.chat_id, text }),
@@ -412,7 +413,6 @@ async function stranded(input: StrandedInput): Promise<boolean> {
 }
 
 const telegram_notify = {
-	REPO_LOOKUP_TIMEOUT_MS,
 	confirm,
 	send,
 	send_or_report,

package/scripts/{git → notify}/telegram-test.ts

@@ -1,11 +1,11 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
 import { parseArgs } from 'node:util'
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
+import { git_gh_repo } from '#scripts/gh/git-gh-repo'
+import { github_issue_url, type IssueUrlTarget } from '#scripts/gh/github-issue-url'
+import { git_error } from '#scripts/git/git-error'
 import { josh_environment_file } from '#scripts/josh/josh-environment-file'
-import { git_error } from './git-error'
-import { git_gh_issue_read } from './git-gh-issue-read'
-import { git_gh_repo } from './git-gh-repo'
-import { github_issue_url, type IssueUrlTarget } from './github-issue-url'
 import { telegram_notify } from './telegram-notify'
 import { telegram_test_logic, type CliValues, type ResolvedContext } from './telegram-test-logic'
 

package/scripts/observations/observation-ledger-home.ts

@@ -115,7 +115,6 @@ async function append(target: string, lines: ReadonlyArray<string>): Promise<voi
 const observation_ledger_home = {
 	append,
 	issue_path,
-	ledger_directory,
 	ledger_root,
 	read,
 	writer_path,

package/scripts/observations/observation-ledger-line.ts

@@ -96,7 +96,6 @@ function missing_lines(candidates: ReadonlyArray<string>, ledger: string): Array
 const observation_ledger_line = {
 	broken_ledger_lines,
 	is_ledger_entry_line,
-	line_reason,
 	missing_lines,
 }
 

package/scripts/observations/observation-ledger-migrate.ts

@@ -146,6 +146,6 @@ function migrate(root: string): boolean {
 	).some(Boolean)
 }
 
-const observation_ledger_migrate = { claim_path, migrate }
+const observation_ledger_migrate = { migrate }
 
 export { observation_ledger_migrate }

package/scripts/observations/observations-flush-landing.ts

@@ -1,6 +1,6 @@
-import { git_gh_command } from '#scripts/git/git-gh-command'
-import type { OpenPull } from '#scripts/git/git-gh-pr-auto-merge'
-import { git_pr_checks } from '#scripts/git/git-pr-checks'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import type { OpenPull } from '#scripts/gh/git-gh-pr-auto-merge'
+import { git_pr_checks } from '#scripts/gh/git-pr-checks'
 import { error_text } from '#scripts/lib/error-message'
 
 // **A flush pull request lands whether or not the flush that opened it is still alive**