@joshuafolkken/kit 1.1010.0 → 1.1050.0

package/scripts/epic/epic-lane-offer.ts

@@ -6,6 +6,7 @@ import {
 	type RepoAnswer,
 } from './epic-candidate-confirm'
 import { epic_graph, type EpicChild } from './epic-graph'
+import { epic_rank } from './epic-rank'
 import type { EpicVerdict } from './epic-report'
 import { epic_solo } from './epic-solo'
 import { epic_triage, type TriageVerdict } from './epic-triage'
@@ -107,6 +108,15 @@ function candidates_in(pool: RepoPool, repo: string): RepoPool {
 	return { ...pool, candidates: pool.candidates.filter((child) => child.repo === repo) }
 }
 
+// A pool's candidates for the repository in `epic_rank.rank` order — the ranking `backlog:next` offers
+// in (joshuafolkken/kit#2928), counted against the pool's own graph. **Within a pool, not across
+// pools**: the pool order is the order a person named the epics in, and that stays the outer key.
+function ranked_in(pool: RepoPool, repo: string): RepoPool {
+	const scoped = candidates_in(pool, repo)
+
+	return { ...scoped, candidates: epic_rank.rank(scoped.candidates, pool.context.children) }
+}
+
 // One pool's candidates, minus every one an earlier pool already carries. `seen` is mutated rather
 // than rebuilt because the earlier pools' claim is what the later one is filtered against.
 function unseen_candidates(pool: RepoPool, seen: Set<string>): RepoPool {
@@ -184,24 +194,6 @@ function solo_offer(
 	return { ...answer, children: offered, notice: offered_notice(offered, read, request) }
 }
 
-// The confirmation walk stops at the free-lane count, so a `run:solo` candidate ranked past it — or
-// in a pool past it — would never reach `solo_offer` to be preferred. Into an idle repository the
-// first pool holding one is asked first, with it at its head through the same `epic_solo.prefer` the
-// offer applies (joshuafolkken/kit#2778). The candidate stays in its own pool, because a pool carries
-// the graph it is confirmed against.
-function solo_first(pools: ReadonlyArray<RepoPool>, read: BusyRead): ReadonlyArray<RepoPool> {
-	if (read.kind !== 'idle') return pools
-
-	const index = pools.findIndex((pool) => pool.candidates.some((child) => epic_solo.is_solo(child)))
-	const pool = pools[index]
-
-	if (pool === undefined) return pools
-
-	const lifted = { ...pool, candidates: epic_solo.prefer(pool.candidates, read) }
-
-	return [lifted, ...pools.filter((other) => other !== pool)]
-}
-
 // The repository is asked how full it is **before** any candidate is confirmed, for the reason
 // joshuafolkken/kit#1121 records: a repository with no free lane is handed nothing, so the relations
 // request that would confirm a candidate there buys an answer nobody reads — and a polling `epicrun`
@@ -247,10 +239,7 @@ async function offer_for_repo(
 		}
 	}
 
-	const for_repo = solo_first(
-		dedupe_pools(pools.map((pool) => candidates_in(pool, request.repo))),
-		read,
-	)
+	const for_repo = dedupe_pools(pools.map((pool) => ranked_in(pool, request.repo)))
 
 	return solo_offer(await collect(for_repo, wanted_of(request, free)), read, request)
 }

package/scripts/epic/epic-next.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
 import { repo_discovery } from '#scripts/discovery/repo-discovery'
-import { git_epic_parse } from '#scripts/git/git-epic-parse'
 import { git_gh_command } from '#scripts/git/git-gh-command'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import { josh_environment_file } from '#scripts/josh/josh-environment-file'
@@ -16,6 +15,7 @@ import { epic_lane_offer, type LaneOffer, type LaneRequest } from './epic-lane-o
 import { epic_next_read, type EpicRead, type SnapshotReads } from './epic-next-read'
 import { epic_next_views, type EpicView } from './epic-next-views'
 import { epic_outside_blocker } from './epic-outside-blocker'
