@joshuafolkken/kit 1.1035.0 → 1.1094.0

package/scripts/backlog/backlog-next.ts

@@ -9,13 +9,14 @@ import { epic_next } from '#scripts/epic/epic-next'
 import { epic_next_read, type EpicRead } from '#scripts/epic/epic-next-read'
 import type { EpicView } from '#scripts/epic/epic-next-views'
 import { epic_report, type EpicNextResult, type EpicVerdict } from '#scripts/epic/epic-report'
-import { epic_solo } from '#scripts/epic/epic-solo'
+import { epic_solo_stale } from '#scripts/epic/epic-solo-stale'
 import { epic_triage, type TriageVerdict } from '#scripts/epic/epic-triage'
-import { git_gh_command } from '#scripts/git/git-gh-command'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { PROJECT_ROOT } from '#scripts/init/init-paths'
 import { issue_citation } from '#scripts/rules/issue-citation'
 import { backlog_defect_priority } from './backlog-defect-priority'
 import { backlog_pool } from './backlog-pool'
+import { backlog_rank } from './backlog-rank'
 
 // `josh backlog:next` — what the whole opted-in backlog may run next (joshuafolkken/kit#1630).
 //
@@ -235,12 +236,15 @@ async function resolve(context: PoolContext): Promise<EpicNextResult | undefined
 		return undefined
 	}
 
-	// The defect priority is applied here rather than when printing, so `backlog:plan` shows the order
-	// the run takes (joshuafolkken/kit#2455).
-	return await backlog_defect_priority.prioritize(
+	// The defect priority and the ranking keys are applied here rather than when printing, so
+	// `backlog:plan` shows the order the run takes (joshuafolkken/kit#2455, joshuafolkken/kit#2928). The
+	// ranking goes last: its sort is stable, so the defect order survives as its final key.
+	const ordered = await backlog_defect_priority.prioritize(
 		combine(views_from(reads, context), context),
 		context.repo,
 	)
+
+	return backlog_rank.rank_result(ordered, context.repo)
 }
 
 // Whether the `error` verdict is really a transport failure wearing the graph's clothes.
@@ -274,13 +278,31 @@ function report_retry(context: PoolContext): number {
 	return SUCCESS_EXIT_CODE
 }
 
+// The rows the offer's cap bounds — the standalone half, which `backlog:plan --waves` reads too.
+function standalone_keys(context: PoolContext): ReadonlySet<string> {
+	return backlog_pool.standalone_keys(context.opted_in.issues, {
+		tracked: epic_index.withheld_children(context.tracking.index, context.opted_in.issues),
+		exclude: context.exclude,
+		repo: context.repo,
+	})
+}
+
 // The `run:solo` gate is applied here rather than in `resolve`, because `backlog:plan` shares
 // `resolve` and a plan made before the run lists everything (joshuafolkken/kit#2776). The holders are
-// read only on a `run` answer — the one answer the gate can change.
-async function gate_solo(result: EpicNextResult, repo: string): Promise<EpicNextResult> {
+// read only on a `run` answer — the one answer the gate can change. The cap follows the gate
+// (`backlog-rank.ts`, joshuafolkken/kit#2928).
+async function gate_solo(result: EpicNextResult, context: PoolContext): Promise<EpicNextResult> {
 	if (result.verdict !== 'run') return result
 
-	const gated = epic_solo.gate(result, await epic_busy.read_repository(repo), repo)
+	const { repo } = context
+	const { read, notice } = await epic_solo_stale.release(
+		await epic_busy.read_repository(repo),
+		repo,
+	)
+
+	if (notice !== undefined) console.error(notice)
+
+	const gated = backlog_rank.gate(result, read, repo, standalone_keys(context))
 
 	if (gated.notice !== undefined) console.error(gated.notice)
 
@@ -314,7 +336,7 @@ async function answer_pool(context: PoolContext): Promise<number> {
 
 	if (untriaged.length > 0) return report_triage(context, untriaged)
 
-	return report(await gate_solo(result, context.repo), context)
+	return report(await gate_solo(result, context), context)
 }
 
 // A backlog nobody has opted into answers `none` before either listing below is asked for.
@@ -395,22 +417,10 @@ const backlog_next = {
 	RETRY_MESSAGE,
 	READ_FAILURES,
 	VERDICT_TOKENS,
-	tokens_of,
-	warn_epic_gap,
-	warn_gaps,
-	report,
-	combine,
-	views_from,
 	resolve,
-	is_transport_failure,
-	report_retry,
-	report_triage,
+	standalone_keys,
 	context_of,
-	answer_pool,
-	report_none,
-	answer,
 	run,
-	main,
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))

package/scripts/backlog/backlog-offer-cli.ts

@@ -262,16 +262,11 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 
 const backlog_offer_cli = {
 	JSON_KEY,
-	USAGE,
 	budget_argv,
 	counts_of,
-	emit,
-	main,
-	mark_drain,
 	next_argv,
 	read_values,
 	run,
-	to_tokens,
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))

