@joshuafolkken/kit 1.1050.0 → 1.1128.0

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

@@ -46,7 +46,7 @@ const DEV_COMMANDS: Record<string, CommandEntry> = {
 		reference: ['', 'automation', ['processes']],
 	},
 	bytes: {
-		script: 'scripts/bytes/bytes-command.ts',
+		script: 'scripts/lines/bytes-command.ts',
 		description:
 			"Print an agent-read document's byte size against its ceiling and the headroom left",
 		category: 'Development',
@@ -128,6 +128,13 @@ const DEV_COMMANDS: Record<string, CommandEntry> = {
 		category: 'Development',
 		reference: ['', 'developer', ['files']],
 	},
+	'exports:unused': {
+		script: 'scripts/exports/unused-members-cli.ts',
+		description:
+			'Report exported namespace members nothing reads (kit only; a consumer project skips it)',
+		category: 'Development',
+		reference: ['', 'developer', ['none']],
+	},
 	'test:unit': {
 		script: 'scripts/test/test-unit-guard.ts',
 		description:

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

@@ -29,7 +29,7 @@ const ISSUE_COMMANDS: Record<string, CommandEntry> = {
 		description:
 			'Before filing: say whether an issue like this exists and which epic it belongs to',
 		category: 'AI tools',
-		reference: ['<title> [--body <summary>]', 'automation', ['network']],
+		reference: ['<title> [--body <summary> | --body-file <path>]', 'automation', ['network']],
 	},
 	'defect:rate': {
 		script: 'scripts/issue/defect-rate-cli.ts',
@@ -49,7 +49,7 @@ const ISSUE_COMMANDS: Record<string, CommandEntry> = {
 		script: 'scripts/issue/issue-fold-existing-cli.ts',
 		description: 'Assess whether a complete draft can join an unstarted issue',
 		category: 'AI tools',
-		reference: ['<assessment.json>', 'automation', ['none']],
+		reference: ['<assessment.json> [--json]', 'automation', ['none']],
 	},
 	'issue:cite': {
 		script: 'scripts/issue/issue-cite-cli.ts',

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

@@ -10,6 +10,13 @@ const MAINTENANCE_COMMANDS: Record<string, CommandEntry> = {
 		reference: ['[--fix]', 'developer', ['files']],
 		tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
 	},
+	'ruleset:check': {
+		script: 'scripts/repo/ruleset-check-cli.ts',
+		description:
+			"Check that the default branch requires every status check kit's workflows report (--apply adds the missing ones)",
+		category: 'Maintenance',
+		reference: ['[--apply]', 'maintainer', ['network']],
+	},
 	overrides: {
 		script: 'scripts/overrides/overrides-check.ts',
 		description: 'Check pnpm overrides for drift',

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

@@ -40,7 +40,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']],
 	},
@@ -57,6 +57,12 @@ const PROJECT_COMMANDS: Record<string, CommandEntry> = {
 		category: 'Project',
 		reference: ['<PR>', 'automation', ['network']],
 	},
+	'sonar:new-code': {
+		script: 'scripts/sonar/sonar-new-code-cli.ts',
+		description: 'Fail when a pull request adds any new SonarCloud issue or duplicated block',
+		category: 'Project',
+		reference: ['<PR>', 'automation', ['network']],
+	},
 	'ui:routes': {
 		script: 'scripts/ui/ui-routes-cli.ts',
 		description: 'List the screenshot-target routes the current change touches',

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

@@ -0,0 +1,114 @@
+import { OPTIONAL_ENV_FILE_FLAGS, type CommandEntry } from './josh-command-types'
+
+// The run-lifecycle registry (`run:hold` through `run:step`), split out of `josh-commands-ai.ts` so
+// that file stays under its 300-code-line limit, as `BACKLOG_COMMANDS` and `LANE_COMMANDS` were
+// (joshuafolkken/kit#2992). It is spread into `AI_COMMANDS` at the place the entries used to sit, so
+// the generated catalog keeps their order.
+
+// One script answers both `run:hold` and `run:release`; the flag below is what tells them apart.
+const RUN_HOLD_SCRIPT = 'scripts/run/run-hold-cli.ts'
+
+/* eslint-disable @typescript-eslint/naming-convention */
+const RUN_COMMANDS: Record<string, CommandEntry> = {
+	'run:hold': {
+		script: RUN_HOLD_SCRIPT,
+		description: 'Claim this working tree for a run, or say which run already holds it',
+		category: 'AI tools',
+		reference: ['[<issue> [--fullrun | --halfrun-stop | --prrun-stop]]', 'automation', ['files']],
+	},
+	'run:release': {
+		script: RUN_HOLD_SCRIPT,
+		description: "Release this working tree's run record",
+		category: 'AI tools',
+		reference: ['[issue|--force]', 'automation', ['files']],
+		default_script_arguments: ['--release'],
+	},
+	'run:tidy': {
+		script: 'scripts/run/run-tidy-cli.ts',
+		description: 'Close merged lanes and drop stashes whose issues are all merged',
+		category: 'AI tools',
+		reference: ['', 'automation', ['git', 'network', 'files']],
+	},
+	'run:carry': {
+		script: 'scripts/run/run-carry-cli.ts',
+		description: 'Carry one invocation’s budget across its own session cuts',
+		category: 'AI tools',
+		reference: ['<operation> [arguments...]', 'automation', ['files']],
+	},
+	'run:wake': {
+		script: 'scripts/run/run-wake-cli.ts',
+		// `.env` rather than the ambient environment:
+		// the failure warning needs the Telegram credentials, the same
+		// reasons `notify` and `followup` carry these flags.
+		tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
+		description: 'Wake the next session of a cut backlogrun from outside the conversation',
+		category: 'AI tools',
+		reference: ['[options]', 'automation', ['processes', 'notifications']],
+	},
+	'run:cut': {
+		script: 'scripts/run/run-cut-cli.ts',
+		description: 'Cut a lane child before the gate and resume a fresh process',
+		category: 'AI tools',
+		reference: ['[--resume] <issue> [--impl] [--handoff <path>]', 'automation', ['files']],
+	},
+	'run:liveness': {
+		script: 'scripts/run/run-liveness-cli.ts',
+		description: 'Say whether a delegated unit is still working, or stopped without reporting',
+		category: 'AI tools',
+		reference: ['<issue> --output <path> [options]', 'automation', ['processes']],
+	},
+	'run:ending': {
+		script: 'scripts/run/run-ending-cli.ts',
+		description: 'Classify how a dispatched lane child ended (merged, cut, abandoned, unreadable)',
+		category: 'AI tools',
+		reference: ['<issue> --output <path> [--repo <owner/repo>]', 'automation', ['network']],
+	},
+	'run:progress': {
+		script: 'scripts/run/run-progress-cli.ts',
+		description: 'Report an unattended run’s progress once it has gone quiet for an interval',
+		category: 'AI tools',
+		reference: [
+			'[--once | --wait] [--interval <minutes>] [--hours <hours>] [--repo <owner/repo>] [--output <path>] | --mark | --path',
+			'automation',
+			['files'],
+		],
+	},
+	'run:prep': {
+		script: 'scripts/run/run-prep-cli.ts',
+		description: 'Bundle a run’s pre-edit reads: body, comments, state, dependency scope',
+		category: 'AI tools',
+		reference: ['<issue>', 'automation', ['network']],
+	},
+	// The entry sequence a lane opened on, folded into one call (joshuafolkken/kit#2372): claim the tree,
+	// read the budget, gather the issue reads and decide the pre-implementation step. `run:hold`,
+	// `cost --cut`, `run:prep` and `run:step` were four round trips re-billing a lane's full context each.
+	'run:entry': {
+		script: 'scripts/run/run-entry-cli.ts',
+		description:
+			'Open a run in one call: claim the tree, read the budget, bundle the reads, decide the pre-implementation step',
+		category: 'AI tools',
+		reference: ['<issue> [--to <command>]', 'automation', ['git', 'network', 'files']],
+	},
+	'run:status': {
+		script: 'scripts/run/run-status-cli.ts',
+		description: 'Bundle a run’s read-only status: issue state, cost verdict, carry counters',
+		category: 'AI tools',
+		reference: ['<issue> [--repo <owner/repo>]', 'automation', ['network']],
+	},
+	'run:next': {
+		script: 'scripts/run/run-next-cli.ts',
+		description: 'Print the next step a fullrun takes, computed from the run’s state',
+		category: 'AI tools',
+		reference: ['<issue>', 'automation', ['network']],
+	},
+	'run:step': {
+		script: 'scripts/run/run-step-cli.ts',
+		description:
+			'Print the run’s next single action, computed from the event stream, carry record and issue state',
+		category: 'AI tools',
+		reference: ['<issue>', 'automation', ['network', 'files']],
+	},
+}
+/* eslint-enable @typescript-eslint/naming-convention */
+
+export { RUN_COMMANDS }

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

@@ -42,6 +42,14 @@ const VERSIONING_COMMANDS: Record<string, CommandEntry> = {
 		category: 'Versioning',
 		reference: ['[--json]', 'automation', ['none']],
 	},
+	// Run by the release workflows, kit's and the one sync distributes, after a tag has published
+	// (joshuafolkken/kit#3007). Settings come from the environment, so the workflow decides them.
+	'release:github': {
+		script: 'scripts/release/github-release-cli.ts',
+		description: 'Create the GitHub Release for a published tag, with generated notes',
+		category: 'Versioning',
+		reference: ['', 'automation', ['network', 'release']],
+	},
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 

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

@@ -35,7 +35,7 @@ const WORKFLOW_COMMANDS: Record<string, CommandEntry> = {
 	// than dropped: `telegram_notify.send` now throws on missing credentials and on a failed send, so
 	// `josh notify` exits non-zero instead of warning and answering 0.
 	followup: {
-		script: 'scripts/git/git-followup-workflow.ts',
+		script: 'scripts/followup/git-followup-workflow.ts',
 		description: 'Follow-up git workflow',
 		category: 'Workflow',
 		reference: [
@@ -46,7 +46,7 @@ const WORKFLOW_COMMANDS: Record<string, CommandEntry> = {
 		tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
 	},
 	notify: {
-		script: 'scripts/git/telegram-test.ts',
+		script: 'scripts/notify/telegram-test.ts',
 		description: 'Send Telegram notification',
 		category: 'Workflow',
 		reference: ['--task-type <type> --body <text>', 'automation', ['notifications']],
@@ -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/path-decision.ts

@@ -93,12 +93,9 @@ const path_decision = {
 	format_path_list,
 	has_unknown_flag,
 	JSON_FLAG,
-	KNOWN_FLAGS,
-	MAX_LISTED_PATHS,
 	parse_options,
 	print_decision,
 	run_path_decision,
-	STAGED_FLAG,
 }
 
 export { path_decision }

package/scripts/josh/process-owner.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod'
+
+// The pair a record names its writing process by, as `process_identity` reads it back
+// (joshuafolkken/kit#1245): the pid, and the opaque start token `process_identity.own_fields` wrote
+// beside it. Every lock, marker and ledger entry that later asks `is_same_process` carries this pair,
+// so its shape is declared once here and each record extends it (joshuafolkken/kit#2986).
+//
+// `process_start` is optional because a record written before joshuafolkken/kit#1245, or on a platform
+// whose start time cannot be read, carries only the pid — `is_same_process` has an answer of its own
+// for that case rather than the record being rejected.
+const process_owner_schema = z.object({ pid: z.number(), process_start: z.string().optional() })
+
+type ProcessOwner = z.infer<typeof process_owner_schema>
+
+export { process_owner_schema }
+export type { ProcessOwner }

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/josh/session-language-cli.ts

@@ -41,7 +41,6 @@ const session_language_cli = {
 	DEFAULT_SESSION_LANG,
 	ENV_KEY,
 	format_line,
-	main,
 	resolve_session_lang,
 	SCOPE_NOTE,
 }

package/scripts/lane/lane-await.ts

@@ -1,8 +1,8 @@
 import { spawnSync } from 'node:child_process'
 import { setTimeout as sleep } from 'node:timers/promises'
-import { git_common_directory } from '#scripts/git/git-common-directory'
-import { run_ship_detach } from '#scripts/run/run-ship-detach'
+import { run_liveness } from '#scripts/run/run-liveness'
 import { lane_child_invocation } from './lane-child-invocation'
+import { lane_handoff } from './lane-handoff'
 
 // Detached lane children are not harness-tracked processes, so their completion fires no
 // re-invocation event in the parent's session. Without a blocking wait the parent notices only
@@ -23,15 +23,20 @@ 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
 }
 
 // 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
@@ -44,6 +49,7 @@ interface CheckConfig {
 }
 
 interface RunConfig extends CheckConfig {
+	is_settled: (issue: string) => Promise<boolean>
 	poll_ms: number
 }
 
@@ -52,30 +58,46 @@ function is_process_running_default(issue: string): boolean {
 	const result = spawnSync('pgrep', ['-f', pattern], { encoding: 'utf8' })
 
 	if (result.status === PROCESS_FOUND) return true
-	const repository = git_common_directory.repository(process.cwd())
 
-	return (
-		repository !== undefined && run_ship_detach.read_result(repository, issue)?.result === 'running'
-	)
+	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()]))
+function make_initial_state(is_settled: boolean): AwaitState {
+	return { appeared: false, disappeared_at: undefined, first_polled_at: undefined, is_settled }
 }
 
-function resolve_options(options: AwaitOptions): RunConfig {
+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
 
@@ -83,13 +105,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
 
@@ -98,10 +123,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,
@@ -115,9 +143,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) {
@@ -148,13 +174,14 @@ 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)
 
 		if (completed !== undefined) return completed
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await sleep(config.poll_ms)
 	}
 }

package/scripts/lane/lane-capacity.ts

@@ -1,4 +1,5 @@
 import type { LaneEnvironment } from './lane-paths'
+import { lane_seed_policy } from './lane-seed'
 
 // How many lanes one repository may run at once, and how many of them are free
 // (joshuafolkken/kit#1491).
@@ -54,14 +55,16 @@ function lane_limit(environment: LaneEnvironment = process.env): LimitChoice {
 // Never negative: a repository holding more `in-progress` issues than the limit allows — the limit
 // was lowered, or a stale label outlived its run — has no free lane, and a negative count read as
 // "how many to offer" would be a slice nobody meant.
+//
+// **A limit above the seat count is capped at the seats** (joshuafolkken/kit#3027). `lane:open` refuses
+// a tenth lane however high `JOSH_LANE_LIMIT` is set, so counting free lanes past the seats offers a
+// launch that is bound to be refused.
 function free_lanes(limit: number, occupied: number): number {
-	return Math.max(NO_LANES, limit - occupied)
+	return Math.max(NO_LANES, Math.min(limit, lane_seed_policy.LAST_LANE_SEAT) - occupied)
 }
 
 const lane_capacity = {
-	DEFAULT_LANE_LIMIT,
 	LANE_LIMIT_KEY,
-	read_limit,
 	lane_limit,
 	free_lanes,
 }

package/scripts/lane/lane-child-invocation.ts

@@ -1,4 +1,10 @@
 import { run_issue_number } from '#scripts/run/run-issue-number'
+import { run_ship_next, type ShipResume } from '#scripts/run/run-ship-next'
+import type { Stage } from '#scripts/run/run-ship-stage'
+
+interface ShipStop extends ShipResume {
+	stage: Stage
+}
 
 const CHILD_INVOCATION = 'fullrun'
 const RESUME_GUIDE = '.claude/skills/workflow-commands/pre-gate-cut.md'
@@ -52,17 +58,24 @@ function outage_resume_invocation(issue: string): string {
 
 // The prompt a lane child is relaunched with when its detached ship supervisor stopped at a failed
 // stage (joshuafolkken/kit#2428) — a red gate, a High/Medium review, a failed push or red CI. The agent
-// ended at the hand-off, so this is how control comes back to one: it reads the stopped report through
-// the command `run:step` names, fixes it and hands the region back. It ends with `child_invocation` for
-// the reason `resume_invocation` does — the parent's poll keeps matching the relaunched process.
-function ship_stop_invocation(issue: string): string {
-	const preamble = `Resuming the lane child for issue #${issue} after its detached ship supervisor stopped at a failed stage — do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md. Do not re-plan or re-implement what is already on the branch.`
+// ended at the hand-off, so this is how control comes back to one: it reads the stopped report, fixes it
+// and hands the region back. It ends with `child_invocation` for the reason `resume_invocation` does —
+// the parent's poll keeps matching the relaunched process.
+//
+// **A known stage puts the next command in the prompt** (joshuafolkken/kit#2964), so the relaunched
+// session runs it rather than re-deriving it from `chain-rule.md`. An OpenAI lane's supervisor sees only
+// that the ship failed, not where, so without a stage the prompt points at `run:step` as before.
+function ship_stop_invocation(issue: string, stop?: ShipStop): string {
+	const opening = `Resuming the lane child for issue #${issue} after its detached ship supervisor stopped at a failed stage — do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md).`
+	const next =
+		stop === undefined
+			? `Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`
+			: run_ship_next.next_step(issue, stop.stage, stop)
 
-	return `${preamble} ${child_invocation(issue)}`
+	return `${opening} ${next} Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`
 }
 
 const lane_child_invocation = {
-	CHILD_INVOCATION,
 	child_invocation,
 	outage_resume_invocation,
 	process_pattern,

package/scripts/lane/lane-cli.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
 import { epic_busy } from '#scripts/epic/epic-busy'
-import { git_gh_command } from '#scripts/git/git-gh-command'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
 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'
@@ -417,9 +417,6 @@ const lane_cli = {
 	ALL_FLAG,
 	NONE_TOKEN,
 	USAGE,
-	main,
-	parse_issue,
-	parse_lane_issue,
 	refusal_message,
 	run,
 }

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
 	}
 }
@@ -158,6 +161,7 @@ async function close_each(issues: ReadonlyArray<string>): Promise<SweepOutcome>
 	const sweep: SweepOutcome = { closed: [], failed: [] }
 
 	for (const issue of issues) {
+		// eslint-disable-next-line no-await-in-loop -- worktree writes contend for the same registration directory
 		const bucket = (await try_close(issue)) ? sweep.closed : sweep.failed
 
 		bucket.push(issue)
@@ -186,10 +190,7 @@ async function close_all_lanes(): Promise<SweepOutcome> {
 const lane_close = {
 	close_all_lanes,
 	close_lane,
-	lane_root_directory,
-	lane_targets,
 	prune_lanes,
-	remove_lane,
 	resolve_lane,
 }
 

package/scripts/lane/lane-dispatch.ts

@@ -1,8 +1,8 @@
 import { agent_argv, type AgentArgv, type AgentArgvResult } from '#scripts/agent/agent-argv'
 import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
-import { git_gh_command } from '#scripts/git/git-gh-command'
-import { IN_PROGRESS_LABEL } from '#scripts/git/issue-labels'
-import { telegram_notify } from '#scripts/git/telegram-notify'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { IN_PROGRESS_LABEL } from '#scripts/issue/issue-labels'
+import { telegram_notify } from '#scripts/notify/telegram-notify'
 import { detached_launch } from '#scripts/run/detached-launch'
 import { run_ending } from '#scripts/run/run-ending'
 import { run_event_stream } from '#scripts/run/run-event-stream'
@@ -444,7 +444,6 @@ async function warn_of_problem(outcome: DispatchOutcome, issue: string): Promise
 }
 
 const lane_dispatch = {
-	CHILD_INVOCATION: lane_child_invocation.CHILD_INVOCATION,
 	child_invocation,
 	default_log_path,
 	describe,

package/scripts/lane/lane-environment.ts

@@ -58,10 +58,6 @@ function is_key_line(line: string, key: string): boolean {
 	return body.slice(key.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR)
 }
 
-function is_seed_line(line: string): boolean {
-	return is_key_line(line, PORT_SEED_KEY)
-}
-
 function is_seat_line(line: string): boolean {
 	return is_key_line(line, LANE_SEAT_KEY)
 }
@@ -235,12 +231,7 @@ function with_lane_output(content: string, output: string, profile?: AgentProfil
 }
 
 const lane_environment = {
-	LANE_OUTPUT_KEY,
-	LANE_PROVIDER_KEY,
-	LANE_ROLE_KEY,
-	is_output_line,
 	is_seat_line,
-	is_seed_line,
 	lane_file_content,
 	read_lane_output,
 	read_lane_profile,