@joshuafolkken/kit 1.1050.0 → 1.1094.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

@@ -2,6 +2,7 @@
 import { fileURLToPath } from 'node:url'
 import { parseArgs } from 'node:util'
 import { josh_command } from '#scripts/josh/josh-run'
+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
@@ -57,6 +58,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 +84,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 +135,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

@@ -138,9 +138,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 +234,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/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/lines-command.ts

@@ -161,7 +161,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**

package/scripts/observations/observations-flush.ts

@@ -1,5 +1,5 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { git_command } from '#scripts/git/git-command'
-import { git_gh_command } from '#scripts/git/git-gh-command'
 import { main_sync } from '#scripts/git/main-sync'
 import { error_text } from '#scripts/lib/error-message'
 import { observation_ledger, OBSERVATION_LEDGER_DIRECTORY } from './observation-ledger'
@@ -308,6 +308,7 @@ async function stage_ledger(): Promise<void> {
 	const ledger_paths = observation_ledger.ledger_paths(await git_command.status())
 
 	for (const file_path of ledger_paths) {
+		// 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_path)
 	}
 }
@@ -423,7 +424,6 @@ const observations_flush = {
 	broken_lines_message,
 	CLEAN_MESSAGE,
 	COMMIT_MESSAGE,
-	empty_flush_message,
 	flush,
 	flush_branch_message,
 	has_ledger_change,

package/scripts/overrides/lockfile-overrides.ts

@@ -1,4 +1,4 @@
-import { yaml_document } from '#scripts/yaml/yaml-document'
+import { yaml_document } from '#scripts/lib/yaml-document'
 import { overrides_check } from './overrides-logic'
 import { lockfile_importers_schema, type LockfileImporter } from './schemas'
 

package/scripts/overrides/overrides-logic.ts

@@ -1,4 +1,4 @@
-import { yaml_document } from '#scripts/yaml/yaml-document'
+import { yaml_document } from '#scripts/lib/yaml-document'
 import {
 	package_pnpm_schema,
 	package_with_deps_schema,

package/scripts/package/package-scout-cli.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
 import { cli_flags } from '#scripts/lib/cli-flags'
+import { timed_fetch } from '#scripts/lib/timed-fetch'
 import { z } from 'zod'
 import {
 	package_scout,
@@ -23,7 +24,6 @@ const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const ARGV_OFFSET = 2
 const DEFAULT_SIZE = 10
-const FETCH_TIMEOUT_MS = 10_000
 const REGISTRY = 'https://registry.npmjs.org'
 const DOWNLOADS_API = 'https://api.npmjs.org/downloads/point/last-week'
 const USAGE = 'Usage: josh pkg:scout <keywords> [--size <n>]'
@@ -51,7 +51,7 @@ type Latest = z.infer<typeof latest_schema>
 
 async function fetch_json<T>(url: string, schema: z.ZodType<T>): Promise<T | undefined> {
 	try {
-		const response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) })
+		const response = await timed_fetch(url)
 		if (!response.ok) return undefined
 
 		return schema.parse(await response.json())
@@ -172,14 +172,9 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 
 const package_scout_cli = {
 	USAGE,
-	SEARCH_FAILED_MESSAGE,
 	DEFAULT_SIZE,
 	read_arguments,
-	facts_of,
-	license_of,
-	to_candidate,
 	run,
-	main,
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))

package/scripts/package/package-scout.ts

@@ -112,8 +112,6 @@ const package_scout = {
 	NEAR_TIE_THRESHOLD,
 	to_metrics,
 	rank,
-	tie_gap,
-	verdict_of,
 	build_table,
 }
 

package/scripts/propagate/propagate-git-failure.ts

@@ -178,7 +178,6 @@ const propagate_git_failure = {
 	NO_COMMIT,
 	NOT_OPENED,
 	PUSH_FAILED,
-	TAIL_LINE_COUNT,
 	UNCOMMITTED,
 	attribute,
 	describe_failure,

package/scripts/propagate/propagate-git.ts

@@ -207,7 +207,6 @@ function return_to_default_branch(repository_path: string): boolean {
 
 const propagate_git = {
 	default_branch,
-	fetch_branch,
 	return_to_default_branch,
 	current_branch,
 	commit_ahead,
@@ -215,7 +214,6 @@ const propagate_git = {
 	has_pre_push_hook,
 	can_push_without_hooks,
 	is_clean,
-	is_up_to_date,
 	decide_tree_state,
 	tree_state,
 }

package/scripts/propagate/propagate-publish.ts

@@ -1,4 +1,4 @@
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 import { poll } from '#scripts/lib/poll'
 import { with_page_size } from '#scripts/version/version-remote'
 
@@ -161,6 +161,7 @@ async function wait_for_publish(
 		const { state } = probe_once(resolved, versions_endpoint, target_version, progress)
 
 		if (state !== undefined) return finish(state, target_version, progress.attempts)
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await resolved.sleep(resolved.interval_ms)
 	}
 
@@ -168,8 +169,6 @@ async function wait_for_publish(
 }
 
 const propagate_publish = {
-	DEFAULT_TIMEOUT_MS,
-	DEFAULT_INTERVAL_MS,
 	UNREADABLE_THRESHOLD,
 	is_version_published,
 	should_keep_waiting,

package/scripts/propagate/propagate-run.ts

@@ -189,8 +189,6 @@ function format_report(results: ReadonlyArray<TargetResult>): string {
 const propagate_run = {
 	PROPAGATED_REASON,
 	LEFTOVER_NOTE,
-	has_leftover_changes,
-	leftover_of,
 	STEP_RETURN,
 	STEP_PRECHECK,
 	STEP_ISSUE,

package/scripts/propagate/propagate-steps.ts

@@ -1,7 +1,7 @@
 import { pr_classification } from '#scripts/ci/pr-classification'
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
-import { git_gh_issue_write } from '#scripts/git/git-gh-issue-write'
-import { OTHER_CHANGE_LABEL } from '#scripts/git/issue-labels'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
+import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
+import { OTHER_CHANGE_LABEL } from '#scripts/issue/issue-labels'
 import { GATE_COMMAND } from '#scripts/josh/josh-command-types'
 import { error_text } from '#scripts/lib/error-message'
 import { build_upgrade_shell_command } from '#scripts/version/upgrade-shell-command'
@@ -428,14 +428,12 @@ function describe_step(target: PropagateTarget, step: string): StepResult {
 }
 
 const propagate_steps = {
-	STEP_COMMANDS,
 	JOSH_BIN,
 	PROPAGATE_ORIGIN,
 	sync_command,
 	upgrade_command,
 	upgrade_commands,
 	sync_commands,
-	return_step,
 	VERIFY_SCRIPT,
 	issue_title,
 	issue_body,