+import { epic_parse } from './epic-parse'
 import { epic_report, type EpicNextResult } from './epic-report'
 
 // `josh epic:next <E…>` — which of the named epics' children can be started right now, bundled per
@@ -170,7 +170,7 @@ function unreadable_anomaly(snapshot: EpicSnapshot): GraphAnomaly | undefined {
 // body whose declared chain and recorded relations agree — a worse outcome than following the chain
 // the run's own `epic:check` already flagged.
 function is_order_declared(body: string | undefined, links: ReadonlyArray<unknown>): boolean {
-	return links.length > 0 || git_epic_parse.has_unordered_declaration(body)
+	return links.length > 0 || epic_parse.has_unordered_declaration(body)
 }
 
 function decide(
@@ -178,7 +178,7 @@ function decide(
 	paths: ReadonlyMap<string, string> = new Map(),
 	running?: ReadonlySet<string>,
 ): EpicNextResult {
-	const links = git_epic_parse.parse_dependency_links(snapshot.body)
+	const links = epic_parse.parse_dependency_links(snapshot.body)
 	const unreadable = body_anomaly(snapshot) ?? unreadable_anomaly(snapshot)
 	const anomalies =
 		unreadable === undefined

package/scripts/{git/git-epic-parse.ts → epic/epic-parse.ts}

@@ -256,7 +256,7 @@ function parse_dependency_links(body: string | undefined): Array<DependencyLink>
 // `None — the children are independent` report as ordered, and `josh followup` then said the batch
 // order was never recorded on every child's merge. The narrowing joshuafolkken/kit#858 applied to
 // the link reader was the same judgement, and `epic --add` writes on that judgement too
-// (`git-epic-add-body.ts` protects an arrow outside the `Dependencies` section as prose) — so the
+// (`epic-add-body.ts` protects an arrow outside the `Dependencies` section as prose) — so the
 // three readers of one body now recognize the same lines, instead of two patterns that could
 // disagree about which line is a declaration. They still answer different questions of those lines:
 // a self-loop (`#101 -> #101`) is a declaration here and yields no link, since `chain_links` drops
@@ -306,7 +306,7 @@ function is_state_closed(state: string | undefined): boolean {
 	return state?.toUpperCase() === CLOSED_STATE
 }
 
-const git_epic_parse = {
+const epic_parse = {
 	fence_mask,
 	is_task_list_line,
 	is_declaration_line,
@@ -328,7 +328,7 @@ const git_epic_parse = {
 
 export type { DeclarationState, DependencyLink, ExternalChild }
 export {
-	git_epic_parse,
+	epic_parse,
 	fence_mask,
 	is_task_list_line,
 	is_declaration_line,

package/scripts/{git/git-epic-promote.ts → epic/epic-promote.ts}

@@ -1,5 +1,5 @@
-import { git_epic_body } from './git-epic-body'
-import { git_epic_parse } from './git-epic-parse'
+import { epic_body } from './epic-body'
+import { epic_parse } from './epic-parse'
 
 // Promoting an existing issue into an epic.
 //
@@ -34,13 +34,13 @@ function has_conflicting_tracking(body: string | undefined): boolean {
 	if (body === undefined) return false
 	if (body.includes(PROMOTED_HEADING)) return true
 
-	return git_epic_parse.parse_task_list_issue_numbers(body).length > 0
+	return epic_parse.parse_task_list_issue_numbers(body).length > 0
 }
 
 // Why the promotion was refused, phrased as what was found rather than as a rule number.
 function conflict_reason(body: string | undefined): string {
 	if (body?.includes(PROMOTED_HEADING) === true) return 'it already carries the epic sections'
-	const tracked = git_epic_parse.parse_task_list_issue_numbers(body)
+	const tracked = epic_parse.parse_task_list_issue_numbers(body)
 	const list = tracked.map((child) => `#${String(child)}`).join(', ')
 
 	return `its body already tracks ${list} as a task list, which would become a second child list`
@@ -50,7 +50,7 @@ function conflict_reason(body: string | undefined): string {
 // what happened. The original text is never rewritten — it is the record of why the split was made.
 function build_promoted_body(input: PromoteInput): string {
 	const existing = (input.body ?? '').trimEnd()
-	const epic_sections = git_epic_body.build_epic_body({
+	const epic_sections = epic_body.build_epic_body({
 		children: input.children,
 		rationale: input.rationale,
 		is_ordered: input.is_ordered,
@@ -71,8 +71,8 @@ function build_promoted_body(input: PromoteInput): string {
 // so the body would declare an order and declare that there is none. Reported as "does not track
 // every child", that state left nothing to act on (joshuafolkken/kit#1155).
 function declaration_error(body: string): string | undefined {
-	const state = git_epic_parse.read_declaration(body)
-	if (git_epic_parse.is_declaration_readable(state)) return undefined
+	const state = epic_parse.read_declaration(body)
+	if (epic_parse.is_declaration_readable(state)) return undefined
 
 	return state.has_chain
 		? 'The promoted body would declare an order and declare that there is none: the issue being promoted already carries a line that is only a chain (`#N -> #M`), and it contradicts the `Dependencies` section written for the epic. Reword that line first; nothing was written.'
@@ -80,7 +80,7 @@ function declaration_error(body: string): string | undefined {
 }
 
 function find_tracking_error(body: string, children: ReadonlyArray<number>): string | undefined {
-	const tracked = git_epic_parse.parse_task_list_issue_numbers(body)
+	const tracked = epic_parse.parse_task_list_issue_numbers(body)
 
 	if (children.some((child) => !tracked.includes(child))) {
 		return 'The promoted body would not track every child; nothing was written.'
@@ -89,7 +89,7 @@ function find_tracking_error(body: string, children: ReadonlyArray<number>): str
 	return declaration_error(body)
 }
 
-const git_epic_promote = {
+const epic_promote = {
 	EPIC_SECTION_MARKER,
 	PROMOTED_HEADING,
 	has_conflicting_tracking,
@@ -99,4 +99,4 @@ const git_epic_promote = {
 }
 
 export type { PromoteInput }
-export { git_epic_promote }
+export { epic_promote }

package/scripts/epic/epic-rank.ts

@@ -0,0 +1,37 @@
+import { issue_rank } from '#scripts/git/issue-rank'
+import { epic_graph, type EpicChild } from './epic-graph'
+
+// `issue-rank.ts`'s keys over graph children (joshuafolkken/kit#2928), for both offer paths that hand
+// out children: `backlog:next` (`backlog-rank.ts`) and a named epic's `epic:next --lanes`
+// (`epic-lane-offer.ts`). One ranking, so the two cannot disagree about which child goes first.
+
+const CLOSED = 'CLOSED'
+
+// How many open issues of the pool wait on each child. Only the pool is counted: it is every issue the
+// caller may run, and an issue outside it is not one this ranking can start sooner.
+function dependents_of(pool: ReadonlyArray<EpicChild>): ReadonlyMap<string, number> {
+	return issue_rank.count_dependents(
+		pool
+			.filter((child) => child.state !== CLOSED)
+			.map((child) => ({
+				key: epic_graph.key_of(child),
+				blockers: child.blocked_by.map((blocker) => epic_graph.blocker_key(blocker)),
+			})),
+	)
+}
+
+function rank(
+	children: ReadonlyArray<EpicChild>,
+	pool: ReadonlyArray<EpicChild>,
+): Array<EpicChild> {
+	const dependents = dependents_of(pool)
+
+	return issue_rank.rank(children, (child) => ({
+		labels: child.labels,
+		dependents: dependents.get(epic_graph.key_of(child)) ?? 0,
+	}))
+}
+
+const epic_rank = { dependents_of, rank }
+
+export { epic_rank }

package/scripts/{git/git-epic-read.ts → epic/epic-read.ts}

@@ -1,8 +1,8 @@
-import { epic_fetch } from '#scripts/epic/epic-fetch'
-import { epic_graph, type EpicChild } from '#scripts/epic/epic-graph'
-import { git_epic_parse } from './git-epic-parse'
-import { git_epic_validate, type EpicSubject } from './git-epic-validate'
-import { git_gh_command } from './git-gh-command'
+import { git_gh_command } from '#scripts/git/git-gh-command'
+import { epic_fetch } from './epic-fetch'
+import { epic_graph, type EpicChild } from './epic-graph'
+import { epic_parse } from './epic-parse'
+import { epic_validate, type EpicSubject } from './epic-validate'
 
 // Reading an epic and its current graph, for the two commands that edit its declared order.
 //
@@ -26,7 +26,7 @@ interface EpicReading {
 }
 
 async function read_subject(epic_number: number): Promise<EpicSubject | undefined> {
-	return git_epic_validate.parse_epic_subject(
+	return epic_validate.parse_epic_subject(
 		await git_gh_command.issue_get_labels_and_body(String(epic_number)),
 	)
 }
@@ -39,7 +39,7 @@ async function read_recorded(
 ): Promise<{ children: ReadonlyArray<EpicChild>; repo: string } | { error: string }> {
 	const repo = await git_gh_command.repo_get_name_with_owner()
 	if (repo === undefined) return { error: UNKNOWN_REPO }
-	const tracked = git_epic_parse.parse_task_list_issue_numbers(body)
+	const tracked = epic_parse.parse_task_list_issue_numbers(body)
 	if (tracked.length === 0) return { children: [], repo }
 
 	const fetched = await epic_fetch.fetch_children(tracked, repo)
@@ -64,10 +64,10 @@ async function read_epic(epic_number: number): Promise<EpicReading | { error: st
 	return { subject, recorded: recorded.children, repo: recorded.repo }
 }
 
-const git_epic_read = {
+const epic_read = {
 	UNKNOWN_REPO,
 	read_epic,
 }
 
-export { git_epic_read }
+export { epic_read }
 export type { EpicReading }

package/scripts/{git/git-epic-reconcile.ts → epic/epic-reconcile.ts}

@@ -1,11 +1,11 @@
-import { epic_graph, type EpicChild, type IssueReference } from '#scripts/epic/epic-graph'
-import { git_epic_add_body } from './git-epic-add-body'
-import { git_epic_chains } from './git-epic-chains'
-import { git_epic_parse, type DependencyLink } from './git-epic-parse'
-import { git_epic_read } from './git-epic-read'
-import { format_dependency_links } from './git-epic-reference'
-import { git_epic_relations } from './git-epic-relations'
-import { git_gh_command } from './git-gh-command'
+import { git_gh_command } from '#scripts/git/git-gh-command'
+import { epic_add_body } from './epic-add-body'
+import { epic_chains } from './epic-chains'
+import { epic_graph, type EpicChild, type IssueReference } from './epic-graph'
+import { epic_parse, type DependencyLink } from './epic-parse'
+import { epic_read } from './epic-read'
+import { format_dependency_links } from './epic-reference'
+import { epic_relations } from './epic-relations'
 
 // `josh epic --reconcile <E>` — bring an epic's `## Dependencies` declaration and its native
 // `blocked-by` relations back into agreement, without a hand edit and without recording a decision
@@ -34,7 +34,7 @@ const RECONCILED = 'reconciled'
 
 interface ReconcilePlanInput {
 	body: string | undefined
-	// The epic's children with their native relations, exactly as `git_epic_read` reads them.
+	// The epic's children with their native relations, exactly as `epic_read` reads them.
 	recorded: ReadonlyArray<EpicChild>
 	// The epic's own repository — what a declared bare number names (joshuafolkken/kit#1126).
 	repo: string
@@ -101,7 +101,7 @@ function to_reconciled_body(
 	body: string | undefined,
 	target_chains: ReadonlyArray<ReadonlyArray<number>>,
 ): { body: string } | { error: string } {
-	return git_epic_add_body.rewrite_body({
+	return epic_add_body.rewrite_body({
 		body: body ?? '',
 		placed: [],
 		position: undefined,
@@ -120,8 +120,8 @@ interface Mismatch {
 }
 
 function read_mismatch(input: ReconcilePlanInput): Mismatch {
-	const chains_before = git_epic_parse.parse_dependency_chains(input.body)
-	const declared = git_epic_chains.links_of(chains_before)
+	const chains_before = epic_parse.parse_dependency_chains(input.body)
+	const declared = epic_chains.links_of(chains_before)
 
 	return {
 		chains_before,
@@ -135,7 +135,7 @@ function read_mismatch(input: ReconcilePlanInput): Mismatch {
 function to_reconciled_plan(input: ReconcilePlanInput, mismatch: Mismatch): ReconcilePlan {
 	const declared_chains = mismatch.declare.map((link) => to_chain(link))
 	const target_chains = [...mismatch.chains_before, ...declared_chains]
-	const cycle = find_cycle(git_epic_chains.links_of(target_chains), input.repo)
+	const cycle = find_cycle(epic_chains.links_of(target_chains), input.repo)
 	if (cycle !== undefined) return { kind: 'cycle', message: cycle }
 
 	const { declare, record } = mismatch
@@ -176,11 +176,9 @@ function report_declared(epic_number: number, declare: ReadonlyArray<DependencyL
 async function record_relations(record: ReadonlyArray<DependencyLink>): Promise<void> {
 	if (record.length === 0) return
 
-	const failures = await git_epic_relations.apply_relations(record, 'record')
+	const failures = await epic_relations.apply_relations(record, 'record')
 
-	console.info(
-		git_epic_relations.format_relation_report({ links: record, failures, action: 'record' }),
-	)
+	console.info(epic_relations.format_relation_report({ links: record, failures, action: 'record' }))
 }
 
 async function apply_reconciliation(
@@ -218,7 +216,7 @@ async function apply_plan(epic_number: number, plan: ReconcilePlan): Promise<num
 // Every refusal — an unreadable epic, an unreadable graph, a cycle — happens before the body edit,
 // so a rejected invocation leaves the epic exactly as it was.
 async function reconcile_epic(epic_number: number): Promise<number> {
-	const epic = await git_epic_read.read_epic(epic_number)
+	const epic = await epic_read.read_epic(epic_number)
 
 	if ('error' in epic) {
 		console.error(`✖ ${epic.error}`)
@@ -235,12 +233,12 @@ async function reconcile_epic(epic_number: number): Promise<number> {
 	return await apply_plan(epic_number, plan)
 }
 
-const git_epic_reconcile = {
+const epic_reconcile = {
 	NOTHING_TO_RECONCILE,
 	RECONCILED,
 	build_reconcile_plan,
 	reconcile_epic,
 }
 
-export { git_epic_reconcile }
+export { epic_reconcile }
 export type { ReconcilePlan, ReconcilePlanInput, Reconciliation }

package/scripts/{git/git-epic-reference.ts → epic/epic-reference.ts}

@@ -1,4 +1,4 @@
-import type { DependencyLink } from './git-epic-parse'
+import type { DependencyLink } from './epic-parse'
 
 // How an issue and a dependency between two of them are written down.
 //
@@ -13,25 +13,6 @@ const DEPENDENCY_ARROW = ' -> '
 // and two separators would let the two disagree over something a reader reads side by side.
 const REFERENCE_SEPARATOR = ', '
 
-// An issue named from outside any one graph — a task-list row, a citation in prose, a blocker
-// relation, a child that could not be read. Repository **and** number, because a number alone cannot
-// identify one: issue numbers are unique per repository, so the same `#40` names two different issues
-// depending on who wrote it (joshuafolkken/kit#1014).
-//
-// It lives here rather than in `epic-graph` because the `blocked-by` relations are read in the git
-// layer and carry a repository of their own (joshuafolkken/kit#1126) — a second declaration there
-// would be the clone `CLAUDE.md` prohibits, and an import the other way would point the lower layer
-// at the higher one. `epic-graph` re-exports it, so every existing importer is unchanged.
-//
-// `state` is present only on a reference read from a `blocked-by` relation whose response carried it
-// (joshuafolkken/kit#1943). The classifier needs it for a blocker no named graph tracks, where there is
-// no child record to read the state from; every other reference leaves it out.
-interface IssueReference {
-	repo: string
-	number: number
-	state?: 'OPEN' | 'CLOSED'
-}
-
 function to_issue_reference(issue_number: number): string {
 	return `#${String(issue_number)}`
 }
@@ -73,7 +54,7 @@ function format_replaced_relations(links: ReadonlyArray<DependencyLink>): string
 	return `Replaced blocked-by: ${join_references(quoted)}.`
 }
 
-const git_epic_reference = {
+const epic_reference = {
 	DEPENDENCY_ARROW,
 	REFERENCE_SEPARATOR,
 	to_issue_reference,
@@ -84,9 +65,9 @@ const git_epic_reference = {
 	format_replaced_relations,
 }
 
-export type { IssueReference }
+export type { IssueReference } from '#scripts/git/issue-reference'
 export {
-	git_epic_reference,
+	epic_reference,
 	DEPENDENCY_ARROW,
 	REFERENCE_SEPARATOR,
 	to_issue_reference,

package/scripts/epic/epic-relation-recheck.ts

@@ -1,5 +1,6 @@
-import { git_epic_parse } from '#scripts/git/git-epic-parse'
+import { error_text } from '#scripts/lib/error-message'
 import { epic_graph, type EpicChild, type IssueReference } from './epic-graph'
+import { epic_parse } from './epic-parse'
 
 // joshuafolkken/kit#1113: a second look at the relations, taken only where the first one is about to
 // become a verdict.
@@ -42,7 +43,7 @@ function suspect_children(
 	body: string | undefined,
 	declared_repo: string,
 ): Set<number> {
-	const links = git_epic_parse.parse_dependency_links(body)
+	const links = epic_parse.parse_dependency_links(body)
 	const local = children.filter((child) => child.repo === declared_repo)
 
 	return new Set(
@@ -57,7 +58,7 @@ async function reread_child(child: EpicChild, read_blockers: BlockersReader): Pr
 	try {
 		return { ...child, blocked_by: await read_blockers(child) }
 	} catch (error) {
-		const reason = error instanceof Error ? error.message : String(error)
+		const reason = error_text.message_of(error)
 
 		console.warn(
 			`⚠ could not re-read the blockers of #${String(child.number)}: ${reason}\n` +

package/scripts/{git/git-epic-relations.ts → epic/epic-relations.ts}

@@ -1,6 +1,6 @@
-import type { DependencyLink } from './git-epic-parse'
-import { format_dependency_links } from './git-epic-reference'
-import { git_gh_command } from './git-gh-command'
+import { git_gh_command } from '#scripts/git/git-gh-command'
+import type { DependencyLink } from './epic-parse'
+import { format_dependency_links } from './epic-reference'
 
 // Recording and dropping the native `blocked-by` relations an epic's declared order implies.
 //
@@ -69,10 +69,10 @@ function format_relation_report(input: {
 	return `⚠️  ${String(input.failures)} of ${total} blocked-by relation(s) could not be ${verb}; the epic body is intact.`
 }
 
-const git_epic_relations = {
+const epic_relations = {
 	apply_relations,
 	format_relation_report,
 }
 
-export { git_epic_relations }
+export { epic_relations }
 export type { RelationAction }

package/scripts/{git/git-epic-remove-plan.ts → epic/epic-remove-plan.ts}

@@ -1,10 +1,10 @@
-import { epic_graph, type EpicChild } from '#scripts/epic/epic-graph'
-import { git_epic_add_body, type RewriteOutcome } from './git-epic-add-body'
-import { git_epic_chains } from './git-epic-chains'
-import { git_epic_decision } from './git-epic-decision'
-import { chain_links, git_epic_parse, type DependencyLink } from './git-epic-parse'
-import { format_dependency_link, format_dependency_links } from './git-epic-reference'
-import { git_epic_shape } from './git-epic-shape'
+import { epic_add_body, type RewriteOutcome } from './epic-add-body'
+import { epic_chains } from './epic-chains'
+import { epic_decision } from './epic-decision'
+import { epic_graph, type EpicChild } from './epic-graph'
+import { chain_links, epic_parse, type DependencyLink } from './epic-parse'
+import { format_dependency_link, format_dependency_links } from './epic-reference'
+import { epic_shape } from './epic-shape'
 
 // Everything `josh epic --remove` decides before it writes anything.
 //
@@ -15,7 +15,7 @@ import { git_epic_shape } from './git-epic-shape'
 // `declaration_mismatch`, which stops an unattended run. Epic joshuafolkken/kit#1262 recorded
 // twenty-nine such removals before the command existed (joshuafolkken/kit#1712).
 //
-// Kept apart from the GitHub calls for the reason `git-epic-add-plan.ts` is: the whole decision is
+// Kept apart from the GitHub calls for the reason `epic-add-plan.ts` is: the whole decision is
 // asserted without a network, and a refusal path only reachable through `gh` is one nobody tests.
 
 // The path whose consecutive pairs name the orders to delete. `--remove <E> 101 102 103` deletes
@@ -71,9 +71,7 @@ function find_undeclared_error(
 	links: ReadonlyArray<DependencyLink>,
 	chains: ReadonlyArray<ReadonlyArray<number>>,
 ): string | undefined {
-	const declared = new Set(
-		git_epic_chains.links_of(chains).map((link) => format_dependency_link(link)),
-	)
+	const declared = new Set(epic_chains.links_of(chains).map((link) => format_dependency_link(link)))
 	const missing = links.filter((link) => !declared.has(format_dependency_link(link)))
 
 	return missing.length === 0
@@ -84,7 +82,7 @@ function find_undeclared_error(
 // A decision record that cannot be written is refused here rather than dropped, exactly as it is for
 // an insertion: `--decision-file` was given because the record has to exist.
 function find_decision_error(decision: string | undefined): string | undefined {
-	return decision === undefined ? undefined : git_epic_decision.find_decision_error(decision)
+	return decision === undefined ? undefined : epic_decision.find_decision_error(decision)
 }
 
 function find_input_error(
@@ -93,7 +91,7 @@ function find_input_error(
 	chains: ReadonlyArray<ReadonlyArray<number>>,
 ): string | undefined {
 	return (
-		git_epic_shape.find_subject_error(input, tracked) ??
+		epic_shape.find_subject_error(input, tracked) ??
 		find_path_error(input.path) ??
 		find_undeclared_error(to_path_links(input.path), chains) ??
 		find_decision_error(input.decision)
@@ -112,7 +110,7 @@ function to_body(
 	input: RemovePlanInput,
 	chains_after: ReadonlyArray<ReadonlyArray<number>>,
 ): RewriteOutcome {
-	return git_epic_add_body.rewrite_body({
+	return epic_add_body.rewrite_body({
 		body: input.body ?? '',
 		placed: [],
 		chains_after,
@@ -122,13 +120,13 @@ function to_body(
 }
 
 function build_removal_plan(input: RemovePlanInput): RemoveOutcome {
-	const tracked = git_epic_parse.parse_task_list_issue_numbers(input.body)
-	const chains_before = git_epic_parse.parse_dependency_chains(input.body)
+	const tracked = epic_parse.parse_task_list_issue_numbers(input.body)
+	const chains_before = epic_parse.parse_dependency_chains(input.body)
 	const error = find_input_error(input, tracked, chains_before)
 	if (error !== undefined) return { error }
 
 	const links = to_path_links(input.path)
-	const chains_after = git_epic_chains.remove_links(chains_before, links)
+	const chains_after = epic_chains.remove_links(chains_before, links)
 	const rewritten = to_body(input, chains_after)
 	if ('error' in rewritten) return { error: rewritten.error }
 
@@ -144,9 +142,9 @@ function build_removal_plan(input: RemovePlanInput): RemoveOutcome {
 	}
 }
 
-const git_epic_remove_plan = {
+const epic_remove_plan = {
 	build_removal_plan,
 }
 
-export { git_epic_remove_plan }
+export { epic_remove_plan }
 export type { RemovePlan, RemovePlanInput, RemoveOutcome }

package/scripts/{git/git-epic-remove.ts → epic/epic-remove.ts}

@@ -1,9 +1,9 @@
-import { git_epic_decision } from './git-epic-decision'
-import { git_epic_read } from './git-epic-read'
-import { format_dependency_links } from './git-epic-reference'
-import { git_epic_relations } from './git-epic-relations'
-import { git_epic_remove_plan, type RemovePlan } from './git-epic-remove-plan'
-import { git_gh_command } from './git-gh-command'
+import { git_gh_command } from '#scripts/git/git-gh-command'
+import { epic_decision } from './epic-decision'
+import { epic_read } from './epic-read'
+import { format_dependency_links } from './epic-reference'
+import { epic_relations } from './epic-relations'
+import { epic_remove_plan, type RemovePlan } from './epic-remove-plan'
 
 // `josh epic --remove <E> <M> <N> [<N2> ...] [--decision-file <path|->]` — delete a declared order
 // from the epic's body and from the native `blocked-by` relations in one input
@@ -32,7 +32,7 @@ async function comment_decision(ends: ReadonlyArray<number>, decision: string):
 	)
 
 	console.info(
-		git_epic_decision.format_decision_report({
+		epic_decision.format_decision_report({
 			total: ends.length,
 			failures: posted.filter((is_posted) => !is_posted).length,
 		}),
@@ -43,7 +43,7 @@ function report_relations(plan: RemovePlan, failures: number): void {
 	if (plan.removed.length === 0) return
 
 	console.info(
-		git_epic_relations.format_relation_report({ links: plan.removed, failures, action: 'drop' }),
+		epic_relations.format_relation_report({ links: plan.removed, failures, action: 'drop' }),
 	)
 }
 
@@ -56,7 +56,7 @@ async function write_plan(
 	console.info(
 		`📋 Removed ${format_dependency_links(plan.links)} from epic #${String(epic_number)}.`,
 	)
-	report_relations(plan, await git_epic_relations.apply_relations(plan.removed, 'drop'))
+	report_relations(plan, await epic_relations.apply_relations(plan.removed, 'drop'))
 
 	if (decision !== undefined) await comment_decision(plan.ends, decision)
 }
@@ -64,7 +64,7 @@ async function write_plan(
 // Delete a declared order, or refuse without writing anything. Every refusal happens before the body
 // edit, so a rejected invocation leaves the epic exactly as it was.
 async function remove_order(input: RemoveOrderInput): Promise<number> {
-	const epic = await git_epic_read.read_epic(input.epic_number)
+	const epic = await epic_read.read_epic(input.epic_number)
 
 	if ('error' in epic) {
 		console.error(`✖ ${epic.error}`)
@@ -72,7 +72,7 @@ async function remove_order(input: RemoveOrderInput): Promise<number> {
 		return FAILURE_EXIT_CODE
 	}
 
-	const outcome = git_epic_remove_plan.build_removal_plan({
+	const outcome = epic_remove_plan.build_removal_plan({
 		epic_number: input.epic_number,
 		body: epic.subject.body,
 		labels: epic.subject.labels,
@@ -93,9 +93,9 @@ async function remove_order(input: RemoveOrderInput): Promise<number> {
 	return SUCCESS_EXIT_CODE
 }
 
-const git_epic_remove = {
+const epic_remove = {
 	remove_order,
 }
 
-export { git_epic_remove }
+export { epic_remove }
 export type { RemoveOrderInput }