package/scripts/backlog/backlog-plan-cli.ts

@@ -3,7 +3,7 @@ import { fileURLToPath } from 'node:url'
 import { auto_ok_cli } from '#scripts/auto-ok/auto-ok-cli'
 import { epic_index } from '#scripts/epic/epic-index'
 import type { EpicNextResult } from '#scripts/epic/epic-report'
-import { git_gh_command } from '#scripts/git/git-gh-command'
+import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { read_json_listing } from '#scripts/git/parse-json-array'
 import { open_issue_schema, type OpenIssueData } from '#scripts/git/schemas'
 import { run_invocation } from '#scripts/run/run-invocation'
@@ -104,6 +104,9 @@ interface Plan {
 	// past the listing cap. Carrying the *whole* index here instead would move that misreport rather
 	// than remove it: the sentence would name an epic that is withholding nothing.
 	tracked: ReadonlyMap<number, number>
+	// The rows the offer's cap bounds, so `--waves` cuts each wave where `backlog:next` does
+	// (joshuafolkken/kit#2928).
+	standalone: ReadonlySet<string>
 }
 
 // The listing plus whether it was cut. Carried together because the rows alone cannot say whether
@@ -138,6 +141,7 @@ async function classify(
 		repo: context.repo,
 		exclude,
 		tracked: epic_index.withheld_children(context.tracking.index, context.opted_in.issues),
+		standalone: backlog_next.standalone_keys(context),
 	}
 }
 
@@ -168,7 +172,7 @@ function print_plan(plan: Plan, listing: OpenListing, view: PlanView): void {
 	const context = context_of(plan, listing)
 
 	if (view.is_waves) {
-		console.info(backlog_waves.format_waves(plan.result, context))
+		console.info(backlog_waves.format_waves(plan.result, context, plan.standalone))
 
 		return
 	}
@@ -259,13 +263,7 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 const backlog_plan_cli = {
 	OPEN_TRUNCATED_MESSAGE,
 	OPEN_UNREADABLE_MESSAGE,
-	USAGE,
 	WAVES_WITH_NAMED_MESSAGE,
-	classify,
-	fetch_open,
-	main,
-	print_plan,
-	report,
 	run,
 }
 

package/scripts/backlog/backlog-plan.ts

@@ -3,7 +3,7 @@ import type { IssueReference } from '#scripts/epic/epic-reference'
 import { epic_report, type EpicNextResult } from '#scripts/epic/epic-report'
 import { epic_solo } from '#scripts/epic/epic-solo'
 import { epic_triage } from '#scripts/epic/epic-triage'
-import { has_label_name, IN_PROGRESS_LABEL, RUN_SOLO_LABEL } from '#scripts/git/issue-labels'
+import { has_label_name, IN_PROGRESS_LABEL, RUN_SOLO_LABEL } from '#scripts/issue/issue-labels'
 import type { OutOfScopeRow } from './backlog-scope'
 
 // The plan a person reads before a `backlogrun` starts (joshuafolkken/kit#1652).

package/scripts/backlog/backlog-pool.ts

@@ -5,14 +5,14 @@ import { epic_index } from '#scripts/epic/epic-index'
 import { epic_issue } from '#scripts/epic/epic-issue'
 import type { EpicView } from '#scripts/epic/epic-next-views'
 import { epic_outside_blocker } from '#scripts/epic/epic-outside-blocker'
-import { git_next_issues } from '#scripts/git/git-next-issues'
+import type { OpenIssueData } from '#scripts/git/schemas'
+import { git_next_issues } from '#scripts/issue/git-next-issues'
 import {
 	ALREADY_DONE_LABEL,
 	EPIC_LABEL,
 	has_any_label,
 	NEEDS_DECISION_LABEL,
-} from '#scripts/git/issue-labels'
-import type { OpenIssueData } from '#scripts/git/schemas'
+} from '#scripts/issue/issue-labels'
 
 // The candidate pool `josh backlog:next` answers from (joshuafolkken/kit#1630).
 //
