@joshuafolkken/kit 1.872.0

package/scripts/backlog/backlog-offer.ts

@@ -0,0 +1,93 @@
+import type { BacklogAnswer } from './backlog-budget'
+import { backlog_next } from './backlog-next'
+
+// The mechanical half of `josh backlog:offer` (joshuafolkken/kit#2162): turn what `backlog:next`
+// answered — its stdout tokens and its exit code — into the one word `backlog:budget` is then asked
+// with, plus the issue numbers to start and the consecutive-retry count carried to the next ask.
+//
+// **The mapping is `backlogrun-steps.md` → "The loop"'s table, held here so it cannot drift.** That table
+// fixed which `backlog:next` answer becomes which `backlog:budget` word, and it carried two context
+// branches an agent had to apply by hand every iteration: `wait` is `blocked` while this run has
+// children in flight and `exhausted` when it has none, and `retry` is `blocked` until the third
+// consecutive one, which is `unreadable`. Both are decided from a count here rather than from a
+// judgement.
+
+// Three consecutive `retry` answers end the run: below that a transport hiccup is re-asked, at it the
+// outage is not a hiccup. `backlogrun-steps.md` → "The loop" is the single source of the count.
+const RETRY_LIMIT = 3
+const FAILURE_EXIT_CODE = 1
+const NO_RETRIES = 0
+const NUMBER_PATTERN = /^[1-9]\d*$/u
+
+const TOKENS = backlog_next.VERDICT_TOKENS
+
+// `backlog:next`'s captured result: the exit code, and the trimmed stdout as one token per line.
+interface NextRead {
+	code: number
+	tokens: ReadonlyArray<string>
+}
+
+interface OfferAnswer {
+	answer: BacklogAnswer
+	issues: ReadonlyArray<string>
+	// The consecutive-retry count after this ask — reset to zero by any answer that is not `retry`.
+	retries: number
+}
+
+// The verdict words that map to one answer regardless of context. `wait` and `retry` are the two that
+// do not, and they are handled by their own functions below.
+const VERDICT_ANSWERS: Readonly<Record<string, BacklogAnswer>> = {
+	[TOKENS.complete]: 'exhausted',
+	[TOKENS.error]: 'unreadable',
+	[TOKENS.stop]: 'parked',
+}
+
+// `wait` is `blocked` while this run has children in flight and `exhausted` when it does not — the
+// mapping `backlog:budget` states, decided from the running count alone.
+function wait_answer(running: number): BacklogAnswer {
+	return running > 0 ? 'blocked' : 'exhausted'
+}
+
+// An unrecognized token is read as `unreadable` rather than guessed at: an answer the loop cannot
+// place must end the run, not silently start work.
+function verdict_answer(token: string, running: number): BacklogAnswer {
+	if (token === TOKENS.wait) return wait_answer(running)
+
+	return VERDICT_ANSWERS[token] ?? 'unreadable'
+}
+
+// A single verdict token, with the retry count advanced. `retry` is the only token that carries the
+// count forward; every other resets it, because the count is of *consecutive* retries.
+function from_verdict(token: string, running: number, retries: number): OfferAnswer {
+	if (token === TOKENS.retry) {
+		const next = retries + 1
+
+		return { answer: next >= RETRY_LIMIT ? 'unreadable' : 'blocked', issues: [], retries: next }
+	}
+
+	return { answer: verdict_answer(token, running), issues: [], retries: NO_RETRIES }
+}
+
+function is_numbers(tokens: ReadonlyArray<string>): boolean {
+	return tokens.length > 0 && tokens.every((token) => NUMBER_PATTERN.test(token))
+}
+
+// **Read the exit code before the tokens.** Exit 1 is "the listing could not be read", which is never
+// an empty backlog — reading it as `none` would report an emptiness that was never seen, so it maps to
+// `unreadable`, and a stray stdout line on that path cannot be mistaken for an issue number.
+function answer_of(read: NextRead, running: number, retries: number): OfferAnswer {
+	if (read.code === FAILURE_EXIT_CODE) {
+		return { answer: 'unreadable', issues: [], retries: NO_RETRIES }
+	}
+
+	if (is_numbers(read.tokens)) {
+		return { answer: 'candidates', issues: read.tokens, retries: NO_RETRIES }
+	}
+
+	return from_verdict(read.tokens[0] ?? '', running, retries)
+}
+
+const backlog_offer = { RETRY_LIMIT, answer_of, verdict_answer, wait_answer }
+
+export type { NextRead, OfferAnswer }
+export { backlog_offer }

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

