@joshuafolkken/kit 1.1050.0 → 1.1094.0

package/scripts/git/git-common-directory.ts

@@ -1,46 +1,102 @@
 import { execFileSync } from 'node:child_process'
 import { git_utilities } from './constants'
 import { git_command } from './git-command'
+import { git_location_environment, GIT_LOCATION_VARIABLES } from './git-location-environment'
+
+// The one synchronous read of a checkout's two git directories (joshuafolkken/kit#2986) — the same
+// `GIT_DIRECTORY_ARGUMENTS` `git_command.git_directories` asks asynchronously, so the two spellings
+// cannot name different directories. It had been run in three places with three timeouts and no
+// memory of the answer, though a `PreToolUse` hook may ask it several times in one call.
 
 const OWN_GIT_DIRECTORY = 0
 const COMMON_GIT_DIRECTORY = 1
-const PROBE_TIMEOUT_MS = 2000
+// The read runs inside `PreToolUse` hooks, which hold the tool call for as long as it takes;
+// `rev-parse` takes no lock, so anything past a few seconds is a fault rather than slow work.
+const PROBE_TIMEOUT_MS = 5000
+
+// **Only an answer is remembered, never a failure** — a timeout or a directory that is not yet a
+// repository is asked again next time. The key carries every input git resolves from: the directory
+// asked about and, where the environment is inherited, the git location variables it holds.
+const answers = new Map<string, ReadonlyArray<string>>()
 