@@ -37,6 +37,9 @@ const DECISION_LABELS: ReadonlySet<string> = new Set([NEEDS_DECISION_LABEL, ALRE
 // `tracked` is the narrowed set `epic_index.withheld_children` builds, not every child an epic
 // tracks (joshuafolkken/kit#1668) — the narrowing itself is defined there, once, for this half and
 // `auto-ok:next` alike.
+// The part of the context that decides which rows the standalone half considers at all.
+type ConsideredContext = Pick<StandaloneContext, 'tracked' | 'exclude' | 'repo'>
+
 interface StandaloneContext {
 	tracked: ReadonlyMap<number, number>
 	exclude: ReadonlyArray<number>
@@ -135,26 +138,28 @@ function standalone_rows(issues: ReadonlyArray<OpenIssueData>): ReadonlyArray<Op
 // are actually going to offer their children and applied here for the same reason. Which rows those
 // are is `epic_index.withheld_children`'s answer, not a second test made here. A row the caller
 // excluded is out of the pool entirely rather than merely unoffered: it has just merged.
-function is_considered(issue: OpenIssueData, context: StandaloneContext): boolean {
+function is_considered(issue: OpenIssueData, context: ConsideredContext): boolean {
 	return !context.tracked.has(issue.number) && !context.exclude.includes(issue.number)
 }
 
 // The standalone half, in the buckets the verdict is read from.
 //
-// The order is `git_next_issues.prioritize`'s and not a second one — the same ranking the
-// `🗒 Next issues` display and `auto-ok:next` already answer with, cap included, so the three cannot
-// disagree about what comes next. Anything it withholds is still open work: `needs-decision` is
-// waiting on a person, and everything else — a standing blocker, a run already in progress, a row
-// past the cap — resolves on its own and is waiting on time. **The cap is one of those**: a sixth
-// runnable standalone issue is reported as waiting rather than offered, and the next ask offers it
-// once one of the five above it merges, so the backlog drains without it ever being lost. That is
-// the cost of having one ranking rather than two, and `docs/josh-commands.md` states it.
+// The order is `git_next_issues.order`'s and not a second one — the same ranking the
+// `🗒 Next issues` display and `auto-ok:next` already answer with, so the three cannot disagree about
+// what comes next. Anything it withholds is still open work: `needs-decision` is waiting on a person,
+// and everything else — a standing blocker, a run already in progress — resolves on its own and is
+// waiting on time.
+//
+// **The display's cap is not applied here** (joshuafolkken/kit#2928). Cut at this point, a sixth
+// runnable `run:solo` issue never reached the gate that holds back what is ranked below it, so the
+// cap is applied after that gate instead (`backlog-rank.ts`). A row past it is still reported as
+// waiting and offered by a later ask, so the backlog drains without it ever being lost.
 function classify_standalone(
 	issues: ReadonlyArray<OpenIssueData>,
 	context: StandaloneContext,
 ): Classification {
 	const considered = issues.filter((issue) => is_considered(issue, context))
-	const runnable = git_next_issues.prioritize(
+	const runnable = git_next_issues.order(
 		considered.filter((issue) => auto_ok_cli.is_runnable(issue, context.tracked, context.exclude)),
 	)
 	const offered = new Set(runnable.map((issue) => issue.number))
@@ -301,22 +306,34 @@ function merge_classifications(left: Classification, right: Classification): Cla
 	}
 }
 
+// The keys of the rows the standalone half considers — the rows the offer's cap bounds. An issue an
+// opted-in epic tracks is that epic's child here, and never capped, exactly as before.
+function standalone_keys(
+	issues: ReadonlyArray<OpenIssueData>,
+	context: ConsideredContext,
+): ReadonlySet<string> {
+	return keys_of(
+		to_children(
+			standalone_rows(issues).filter((issue) => is_considered(issue, context)),
+			context.repo,
+		),
+	)
+}
+
 const backlog_pool = {
 	classify_standalone,
 	cross_epic_cycles,
 	running_set,
 	settle_standalone,
+	standalone_keys,
 	drop_excluded,
 	epic_classification,
-	is_epic_row,
-	keys_of,
 	merge_classifications,
 	opted_in_epics,
 	standalone_rows,
 	to_child,
 	to_children,
-	unique_children,
 }
 
 export { backlog_pool }
-export type { StandaloneContext }
+export type { ConsideredContext, StandaloneContext }

package/scripts/backlog/backlog-rank.ts

@@ -0,0 +1,106 @@
+import type { BusyRead } from '#scripts/epic/epic-busy'
+import { epic_graph, type EpicChild } from '#scripts/epic/epic-graph'
+import { epic_rank } from '#scripts/epic/epic-rank'
+import type { EpicNextResult } from '#scripts/epic/epic-report'
+import { epic_solo, type SoloGate, type SoloSelection } from '#scripts/epic/epic-solo'
+import { git_next_issues } from '#scripts/issue/git-next-issues'
+
+// What the backlog offers, in the order it is decided (joshuafolkken/kit#2928): rank, then the
+// `run:solo` gate, then the cap. `backlog:next` and `backlog:plan --waves` both call `select`, so the
+// plan's first wave is what the run starts into an idle repository rather than an order the run never
+// takes.
+//
+// **The cap comes last.** It used to be applied while the standalone half was classified, before the
+// gate, so a `run:solo` issue ranked sixth or lower was cut before the gate could see it — and the
+// issues below it were offered past it. Cut after the gate, the cap only ever removes what the gate
+// would have offered, so it cannot hide a waiting `run:solo` issue from it. It still bounds only the
+// standalone rows, as it always has; an epic's children were never capped.
+
+// Every child the classification placed, in the order it placed them: the ranked candidates first,
+// then the waiting ones, then the ones waiting on a person.
+function everything_in(result: EpicNextResult): ReadonlyArray<EpicChild> {
+	const candidates = result.candidates.flatMap((bundle) => bundle.children)
+
+	return [...candidates, ...result.waiting, ...result.blocked_on_people]
+}
+
+// The ranking is `epic_rank.rank`, shared with a named epic's lanes.
+const { rank } = epic_rank
+
+// This repository's candidates re-ranked inside the result, so `backlog:plan` prints the order the
+// offer is decided in.
+function rank_result(result: EpicNextResult, repo: string): EpicNextResult {
+	if (result.verdict !== 'run') return result
+
+	const pool = everything_in(result)
+
+	return {
+		...result,
+		candidates: result.candidates.map((bundle) =>
+			bundle.repo === repo ? { ...bundle, children: rank(bundle.children, pool) } : bundle,
+		),
+	}
+}
+
+// The standalone rows past the cap, in offer order.
+function overflow_of(
+	offered: ReadonlyArray<EpicChild>,
+	standalone: ReadonlySet<string>,
+): ReadonlySet<string> {
+	const keys = offered.map((child) => epic_graph.key_of(child)).filter((key) => standalone.has(key))
+
+	return new Set(keys.slice(git_next_issues.DISPLAY_LIMIT))
+}
+
+function is_in(child: EpicChild, keys: ReadonlySet<string>): boolean {
+	return keys.has(epic_graph.key_of(child))
+}
+
+function cap(selection: SoloSelection, standalone: ReadonlySet<string>): SoloSelection {
+	const overflow = overflow_of(selection.offered, standalone)
+
+	if (overflow.size === 0) return selection
+
+	return {
+		...selection,
+		offered: selection.offered.filter((child) => !is_in(child, overflow)),
+		withheld: [
+			...selection.offered.filter((child) => is_in(child, overflow)),
+			...selection.withheld,
+		],
+	}
+}
+
+interface OfferInput {
+	candidates: ReadonlyArray<EpicChild>
+	pool: ReadonlyArray<EpicChild>
+	read: BusyRead
+	repo: string
+	// The keys of the standalone rows — the ones the cap bounds.
+	standalone: ReadonlySet<string>
+}
+
+function select(input: OfferInput): SoloSelection {
+	const ranked = rank(input.candidates, input.pool)
+
+	return cap(epic_solo.select(ranked, input.read, input.repo), input.standalone)
+}
+
+// `backlog:next`'s gate: `epic_solo.gate` with this selection in place of its bare one.
+function gate(
+	result: EpicNextResult,
+	read: BusyRead,
+	repo: string,
+	standalone: ReadonlySet<string>,
+): SoloGate {
+	const pool = everything_in(result)
+
+	return epic_solo.gate(result, read, repo, (candidates) =>
+		select({ candidates, pool, read, repo, standalone }),
+	)
+}
+
+const backlog_rank = { everything_in, gate, rank_result, select }
+
+export { backlog_rank }
+export type { OfferInput }

package/scripts/backlog/backlog-ready.ts

@@ -21,6 +21,13 @@ interface ReadyPorts {
 	ready_issues: () => Promise<ReadonlyArray<string>>
 }
 
+async function free_under(limit: number): Promise<number> {
+	const lanes = await lane_registry.list_lanes()
+	const live = lanes.filter((lane) => !lane.is_stranded).length
+
+	return lane_capacity.free_lanes(limit, live)
+}
+
 // Free lanes right now: the limit less the live lanes. An unreadable limit reads as no free lane — the
 // safe direction, since both the stall and the ready line need a free lane and reporting one that is
 // not there is the false positive neither may raise.
@@ -35,10 +42,18 @@ async function free_lane_count(): Promise<number> {
 
 	if (limit.kind !== 'limit') return NO_FREE
 
-	const lanes = await lane_registry.list_lanes()
-	const live = lanes.filter((lane) => !lane.is_stranded).length
+	return await free_under(limit.limit)
+}
+
+// **The drive's count throws on an unreadable limit** (joshuafolkken/kit#3027). The drive launches no
+// more than this count, so the safe-direction zero above would leave it launching nothing and reporting
+// nothing for good; a bad setting is the hard error `lane_capacity` says it is, ending the drive loudly.
+async function drive_free_lane_count(): Promise<number> {
+	const limit = lane_capacity.lane_limit()
+
+	if (limit.kind !== 'limit') throw new Error(limit.problem)
 
-	return lane_capacity.free_lanes(limit.limit, live)
+	return await free_under(limit.limit)
 }
 
 // **A `--only` run has no pool to drain** (joshuafolkken/kit#2472). `backlog:next` lists the opted-in
@@ -135,6 +150,7 @@ const backlog_ready = {
 	read_backlog_next,
 	print_offer_hint,
 	free_lane_count,
+	drive_free_lane_count,
 	drains_pool,
 	print_ready_line,
 	read_ready,

package/scripts/backlog/backlog-scope.ts

@@ -1,6 +1,6 @@
 import type { EpicNextResult } from '#scripts/epic/epic-report'
-import { AUTO_OK_LABEL, EPIC_LABEL, has_any_label } from '#scripts/git/issue-labels'
 import type { OpenIssueData } from '#scripts/git/schemas'
+import { AUTO_OK_LABEL, EPIC_LABEL, has_any_label } from '#scripts/issue/issue-labels'
 
 // Which open issues the backlog will not run, and why (joshuafolkken/kit#1652).
 //
@@ -135,8 +135,6 @@ const backlog_scope = {
 	OPTED_IN_UNPLACED_REASON,
 	open_numbers_of,
 	out_of_scope,
-	planned_numbers,
-	reason_for,
 	titles_of,
 }
 

package/scripts/backlog/backlog-stalled-detect.ts

@@ -1,4 +1,4 @@
-import { telegram_notify } from '#scripts/git/telegram-notify'
+import { telegram_notify } from '#scripts/notify/telegram-notify'
 import { run_event_stream, type RunEvent } from '#scripts/run/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/run-event-stream-emit'
 import { backlog_ready, type ReadyPorts } from './backlog-ready'
@@ -137,7 +137,7 @@ async function run_stall_check(ready: ReadyPorts = backlog_ready.DEFAULT_PORTS):
 	}
 }
 
-const backlog_stalled_detect = { DEFAULT_PORTS, detect_and_report, gather, report, run_stall_check }
+const backlog_stalled_detect = { detect_and_report, run_stall_check }
 
 export { backlog_stalled_detect }
 export type { DetectPorts }

package/scripts/backlog/backlog-stalled.ts

@@ -118,7 +118,6 @@ const backlog_stalled = {
 	count_ready_tokens,
 	describe,
 	dispatch_age_ms,
-	is_stalled,
 	needs_triage,
 	ready_tokens,
 }

package/scripts/backlog/backlog-waves.ts

@@ -4,9 +4,13 @@ import { epic_cross_repo } from '#scripts/epic/epic-cross-repo'
 import { epic_graph, type EpicChild } from '#scripts/epic/epic-graph'
 import { epic_outside_blocker } from '#scripts/epic/epic-outside-blocker'
 import { epic_report, type EpicNextResult } from '#scripts/epic/epic-report'
-import { epic_solo } from '#scripts/epic/epic-solo'
-import { has_label_name, IN_PROGRESS_LABEL, NEEDS_DECISION_LABEL } from '#scripts/git/issue-labels'
+import {
+	has_label_name,
+	IN_PROGRESS_LABEL,
+	NEEDS_DECISION_LABEL,
+} from '#scripts/issue/issue-labels'
 import { backlog_plan, type PlanContext } from './backlog-plan'
+import { backlog_rank } from './backlog-rank'
 
 // The order a `backlogrun` takes, wave by wave, before it starts (joshuafolkken/kit#2778).
 //
@@ -14,13 +18,13 @@ import { backlog_plan, type PlanContext } from './backlog-plan'
 // made from, so the order past the first answer was left for a person to work out by hand. This plays
 // the asks forward under one assumption: **every issue of a wave merges before the next wave starts**.
 //
-// **No rule is written twice.** The first wave is `epic_solo.select` over the very candidates
-// `backlog:next` resolves, asked of an idle repository — so it is what `backlog:next` prints when
-// nothing is running. Each later wave marks the earlier waves closed and re-classifies the same pool
+// **No rule is written twice.** The first wave is `backlog_rank.select` — rank, `run:solo` gate, cap —
+// over the very candidates `backlog:next` resolves, asked of an idle repository — so it is what
+// `backlog:next` prints when nothing is running (joshuafolkken/kit#2928). Each later wave marks the earlier waves closed and re-classifies the same pool
 // through `epic_classify.classify_children` with the resolver `epic:next` sorted it with the first
 // time — `epic_cross_repo.resolve_cross_repo`, so a blocker in another repository still waits for its
 // release rather than counting as done on close — then puts the runnable set through
-// `epic_solo.select` again.
+// `backlog_rank.select` again.
 
 const IDLE: BusyRead = { kind: 'idle' }
 const CLOSED = 'CLOSED'
@@ -45,14 +49,6 @@ function is_running(child: EpicChild): boolean {
 	return has_label_name(child.labels, IN_PROGRESS_LABEL)
 }
 
-// Every child the classification placed, in the order it placed them: the ranked candidates first,
-// then the waiting ones, then the ones waiting on a person.
-function everything_in(result: EpicNextResult): ReadonlyArray<EpicChild> {
-	const candidates = result.candidates.flatMap((bundle) => bundle.children)
-
-	return [...candidates, ...result.waiting, ...result.blocked_on_people]
-}
-
 function as_closed(child: EpicChild, done: ReadonlySet<string>): EpicChild {
 	return done.has(epic_graph.key_of(child)) ? { ...child, state: CLOSED } : child
 }
@@ -63,24 +59,35 @@ interface WavePool {
 	children: ReadonlyArray<EpicChild>
 	running: ReadonlySet<string>
 	repo: string
+	standalone: ReadonlySet<string>
 }
 
-function pool_of(result: EpicNextResult, repo: string): WavePool {
-	const all = everything_in(result)
+function pool_of(result: EpicNextResult, repo: string, standalone: ReadonlySet<string>): WavePool {
+	const all = backlog_rank.everything_in(result)
 
 	return {
 		children: all.filter((child) => !is_running(child)),
 		running: epic_outside_blocker.running_keys(all),
 		repo,
+		standalone,
 	}
 }
 
-function offer(runnable: ReadonlyArray<EpicChild>, repo: string): ReadonlyArray<EpicChild> {
-	return epic_solo.select(runnable, IDLE, repo).offered
+function offer(
+	candidates: ReadonlyArray<EpicChild>,
+	children: ReadonlyArray<EpicChild>,
+	pool: WavePool,
+): ReadonlyArray<EpicChild> {
+	const { repo, standalone } = pool
+
+	return backlog_rank.select({ candidates, pool: children, read: IDLE, repo, standalone }).offered
 }
 
-function first_wave(result: EpicNextResult, repo: string): ReadonlyArray<EpicChild> {
-	return offer(epic_report.candidates_for_repo(result, repo), repo)
+// Ranked against the whole result, exactly as `backlog:next` ranks it, so the two agree.
+function first_wave(result: EpicNextResult, pool: WavePool): ReadonlyArray<EpicChild> {
+	const candidates = epic_report.candidates_for_repo(result, pool.repo)
+
+	return offer(candidates, backlog_rank.everything_in(result), pool)
 }
 
 function next_wave(pool: WavePool, done: ReadonlySet<string>): ReadonlyArray<EpicChild> {
@@ -93,25 +100,31 @@ function next_wave(pool: WavePool, done: ReadonlySet<string>): ReadonlyArray<Epi
 
 	return offer(
 		runnable.filter((child) => child.repo === pool.repo),
-		pool.repo,
+		children,
+		pool,
 	)
 }
 
 // Each wave is closed before the next is asked for; a wave that offers nothing ends the plan, which
-// the pool's size bounds because every wave closes at least one child.
-function build(result: EpicNextResult, repo: string): WavePlan {
-	const pool = pool_of(result, repo)
+// the pool's size bounds because every wave closes at least one child. `standalone` names the rows the
+// offer's cap bounds; left empty, no wave is capped.
+function build(
+	result: EpicNextResult,
+	repo: string,
+	standalone: ReadonlySet<string> = new Set(),
+): WavePlan {
+	const pool = pool_of(result, repo, standalone)
 	const done = new Set<string>()
 	const waves: Array<ReadonlyArray<EpicChild>> = []
 
-	for (let wave = first_wave(result, repo); wave.length > 0; wave = next_wave(pool, done)) {
+	for (let wave = first_wave(result, pool); wave.length > 0; wave = next_wave(pool, done)) {
 		waves.push(wave)
 		for (const child of wave) done.add(epic_graph.key_of(child))
 	}
 
-	const unreached = everything_in(result).filter(
-		(child) => child.repo === repo && !done.has(epic_graph.key_of(child)),
-	)
+	const unreached = backlog_rank
+		.everything_in(result)
+		.filter((child) => child.repo === repo && !done.has(epic_graph.key_of(child)))
 
 	return { waves, unreached }
 }
@@ -139,10 +152,14 @@ function unreached_lines(plan: WavePlan, context: PlanContext): Array<string> {
 	)
 }
 
-function format_waves(result: EpicNextResult, context: PlanContext): string {
+function format_waves(
+	result: EpicNextResult,
+	context: PlanContext,
+	standalone: ReadonlySet<string> = new Set(),
+): string {
 	if (result.verdict === 'error') return backlog_plan.format_unusable(result)
 
-	const plan = build(result, context.repo)
+	const plan = build(result, context.repo, standalone)
 	const waves = plan.waves.map((wave, index) => wave_line(wave, index, context.repo))
 
 	return [
@@ -158,7 +175,6 @@ function format_waves(result: EpicNextResult, context: PlanContext): string {
 const backlog_waves = {
 	HEADING_ASSUMPTION,
 	NEEDS_DECISION_NOTE,
-	NOT_REACHED_NOTE,
 	PARALLEL_NOTE,
 	UNREACHED_HEADING,
 	build,

package/scripts/behavior/behavior-cli.ts

@@ -81,7 +81,7 @@ function run(cwd: string = process.cwd()): number {
 	return file === undefined ? report_no_transcript() : check_session(file)
 }
 
-const behavior_cli = { LABEL, check_session, current_session, run }
+const behavior_cli = { check_session, run }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) process.exitCode = run()