@@ -0,0 +1,235 @@
+#!/usr/bin/env tsx
+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 { 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'
+import { backlog_named } from './backlog-named'
+import { backlog_next, type OptedIn } from './backlog-next'
+import { backlog_plan, type NamedPlan } from './backlog-plan'
+import { backlog_scope } from './backlog-scope'
+
+// `josh backlog:plan` — the whole backlog as a plan a person reads before a run starts
+// (joshuafolkken/kit#1652).
+//
+// `backlog:next` already answers what may start, and a `backlogrun` acted on that answer one ask at a
+// time, so nothing ever showed the shape of the run: the order, which issue waits on which, what is
+// waiting on a person, and what the backlog will not run at all. That last one was invisible by
+// construction — an issue without `auto-ok` never enters the pool, so silence covered both "not opted
+// in" and "not reached yet".
+//
+// It is a second command rather than a flag on `backlog:next`, because that command's standard output
+// is a contract a loop branches on — one bare token per line — and a plan printed there would break
+// every consumer of it. What it is *not* is a second implementation: the classification comes from
+// `backlog_next.resolve`, so the plan cannot promise an order the run does not take.
+
+const ARGV_OFFSET = 2
+const SUCCESS_EXIT_CODE = 0
+const FAILURE_EXIT_CODE = 1
+
+// The keyword `run_invocation` parses a named-issue prefix behind, reused rather than parsing `#N`
+// again here so the `0` / leading-zero / safe-integer rules stay single-sourced (joshuafolkken/kit#1984).
+const NAMED_COMMAND = 'backlogrun'
+// The flag that runs the named list and stops, mirrored here so the plan the person reads before the
+// run shows the same scope the run will take (joshuafolkken/kit#1984).
+const ONLY_FLAG = '--only'
+
+const USAGE =
+	'Usage: josh backlog:plan [#<issue-number>...] [--only] [--exclude <issue-number>[,<issue-number>...]]...'
+
+// The leading `#N` tokens are the named prefix a `backlogrun #N1 #N2 …` runs before the pool. They are
+// read through the invocation grammar so the plan and the run agree on what counts as a named issue.
+function named_of(argv: ReadonlyArray<string>): ReadonlyArray<number> {
+	return run_invocation.issue_numbers(`${NAMED_COMMAND} ${argv.join(' ')}`) ?? []
+}
+
+// The tokens after the named prefix — what the option parser sees, so a `#N` is never read as an
+// unknown positional.
+function without_named(argv: ReadonlyArray<string>): ReadonlyArray<string> {
+	return argv.slice(named_of(argv).length)
+}
+
+function has_only_flag(argv: ReadonlyArray<string>): boolean {
+	return argv.includes(ONLY_FLAG)
+}
+
+// `--only` is stripped before the named block and the options are read, so it is never taken for a
+// positional or an unknown option; whether it was present is carried as a boolean instead.
+function without_only(argv: ReadonlyArray<string>): ReadonlyArray<string> {
+	return argv.filter((token) => token !== ONLY_FLAG)
+}
+
+// The one start-time refusal: `--only` with no named issues has nothing to run. `backlog_named` is the
+// single source of that decision, so the plan and the run refuse it alike. The refusal turns only on
+// whether anything was named, so the items are built with `is_epic: false` — which item is an epic is
+// decided by the run at dispatch time, not here (joshuafolkken/kit#1985).
+function only_refusal(named: ReadonlyArray<number>, is_only: boolean): string | undefined {
+	const items = named.map((issue) => ({ issue, is_epic: false }))
+	const startup = backlog_named.startup(items, is_only)
+
+	return startup.kind === 'refused' ? startup.reason : undefined
+}
+
+// A failed open listing is not "nothing is out of scope". Reported rather than rendered around, for
+// the reason joshuafolkken/kit#950 records: a confident absence built on a read that failed is worse
+// than no answer.
+const OPEN_UNREADABLE_MESSAGE =
+	"Could not read this repository's open issues, so the out-of-scope half of the plan cannot be told from an empty one. Check `gh auth status` and ask again."
+
+// A cut listing is a cut *set difference*, which is not the ignorable prefix a display's cap is: an
+// open issue past the cut is missing from the out-of-scope section and its title is missing from
+// every other one. Reported as a gap, the way `backlog:next` reports its own truncated listings.
+const OPEN_TRUNCATED_MESSAGE = `⚠ The open-issue listing stopped at ${String(auto_ok_cli.LISTING_LIMIT)} rows, so the out-of-scope section is partial, some titles are missing, and a blocker that has since closed can still be named. The plan below is incomplete.`
+
+interface Plan {
+	result: EpicNextResult
+	repo: string
+	exclude: ReadonlyArray<number>
+	// Which **opted-in** epic is withholding which issue, narrowed by the same function the pool
+	// decided membership with (joshuafolkken/kit#1668). Without it the scope layer had no branch for
+	// "an epic is offering this one instead", so every opted-in row it could not place was reported as
+	// 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 listing plus whether it was cut. Carried together because the rows alone cannot say whether
+// what is missing from them is absent or merely past the cap.
+interface OpenListing {
+	rows: ReadonlyArray<OpenIssueData>
+	is_capped: boolean
+}
+
+// The same reads and the same classification `backlog:next` makes, through the same two functions.
+// `undefined` is a failure it has already reported.
+async function classify(
+	opted_in: OptedIn,
+	exclude: ReadonlyArray<number>,
+): Promise<Plan | undefined> {
+	const context = await backlog_next.context_of(opted_in, exclude)
+
+	if (context === undefined) return undefined
+
+	const result = await backlog_next.resolve(context)
+
+	if (result === undefined) return undefined
+
+	return {
+		result,
+		repo: context.repo,
+		exclude,
+		tracked: epic_index.withheld_children(context.tracking.index, context.opted_in.issues),
+	}
+}
+
+// Every open issue, read once. It carries both halves the plan needs and the pool does not hold: the
+// titles, and the set the out-of-scope rows are subtracted from. One read serves both, so the plan
+// costs exactly one `gh` call more than the answer it is rendering.
+async function fetch_open(): Promise<OpenListing | undefined> {
+	const { json, is_capped } = await git_gh_command.issue_list_recent(auto_ok_cli.LISTING_LIMIT)
+
+	if (json === undefined) return undefined
+
+	const read = read_json_listing(json, open_issue_schema)
+
+	return read.kind === 'read' ? { rows: read.rows, is_capped } : undefined
+}
+
+function print_plan(
+	plan: Plan,
+	open_issues: ReadonlyArray<OpenIssueData>,
+	is_capped: boolean,
+	named: NamedPlan,
+): void {
+	const scope = { repo: plan.repo, exclude: plan.exclude, tracked: plan.tracked }
+	const rows = backlog_scope.out_of_scope(open_issues, plan.result, scope)
+	// A cut listing cannot say an issue is closed, only that it was not read — so the blocker filter is
+	// switched off rather than fed a set that would silently report standing blockers as gone.
+	const context = {
+		repo: plan.repo,
+		titles: backlog_scope.titles_of(open_issues),
+		open_numbers: is_capped ? undefined : backlog_scope.open_numbers_of(open_issues),
+	}
+
+	console.info(backlog_plan.format_plan(plan.result, rows, context, named))
+}
+
+async function report(plan: Plan, named: NamedPlan): Promise<number> {
+	const listing = await fetch_open()
+
+	if (listing === undefined) {
+		console.error(OPEN_UNREADABLE_MESSAGE)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	if (listing.is_capped) console.error(OPEN_TRUNCATED_MESSAGE)
+	print_plan(plan, listing.rows, listing.is_capped, named)
+
+	return SUCCESS_EXIT_CODE
+}
+
+async function run_plan(rest: ReadonlyArray<string>, named: NamedPlan): Promise<number> {
+	const options = auto_ok_cli.parse_options(without_named(rest), USAGE)
+
+	if (options.usage !== undefined) {
+		console.error(options.usage)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	const opted_in = await auto_ok_cli.fetch_opted_in()
+
+	if (opted_in.kind !== 'read') {
+		console.error(backlog_next.READ_FAILURES[opted_in.kind])
+
+		return FAILURE_EXIT_CODE
+	}
+
+	const plan = await classify(opted_in, options.exclude ?? [])
+
+	return plan === undefined ? FAILURE_EXIT_CODE : await report(plan, named)
+}
+
+async function run(argv: ReadonlyArray<string>): Promise<number> {
+	const is_only = has_only_flag(argv)
+	const rest = without_only(argv)
+	// Read the named block from the *original* argv, so `--only` placed before the `#N` block breaks the
+	// leading block exactly as the run grammar does — the plan then refuses an ordering the run refuses,
+	// rather than promising a scope the resumed invocation would stop on (joshuafolkken/kit#1984).
+	const named = named_of(argv)
+	const refusal = only_refusal(named, is_only)
+
+	if (refusal !== undefined) {
+		console.error(refusal)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	return await run_plan(rest, { issues: named, only: is_only })
+}
+
+// `process.exitCode` rather than `process.exit()`, the reason `backlog:next` records: the plan is
+// several kilobytes on standard output, and exiting outright can cut the pipe before it has drained.
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
+}
+
+const backlog_plan_cli = {
+	OPEN_TRUNCATED_MESSAGE,
+	OPEN_UNREADABLE_MESSAGE,
+	USAGE,
+	classify,
+	fetch_open,
+	main,
+	print_plan,
+	report,
+	run,
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
+
+export { backlog_plan_cli }

package/scripts/backlog/backlog-plan.ts

@@ -0,0 +1,231 @@
+import type { EpicChild } from '#scripts/epic/epic-graph'
+import { epic_report, type EpicNextResult } from '#scripts/epic/epic-report'
+import type { IssueReference } from '#scripts/git/git-epic-reference'
+import { has_label_name, IN_PROGRESS_LABEL } from '#scripts/git/issue-labels'
+import type { OutOfScopeRow } from './backlog-scope'
+
+// The plan a person reads before a `backlogrun` starts (joshuafolkken/kit#1652).
+//
+// `backlog:next` answers the **next** question — which numbers may start now — and its report is
+// shaped for the loop that consumes it. This renders the **whole** picture from the same classified
+// pool: what may start in parallel, what is waiting and on which issue, what is waiting on a person,
+// and what the backlog will not run at all. Rendering only: the classification is
+// `backlog-next.ts`'s, so a plan can never promise an order the run does not take.
+
+// Two spaces deeper than `epic_report`'s repository headings, so a child reads as sitting under one.
+const ROW_INDENT_WIDTH = 4
+const ROW_INDENT = ' '.repeat(ROW_INDENT_WIDTH)
+const NOTHING = `${ROW_INDENT}(none)`
+
+// The named-issue prefix of a `backlogrun #N1 #N2 …` (joshuafolkken/kit#1984): these run one at a
+// time, in the order they were typed, before anything in the pool below is picked up.
+const NAMED_HEADING = 'Named issues — run in order first, one at a time, then the backlog:'
+// `--only` runs the named list and stops, so its heading says the pool is not drained
+// (joshuafolkken/kit#1984). The plan then shows the named section alone.
+const ONLY_NAMED_HEADING =
+	'Named issues — run in order, one at a time, then stop (`--only`; the opted-in backlog is not run):'
+const READY_HEADING =
+	'Ready now — each takes a free lane in its repository, so these may run in parallel:'
+const WAITING_HEADING = 'Waiting — each names what it is waiting on:'
+const HUMAN_HEADING =
+	'Waiting on a person (`needs-decision`) — resolve these before the run starts:'
+const SCOPE_HEADING = 'Out of scope — open, but the backlog will not run these:'
+// `epic_report`'s own words for the same condition, so the plan and the run name it identically.
+const UNUSABLE_HEADING = 'The dependency graph is unusable, so there is no plan:'
+
+const IN_PROGRESS_NOTE = 'a run already has it'
+const PAST_OFFER_NOTE = 'ready, but past the offer this ask could make'
+
+// The repository the plan is written from, and the titles the pool does not carry. Passed together
+// because every row needs both: a bare number is not a plan, and a child elsewhere has to be
+// qualified or it names this repository's issue of that number.
+interface PlanContext {
+	repo: string
+	titles: ReadonlyMap<number, string>
+	// The open issues of this repository by number, or `undefined` when the listing was cut short and
+	// absence from it therefore proves nothing.
+	//
+	// A `blocked_by` edge keeps a blocker that has since closed — `backlog-pool.ts`'s `to_child` drops
+	// the node's state — so with a complete listing this is what tells a standing blocker from a
+	// closed one. **With an incomplete one every blocker is named**, because the two errors are not
+	// symmetric: naming a closed blocker sends a person to an issue that turns out to be done, while
+	// dropping a standing one reports the child as merely next in line when the run will keep waiting.
+	open_numbers: ReadonlySet<number> | undefined
+}
+
+// A child elsewhere is qualified, because a bare number would name *this* repository's issue of that
+// number — a different issue (joshuafolkken/kit#1016). Takes the reference rather than the child, so
+// a `blocked_by` edge is named by the same rule the child itself is.
+function reference_of(reference: IssueReference, repo: string): string {
+	const number = String(reference.number)
+
+	return reference.repo === repo ? `#${number}` : `${reference.repo}#${number}`
+}
+
+// A title is only known for this repository's issues — the open listing the titles come from is this
+// repository's. A child elsewhere is still named, just without one.
+function title_of(child: EpicChild, context: PlanContext): string {
+	return child.repo === context.repo ? (context.titles.get(child.number) ?? '') : ''
+}
+
+function join_row(reference: string, title: string, note: string): string {
+	const parts = [reference, title, note === '' ? '' : `— ${note}`].filter((part) => part !== '')
+
+	return `${ROW_INDENT}${parts.join('  ')}`
+}
+
+function row_of(child: EpicChild, context: PlanContext, note: string): string {
+	return join_row(reference_of(child, context.repo), title_of(child, context), note)
+}
+
+// Why this one is not offered yet. The blocker numbers are the answer whenever there are any — that
+// is the dependency the report has never shown — and the two label-free cases are told apart so
+// "waiting" does not read as "blocked" for an issue that is simply next in line.
+// A blocker is dropped only where it is *known* closed: this repository's, and absent from a listing
+// that was read to the end. Anything else is named.
+function is_standing(edge: IssueReference, context: PlanContext): boolean {
+	if (context.open_numbers === undefined) return true
+
+	return edge.repo !== context.repo || context.open_numbers.has(edge.number)
+}
+
+function open_blockers(child: EpicChild, context: PlanContext): Array<string> {
+	return child.blocked_by
+		.filter((edge) => is_standing(edge, context))
+		.map((edge) => reference_of(edge, context.repo))
+}
+
+// The label is read before the edges, the order `epic_classify.local_category` already settles the
+// same question in: a child a run already holds is withheld for that reason whatever else it
+// declares, and saying it waits on an issue would send a person to the wrong place.
+function waiting_note(child: EpicChild, context: PlanContext): string {
+	if (has_label_name(child.labels, IN_PROGRESS_LABEL)) return IN_PROGRESS_NOTE
+	const blockers = open_blockers(child, context)
+
+	if (blockers.length > 0) return `waiting on ${blockers.join(', ')}`
+
+	return PAST_OFFER_NOTE
+}
+
+function section(heading: string, lines: ReadonlyArray<string>): string {
+	return [heading, ...(lines.length === 0 ? [NOTHING] : lines)].join('\n')
+}
+
+// The three child sections differ only in the note each row carries, so one function renders all of
+// them and the note is what varies.
+function child_lines(
+	children: ReadonlyArray<EpicChild>,
+	context: PlanContext,
+	note: (child: EpicChild) => string,
+): Array<string> {
+	return children.map((child) => row_of(child, context, note(child)))
+}
+
+// A section whose rows say nothing beyond naming the issue: being under the heading is the whole
+// statement.
+function no_note(): string {
+	return ''
+}
+
+// Grouped by repository, because a lane is per repository — so the grouping is the parallelism, not
+// a presentational choice. The heading is `epic_report`'s own, checkout path included.
+function ready_lines(result: EpicNextResult, context: PlanContext): Array<string> {
+	return result.candidates.flatMap((bundle) => [
+		epic_report.format_bundle_heading(bundle),
+		...child_lines(bundle.children, context, no_note),
+	])
+}
+
+function waiting_lines(children: ReadonlyArray<EpicChild>, context: PlanContext): Array<string> {
+	return child_lines(children, context, function note(child: EpicChild): string {
+		return waiting_note(child, context)
+	})
+}
+
+function scope_lines(rows: ReadonlyArray<OutOfScopeRow>): Array<string> {
+	return rows.map((row) => join_row(`#${String(row.number)}`, row.title, row.reason))
+}
+
+// The classification could not be made, so every section below it would be rendered from buckets
+// that mean nothing — and `build_result` empties only `candidates`, so an unusable graph would
+// otherwise print as an ordinary plan with nothing ready. `backlog:next` answers `error` for this
+// same pool, and a plan that read as normal beside it is exactly the disagreement this command
+// promises cannot happen.
+function format_unusable(result: EpicNextResult): string {
+	const lines = result.anomalies.map((anomaly) => `${ROW_INDENT}${anomaly.message}`)
+
+	return [UNUSABLE_HEADING, ...(lines.length === 0 ? [NOTHING] : lines)].join('\n')
+}
+
+// The named prefix a `backlogrun` runs, and whether `--only` stops it there. Carried together because
+// the plan renders the same two facts the run acts on: which issues lead, and whether the pool follows.
+interface NamedPlan {
+	issues: ReadonlyArray<number>
+	only: boolean
+}
+
+// The named issues are this repository's own, so a bare `#N` names them and a title is looked up the
+// same way the pool's rows are. The order is the invocation's, never sorted.
+function named_lines(named: ReadonlyArray<number>, context: PlanContext): Array<string> {
+	return named.map((issue) => join_row(`#${String(issue)}`, context.titles.get(issue) ?? '', ''))
+}
+
+// The section leads the plan when the invocation named issues, and is absent otherwise — a bare
+// `backlogrun` has no named prefix, so the plan opens on the pool as it always did. This is the
+// non-`--only` prefix; `--only` renders its own whole plan in `format_only`.
+function named_prefix(named: NamedPlan, context: PlanContext): Array<string> {
+	if (named.issues.length === 0) return []
+
+	return [section(NAMED_HEADING, named_lines(named.issues, context)), '']
+}
+
+// `--only` runs the named list and stops, so its plan is the named section alone — the pool is not
+// run, and rendering it would promise work `--only` excludes. The header still names the repository.
+function format_only(named: NamedPlan, context: PlanContext): string {
+	return [
+		`Backlog plan — ${context.repo}`,
+		'',
+		section(ONLY_NAMED_HEADING, named_lines(named.issues, context)),
+	].join('\n')
+}
+
+function format_plan(
+	result: EpicNextResult,
+	out_of_scope: ReadonlyArray<OutOfScopeRow>,
+	context: PlanContext,
+	named: NamedPlan,
+): string {
+	if (result.verdict === 'error') return format_unusable(result)
+	if (named.only) return format_only(named, context)
+
+	return [
+		`Backlog plan — ${context.repo}`,
+		'',
+		...named_prefix(named, context),
+		section(READY_HEADING, ready_lines(result, context)),
+		'',
+		section(WAITING_HEADING, waiting_lines(result.waiting, context)),
+		'',
+		section(HUMAN_HEADING, child_lines(result.blocked_on_people, context, no_note)),
+		'',
+		section(SCOPE_HEADING, scope_lines(out_of_scope)),
+	].join('\n')
+}
+
+const backlog_plan = {
+	HUMAN_HEADING,
+	IN_PROGRESS_NOTE,
+	NAMED_HEADING,
+	NOTHING,
+	ONLY_NAMED_HEADING,
+	PAST_OFFER_NOTE,
+	READY_HEADING,
+	SCOPE_HEADING,
+	UNUSABLE_HEADING,
+	WAITING_HEADING,
+	format_plan,
+	waiting_note,
+}
+
+export { backlog_plan }
+export type { NamedPlan, PlanContext }