@joshuafolkken/kit 1.1435.0 → 1.1453.0

package/scripts/issue/issue-release-cli.ts

@@ -18,16 +18,21 @@ import { session_cite } from './session-cite'
 // --release` calls the same `link` once its Issue exists, so a new and an existing Issue are linked
 // by one body of code.
 //
+// `--wait` points the edge the other way: `<N>` is blocked by the release Issue, so a run that needs
+// the published version records a dependency rather than a `needs-decision` park, and the backlog
+// offers `<N>` again once a person closes the release Issue (joshuafolkken/kit#3824).
+//
 // The relation is written through `issue_add_blocked_by`, which addresses the repository `gh`
 // resolves — the current one, or the target a cross-repository `issue:file` has pointed `GH_REPO` at.
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const ARGV_OFFSET = 2
-const USAGE = 'Usage: josh issue:release <issue-number>'
+const USAGE = 'Usage: josh issue:release <issue-number> [--wait]'
 const NONE = 'none'
 const UNKNOWN_REPO_MESSAGE =
 	'Could not read this repository from `git remote` — check `gh auth status`.'
+const OPTIONS = { wait: { type: 'boolean' } } as const
 
 interface ReleaseIssue {
 	issue_number: number
@@ -35,7 +40,20 @@ interface ReleaseIssue {
 	is_filed: boolean
 }
 
+interface ReleaseRequest {
+	issue_number: number
+	// `<N>` waits on the release Issue, rather than blocking it.
+	is_wait: boolean
+}
+
+// The two ends of one `blocked_by` edge.
+interface Edge {
+	blocked: number
+	blocker: number
+}
+
 // `undefined` when the listing is unreadable, `NONE` when it reads and names no open release Issue.
+// `pnpm josh release` asks the same question to close the Issue it has just published.
 async function find_open(target: string): Promise<number | typeof NONE | undefined> {
 	const outcome = await git_gh_issue_list.issue_list({
 		json_fields: 'number',
@@ -91,41 +109,59 @@ async function release_of(target: string): Promise<ReleaseIssue | undefined> {
 	return filed === undefined ? undefined : { issue_number: filed, is_filed: true }
 }
 
-function linked_line(release: ReleaseIssue, issue_number: number, target: string): string {
+function release_label_of(release: ReleaseIssue, target: string): string {
 	const how = release.is_filed ? 'filed' : 'open'
-	const release_cite = session_cite.issue(release.issue_number, undefined, target)
 
-	return `release: ${release_cite} (${how}) is blocked by ${session_cite.issue(issue_number, undefined, target)}`
+	return `${session_cite.issue(release.issue_number, undefined, target)} (${how})`
 }
 
-function unlinked_line(issue_number: number, blocked: string, target: string): string {
-	const blocker = session_cite.issue(issue_number, undefined, target)
+function linked_line(release: ReleaseIssue, request: ReleaseRequest, target: string): string {
+	const release_label = release_label_of(release, target)
+	const issue_label = session_cite.issue(request.issue_number, undefined, target)
 
-	return `✖ ${blocker} could not be recorded as a blocker of ${session_cite.issue(blocked, undefined, target)}`
+	return request.is_wait
+		? `release: ${issue_label} waits on ${release_label}`
+		: `release: ${release_label} is blocked by ${issue_label}`
 }
 
-// Whether Issue `issue_number` of `target` now blocks the release Issue. Every outcome is printed.
-async function link(issue_number: number, target: string): Promise<boolean> {
+function unlinked_line(edge: Edge, target: string): string {
+	const blocker = session_cite.issue(edge.blocker, undefined, target)
+
+	return `✖ ${blocker} could not be recorded as a blocker of ${session_cite.issue(edge.blocked, undefined, target)}`
+}
+
+function edge_of(release: ReleaseIssue, request: ReleaseRequest): Edge {
+	return request.is_wait
+		? { blocked: request.issue_number, blocker: release.issue_number }
+		: { blocked: release.issue_number, blocker: request.issue_number }
+}
+
+// Whether the edge between Issue `<N>` of `target` and the release Issue is now recorded. Every
+// outcome is printed.
+async function record(request: ReleaseRequest, target: string): Promise<boolean> {
 	const release = await release_of(target)
 
 	if (release === undefined) return false
-	const blocked = String(release.issue_number)
-	const is_linked = await git_gh_issue_write.issue_add_blocked_by(blocked, String(issue_number))
+	const edge = edge_of(release, request)
+	const is_linked = await git_gh_issue_write.issue_add_blocked_by(
+		String(edge.blocked),
+		String(edge.blocker),
+	)
 
-	if (is_linked) console.info(linked_line(release, issue_number, target))
-	else console.error(unlinked_line(issue_number, blocked, target))
+	if (is_linked) console.info(linked_line(release, request, target))
+	else console.error(unlinked_line(edge, target))
 
 	return is_linked
 }
 
-// An unknown flag parses to no positionals, so it refuses the call like a missing number.
-function positionals_of(argv: ReadonlyArray<string>): ReadonlyArray<string> {
-	return cli_flags.arguments_of(argv, {})?.positionals ?? []
+// Whether Issue `issue_number` of `target` now blocks the release Issue.
+async function link(issue_number: number, target: string): Promise<boolean> {
+	return await record({ issue_number, is_wait: false }, target)
 }
 
 // The number is the one positional: a missing, malformed or second one refuses the whole call.
-function issue_number_of(argv: ReadonlyArray<string>): number | undefined {
-	const [issue_number, ...rest] = positionals_of(argv)
+function issue_number_of(positionals: ReadonlyArray<string>): number | undefined {
+	const [issue_number, ...rest] = positionals
 	const is_single = rest.length === 0 && issue_number !== undefined
 
 	return is_single && issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue_number)
@@ -133,10 +169,20 @@ function issue_number_of(argv: ReadonlyArray<string>): number | undefined {
 		: undefined
 }
 
+// An unknown flag parses to no request at all, so it refuses the call like a missing number.
+function request_of(argv: ReadonlyArray<string>): ReleaseRequest | undefined {
+	const parsed = cli_flags.arguments_of(argv, OPTIONS)
+	const issue_number = issue_number_of(parsed?.positionals ?? [])
+
+	if (parsed === undefined || issue_number === undefined) return undefined
+
+	return { issue_number, is_wait: parsed.values.wait === true }
+}
+
 async function run(argv: ReadonlyArray<string>): Promise<number> {
-	const issue_number = issue_number_of(argv)
+	const request = request_of(argv)
 
-	if (issue_number === undefined) {
+	if (request === undefined) {
 		console.error(USAGE)
 
 		return FAILURE_EXIT_CODE
@@ -150,7 +196,7 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 		return FAILURE_EXIT_CODE
 	}
 
-	return (await link(issue_number, current)) ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
+	return (await record(request, current)) ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
 }
 
 // `process.exitCode` rather than `process.exit()`, so the report on standard output drains first.
@@ -158,8 +204,8 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 	process.exitCode = await run(argv)
 }
 
-const issue_release_cli = { link, run }
+const issue_release_cli = { find_open, link, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 
-export { issue_release_cli }
+export { issue_release_cli, NONE }

package/scripts/issue/issue-release.ts

@@ -42,7 +42,9 @@ function body_of(repo: string): string {
 		'',
 		'Every Issue this one is blocked by changes something a consumer can use only once it is published. Once they have merged, a person runs `pnpm josh release` in the primary checkout.',
 		'',
-		'Close this Issue once that release is published: the next blocker files a new one, so an open release Issue names only unreleased work.',
+		'`pnpm josh release` closes this Issue once that release is published: the next blocker files a new one, so an open release Issue names only unreleased work.',
+		'',
+		'Every Issue this one blocks needs the published version (`pnpm josh issue:release <N> --wait`); closing this Issue hands each of them back to the backlog.',
 		'',
 		'`auto-ok` is never applied to this Issue by a run; a person may apply it.',
 		'',

package/scripts/josh/josh-commands-ai.ts

@@ -61,6 +61,17 @@ const AI_COMMANDS: Record<string, CommandEntry> = {
 		category: 'AI tools',
 		reference: ['[--exclude <n>[,<n>...]] [--label <name>]', 'automation', ['network']],
 	},
+	'auto-ok:judge': {
+		script: 'scripts/auto-ok/auto-ok-judge-cli.ts',
+		description:
+			'List the open issues backlogrun owes an auto-ok judgement, or record one (--apply / --decline)',
+		category: 'AI tools',
+		reference: [
+			'[--apply <n> (--lane | --solo) | --decline <n> --reason <text>]',
+			'automation',
+			['network'],
+		],
+	},
 	...BACKLOG_COMMANDS,
 	cost: {
 		script: 'scripts/cost-runtime/cost-cli.ts',

package/scripts/josh/josh-commands-issue.ts

@@ -75,7 +75,7 @@ const ISSUE_COMMANDS: Record<string, CommandEntry> = {
 			'File an Issue with every filing step: lint, Origin, fold, WIP cap, duplicate scout, labels, then epic:bundle',
 		category: 'AI tools',
 		reference: [
-			'<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,…>] [--over-cap] [--no-auto-ok] [--requested] [--release]',
+			'<title> --body-file <path> --depth <0|1|2> [--route <route>] [--label <name>] [--repo <owner/repo>] [--distinct <N,…>] [--over-cap] [--no-auto-ok] [--release]',
 			'automation',
 			['network'],
 		],
@@ -83,9 +83,9 @@ const ISSUE_COMMANDS: Record<string, CommandEntry> = {
 	'issue:release': {
 		script: 'scripts/issue/issue-release-cli.ts',
 		description:
-			"Link an Issue to the repository's open release Issue as its blocker, filing one when none is open",
+			"Link an Issue to the repository's open release Issue as its blocker (or, with --wait, as waiting on it), filing one when none is open",
 		category: 'AI tools',
-		reference: ['<issue>', 'automation', ['network']],
+		reference: ['<issue> [--wait]', 'automation', ['network']],
 	},
 }
 /* eslint-enable @typescript-eslint/naming-convention */

package/scripts/josh/josh-commands-project.ts

@@ -17,7 +17,7 @@ const PROJECT_COMMANDS: Record<string, CommandEntry> = {
 		description: 'Set a project up for the GitHub Issue workflow, from git init to the setup PR',
 		category: 'Project',
 		reference: [
-			`${PROFILE_ARGUMENTS} [--yes] [--github] [--public] [--init-command <command>] [--push-preflight-command <command>]`,
+			`${PROFILE_ARGUMENTS} [--yes] [--github] [--public] [--dry-run] [--init-command <command>] [--push-preflight-command <command>]`,
 			'developer',
 			['files', 'git', 'network', 'processes'],
 		],
@@ -52,7 +52,7 @@ const PROJECT_COMMANDS: Record<string, CommandEntry> = {
 		description: 'Initialize config in a new project',
 		category: 'Project',
 		reference: [
-			`${PROFILE_ARGUMENTS} [--no-install]`,
+			`${PROFILE_ARGUMENTS} [--no-install] [--dry-run]`,
 			'developer',
 			['files', 'network', 'processes'],
 		],

package/scripts/josh/process-identity.ts

@@ -52,6 +52,7 @@ const PROBE_ENVIRONMENT = { TZ: 'UTC', LC_ALL: 'C' }
 // `process.kill(pid, 0)` runs every permission check and delivers nothing, so it is the standard
 // liveness probe: it throws `ESRCH` where the process is gone.
 const LIVENESS_SIGNAL = 0
+const NO_SUCH_PROCESS = 'ESRCH'
 // Below this a pid is not a process: `0` addresses the caller's own process group and anything
 // negative addresses another group, so a truncated or hand-edited record carrying either would
 // otherwise answer "alive" forever.
@@ -79,18 +80,28 @@ interface StartProbes {
 	read_ps_start: (pid: number) => string | undefined
 }
 
-function is_live_pid(pid: number): boolean {
-	if (pid < LOWEST_REAL_PID) return false
-
+// The code the liveness probe was refused with, or nothing where the caller may signal the process.
+function signal_refusal(pid: number): string | undefined {
 	try {
 		process.kill(pid, LIVENESS_SIGNAL)
 
-		return true
-	} catch {
-		return false
+		return undefined
+	} catch (error) {
+		return (error as NodeJS.ErrnoException).code ?? NO_SUCH_PROCESS
 	}
 }
 
+function is_live_pid(pid: number): boolean {
+	return pid >= LOWEST_REAL_PID && signal_refusal(pid) === undefined
+}
+
+// **Whether a pid names any process at all, for a reader that may not be allowed to signal it.** Only
+// `ESRCH` proves the process gone: `EPERM` is the kernel refusing a signal to a process it has just
+// found — one under another user, or outside a sandbox that may only signal its own — so it is present.
+function is_present_pid(pid: number): boolean {
+	return pid >= LOWEST_REAL_PID && signal_refusal(pid) !== NO_SUCH_PROCESS
+}
+
 // Linux exposes field 22 as the process start time in clock ticks since boot. The command name in
 // field 2 may itself contain spaces or `)`, so parsing starts after its final closing parenthesis;
 // `state` is then index 0 and `starttime` index 19. A direct file read avoids process enumeration and
@@ -315,6 +326,19 @@ function is_same_process(
 	return matches_recorded_start(pid, recorded_start, read)
 }
 
+// `is_same_process` for a reader that may not be allowed to signal the writer (`is_present_pid`): a
+// refused signal still compares the start time, so a reissued pid separates from its writer here too.
+function is_present_process(
+	pid: number,
+	recorded_start: string | undefined,
+	read: (pid: number) => string | undefined = read_start,
+): boolean | undefined {
+	if (!is_present_pid(pid)) return false
+	if (recorded_start === undefined) return undefined
+
+	return matches_recorded_start(pid, recorded_start, read)
+}
+
 // **Whether a record is the caller's own, which is a different question from whether its writer is
 // alive**. `is_same_process` asks about the recorded process; this asks
 // whether that process *is this one*. A supervisor that has been replaced reads its successor's
@@ -339,6 +363,8 @@ const process_identity = {
 	is_live_beacon,
 	is_live_pid,
 	is_own_process,
+	is_present_pid,
+	is_present_process,
 	is_same_process,
 	open_beacon,
 	own_fields,

package/scripts/lane/lane-broker-server.ts

@@ -0,0 +1,69 @@
+import { readFileSync } from 'node:fs'
+import { process_identity } from '#scripts/josh/process-identity'
+import { stamp_file } from '#scripts/josh/stamp-file'
+import { json_value } from '#scripts/lib/json-value'
+import { z } from 'zod'
+
+// Which process serves a lane's brokered sessions, recorded beside the response it answers in.
+//
+// **A server is live while its process is, never while its event loop happens to answer.** One
+// supervisor serves every Claude lane beside its drive passes, so any synchronous call in it — a
+// `spawnSync` of an agent CLI's `--version` alone may take 10 s — stalled the timer-written heartbeat
+// past its limit and failed every review then in flight (joshuafolkken/kit#3840).
+//
+// **A record of its own rather than fields on the response**, because a ship branched before this
+// record existed parses the response strictly and reads any new field as no server at all; the
+// response keeps the shape and heartbeat that ship reads, and this record names the writer by
+// `process_identity.own_fields()`, so a pid the operating system reissued is not taken for it.
+
+const SERVER_SUFFIX = '.server'
+const server_schema = z
+	.object({
+		session: z.uuid(),
+		pid: z.number().int().positive(),
+		process_start: z.string().optional(),
+	})
+	.strict()
+type BrokerServer = z.infer<typeof server_schema>
+
+function server_path(response: string): string {
+	return `${response}${SERVER_SUFFIX}`
+}
+
+function write(response: string, session: string): void {
+	stamp_file.replace_stamp(server_path(response), { session, ...process_identity.own_fields() })
+}
+
+function remove(response: string): void {
+	stamp_file.remove_stamp(server_path(response))
+}
+
+// Only the record of the session the response names: one left by an earlier server is no answer.
+function read(response: string, session: string): BrokerServer | undefined {
+	try {
+		const server = json_value.parse_with(readFileSync(server_path(response), 'utf8'), server_schema)
+
+		return server?.session === session ? server : undefined
+	} catch {
+		return undefined
+	}
+}
+
+// **The identity is checked when a ship first finds the server, the pid while it waits.** A response
+// a killed supervisor left behind is met on that first look, where a reissued pid must not read as
+// it; the wait polls every 100 ms, where a start-time probe would spawn `ps` on each. Both read
+// through `is_present_*`, because a Codex lane's ship probes from inside its sandbox, where the kernel
+// answers `EPERM` for a supervisor it has found. A start time that cannot be read is no proof of a
+// dead server, so it does not fail the review.
+function is_serving_process(server: BrokerServer): boolean {
+	return process_identity.is_present_process(server.pid, server.process_start) !== false
+}
+
+function is_running(server: BrokerServer): boolean {
+	return process_identity.is_present_pid(server.pid)
+}
+
+const lane_broker_server = { is_running, is_serving_process, read, remove, server_path, write }
+
+export type { BrokerServer }
+export { lane_broker_server }

package/scripts/lane/lane-session-broker.ts

@@ -12,6 +12,7 @@ import { detached_launch } from '#scripts/run/detached-launch'
 import { run_ship_review } from '#scripts/run/ship/run-ship-review'
 import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
 import { z } from 'zod'
+import { lane_broker_server, type BrokerServer } from './lane-broker-server'
 import { lane_child_invocation, type ShipStop } from './lane-child-invocation'
 import { lane_child_marker } from './lane-child-marker'
 import type { LaneInfo } from './lane-registry'
@@ -32,8 +33,10 @@ const FINDINGS_PREFIX = 'josh-ship-review-findings-'
 const LOG_PREFIX = 'josh-ship-review-log-'
 const CACHE_DIRECTORY = ['node_modules', '.cache']
 const POLL_MS = 100
-const HEARTBEAT_MS = 500
-const HEARTBEAT_LIMIT_MS = 3000
+// The heartbeat is kept for a ship branched before the server record, and read only where a
+// supervisor started before it left no such record (`lane-broker-server.ts`).
+const LEGACY_HEARTBEAT_MS = 500
+const LEGACY_HEARTBEAT_LIMIT_MS = 3000
 const MINUTE_MS = 60_000
 const REQUEST_LIMIT_MINUTES = 30
 const REQUEST_LIMIT_MS = REQUEST_LIMIT_MINUTES * MINUTE_MS
@@ -203,6 +206,7 @@ async function serve(
 	}
 }
 
+// The server record is written before the response, so a ship that finds the response finds it too.
 function prepare(lane: LaneInfo): { response: string; current: BrokerResponse } {
 	const response = response_path(lane.directory, lane.issue)
 	if (response === undefined) throw new Error('review broker has no trusted response location')
@@ -211,6 +215,7 @@ function prepare(lane: LaneInfo): { response: string; current: BrokerResponse }
 
 	mkdirSync(path.dirname(response), { recursive: true })
 	mkdirSync(path.dirname(request_path(lane.directory, lane.issue)), { recursive: true })
+	lane_broker_server.write(response, session)
 	const current: BrokerResponse = {
 		session,
 		nonce: '',
@@ -227,7 +232,7 @@ function start_heartbeat(state: { current: BrokerResponse }, response: string):
 	const heartbeat = setInterval(() => {
 		state.current = { ...state.current, heartbeat_at: Date.now() }
 		write_response(response, state.current)
-	}, HEARTBEAT_MS)
+	}, LEGACY_HEARTBEAT_MS)
 
 	heartbeat.unref()
 
@@ -246,6 +251,7 @@ async function stop_server(
 	await serving
 	clearInterval(heartbeat)
 	unlinkSync(response)
+	lane_broker_server.remove(response)
 }
 
 async function with_server<T>(lane: LaneInfo, run: () => Promise<T>): Promise<T> {
@@ -261,25 +267,40 @@ async function with_server<T>(lane: LaneInfo, run: () => Promise<T>): Promise<T>
 	}
 }
 
+function is_fresh_heartbeat(heartbeat_at: number): boolean {
+	const now = Date.now()
+
+	return heartbeat_at <= now && heartbeat_at >= now - LEGACY_HEARTBEAT_LIMIT_MS
+}
+
+// Live by the server record (`lane-broker-server.ts`); a response with none was written by a
+// supervisor started before it, read by the heartbeat that supervisor still writes.
 function is_live_response(
+	target: string,
 	response: BrokerResponse | undefined,
-	session: string,
+	is_live: (server: BrokerServer) => boolean,
 ): response is BrokerResponse {
-	const now = Date.now()
+	if (response === undefined) return false
 
-	return (
-		response?.session === session &&
-		response.heartbeat_at <= now &&
-		response.heartbeat_at >= now - HEARTBEAT_LIMIT_MS
-	)
+	const server = lane_broker_server.read(target, response.session)
+
+	return server === undefined ? is_fresh_heartbeat(response.heartbeat_at) : is_live(server)
+}
+
+function session_response(target: string, session: string): BrokerResponse | undefined {
+	const response = read_record(target, response_schema)
+
+	return response?.session === session ? response : undefined
 }
 
 function response_verdict(
-	response: BrokerResponse | undefined,
+	target: string,
 	session: string,
 	nonce: string,
 ): 'wait' | 'success' | 'failure' {
-	if (!is_live_response(response, session)) return 'failure'
+	const response = session_response(target, session)
+
+	if (!is_live_response(target, response, lane_broker_server.is_running)) return 'failure'
 	if (response.nonce !== nonce) return 'wait'
 
 	return response.is_success ? 'success' : 'failure'
@@ -289,7 +310,7 @@ async function wait_response(target: string, session: string, nonce: string): Pr
 	const deadline = Date.now() + REQUEST_LIMIT_MS
 
 	while (Date.now() < deadline) {
-		const verdict = response_verdict(read_record(target, response_schema), session, nonce)
+		const verdict = response_verdict(target, 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
@@ -302,7 +323,9 @@ async function wait_response(target: string, session: string, nonce: string): Pr
 function live_response(target: string): BrokerResponse | undefined {
 	const response = read_record(target, response_schema)
 
-	return is_live_response(response, response?.session ?? '') ? response : undefined
+	return is_live_response(target, response, lane_broker_server.is_serving_process)
+		? response
+		: undefined
 }
 
 // Whether a server answers for this lane now — what a Claude lane's ship asks before it hands a session

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

@@ -8,6 +8,7 @@ import {
 	rmSync,
 } from 'node:fs'
 import path from 'node:path'
+import { process_identity } from '#scripts/josh/process-identity'
 import { file_reader } from '#scripts/lib/read-file'
 import {
 	LEDGER_FILE_EXTENSION,
@@ -38,8 +39,6 @@ import { observation_ledger_line } from './observation-ledger-line'
 // migration with no await point cannot be interleaved with another write in the same process.
 
 const NEWLINE = '\n'
-const NO_SIGNAL = 0
-const NO_SUCH_PROCESS = 'ESRCH'
 
 function claim_path(legacy: string): string {
 	return `${legacy}.${String(process.pid)}${MIGRATION_CLAIM_SUFFIX}`
@@ -55,18 +54,6 @@ function claim(from: string, to: string): boolean {
 	}
 }
 
-// Only `ESRCH` means the process is gone; `EPERM` means it runs under another user, and its claim is
-// still its own.
-function is_alive(pid: number): boolean {
-	try {
-		process.kill(pid, NO_SIGNAL)
-
-		return true
-	} catch (error) {
-		return (error as NodeJS.ErrnoException).code !== NO_SUCH_PROCESS
-	}
-}
-
 // A claim is named `<old ledger>.<pid>.migrating`, so the pid is what sits between the two.
 function is_stale_claim(name: string, legacy_name: string): boolean {
 	const prefix = `${legacy_name}.`
@@ -75,7 +62,8 @@ function is_stale_claim(name: string, legacy_name: string): boolean {
 
 	const pid = Number(name.slice(prefix.length, -MIGRATION_CLAIM_SUFFIX.length))
 
-	return Number.isSafeInteger(pid) && !is_alive(pid)
+	// A process under another user still holds its claim (`process_identity.is_present_pid`).
+	return Number.isSafeInteger(pid) && !process_identity.is_present_pid(pid)
 }
 
 function stale_claims(legacy: string): ReadonlyArray<string> {