@joshuafolkken/kit 1.1010.0 → 1.1050.0

package/scripts/init/start-setup-pr.ts

@@ -12,15 +12,22 @@ import { start_exec } from './start-exec'
 const SETUP_TITLE = `Set up ${KIT_PACKAGE_NAME}`
 const SETUP_BODY = [
 	`Adds the files \`josh start\` wrote while setting up ${KIT_PACKAGE_NAME}, so main carries the`,
-	'rules, settings and workflows every later Issue is run with. Only the files kit wrote are in the',
-	'pull request; anything else in the working tree is left as it was.',
+	'rules, settings and workflows every later Issue is run with. Only the files the setup wrote are in',
+	'the pull request; anything else in the working tree is left as it was.',
 ].join('\n')
+const NAME_ONLY = '--name-only'
 const NOTHING_TO_COMMIT = 'The kit setup has no changes to commit, so no pull request was opened.'
 const OPEN_SETUP_ISSUES_QUERY = `?state=open&labels=${IGNORE_FOR_RELEASE_LABEL}&per_page=100`
 const FIRST_SETUP_ISSUE_FILTER = `[.[] | select(.title == "${SETUP_TITLE}") | .number][0] // empty`
 
-function lines_of(output: string | undefined): Array<string> {
-	return (output ?? '').split('\n').filter((line) => line.length > 0)
+// Listings are read NUL-separated (`-z`), so a path is never quoted — a name a caller's initialize
+// command wrote need not be ASCII the way kit's own are (#2872).
+function paths_of(output: string | undefined): Array<string> {
+	return (output ?? '').split('\0').filter((listed) => listed.length > 0)
+}
+
+function listing(args: ReadonlyArray<string>, root: string): Array<string> {
+	return paths_of(start_exec.read_output('git', [...args, '-z'], root))
 }
 
 function setup_issue(issue_number: string): IssueInfo {
@@ -42,17 +49,18 @@ function is_setup_branch(branch: string | undefined): boolean {
 }
 
 // Untracked files the ignore rules let through, plus tracked files the setup changed — two plain
-// listings, so nothing has to be parsed out of `git status`. Every kit path is ASCII, so git's
-// quoting of other names never hides one.
+// listings, so nothing has to be parsed out of `git status`.
 function changed_paths(root: string): Array<string> {
-	const untracked = start_exec.read_output(
-		'git',
-		['ls-files', '--others', '--exclude-standard'],
-		root,
-	)
-	const modified = start_exec.read_output('git', ['diff', '--name-only', 'HEAD'], root)
-
-	return [...lines_of(untracked), ...lines_of(modified)]
+	const untracked = listing(['ls-files', '--others', '--exclude-standard'], root)
+	const modified = listing(['diff', NAME_ONLY, 'HEAD'], root)
+
+	return [...untracked, ...modified]
+}
+
+// On the setup branch a failed commit left, that run's `git add` already staged its files, so they
+// read as changed before this run's command ran — the staged ones count as setup output (#2872).
+function carried_paths(root: string, current: string | undefined): Array<string> {
+	return is_setup_branch(current) ? listing(['diff', NAME_ONLY, '--cached'], root) : []
 }
 
 // The Issue carries the release classification the pull request is opened with, so the PR step finds
@@ -113,10 +121,30 @@ function commit_kit_paths(paths: ReadonlyArray<string>, issue: IssueInfo, root:
 	start_exec.run('git', ['commit', '--message', issue.commit_message, '--', ...paths], root)
 }
 
-// Issue → branch → only kit's files committed → push → pull request. The merge is left to a person:
-// it is the one step that changes main.
-async function open(root: string): Promise<void> {
-	const paths = kit_written_paths.select(changed_paths(root))
+// A caller's initialize command writes files kit cannot name, so with a `baseline` — what was already
+// changed before that command ran — everything changed since joins kit's own files, while a change
+// the user had made before the run still stays out (#2872).
+function setup_paths(
+	root: string,
+	baseline: ReadonlyArray<string> | undefined,
+	current: string | undefined,
+): Array<string> {
+	const changed = changed_paths(root)
+	const kit_paths = kit_written_paths.select(changed)
+
+	if (baseline === undefined) return kit_paths
+
+	const carried = carried_paths(root, current)
+	const written = changed.filter((path) => !baseline.includes(path) || carried.includes(path))
+
+	return [...new Set([...kit_paths, ...written])]
+}
+
+// Issue → branch → only the setup's files committed → push → pull request. The merge is left to a
+// person: it is the one step that changes main.
+async function open(root: string, baseline?: ReadonlyArray<string>): Promise<void> {
+	const current = start_exec.read_output('git', ['symbolic-ref', '--short', 'HEAD'], root)
+	const paths = setup_paths(root, baseline, current)
 
 	if (paths.length === 0) {
 		console.info(NOTHING_TO_COMMIT)
@@ -124,7 +152,6 @@ async function open(root: string): Promise<void> {
 		return
 	}
 
-	const current = start_exec.read_output('git', ['symbolic-ref', '--short', 'HEAD'], root)
 	const issue = resolve_issue(current)
 
 	switch_to(issue.branch_name, current, root)

package/scripts/init/start-steps.ts

@@ -1,6 +1,8 @@
 import path from 'node:path'
+import { error_text } from '#scripts/lib/error-message'
 import { repository_labels } from '#scripts/repo/repository-labels'
 import { self_sync_guard } from '#scripts/self-sync-guard/self-sync-guard-logic'
+import { parseCommandString } from 'execa'
 import { main as init_main } from './init'
 import { PACKAGE_DIR } from './init-paths'
 import { kit_setup_state } from './kit-setup-state'
@@ -13,6 +15,11 @@ interface StepContext {
 	root: string
 	profile: ProjectProfile
 	visibility: Visibility
+	init_command: string | undefined
+}
+
+interface RunContext extends StepContext {
+	baseline: ReadonlyArray<string> | undefined
 }
 
 const DEFAULT_BRANCH = 'main'
@@ -21,7 +28,7 @@ const GH_INSTALL_HINT =
 const GH_AUTH_HINT =
 	'GitHub CLI is not signed in. Run gh auth login, then run josh start again. Nothing was changed.'
 
-const { succeeds, read_output, run } = start_exec
+const { succeeds, read_output, run, run_local } = start_exec
 
 function read_git_state(root: string, shape: ProjectShape): GitState {
 	const { has_git, has_github } = shape
@@ -66,8 +73,19 @@ function create_git_repository(context: StepContext): void {
 }
 
 // The same setup `josh init` runs, called rather than copied, with the profile the user confirmed.
+// A toolkit that layers its files over kit's (`josh-app init`) names its own setup instead, so every
+// other step and guard stays here rather than in a copy of this command (#2872). That command runs
+// without a shell, is given the same profile, and a non-zero exit stops the run before the commit.
 function initialize(context: StepContext): void {
-	init_main(['--profile', context.profile])
+	if (context.init_command === undefined) {
+		init_main(['--profile', context.profile])
+
+		return
+	}
+
+	const [command = '', ...args] = parseCommandString(context.init_command)
+
+	run_local(command, [...args, '--profile', context.profile], context.root)
 }
 
 function commit_all(context: StepContext): void {
@@ -96,11 +114,22 @@ function add_missing_labels(): void {
 
 // Main already has a history here, so the setup reaches it the way every other change does: through
 // an Issue and a pull request a person merges (joshuafolkken/kit#2816).
-async function open_setup_pull_request(context: StepContext): Promise<void> {
-	await start_setup_pr.open(context.root)
+async function open_setup_pull_request(context: RunContext): Promise<void> {
+	await start_setup_pr.open(context.root, context.baseline)
 }
 
-type StepAction = (context: StepContext) => void | Promise<void>
+// What was already changed before a caller's initialize command ran, read only when the setup pull
+// request will need to tell that command's files from the user's own (#2872).
+function baseline_of(
+	steps: ReadonlyArray<StartStep>,
+	context: StepContext,
+): ReadonlyArray<string> | undefined {
+	if (context.init_command === undefined || !steps.includes('setup_pr')) return undefined
+
+	return start_setup_pr.changed_paths(context.root)
+}
+
+type StepAction = (context: RunContext) => void | Promise<void>
 
 const STEP_ACTIONS: Readonly<Record<StartStep, StepAction>> = {
 	git_init: create_git_repository,
@@ -113,24 +142,28 @@ const STEP_ACTIONS: Readonly<Record<StartStep, StepAction>> = {
 
 async function run_step(
 	step: StartStep,
-	context: StepContext,
+	context: RunContext,
 	completed: ReadonlyArray<StartStep>,
 ): Promise<void> {
 	try {
 		await STEP_ACTIONS[step](context)
 	} catch (error) {
-		const cause = error instanceof Error ? error.message : String(error)
+		const cause = error_text.message_of(error)
+		const labels = start_plan.step_labels(context.init_command)
 
-		throw new Error(start_plan.progress_report(step, completed, cause), { cause: error })
+		throw new Error(start_plan.progress_report(step, completed, cause, labels), { cause: error })
 	}
 }
 
 async function run_steps(steps: ReadonlyArray<StartStep>, context: StepContext): Promise<void> {
+	const labels = start_plan.step_labels(context.init_command)
+	const run_context: RunContext = { ...context, baseline: baseline_of(steps, context) }
+
 	for (const [index, step] of steps.entries()) {
 		const position = `${String(index + 1)}/${String(steps.length)}`
 
-		console.info(`\n[${position}] ${start_plan.STEP_LABELS[step]}`)
-		await run_step(step, context, steps.slice(0, index))
+		console.info(`\n[${position}] ${labels[step]}`)
+		await run_step(step, run_context, steps.slice(0, index))
 	}
 }
 

package/scripts/init/start.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { error_text } from '#scripts/lib/error-message'
 import { project_profile, type ProjectProfile } from './project-profile'
 import {
 	start_plan,
@@ -13,7 +14,9 @@ import { start_steps } from './start-steps'
 
 const ARGUMENT_START_INDEX = 2
 const READY_MESSAGE = 'GitHub workflow ready. Use kickoff new in your assistant to plan an Issue.'
-const START_USAGE = 'josh start [--profile basic|full] [--yes] [--github] [--public]'
+const START_USAGE =
+	'josh start [--profile basic|full] [--yes] [--github] [--public] [--init-command <command>]'
+const INIT_COMMAND_FLAG = '--init-command'
 const YES_FLAG = '--yes'
 const GITHUB_FLAG = '--github'
 const PUBLIC_FLAG = '--public'
@@ -25,16 +28,42 @@ interface Prepared {
 	choices: Choices
 }
 
-// The switches are peeled off first, so what remains is exactly the `--profile` pair `josh init`
-// accepts — one parser for the profile in both commands.
+interface InitCommandSplit {
+	init_command: string | undefined
+	rest: ReadonlyArray<string>
+}
+
+// A value that is blank or another flag means the command itself was left out, which would otherwise
+// swallow the next switch or hand the initialize step nothing to run.
+function is_command_value(value: string | undefined): value is string {
+	return value !== undefined && value.trim() !== '' && !value.startsWith('-')
+}
+
+// The command arrives as the one argument after its flag and is removed together with it.
+function split_init_command(args: ReadonlyArray<string>): InitCommandSplit {
+	const index = args.indexOf(INIT_COMMAND_FLAG)
+
+	if (index === -1) return { init_command: undefined, rest: args }
+
+	const value = args[index + 1]
+
+	if (!is_command_value(value)) throw new Error(`Usage: ${START_USAGE}`)
+
+	return { init_command: value, rest: args.filter((_, at) => at !== index && at !== index + 1) }
+}
+
+// The switches and the initialize command are peeled off first, so what remains is exactly the
+// `--profile` pair `josh init` accepts — one parser for the profile in both commands.
 function parse_start_options(args: ReadonlyArray<string>): StartOptions {
-	const profile_args = args.filter((argument) => !SWITCHES.has(argument))
+	const { init_command, rest } = split_init_command(args)
+	const profile_args = rest.filter((argument) => !SWITCHES.has(argument))
 
 	return {
 		profile: project_profile.requested_profile(profile_args, START_USAGE),
-		is_yes: args.includes(YES_FLAG),
-		is_github: args.includes(GITHUB_FLAG),
-		visibility: args.includes(PUBLIC_FLAG) ? 'public' : 'private',
+		is_yes: rest.includes(YES_FLAG),
+		is_github: rest.includes(GITHUB_FLAG),
+		visibility: rest.includes(PUBLIC_FLAG) ? 'public' : 'private',
+		init_command,
 	}
 }
 
@@ -82,11 +111,13 @@ function prepare(args: ReadonlyArray<string>, is_tty: boolean, root: string): Pr
 async function main(args: ReadonlyArray<string>, is_tty: boolean): Promise<void> {
 	const { steps, interaction, choices } = prepare(args, is_tty, process.cwd())
 
-	console.info(start_plan.plan_summary(steps))
-	const profile = await resolve_profile(choices, interaction)
 	const { root, options } = choices
+	const { visibility, init_command } = options
+
+	console.info(start_plan.plan_summary(steps, start_plan.step_labels(init_command)))
+	const profile = await resolve_profile(choices, interaction)
 
-	await start_steps.run_steps(steps, { root, profile, visibility: options.visibility })
+	await start_steps.run_steps(steps, { root, profile, visibility, init_command })
 	console.info(`\n${READY_MESSAGE}`)
 }
 
@@ -96,7 +127,7 @@ async function run(args: ReadonlyArray<string>, is_tty: boolean): Promise<number
 
 		return 0
 	} catch (error) {
-		console.error(error instanceof Error ? error.message : String(error))
+		console.error(error_text.message_of(error))
 
 		return 1
 	}

package/scripts/issue/issue-cite.ts

@@ -40,6 +40,23 @@ function citation_line(slug: string, number: string, summary: string): string {
 	return `[#${number}](${issue_url(slug, number)})${SUMMARY_SEPARATOR}${summary}`
 }
 
+// How a listing names one issue, given what it already holds (joshuafolkken/kit#2943). A progress
+// command's output is copied into a report verbatim, so the line it prints is the citation the report
+// carries: the full form when the title is in hand, the bare number-link when only the repository is,
+// and the plain `#N` only when the repository could not be read at all.
+type IssueCiter = (number: string) => string
+
+function citer(slug: string | undefined, titles: ReadonlyMap<string, string>): IssueCiter {
+	return function cite(number: string): string {
+		if (slug === undefined) return `#${number}`
+		const title = titles.get(number)
+
+		return title === undefined
+			? `[#${number}](${issue_url(slug, number)})`
+			: citation_line(slug, number, title)
+	}
+}
+
 function qualified_target(token: string): CiteTarget | undefined {
 	const match = REPO_QUALIFIED.exec(token)
 	if (match === null) return undefined
@@ -90,6 +107,7 @@ function no_repo_line(target: CiteTarget): string {
 const issue_cite = {
 	SUMMARY_SEPARATOR,
 	citation_line,
+	citer,
 	issue_url,
 	label,
 	missing_line,
@@ -98,5 +116,5 @@ const issue_cite = {
 	unreadable_line,
 }
 
-export type { CiteTarget }
+export type { CiteTarget, IssueCiter }
 export { issue_cite }

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

@@ -2,6 +2,7 @@
 import { fileURLToPath } from 'node:url'
 import { git_gh_command } from '#scripts/git/git-gh-command'
 import { cli_body } from '#scripts/josh/cli-body'
+import { error_text } from '#scripts/lib/error-message'
 
 // `josh issue:comment <N> --body <text> | --body-file <path>` — post one comment to an issue (a PR
 // comment is an issue comment over REST) and print the comment URL (joshuafolkken/kit#2304).
@@ -66,7 +67,7 @@ function resolve_request(argv: ReadonlyArray<string>): CommentRequest | undefine
 
 		return request
 	} catch (error) {
-		console.error(error instanceof Error ? error.message : String(error))
+		console.error(error_text.message_of(error))
 
 		return undefined
 	}

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

@@ -7,6 +7,7 @@ import { git_gh_command } from '#scripts/git/git-gh-command'
 import { git_gh_exec } from '#scripts/git/git-gh-exec'
 import { git_gh_issue_write } from '#scripts/git/git-gh-issue-write'
 import { github_issue_url } from '#scripts/git/github-issue-url'
+import { error_text } from '#scripts/lib/error-message'
 import { issue_file, type FileArguments } from './issue-file'
 import { issue_lint_cli } from './issue-lint-cli'
 import { issue_scout_cli } from './issue-scout-cli'
@@ -105,7 +106,7 @@ async function create(filing: Filing): Promise<string | undefined> {
 	try {
 		return await git_gh_exec.exec_gh_api(request)
 	} catch (error) {
-		const reason = error instanceof Error ? error.message : String(error)
+		const reason = error_text.message_of(error)
 
 		console.error(`✖ the create call failed: ${reason}`)
 

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

@@ -1,8 +1,8 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { parseArgs } from 'node:util'
 import { git_command } from '#scripts/git/git-command'
 import { path_decision } from '#scripts/josh/path-decision'
+import { cli_flags } from '#scripts/lib/cli-flags'
 import { split_assess, type SplitVerdict } from '#scripts/split/split-assess'
 import { issue_fold, type FoldVerdict } from './issue-fold'
 
@@ -33,27 +33,20 @@ interface FoldArguments {
 	is_json: boolean
 }
 
-function parse_arguments(argv: ReadonlyArray<string>): FoldArguments {
-	const { values, positionals } = parseArgs({
+// An unknown flag is `undefined` rather than a throw, so the answer is the usage line rather than a
+// stack trace, on a command whose output a workflow reads.
+function read_arguments(argv: ReadonlyArray<string>): FoldArguments | undefined {
+	const parsed = cli_flags.parse_or_undefined({
 		args: [...argv],
 		options: { json: { type: 'boolean' }, 'not-separable': { type: 'boolean' } },
 		allowPositionals: true,
 	})
+	if (parsed === undefined) return undefined
 
 	return {
-		titles: positionals,
-		is_separable: values['not-separable'] !== true,
-		is_json: values.json === true,
-	}
-}
-
-// An unknown flag makes `parseArgs` throw. Caught so the answer is the usage line rather than a stack
-// trace, on a command whose output a workflow reads.
-function read_arguments(argv: ReadonlyArray<string>): FoldArguments | undefined {
-	try {
-		return parse_arguments(argv)
-	} catch {
-		return undefined
+		titles: parsed.positionals,
+		is_separable: parsed.values['not-separable'] !== true,
+		is_json: parsed.values.json === true,
 	}
 }
 

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

@@ -1,12 +1,12 @@
 #!/usr/bin/env tsx
 import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
-import { parseArgs } from 'node:util'
 import { epic_audit_logic } from '#scripts/epic/epic-audit'
 import { epic_bundle, type BacklogIssue, type BundleDecision } from '#scripts/epic/epic-bundle'
 import { epic_bundle_cli } from '#scripts/epic/epic-bundle-cli'
 import { epic_bundle_gaps } from '#scripts/epic/epic-bundle-gaps'
 import { git_gh_command } from '#scripts/git/git-gh-command'
+import { cli_flags } from '#scripts/lib/cli-flags'
 import { issue_citation } from '#scripts/rules/issue-citation'
 import {
 	issue_scout,
@@ -59,12 +59,17 @@ function has_invalid_arguments(
 	)
 }
 
-function parse_arguments(argv: ReadonlyArray<string>): ScoutArguments | undefined {
-	const { values, positionals } = parseArgs({
+// An unknown flag is `undefined` rather than a throw, so the answer is the usage line rather than a
+// stack trace, on a command whose output a workflow reads.
+function read_arguments(argv: ReadonlyArray<string>): ScoutArguments | undefined {
+	const parsed = cli_flags.parse_or_undefined({
 		args: [...argv],
 		options: { body: { type: 'string' }, 'body-file': { type: 'string' } },
 		allowPositionals: true,
 	})
+	if (parsed === undefined) return undefined
+
+	const { values, positionals } = parsed
 	const [title] = positionals
 
 	if (has_invalid_arguments(title, values.body, values['body-file'])) return undefined
@@ -83,16 +88,6 @@ async function with_draft_body(args: ScoutArguments): Promise<ScoutArguments | u
 	}
 }
 
-// An unknown flag makes `parseArgs` throw. Caught so the answer is the usage line rather than a stack
-// trace, on a command whose output a workflow reads.
-function read_arguments(argv: ReadonlyArray<string>): ScoutArguments | undefined {
-	try {
-		return parse_arguments(argv)
-	} catch {
-		return undefined
-	}
-}
-
 // The issue as it would be filed. The summary is carried as the body because that is what the epic
 // half reads: the issue numbers its prose names are the references `decide_bundle` decides from.
 function draft_of(args: ScoutArguments, repo: string): BacklogIssue {

package/scripts/issue/measure-rerun-cli.ts

@@ -2,6 +2,7 @@
 import { execSync } from 'node:child_process'
 import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
+import { error_text } from '#scripts/lib/error-message'
 import { observation_ledger_home } from '#scripts/observations/observation-ledger-home'
 import { baseline_measure, type Baseline } from './baseline-measure'
 
@@ -21,7 +22,7 @@ function measure(command: string): string {
 	try {
 		return execSync(command, { encoding: 'utf8' }).trim()
 	} catch (error) {
-		return `(command failed: ${error instanceof Error ? error.message : String(error)})`
+		return `(command failed: ${error_text.message_of(error)})`
 	}
 }
 
@@ -40,12 +41,12 @@ function rerun_one(baseline: Baseline, date: string): Outcome {
 	}
 }
 
-async function append_ledger(lines: ReadonlyArray<string>): Promise<void> {
+async function append_ledger(lines: ReadonlyArray<string>, now: Date): Promise<void> {
 	if (lines.length === 0) return
 
-	// The primary checkout's ledger even inside a lane, whose own copy never reaches the default branch
-	// (joshuafolkken/kit#2419).
-	const ledger_path = observation_ledger_home.ledger_path()
+	// The running work tree's file for the checked-out issue, a lane's inside a lane — the run's own
+	// commit carries it (joshuafolkken/kit#2919).
+	const ledger_path = await observation_ledger_home.writer_path(now)
 
 	await observation_ledger_home.append(ledger_path, lines)
 	console.info(`Recorded ${String(lines.length)} refuted premise(s) in ${ledger_path}.`)
@@ -70,7 +71,7 @@ async function rerun(body_path: string, now: Date): Promise<number> {
 		.filter((line): line is string => line !== undefined)
 
 	console.info(outcomes.map((outcome) => outcome.pair).join('\n\n'))
-	await append_ledger(ledger_lines)
+	await append_ledger(ledger_lines, now)
 
 	return 0
 }

package/scripts/josh/josh-command-map.ts

@@ -38,8 +38,6 @@ const ALIASES: Record<string, string> = {
 	ln: 'lines',
 	by: 'bytes',
 	f: 'format',
-	fd: 'format:edited',
-	bg: 'batch:guard',
 	sd: 'cspell:dot',
 	bh: 'behavior',
 	t: 'test',
@@ -48,8 +46,6 @@ const ALIASES: Record<string, string> = {
 	td: 'test:declared',
 	trd: 'test:red',
 	te: 'test:e2e',
-	er: 'e2e:retry-check',
-	sl: 'session:lang',
 	c: 'check',
 	pt: 'port',
 	i: 'init',
@@ -57,19 +53,12 @@ const ALIASES: Record<string, string> = {
 	st: 'start',
 	sy: 'sync',
 	rmi: 'registry:migrate',
-	sys: 'sync:scope',
 	g: 'git',
 	gp: 'pr',
-	prc: 'pr:classification',
-	fu: 'followup',
-	nf: 'notify',
-	obf: 'observations:flush',
-	mrr: 'measure:rerun',
 	ms: 'main:sync',
 	mm: 'main:merge',
 	bp: 'bump',
 	re: 'release',
-	res: 'release:scope',
 	v: 'version',
 	r: 'ranges',
 	dr: 'doctor',
@@ -77,107 +66,16 @@ const ALIASES: Record<string, string> = {
 	ad: 'adopt',
 	ov: 'overrides',
 	a: 'audit',
-	ap: 'audit:provision',
 	rt: 'reconcile-templates',
 	u: 'latest',
-	lg: 'latest:guard',
 	lc: 'latest:corepack',
 	lu: 'latest:update',
-	ls: 'latest:scope',
-	pm: 'prevent-main-commit',
-	cm: 'check-commit-message',
-	ss: 'secretlint-scan',
-	ppu: 'pre-push-unit',
-	rer: 'reserved-run',
-	ptc: 'pre-commit-type-check',
-	ird: 'issue:read',
-	ist: 'issue:state',
-	isc: 'issue:scout',
-	ifl: 'issue:file',
-	isf: 'issue:fold',
-	isfe: 'issue:fold-existing',
-	dfr: 'defect:rate',
-	ici: 'issue:cite',
-	icm: 'issue:comment',
-	pks: 'pkg:scout',
-	iln: 'issue:lint',
-	ibl: 'issue:backlinks',
-	rl: 'report:lint',
-	ep: 'epic',
-	ec: 'epic:check',
-	en: 'epic:next',
-	ea: 'epic:audit',
-	eb: 'epic:bundle',
-	ao: 'auto-ok:next',
-	bl: 'backlog:next',
-	blo: 'backlog:offer',
-	bld: 'backlog:drive',
-	blp: 'backlog:plan',
-	bls: 'backlog:stalled',
-	bb: 'backlog:budget',
-	co: 'cost',
-	ds: 'doc:section',
-	rs: 'read:set',
-	dcr: 'doc:read',
-	rf: 'read:files',
-	ef: 'edit:files',
-	rfs: 'refactor:scan',
 	tm: 'time',
 	tmd: 'time:density',
 	rtr: 'retrospective',
-	rb: 'review:brief',
-	r2: 'review:round2',
-	ra: 'review:attest',
-	rvr: 'review:record',
 	rvf: 'review:findings',
-	dp: 'disposition',
-	dg: 'delegate',
-	fo: 'fanout',
-	rh: 'run:hold',
-	rr: 'run:release',
-	rc: 'run:carry',
-	rtd: 'run:tidy',
-	rw: 'run:wake',
-	rct: 'run:cut',
-	rv: 'run:liveness',
-	red: 'run:ending',
-	rg: 'run:progress',
-	rp: 'run:prep',
-	ren: 'run:entry',
-	rtl: 'run:tail',
-	shp: 'ship',
-	rst: 'run:status',
-	rn: 'run:next',
-	rsp: 'run:step',
-	rpy: 'repo:party',
-	rmg: 'run:merge',
-	rrp: 'run:report',
-	rrv: 'run:review',
-	rev: 'run:event',
-	sp: 'stash:pop',
-	lno: 'lane:open',
-	lnc: 'lane:close',
-	lnl: 'lane:list',
-	lnp: 'lane:prune',
-	lnv: 'lane:output',
-	lnd: 'lane:dispatch',
-	lna: 'lane:await',
-	lnla: 'lane:launch',
-	rwg: 'run:watcher:guard',
-	rsd: 'run:stranded',
-	ig: 'investigation:guard',
-	drg: 'duplicate-read:guard',
-	rug: 'rule:guard',
 	ruv: 'rule:value',
-	ptg: 'pretool:guard',
-	sg: 'stop:guard',
 	ev: 'eval',
-	ol: 'oracle:list',
-	sa: 'split:assess',
-	shs: 'sonar:hotspots',
-	uir: 'ui:routes',
-	cs: 'clone:scan',
-	ca: 'cases',
 }
 
 // The canonical name of a `josh` subcommand: an alias expands, and anything else passes through