-function read_directories(cwd: string): Array<string> {
-	const git = git_utilities.get_git_command_for_spawn()
-	const output = execFileSync(git, [...git_command.GIT_DIRECTORY_ARGUMENTS], {
-		cwd,
-		encoding: 'utf8',
-		stdio: ['ignore', 'pipe', 'ignore'],
-		timeout: PROBE_TIMEOUT_MS,
-	})
+// With an explicit `cwd`, the git location variables are cleared so that directory is what git answers
+// for: a hook exports `GIT_DIR`, which beats `cwd` and would name the hook's checkout instead
+// (joshuafolkken/kit#2515). Without one the environment is kept, so the read resolves the same
+// checkout as the asynchronous `git_directories`.
+function probe_environment(cwd: string | undefined): NodeJS.ProcessEnv {
+	if (cwd === undefined) return process.env
 
-	return output.trim().split('\n')
+	return { ...process.env, ...git_location_environment.location_free_environment() }
 }
 
-function select_linked(directories: ReadonlyArray<string>): string | undefined {
-	const own = directories[OWN_GIT_DIRECTORY]
-	const common = directories[COMMON_GIT_DIRECTORY]
+function cache_key(cwd: string | undefined): string {
+	if (cwd !== undefined) return `explicit\0${cwd}`
+
+	const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? '')
 
-	return own !== undefined && common !== undefined && own !== common ? common : undefined
+	return ['inherited', process.cwd(), ...locations].join('\0')
 }
 
-function resolve(cwd: string): string | undefined {
+// git's own diagnostics are discarded: a checkout it cannot describe is already the empty answer, and
+// a hook that let `fatal: not a git repository` through would print it in front of a tool call. The
+// binary is resolved through `git_utilities` exactly as `git-spawn.ts` resolves it and run with an
+// argument array and no `shell`; both are internally controlled, never untrusted input.
+function read_directories(cwd: string | undefined): ReadonlyArray<string> {
 	try {
-		return select_linked(read_directories(cwd))
+		const output = execFileSync(
+			git_utilities.get_git_command_for_spawn(),
+			[...git_command.GIT_DIRECTORY_ARGUMENTS],
+			{
+				cwd,
+				env: probe_environment(cwd),
+				encoding: 'utf8',
+				stdio: ['ignore', 'pipe', 'ignore'],
+				timeout: PROBE_TIMEOUT_MS,
+			},
+		) // NOSONAR
+
+		return output.split('\n').filter((line) => line !== '')
 	} catch {
-		return undefined
+		return []
 	}
 }
 
-function repository(cwd: string): string | undefined {
-	try {
-		return read_directories(cwd)[COMMON_GIT_DIRECTORY]
-	} catch {
-		return undefined
-	}
+// The work tree's own git directory, then the common one every work tree of the repository shares —
+// or nothing, where git cannot describe the checkout.
+function directories(cwd?: string): ReadonlyArray<string> {
+	const key = cache_key(cwd)
+	const known = answers.get(key)
+
+	if (known !== undefined) return known
+
+	const read = read_directories(cwd)
+
+	if (read.length > 0) answers.set(key, read)
+
+	return read
+}
+
+function own(cwd?: string): string | undefined {
+	return directories(cwd)[OWN_GIT_DIRECTORY]
+}
+
+function repository(cwd?: string): string | undefined {
+	return directories(cwd)[COMMON_GIT_DIRECTORY]
+}
+
+function select_linked(found: ReadonlyArray<string>): string | undefined {
+	const own_directory = found[OWN_GIT_DIRECTORY]
+	const common = found[COMMON_GIT_DIRECTORY]
+
+	return own_directory !== undefined && common !== undefined && own_directory !== common
+		? common
+		: undefined
+}
+
+function resolve(cwd: string): string | undefined {
+	return select_linked(directories(cwd))
 }
 
-const git_common_directory = { repository, resolve, select_linked }
+const git_common_directory = { directories, own, repository, resolve, select_linked }
 
 export { git_common_directory }

package/scripts/git/git-error.ts

@@ -1,5 +1,5 @@
+import { has_stderr_field } from '#scripts/gh/git-gh-exec'
 import { error_text } from '#scripts/lib/error-message'
-import { has_stderr_field } from './git-gh-exec'
 
 function get_stderr_from_error(cause: Error): string | undefined {
 	if (!has_stderr_field(cause)) return undefined
@@ -42,7 +42,41 @@ function display_error_details(cause: unknown): void {
 	console.error('💡 Details:', cause_message)
 }
 
-function handle(error: unknown): void {
+const FAILURE_EXIT_CODE = 1
+const OPERATION_CANCELLED_MESSAGE = '💡 Operation cancelled.'
+
+// **A library refuses by throwing; only the CLI entry decides the exit code** (joshuafolkken/kit#2985).
+// `process.exit()` from an imported module skips every `finally` above it (a lock release included)
+// and truncates a piped stdout, so these modules throw a typed error instead, and `handle` — the catch
+// at each entry — renders it and sets `process.exitCode`.
+interface BranchMismatch {
+	current_branch: string
+	target_branch_name: string
+}
+
+class BranchMismatchError extends Error {
+	readonly current_branch: string
+	readonly target_branch_name: string
+
+	constructor(mismatch: BranchMismatch, options?: ErrorOptions) {
+		super(
+			`Branch mismatch: on ${mismatch.current_branch}, expected ${mismatch.target_branch_name}`,
+			options,
+		)
+		this.name = 'BranchMismatchError'
+		this.current_branch = mismatch.current_branch
+		this.target_branch_name = mismatch.target_branch_name
+	}
+}
+
+class OperationCancelledError extends Error {
+	constructor() {
+		super('Operation cancelled')
+		this.name = 'OperationCancelledError'
+	}
+}
+
+function display_failure(error: unknown): void {
 	const error_message = error_text.message_of(error)
 
 	console.error('')
@@ -53,23 +87,46 @@ function handle(error: unknown): void {
 	}
 
 	console.error('')
-	process.exit(1)
 }
 
-function display_branch_mismatch_error(current_branch: string, target_branch_name: string): void {
+function display_branch_mismatch(error: BranchMismatchError): void {
 	console.error('')
 	console.error('❌ Branch mismatch detected')
 	console.error('')
-	console.error(`Current branch: ${current_branch}`)
-	console.error(`Expected branch: ${target_branch_name}`)
+	console.error(`Current branch: ${error.current_branch}`)
+	console.error(`Expected branch: ${error.target_branch_name}`)
 	console.error('')
 	console.error('💡 Please update main branch to the latest and try again.')
-	process.exit(1)
+}
+
+function display_cancelled(): void {
+	console.info(OPERATION_CANCELLED_MESSAGE)
+	console.info('')
+}
+
+function display(error: unknown): void {
+	if (error instanceof BranchMismatchError) {
+		display_branch_mismatch(error)
+
+		return
+	}
+
+	if (error instanceof OperationCancelledError) {
+		display_cancelled()
+
+		return
+	}
+
+	display_failure(error)
+}
+
+function handle(error: unknown): void {
+	display(error)
+	process.exitCode = FAILURE_EXIT_CODE
 }
 
 const git_error = {
 	handle,
-	display_branch_mismatch_error,
 }
 
-export { git_error }
+export { git_error, BranchMismatchError, OperationCancelledError }

package/scripts/git/git-issue.ts

@@ -1,6 +1,6 @@
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
 import { lane_paths } from '#scripts/lane/lane-paths'
 import { SEPARATOR_LINE } from './constants'
-import { git_gh_issue_read } from './git-gh-issue-read'
 import { git_prompt } from './git-prompt'
 
 interface IssueInfo {

package/scripts/git/git-preflight.ts

@@ -1,11 +1,11 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { git_pr } from '#scripts/gh/git-pr'
 import { error_text } from '#scripts/lib/error-message'
 import { live_evidence } from '#scripts/review/live-evidence'
 import { changed_paths } from './changed-paths'
 import { git_branch } from './git-branch'
 import { git_command } from './git-command'
-import { git_gh_command } from './git-gh-command'
 import { git_issue, type IssueInfo } from './git-issue'
-import { git_pr } from './git-pr'
 
 // joshuafolkken/kit#2817. A first `josh git -y` was refused once per unmet precondition — the title's
 // issue number, the branch name, the issue's release classification — each only after the stage

package/scripts/git/git-prompt.ts

@@ -1,9 +1,8 @@
 import { stdin as input, stdout as output } from 'node:process'
 import { createInterface, type Interface } from 'node:readline/promises'
+import { OperationCancelledError } from './git-error'
 import { git_prompt_display } from './git-prompt-display'
 
-const OPERATION_CANCELLED_MESSAGE = '💡 Operation cancelled.'
-
 const PROMPT_MESSAGES = {
 	unstaged_files: '💬 Unstaged files found. Continue anyway? (y/n): ',
 	package_json_not_staged: '💬 package.json is not staged. Continue anyway? (y/n): ',
@@ -85,16 +84,10 @@ async function with_prompt<T>(callback: PromptCallback<T>, fallback_value?: T):
 	}
 }
 
-async function confirm_with_exit_on_cancel(should_continue: () => Promise<boolean>): Promise<void> {
+async function confirm_or_cancel(should_continue: () => Promise<boolean>): Promise<void> {
 	const is_confirmed = await should_continue()
 
-	if (is_confirmed) {
-		return
-	}
-
-	console.info(OPERATION_CANCELLED_MESSAGE)
-	console.info('')
-	process.exit(1)
+	if (!is_confirmed) throw new OperationCancelledError()
 }
 
 function create_confirm_function(message: string): () => Promise<boolean> {
@@ -112,11 +105,11 @@ async function confirm_without_package_json(): Promise<boolean> {
 }
 
 async function confirm_unstaged_files(): Promise<void> {
-	await confirm_with_exit_on_cancel(confirm_continue)
+	await confirm_or_cancel(confirm_continue)
 }
 
 async function confirm_missing_package_json(): Promise<void> {
-	await confirm_with_exit_on_cancel(confirm_without_package_json)
+	await confirm_or_cancel(confirm_without_package_json)
 }
 
 async function confirm_version_not_updated(): Promise<boolean> {
@@ -124,19 +117,7 @@ async function confirm_version_not_updated(): Promise<boolean> {
 }
 
 async function confirm_without_version_update(): Promise<void> {
-	await confirm_with_exit_on_cancel(confirm_version_not_updated)
-}
-
-async function confirm_commit(): Promise<boolean> {
-	return await create_confirm_function(PROMPT_MESSAGES.commit)()
-}
-
-async function confirm_push(): Promise<boolean> {
-	return await create_confirm_function(PROMPT_MESSAGES.push)()
-}
-
-async function confirm_pr(): Promise<boolean> {
-	return await create_confirm_function(PROMPT_MESSAGES.pr)()
+	await confirm_or_cancel(confirm_version_not_updated)
 }
 
 async function ask_issue_info(prompt: Interface, question: string): Promise<string> {
@@ -190,15 +171,9 @@ async function confirm_workflow_steps(): Promise<WorkflowConfirmations> {
 }
 
 const git_prompt = {
-	confirm_continue,
 	confirm_unstaged_files,
-	confirm_without_package_json,
 	confirm_missing_package_json,
-	confirm_version_not_updated,
 	confirm_without_version_update,
-	confirm_commit,
-	confirm_push,
-	confirm_pr,
 	get_issue_info,
 	confirm_workflow_steps,
 }

package/scripts/git/git-push.ts

@@ -1,4 +1,4 @@
-import { animation_helpers, create_git_operation_config } from './animation-helpers'
+import { animation_helpers, create_git_operation_config } from '#scripts/lib/animation-helpers'
 import { git_command } from './git-command'
 
 async function push(): Promise<void> {

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}

@@ -47,7 +47,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,
 }