@joshuafolkken/kit 1.1094.0 → 1.1136.0

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

@@ -22,6 +22,13 @@ const PROJECT_COMMANDS: Record<string, CommandEntry> = {
 			['files', 'git', 'network', 'processes'],
 		],
 	},
+	'dogfood:commit': {
+		script: 'scripts/dogfood/dogfood-commit-cli.ts',
+		description: "Make the first commit of a dogfood run's own kit-test-* project",
+		category: 'Project',
+		reference: ['<dir>', 'automation', ['files', 'git']],
+		is_kit_only: true,
+	},
 	init: {
 		script: 'scripts/init/init.ts',
 		description: 'Initialize config in a new project',
@@ -40,7 +47,7 @@ const PROJECT_COMMANDS: Record<string, CommandEntry> = {
 	},
 	'registry:migrate': {
 		script: 'scripts/registry-migration/migrate.ts',
-		description: 'Migrate a kit-only project from GitHub Packages to public npm',
+		description: 'Migrate a project from GitHub Packages to public npm',
 		category: 'Project',
 		reference: ['', 'developer', ['files', 'network', 'processes']],
 	},

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

@@ -89,7 +89,7 @@ const WORKFLOW_COMMANDS: Record<string, CommandEntry> = {
 		script: 'scripts/issue/measure-rerun-cli.ts',
 		description: 'Re-run a merged issue’s baseline command and print the before/after pair',
 		category: 'Workflow',
-		reference: ['<path>', 'automation', ['processes', 'files']],
+		reference: ['<issue-number>', 'automation', ['network', 'processes', 'files']],
 	},
 	// A script rather than an `sh -c` chain, because it has a precondition to enforce: run inside a
 	// linked work tree it would hijack the default branch from every other one (joshuafolkken/kit#1535).

package/scripts/josh/run-github-prerequisite.ts

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { repo_origin } from '#scripts/discovery/repo-origin'
-import { execaSync } from 'execa'
+import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
 
 const GITHUB_RUN_COMMANDS = new Set([
 	'run:entry',
@@ -19,11 +19,8 @@ function explanation(root: string, command: string): string | undefined {
 		return `${command} requires Git and a GitHub origin. Run git init and add a GitHub origin first.`
 	}
 
-	const result = execaSync('git', ['config', '--get', 'remote.origin.url'], {
-		cwd: root,
-		reject: false,
-	})
-	if (result.exitCode === 0 && repo_origin.parse_origin_url(result.stdout)) return undefined
+	const url = git_spawn_sync.origin_url(root)
+	if (url !== undefined && repo_origin.parse_origin_url(url)) return undefined
 
 	return `${command} requires a GitHub origin. Add an origin pointing to GitHub first.`
 }

package/scripts/lane/lane-await.ts

@@ -1,5 +1,7 @@
 import { spawnSync } from 'node:child_process'
 import { setTimeout as sleep } from 'node:timers/promises'
+import { parseArgs } from 'node:util'
+import { run_liveness } from '#scripts/run/run-liveness'
 import { lane_child_invocation } from './lane-child-invocation'
 import { lane_handoff } from './lane-handoff'
 
@@ -22,15 +24,30 @@ const MS_PER_SECOND = 1000
 const ISSUE_PATTERN = /^[1-9]\d*$/u
 const PROCESS_FOUND = 0
 
+// `is_settled` is read once, when the wait starts: a child that ended between two `lane:await` calls
+// never appears in the second one, and only its settled issue tells it apart from one not yet
+// launched (joshuafolkken/kit#3133).
 interface AwaitState {
 	appeared: boolean
 	disappeared_at: number | undefined
 	first_polled_at: number | undefined
+	is_settled?: boolean
+}
+
+interface AwaitArguments {
+	issues: ReadonlyArray<string>
+	owner: number | undefined
+}
+
+interface RawAwaitArguments {
+	positionals: Array<string>
+	values: { owner?: string | undefined }
 }
 
 // Injectable for testing -- the CLI never overrides these.
 interface AwaitOptions {
 	is_running?: (issue: string) => boolean
+	is_settled?: (issue: string) => Promise<boolean>
 	poll_ms?: number
 	reconfirm_ms?: number
 	never_appeared_timeout_ms?: number
@@ -43,6 +60,7 @@ interface CheckConfig {
 }
 
 interface RunConfig extends CheckConfig {
+	is_settled: (issue: string) => Promise<boolean>
 	poll_ms: number
 }
 
@@ -55,23 +73,75 @@ function is_process_running_default(issue: string): boolean {
 	return lane_handoff.is_ship_running(issue, process.cwd())
 }
 
-function make_initial_state(): AwaitState {
-	return { appeared: false, disappeared_at: undefined, first_polled_at: undefined }
+// The same positive evidence `run:liveness` answers `settled` on: the issue closed, or it was parked.
+async function is_settled_default(issue: string): Promise<boolean> {
+	return (await run_liveness.read_child_settled(issue)) === true
 }
 
-function make_states(issues: ReadonlyArray<string>): Map<string, AwaitState> {
-	return new Map(issues.map((issue) => [issue, make_initial_state()]))
+// An unknown flag or a flag without its value is `undefined`, which is usage.
+function read_await_args(rest: ReadonlyArray<string>): RawAwaitArguments | undefined {
+	try {
+		return parseArgs({
+			args: [...rest],
+			allowPositionals: true,
+			strict: true,
+			options: { owner: { type: 'string' } },
+		})
+	} catch {
+		return undefined
+	}
 }
 
-function resolve_options(options: AwaitOptions): RunConfig {
+// Every positional is an issue number, at least one is given, and `--owner` is a pid.
+function is_valid(raw: RawAwaitArguments): boolean {
+	const { owner } = raw.values
+	const numbers = owner === undefined ? raw.positionals : [...raw.positionals, owner]
+
+	return raw.positionals.length > 0 && numbers.every((value) => ISSUE_PATTERN.test(value))
+}
+
+// The issues to wait on and the waiting session's pid, or `undefined` for anything else.
+function parse_arguments(rest: ReadonlyArray<string>): AwaitArguments | undefined {
+	const raw = read_await_args(rest)
+
+	if (raw === undefined || !is_valid(raw)) return undefined
+
+	const { owner } = raw.values
+
+	return { issues: raw.positionals, owner: owner === undefined ? undefined : Number(owner) }
+}
+
+function make_initial_state(is_settled: boolean): AwaitState {
+	return { appeared: false, disappeared_at: undefined, first_polled_at: undefined, is_settled }
+}
+
+async function make_states(
+	issues: ReadonlyArray<string>,
+	is_settled: (issue: string) => Promise<boolean>,
+): Promise<Map<string, AwaitState>> {
+	const settled = await Promise.all(issues.map(async (issue) => await is_settled(issue)))
+
+	return new Map(issues.map((issue, index) => [issue, make_initial_state(settled[index] === true)]))
+}
+
+function resolve_timing(
+	options: AwaitOptions,
+): Pick<RunConfig, 'never_appeared_timeout_ms' | 'poll_ms' | 'reconfirm_ms'> {
 	return {
-		is_running: options.is_running ?? is_process_running_default,
 		poll_ms: options.poll_ms ?? DEFAULT_POLL_MS,
 		reconfirm_ms: options.reconfirm_ms ?? RECONFIRM_MS,
 		never_appeared_timeout_ms: options.never_appeared_timeout_ms ?? NEVER_APPEARED_TIMEOUT_MS,
 	}
 }
 
+function resolve_options(options: AwaitOptions): RunConfig {
+	return {
+		is_running: options.is_running ?? is_process_running_default,
+		is_settled: options.is_settled ?? is_settled_default,
+		...resolve_timing(options),
+	}
+}
+
 function update_liveness(state: AwaitState, is_live: boolean): void {
 	if (!is_live) return
 
@@ -79,13 +149,16 @@ function update_liveness(state: AwaitState, is_live: boolean): void {
 	state.disappeared_at = undefined
 }
 
-// Throws if the issue never appeared within the timeout window; otherwise records the first-seen time.
+// Returns the issue when it had already settled before the wait started — it ended and will never
+// appear. Otherwise throws if it never appeared within the timeout window, and records the first-seen time.
 function check_not_appeared(
 	issue: string,
 	state: AwaitState,
 	now_ms: number,
 	timeout_ms: number,
-): void {
+): string | undefined {
+	if (state.is_settled === true) return issue
+
 	state.first_polled_at ??= now_ms
 	const elapsed_ms = now_ms - state.first_polled_at
 
@@ -94,10 +167,13 @@ function check_not_appeared(
 			`lane child ${issue} never appeared within ${String(timeout_ms / MS_PER_SECOND)}s`,
 		)
 	}
+
+	return undefined
 }
 
 // Returns the issue that has confirmed-completed this tick, `undefined` if none yet.
-// The `appeared` guard prevents a process that never showed up from being declared done.
+// The `appeared` guard prevents a process that never showed up from being declared done, unless its
+// issue had already settled when the wait started.
 function check_issue(
 	issue: string,
 	state: AwaitState,
@@ -111,9 +187,7 @@ function check_issue(
 	if (is_live) return undefined
 
 	if (!state.appeared) {
-		check_not_appeared(issue, state, now_ms, config.never_appeared_timeout_ms)
-
-		return undefined
+		return check_not_appeared(issue, state, now_ms, config.never_appeared_timeout_ms)
 	}
 
 	if (state.disappeared_at === undefined) {
@@ -144,7 +218,7 @@ async function wait_for_any(
 	options: AwaitOptions = {},
 ): Promise<string> {
 	const config = resolve_options(options)
-	const states = make_states(issues)
+	const states = await make_states(issues, config.is_settled)
 
 	for (;;) {
 		const completed = check_any(states, Date.now(), config)
@@ -157,13 +231,13 @@ async function wait_for_any(
 }
 
 const lane_await = {
-	ISSUE_PATTERN,
 	NEVER_APPEARED_TIMEOUT_MS,
 	RECONFIRM_MS,
 	check_issue,
 	is_process_running_default,
+	parse_arguments,
 	wait_for_any,
 }
 
-export type { AwaitState, CheckConfig }
+export type { AwaitArguments, AwaitState, CheckConfig }
 export { lane_await }

package/scripts/lane/lane-cli.ts

@@ -6,6 +6,7 @@ import type { OpenIssueData } from '#scripts/git/schemas'
 import { issue_cite, type IssueCiter } from '#scripts/issue/issue-cite'
 import { error_text } from '#scripts/lib/error-message'
 import { run_carry } from '#scripts/run/run-carry'
+import { run_carry_reclaim } from '#scripts/run/run-carry-reclaim'
 import { lane_await } from './lane-await'
 import { lane_close, type CloseOutcome, type SweepOutcome } from './lane-close'
 import { lane_dispatch, type DispatchOutcome } from './lane-dispatch'
@@ -40,7 +41,7 @@ const USAGE = [
 	'       josh lane:prune',
 	'       josh lane:output <issue-number> [<path>]',
 	'       josh lane:dispatch <issue-number>',
-	'       josh lane:await <issue-number> ...',
+	'       josh lane:await <issue-number> ... [--owner <pid>]',
 ].join('\n')
 
 type Handler = (rest: ReadonlyArray<string>) => Promise<number>
@@ -356,22 +357,19 @@ async function dispatch_command(rest: ReadonlyArray<string>): Promise<number> {
 	return await report_dispatch(await lane_dispatch.dispatch_child(issue), issue)
 }
 
-// Each valid argument is an issue number; any non-number stops parsing and triggers usage.
-function parse_issues(rest: ReadonlyArray<string>): ReadonlyArray<string> | undefined {
-	if (rest.length === 0) return undefined
-	const issues = rest.filter((value) => lane_await.ISSUE_PATTERN.test(value))
-
-	return issues.length === rest.length ? issues : undefined
-}
-
 // The completed issue number goes to standard output so `N=$(pnpm josh lane:await ...)` captures
-// which child finished without parsing stderr.
+// which child finished without parsing stderr. `--owner` reclaims the carry record for a resumed
+// conversation before the wait (`run-carry-reclaim.ts`).
 async function await_command(rest: ReadonlyArray<string>): Promise<number> {
-	const issues = parse_issues(rest)
+	const parsed = lane_await.parse_arguments(rest)
 
-	if (issues === undefined) return report_usage()
+	if (parsed === undefined) return report_usage()
+
+	if (parsed.owner !== undefined) {
+		await run_carry_reclaim.reclaim_carry(run_carry.owner_of(parsed.owner))
+	}
 
-	const completed = await lane_await.wait_for_any(issues)
+	const completed = await lane_await.wait_for_any(parsed.issues)
 
 	console.info(completed)
 

package/scripts/lane/lane-close.ts

@@ -1,6 +1,7 @@
 import { existsSync, rmSync } from 'node:fs'
 import { git_command } from '#scripts/git/git-command'
 import { git_worktree } from '#scripts/git/git-worktree'
+import { error_text } from '#scripts/lib/error-message'
 import { lane_paths } from './lane-paths'
 import { lane_reap } from './lane-reap'
 import { lane_registry, type LaneInfo } from './lane-registry'
@@ -147,7 +148,9 @@ async function try_close(issue: string): Promise<boolean> {
 		const outcome = await close_lane(issue)
 
 		return outcome.kind !== 'incomplete'
-	} catch {
+	} catch (error) {
+		error_text.trace_swallowed('lane_close.try_close', error)
+
 		return false
 	}
 }

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

@@ -1,7 +1,7 @@
 #!/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'
 
@@ -35,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

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
 	}
 }

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/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`)

package/scripts/propagate/propagate-git.ts

@@ -2,7 +2,7 @@ import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { git_location_environment } from '#scripts/git/git-location-environment'
 import { ls_remote_branch_arguments } from '#scripts/git/git-ls-remote'
-import { execaSync } from 'execa'
+import { git_spawn_sync } from '#scripts/git/git-spawn-sync'
 
 // The git probes propagation needs before it writes anything into a working tree.
 //
@@ -16,7 +16,6 @@ const GIT_TIMEOUT_MS = 10_000
 // `rev-parse` and tight for an ssh handshake, and a probe that times out answers "no" — which for
 // the two below would report a push that never reached origin as a push nobody attempted.
 const REMOTE_TIMEOUT_MS = 60_000
-const SUCCESS_EXIT_CODE = 0
 const DEFAULT_BRANCH_REF = 'refs/remotes/origin/HEAD'
 const FALLBACK_DEFAULT_BRANCH = 'main'
 const ORIGIN_PREFIX = 'refs/remotes/origin/'
@@ -54,15 +53,11 @@ function run_git(
 	args: ReadonlyArray<string>,
 	timeout_ms: number = GIT_TIMEOUT_MS,
 ): string | undefined {
-	const result = execaSync('git', args, {
+	return git_spawn_sync.read(args, {
 		cwd: repository_path,
-		reject: false,
 		timeout: timeout_ms,
-		env: { LC_ALL: 'C', LANGUAGE: 'C', ...git_location_environment.location_free_environment() },
-		extendEnv: true,
+		env: { ...git_spawn_sync.C_LOCALE, ...git_location_environment.location_free_environment() },
 	})
-
-	return result.exitCode === SUCCESS_EXIT_CODE ? result.stdout.trim() : undefined
 }
 
 // The repository's default branch, from the remote's own HEAD. Falls back to `main` when the ref is

package/scripts/refactor/refactor-scan.ts

@@ -1,3 +1,4 @@
+import { git_command } from '#scripts/git/git-command'
 import { line_targets } from '#scripts/lines/line-targets'
 import { import_graph } from './import-graph'
 import { refactor_lint, type CategoryResult } from './refactor-lint'
@@ -97,7 +98,7 @@ async function scan(root: string): Promise<ScanResult> {
 }
 
 async function run_scan(): Promise<number> {
-	const root = await line_targets.repo_root()
+	const root = await git_command.repository_root()
 	const result = await scan(root)
 
 	process.stdout.write(`${render_result(result)}\n`)

package/scripts/registry-migration/migrate-logic.ts

@@ -99,25 +99,33 @@ function is_github_tarball_line(line: string): boolean {
 	return line.trimStart().startsWith('tarball: https://npm.pkg.github.com/')
 }
 
-function clean_kit_line(
+// Integrities are keyed by `name@version`, so two scoped packages sharing a version never collide.
+function package_id(key: string): string {
+	const name = fix_gh_packages_logic.package_path_from_key(key)
+
+	return `${name}@${fix_gh_packages_logic.package_version_from_key(key)}`
+}
+
+function clean_scoped_line(
 	line: string,
-	version: string,
+	id: string,
 	integrities: ReadonlyMap<string, IntegrityPair>,
 ): string | undefined {
-	if (!version) return line
+	if (!id) return line
 	if (is_github_tarball_line(line)) return undefined
 	const cleaned = remove_flow_tarball(line)
-	const pair = integrities.get(version)
+	const pair = integrities.get(id)
 	if (pair === undefined) return cleaned
 
 	return cleaned.split(`integrity: ${pair[0]}`).join(`integrity: ${pair[1]}`)
 }
 
-function next_kit_version(line: string, version: string): string {
-	if (!is_package_entry(line)) return version
-	const prefix = "  '@joshuafolkken/kit@"
+function next_scoped_id(line: string, id: string): string {
+	if (!is_package_entry(line)) return id
+	const prefix = `  '${SCOPE}/`
+	if (!line.startsWith(prefix)) return ''
 
-	return line.startsWith(prefix) ? (line.slice(prefix.length).split("'", 1)[0] ?? '') : ''
+	return package_id(line.slice("  '".length).split("'", 1)[0] ?? '')
 }
 
 function integrity_pair(
@@ -135,12 +143,12 @@ function lock_integrities(
 ): Map<string, IntegrityPair> {
 	const packages = fix_gh_packages_logic.parse_lockfile_packages(lockfile)
 	const pairs = new Map<string, IntegrityPair>()
-	const kit_entries = Object.entries(packages).filter(([key]) => key.startsWith(`${SCOPE}/kit@`))
+	const scoped_entries = Object.entries(packages).filter(([key]) => key.startsWith(`${SCOPE}/`))
 
-	for (const [key, entry] of kit_entries) {
-		const version = fix_gh_packages_logic.package_version_from_key(key)
-		const pair = integrity_pair(entry.resolution?.integrity, npm_integrities.get(version))
-		if (pair !== undefined) pairs.set(version, pair)
+	for (const [key, entry] of scoped_entries) {
+		const id = package_id(key)
+		const pair = integrity_pair(entry.resolution?.integrity, npm_integrities.get(id))
+		if (pair !== undefined) pairs.set(id, pair)
 	}
 
 	return pairs
@@ -150,17 +158,17 @@ function push_if_defined(lines: Array<string>, cleaned: string | undefined): voi
 	if (cleaned !== undefined) lines.push(cleaned)
 }
 
-function rewrite_kit_lockfile(
+function rewrite_scoped_lockfile(
 	lockfile: string,
 	npm_integrities: ReadonlyMap<string, string>,
 ): string {
-	let kit_version = ''
+	let id = ''
 	const lines: Array<string> = []
 	const integrities = lock_integrities(lockfile, npm_integrities)
 
 	for (const line of lockfile.split('\n')) {
-		kit_version = next_kit_version(line, kit_version)
-		const cleaned = clean_kit_line(line, kit_version, integrities)
+		id = next_scoped_id(line, id)
+		const cleaned = clean_scoped_line(line, id, integrities)
 
 		push_if_defined(lines, cleaned)
 	}
@@ -206,7 +214,8 @@ function previous_registry(project_npmrc: string, user_npmrc: string): string {
 
 function plan(project_npmrc: string, user_npmrc: string, lockfile: string): MigrationPlan {
 	const packages = scoped_packages(lockfile)
-	const blocked = packages.filter((name) => name !== `${SCOPE}/kit`)
+	// Every scoped package may migrate; `migrate` blocks any whose locked version is not on public npm.
+	const blocked: Array<string> = []
 	if (has_duplicate_mapping(project_npmrc, user_npmrc)) blocked.push('duplicate registry mappings')
 	const unsupported = unsupported_registry(project_npmrc)
 	if (unsupported !== undefined) blocked.push(unsupported)
@@ -220,7 +229,7 @@ const migrate_logic = {
 	plan,
 	github_tarballs,
 	is_github_tarball,
-	rewrite_kit_lockfile,
+	rewrite_scoped_lockfile,
 	scoped_versions,
 }