@joshuafolkken/kit 1.1240.0 → 1.1370.0

package/scripts/epic/epic-close-comment.ts

@@ -1,6 +1,7 @@
 import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { rest_comment_schema, type RestCommentData } from '#scripts/git/git-schemas'
 import { read_json_listing } from '#scripts/git/parse-json-array'
+import { issue_cite } from '#scripts/issue/issue-cite'
 import { epic_parse, type ExternalChild } from './epic-parse'
 
 // The comment the epic auto-close announces itself with, and how a run recognizes the one a previous
@@ -9,7 +10,7 @@ import { epic_parse, type ExternalChild } from './epic-parse'
 // Kept apart from `epic-close.ts` because the two answer different questions — that file decides
 // *whether* an epic may close, this one decides what the announcement says and whether it is already
 // there — and because the file it was split from is within twenty lines of the three hundred a file
-// may hold (joshuafolkken/kit#1039).
+// may hold.
 
 // The epic's children, near and far. Named structurally rather than by importing `EpicIssue`: the
 // dependency runs one way, from the auto-close to here, and a type import back would put a cycle
@@ -20,31 +21,30 @@ interface EpicChildren {
 }
 
 // The fixed sentence the announcement's prose ends with. It is what a person reads, and it is no
-// longer what the retry check matches on (joshuafolkken/kit#1068): people and agents quote the
+// longer what the retry check matches on: people and agents quote the
 // auto-close output in ordinary issue comments, and matching prose made any such quote answer
 // "already announced" — the epic then closed with no comment, losing the record of which children it
 // closed against.
 const CLOSE_ANNOUNCEMENT = 'Closing this epic automatically.'
 
-// The marker, which GitHub renders as nothing at all. Quoting the sentence above therefore no longer
-// suppresses anything: what is quoted is the rendered text, and the marker is not in it.
+// The marker, which GitHub renders as nothing at all. Quoting the sentence above therefore does not
+// suppress anything: what is quoted is the rendered text, and the marker is not in it.
 //
 // **It carries the child set the announcement named.** That is what makes an epic which was
 // reopened, gained a child and completed again announce a *second* time instead of closing silently
-// against a stale list. joshuafolkken/kit#1039 rejected matching the whole composed body for a
-// neighboring reason — the visible child list varies, so an unchanged epic would have been read as
-// "not posted yet" whenever the wording drifted — and the marker keeps that failure out by being
+// against a stale list. Matching the whole composed body instead would read an unchanged epic as
+// "not posted yet" whenever the wording drifted, and the marker keeps that failure out by being
 // built from the child set alone: the prose can be rephrased without moving it, and the set is
 // compared as a set, so reordering the epic's task list does not move it either.
 const MARKER_OPEN = '<!-- josh:epic-auto-close children='
 const MARKER_CLOSE = ' -->'
 
 // Every child, near and far. Listing only the local ones left an all-external epic announcing "All
-// child issues are closed ()" (joshuafolkken/kit#864).
+// child issues are closed ()".
 function child_references(epic: EpicChildren): Array<string> {
 	return [
-		...epic.children.map((child) => `#${String(child)}`),
-		...epic.external_children.map((child) => `${child.repo}#${String(child.number)}`),
+		...epic.children.map((child) => issue_cite.plain(child)),
+		...epic.external_children.map((child) => issue_cite.plain(child.number, child.repo)),
 	]
 }
 
@@ -91,11 +91,11 @@ function build_close_comment(epic: EpicChildren): string {
 	return `All child issues are closed (${child_references(epic).join(', ')}). ${CLOSE_ANNOUNCEMENT}\n\n${build_marker(epic)}`
 }
 
-// MIGRATION ONLY (joshuafolkken/kit#1068) — remove together with `is_legacy_announcement`.
+// MIGRATION ONLY — remove together with `is_legacy_announcement`.
 //
 // Announcements posted by v1.179.0 through the release before this one carry no marker, so an epic
 // sitting in the half-succeeded state right now would be read as "not announced" and receive the
-// second comment joshuafolkken/kit#1039 removed. This matches those.
+// second comment. This matches those.
 //
 // **The wording here is a frozen copy of what was released, not a second spelling of the constants
 // above.** Deriving it from them would make a future rephrasing of the announcement silently stop
@@ -129,8 +129,7 @@ function is_legacy_announcement(body: string): boolean {
 //
 // `unreadable` is deliberately not folded into `absent`, though the caller acts the same way on
 // both: a listing that could not be read says nothing about what is on the issue, and reporting it
-// as "nothing is there" would have the run state a fact it never established — the misread
-// joshuafolkken/kit#973 and joshuafolkken/kit#959 were each about. Keeping it apart is what lets
+// as "nothing is there" would have the run state a fact it never established. Keeping it apart is what lets
 // `epic-close.ts` say out loud that the duplicate check did not run, which is the whole
 // difference between the two answers there.
 //
@@ -145,7 +144,7 @@ type CloseCommentState = 'present' | 'absent' | 'unreadable'
 // announcement carry the raw marker along with everything else: GitHub's "Quote reply" puts every
 // line behind `> `, which the line comparison rejects, and a code block reproduces the marker line
 // verbatim — a fenced one caught by the mask, an indented one by the indent check. `fence_mask` is the same walk every other body predicate
-// in this codebase reads through, rather than a second one written here (joshuafolkken/kit#890).
+// in this codebase reads through, rather than a second one written here.
 function has_marker(body: string, children: ReadonlyArray<string>): boolean {
 	const mask = epic_parse.fence_mask(body)
 

package/scripts/epic/epic-close.ts

@@ -3,22 +3,21 @@ import { epic_child_schema, epic_issue_schema, type EpicChildData } from '#scrip
 import { cutoff_cause, cutoff_of, type ScanCutoff } from '#scripts/git/listing-cutoff'
 import {
 	parse_json_array_or_undefined,
-	parse_json_object_safe,
+	parse_json_object_or_undefined,
 } from '#scripts/git/parse-json-array'
 import { EPIC_LABEL } from '#scripts/issue/issue-labels'
+import { session_cite } from '#scripts/issue/session-cite'
 import { error_text } from '#scripts/lib/error-message'
 import { epic_close_comment } from './epic-close-comment'
 import { epic_parse, type ExternalChild } from './epic-parse'
 
 // How many open epics the auto-close will look at. `git-gh-issue-list.ts` pages until `limit` rows
 // have been selected or the backlog runs out, so this is what keeps the ordinary case at exactly one
-// request — 100 is `PER_PAGE`. Since joshuafolkken/kit#1067 the paging's own page ceiling bounds
-// this listing too, but as a backstop rather than as this number's replacement: it stops the request
-// count, not the row count.
+// request — 100 is `PER_PAGE`. The paging's own page ceiling bounds this listing too, but as a
+// backstop rather than as this number's replacement: it stops the request count, not the row count.
 //
 // The listing is newest-first and the surplus is cut off the tail, so a repository holding more open
-// epics than this loses the oldest. It no longer loses them silently: since joshuafolkken/kit#1067
-// both cutoffs are reported, because an epic past the cut is never checked for completion and stays
+// epics than this loses the oldest. It does not lose them silently: both cutoffs are reported, because an epic past the cut is never checked for completion and stays
 // open with nothing saying why — the same silence this file's `undefined`-not-`[]` handling exists
 // to remove. The value still sits well above the number of epics ever open at once, so the report is
 // the exception rather than a line on every merge.
@@ -60,8 +59,7 @@ function to_epic_issue(raw: { number: number; body?: string | undefined }): Epic
 // `parse_json_array_safe` returns `[]` for both, and the auto-close then decides there is no epic to
 // close: it stops for a reason that never reaches a log, and the epic stays open with nothing saying
 // why. The failure leans safe — the other direction, taken by `epic:bundle`, invented a second epic
-// (joshuafolkken/kit#950) — but silence is the same defect, so the two are told apart here as well
-// (joshuafolkken/kit#959).
+// — but silence is the same defect, so the two are told apart here as well.
 //
 // The two ways of failing are folded into one answer deliberately. Which one occurred does not
 // change what the auto-close may do — in neither case does it know what the open epics are — and
@@ -82,7 +80,7 @@ async function fetch_open_epics(): Promise<Array<EpicIssue> | undefined> {
 function parse_child(raw_json: string | undefined): EpicChildData | undefined {
 	if (raw_json === undefined) return undefined
 
-	return parse_json_object_safe(raw_json, epic_child_schema)
+	return parse_json_object_or_undefined(raw_json, epic_child_schema)
 }
 
 function has_blocked_by(child: EpicChildData | undefined): boolean {
@@ -106,8 +104,7 @@ async function inspect_sibling(sibling: number, repo?: string): Promise<SiblingS
 
 // A cross-repository child, read by naming its repository in the read's REST path. `is_readable`
 // is what decides whether the epic may close at all: closing while a child's state is unknown is
-// exactly what the old refusal prevented, and reading them is the only thing that changed
-// (joshuafolkken/kit#864).
+// exactly what the old refusal prevented, and reading them is the only thing that changed.
 async function inspect_external(
 	child: ExternalChild,
 ): Promise<SiblingState & { is_readable: boolean }> {
@@ -128,13 +125,12 @@ async function inspect_siblings(
 }
 
 // `pnpm josh epic --ordered` and `--add` record the declared chain themselves, through the REST
-// dependencies endpoint (`epic-relations.ts`, joshuafolkken/kit#1026), so the default route
+// dependencies endpoint (`epic-relations.ts`), so the default route
 // arrives here with the relations already in place. Three routes still reach a declared order with
 // none recorded: an epic body written by hand, the manual fallback in `issue-template.md`, and
 // `apply_relations` failing — it counts the refusals, reports that the body is intact and lets the
 // batch finish. Each is otherwise symptomless, which is what this warning is for. The epic body's
-// declared chain is the trigger: since #713 every split gets an epic, so its existence no longer
-// implies an order, and warning on that alone would fire on every unordered batch. Only a total
+// declared chain is the trigger: every split gets an epic, so its existence does not imply an order, and warning on that alone would fire on every unordered batch. Only a total
 // absence of relations is reported — checking each dependent pair would mean inferring the chain
 // from task-list order, which need not match.
 function warn_when_order_unrecorded(epic: EpicIssue, states: ReadonlyArray<SiblingState>): void {
@@ -147,18 +143,18 @@ function warn_when_order_unrecorded(epic: EpicIssue, states: ReadonlyArray<Sibli
 	}
 
 	console.info(
-		`ℹ️  Epic #${String(epic.number)} has no blocked-by relation on any child; ` +
+		`ℹ️  Epic ${session_cite.issue(epic.number)} has no blocked-by relation on any child; ` +
 			'the batch order was never recorded natively (see the epic creation procedure).',
 	)
 }
 
 // The one thing the two refusals below ask for, written once — a child state that could not be read,
-// and a close the API refused (joshuafolkken/kit#1039).
+// and a close the API refused.
 const CLOSE_MANUALLY = 'close it manually.'
 
 // The nesting cascade's safety valve. A closed child epic is itself a completed child, so the same
-// completion check is re-run for the epics that list *it*, closing a nested parent in the same pass
-// (joshuafolkken/kit#2008). `evaluated` already terminates a cycle or a shared child; this is the
+// completion check is re-run for the epics that list *it*, closing a nested parent in the same pass.
+// `evaluated` already terminates a cycle or a shared child; this is the
 // backstop for a nesting so deep it is likelier a mistake than a plan. On reaching it the cascade
 // stops and asks for a manual close, exactly as an unreadable or refused child close does.
 const MAX_CASCADE_DEPTH = 10
@@ -174,27 +170,26 @@ const CASCADE_DEPTH_NOTE = `⚠️  Epic auto-close cascade reached its ${String
 // would leave a finished epic open until somebody noticed.
 //
 // The direction is chosen on what each mistake costs, and they are not symmetric. Announcing twice
-// costs one redundant comment and nothing else, because the epic *closes* — which is what ends the
-// loop joshuafolkken/kit#1039 is about, where the comment repeated once per attempt for as long as
-// the close kept failing. Refusing costs a manual close on every transient failure.
+// costs one redundant comment and nothing else, because the epic *closes* — which is what ends a loop
+// where the comment would repeat once per attempt for as long as the close kept failing. Refusing costs a manual close on every transient failure.
 const UNREADABLE_COMMENTS_NOTE =
 	"'s comments could not be read; announcing again rather than leaving it open."
 
 // The write, once the announcement has been decided. `comment` is `undefined` when the epic already
 // carries one — which is what stops a run whose comment landed and whose close was refused from
 // posting the same comment again on the next attempt, and again for as long as the close keeps
-// failing (joshuafolkken/kit#1039).
+// failing.
 //
 // The comment-first ordering inside `issue_close` is what produces that half-succeeded state, and it
 // is left exactly as it is: it is what keeps a `false` meaning "the epic is still open" in every
-// branch, which is the answer the second message here is written against (joshuafolkken/kit#1026).
+// branch, which is the answer the second message here is written against.
 async function close_epic_with(epic_number: string, comment: string | undefined): Promise<boolean> {
 	const is_closed = await git_gh_command.issue_close(epic_number, comment)
 
 	console.info(
 		is_closed
-			? `🏁 Closed epic #${epic_number} — every child issue is complete.`
-			: `⚠️  Could not close epic #${epic_number}; ${CLOSE_MANUALLY}`,
+			? `🏁 Closed epic ${session_cite.issue(epic_number)} — every child issue is complete.`
+			: `⚠️  Could not close epic ${session_cite.issue(epic_number)}; ${CLOSE_MANUALLY}`,
 	)
 
 	return is_closed
@@ -205,8 +200,9 @@ async function close_epic_with(epic_number: string, comment: string | undefined)
 async function close_epic(epic: EpicIssue): Promise<boolean> {
 	const epic_number = String(epic.number)
 	const state = await epic_close_comment.read_close_comment_state(epic_number, epic)
+	const note = `ℹ️  Epic ${session_cite.issue(epic_number)}${UNREADABLE_COMMENTS_NOTE}`
 
-	if (state === 'unreadable') console.info(`ℹ️  Epic #${epic_number}${UNREADABLE_COMMENTS_NOTE}`)
+	if (state === 'unreadable') console.info(note)
 
 	const comment = state === 'present' ? undefined : epic_close_comment.build_close_comment(epic)
 
@@ -237,7 +233,7 @@ async function close_epic_when_complete(epic: EpicIssue, merged_number: number):
 
 	if (!external.is_complete) {
 		console.info(
-			`ℹ️  Epic #${String(epic.number)} has a child in another repository whose state could not be read; ${CLOSE_MANUALLY}`,
+			`ℹ️  Epic ${session_cite.issue(epic.number)} has a child in another repository whose state could not be read; ${CLOSE_MANUALLY}`,
 		)
 
 		return false
@@ -255,14 +251,14 @@ async function close_epic_when_complete(epic: EpicIssue, merged_number: number):
 // Each epic is isolated: one that cannot be read or closed must not stop the others from being
 // evaluated, since they are independent batches that merely share this child. `false` — the epic did
 // not close, whether because a sibling is still open, a read failed or the close was refused — is
-// what stops the cascade from walking past it to a parent (joshuafolkken/kit#2008).
+// what stops the cascade from walking past it to a parent.
 async function close_epic_isolated(epic: EpicIssue, merged_number: number): Promise<boolean> {
 	try {
 		return await close_epic_when_complete(epic, merged_number)
 	} catch (error) {
 		const message = error_text.message_of(error)
 
-		console.info(`⚠️  Skipped epic #${String(epic.number)}: ${message}`)
+		console.info(`⚠️  Skipped epic ${session_cite.issue(epic.number)}: ${message}`)
 
 		return false
 	}

package/scripts/epic/epic-cross-repo.ts

@@ -15,9 +15,9 @@ import type { EpicChild } from './epic-graph'
 // too early. Merging kit's issue does not publish kit — the merge, the auto-tag and the publish run
 // one after another — so a consumer child told it may start at that moment either fails to install
 // the version it needs or, worse, installs the previous one and implements against it. That failure
-// shows up as "it breaks sometimes", which is the hardest kind to diagnose (joshuafolkken/kit#864).
+// shows up as "it breaks sometimes", which is the hardest kind to diagnose.
 //
-// The publish check itself is joshuafolkken/kit#863's, imported rather than restated: two
+// The publish check itself is imported rather than restated: two
 // implementations of "has this version appeared" would drift, and the looser one would decide.
 
 // The package a repository distributes, by convention: the npm scope is the GitHub owner and the
@@ -78,7 +78,7 @@ const NOT_FOUND_STATUS = 404
 
 // What the blocker repository's default branch says about what it ships.
 //
-// **`absent` is not `unreadable`, and joshuafolkken/kit#1129 is the difference.** A repository with no
+// **`absent` is not `unreadable`.** A repository with no
 // manifest, or one whose manifest says `private`, publishes nothing — so a closed blocker there has
 // no release anyone could wait for, and waiting means waiting until the run's own eight-hour timeout
 // with nothing an operator can edit to clear it. A read that merely failed says none of that.
@@ -89,7 +89,7 @@ const NOT_FOUND_STATUS = 404
 // registry 404 would start a consumer child before its blocker's release existed. The manifest is a
 // fact about the repository we already have access to, and `private: true` is a positive statement
 // rather than an inference from an absence.
-// **`private` alone does not settle it** (joshuafolkken/kit#1134). A workspace root is private by
+// **`private` alone does not settle it**. A workspace root is private by
 // convention while the packages under it publish, so reading one as "ships nothing" would resolve a
 // dependency before its blocker's release existed — the direction this module may not fail in.
 // `is_workspace` is what keeps that case waiting.
@@ -103,7 +103,7 @@ type ManifestAnswer =
 // Read from GitHub rather than from a local checkout: a consumer's state is a GitHub fact, and the
 // wait must work before anyone has cloned the repository.
 //
-// **It moves when `josh release` runs, not when a child merges** (joshuafolkken/kit#1486). A child's
+// **It moves when `josh release` runs, not when a child merges**. A child's
 // pull request carries no version change at all, so the number here right after one merges is still
 // the previous release. The target of a wait is therefore the version that follows the release the
 // change lands in, never the one the merge itself leaves behind.
@@ -122,10 +122,9 @@ type WorkspaceCheck = 'workspace' | 'single' | 'unreadable'
 // Whether `pnpm-workspace.yaml` actually declares members.
 //
 // **The file's existence proves nothing.** `josh sync` distributes it to every consumer regardless of
-// layout — it carries `allowBuilds`, `overrides` and the like — so probing for its presence read every
-// private first-party repository as a workspace and restored joshuafolkken/kit#1129's eight-hour wait
-// for all of them. Measured: 20 of 20 private first-party checkouts have the file and none declares
-// `packages:` (joshuafolkken/kit#1134). What makes a repository a workspace is a non-empty `packages`
+// layout — it carries `allowBuilds`, `overrides` and the like — so probing for its presence would read
+// every private first-party repository as a workspace and wait the eight-hour timeout on each. What
+// makes a repository a workspace is a non-empty `packages`
 // key, so that is what is read.
 function declares_packages(yaml: string): boolean {
 	try {
@@ -225,7 +224,7 @@ function to_manifest(repo: string, stdout: string): ManifestAnswer {
 //
 // The probe is `exec_gh_api_status_sync`, the synchronous twin of `exec_gh_api_status`: every caller
 // down to `resolve_cross_repo` is synchronous, and turning the classifier, the resolver and
-// `epic_classify` async for one probe would cost more than the twin (joshuafolkken/kit#2901). A 404
+// `epic_classify` async for one probe would cost more than the twin. A 404
 // here is trustworthy in a way a registry 404 is not: the repository's issues are already being read,
 // so access is established and what is missing is the file.
 function classify_manifest_failure(repo: string): ManifestAnswer {
@@ -245,8 +244,8 @@ function fetch_manifest(repo: string): ManifestAnswer {
 }
 
 // Read once per pass, for the reason `published_cache` holds the other half: every edge to one
-// repository asks the same question, and joshuafolkken/kit#1121 made a pass run once per withheld
-// candidate rather than once — so an uncached read is a blocking `gh` call multiplied by both.
+// repository asks the same question, and a pass runs once per withheld candidate rather than
+// once — so an uncached read is a blocking `gh` call multiplied by both.
 function read_manifest(repo: string): ManifestAnswer {
 	const cached = version_cache.get(repo)
 	if (cached !== undefined) return cached
@@ -267,7 +266,7 @@ function read_default_branch_version(repo: string): string | undefined {
 // Whether the repository ships no package at all: no manifest on its default branch, or one that
 // declares itself private. Either way there is no release for a dependency to wait on.
 //
-// **A workspace root is excluded, and the exclusion is deliberately coarse** (joshuafolkken/kit#1134).
+// **A workspace root is excluded, and the exclusion is deliberately coarse**.
 // Such a root is private by convention while its packages publish, so reading one as shipping nothing
 // would start a dependent before its blocker's release existed. What is asked is only whether the
 // repository *is* a workspace — the members are not enumerated and nothing looks for which of them
@@ -284,11 +283,10 @@ function publishes_nothing(repo: string): boolean {
 // A version that could not be read leaves the dependency waiting rather than resolved: not knowing
 // what to wait for is not the same as having nothing to wait for.
 //
-// **"Ships nothing" is asked first, and it is a different question** (joshuafolkken/kit#1129, the
-// state joshuafolkken/kit#1126 made reachable). Waiting is right only where something could still
-// arrive; a closed blocker in a repository that publishes no package has no release for
-// `is_published` to ever find, so it waited until the run's own eight-hour timeout with nothing an
-// operator could edit to clear it. It is answered from that repository's own manifest and never from
+// **"Ships nothing" is asked first, and it is a different question.** Waiting is right only where
+// something could still arrive; a closed blocker in a repository that publishes no package has no
+// release for `is_published` to ever find, so it would wait until the run's own eight-hour timeout
+// with nothing an operator could edit to clear it. It is answered from that repository's own manifest and never from
 // the registry, for the reason `ManifestAnswer` records: a registry 404 also means "this token may
 // not see it", and resolving on one would start a consumer child before its blocker's release
 // existed.
@@ -323,9 +321,8 @@ function owner_of(repo: string): string {
 	return repo.split('/', 1)[0] ?? ''
 }
 
-// Whether a repository may be depended on at all. Inherited from joshuafolkken/kit#869's
-// restriction rather than restated: a child in a repository this owner does not own is not something
-// to wait for, dispatch to, or write into — nor, since joshuafolkken/kit#1014, an issue reference to
+// Whether a repository may be depended on at all: a child in a repository this owner does not own is
+// not something to wait for, dispatch to, or write into — nor an issue reference to
 // resolve: a body that mentions a third party's issue must not send this command to their tracker.
 function is_same_owner_repo(repo: string, current_owner: string): boolean {
 	const identity = repo_origin.parse_origin_url(`https://${repo_origin.GITHUB_HOST}/${repo}`)

package/scripts/epic/epic-decision.ts

@@ -5,11 +5,9 @@ import { epic_sections, type BodyLines, type SectionRange } from './epic-section
 // Placing a decision record inside an epic body's `## Decisions` section.
 //
 // `epic-commands` requires an auto-decision to be written in **both** the epic's `## Decisions` and a
-// comment on each child it applies to, and until now no command wrote the epic half — so a run had to
-// read the body, edit it and `PATCH` it back by hand, which is the one operation `CLAUDE.md` forbids.
-// Measured on runs #1333 and #1349, that repair-shaped detour is where the post-merge bookkeeping
-// spends its round trips, and the two most recent filings skipped the epic half entirely rather than
-// pay for it (joshuafolkken/kit#1350).
+// comment on each child it applies to. Without a command for the epic half, a run would have to read
+// the body, edit it and `PATCH` it back by hand, which is the one operation `CLAUDE.md` forbids — or
+// skip the epic half entirely.
 //
 // So the record rides on the body edit `--add` already makes: no extra round trip, and the half that
 // was being dropped is written by the command instead of by hand.
@@ -27,7 +25,7 @@ const EMPTY_RECORD =
 
 // **The offending line is named, never quoted.** The record is a file the caller handed over, and
 // echoing a line of it into stderr puts arbitrary file content in the console — the leak SonarCloud's
-// `tssecurity:S8689` reports for exactly this path on joshuafolkken/kit#1350. A line number is as
+// `tssecurity:S8689` reports for exactly this path. A line number is as
 // actionable, since the author has the file open, and it carries nothing out of it.
 function to_declaration_error(line_number: number): string {
 	return `Line ${String(line_number)} of the decision record is nothing but a dependency chain, which \`epic:next\` would read as part of the epic's dependency order; wrap it in backticks, fence it, or reword it.`
@@ -35,8 +33,7 @@ function to_declaration_error(line_number: number): string {
 
 // Whether the record can be written at all. The declaration check is the load-bearing one: a bare
 // `#A -> #B` line anywhere in the body is parsed as a declaration, so a record quoting an order as a
-// standalone line would silently add a dependency nobody declared — the failure mode
-// joshuafolkken/kit#1253 documents, arriving by a second route.
+// standalone line would silently add a dependency nobody declared.
 //
 // **It is judged exactly the way the merged body will be judged**: the predicate is the parser's own,
 // and the lines are read through the same fence mask, so a record whose chain sits inside a fenced
@@ -91,16 +88,15 @@ function append_decision(body: string, record: string): string {
 }
 
 // The record as it will actually be written, with the relations this insertion replaced appended to
-// it (joshuafolkken/kit#1711).
+// it.
 //
-// **A positioned `--add` discards the `blocked-by` relation the child already had, and until now the
-// record said nothing about it.** On joshuafolkken/kit#1703 that overwrote a decision whose reasoning
-// was written down, twice in four minutes, leaving the body's declaration, the native relations and
-// the recorded decision disagreeing with one another. The record is the artifact read months later, so
-// it is where what was replaced has to survive — the console line scrolls away.
+// **A positioned `--add` discards the `blocked-by` relation the child already had, so the record says
+// so.** Unsaid, it can overwrite a decision whose reasoning was written down, leaving the body's
+// declaration, the native relations and the recorded decision disagreeing with one another. The
+// record is the artifact read months later, so it is where what was replaced has to survive — the
+// console line scrolls away.
 //
-// **The policy is to report, not to refuse.** Re-pointing a position is what joshuafolkken/kit#1701
-// deliberately added, so refusing an invocation that carries no `--decision-file` would close a
+// **The policy is to report, not to refuse.** Re-pointing a position is deliberate, so refusing an invocation that carries no `--decision-file` would close a
 // working route to force a record; naming what was dropped costs the caller nothing and loses nothing.
 //
 // `undefined` stays `undefined`: an insertion that records no decision gains none here, and an
@@ -128,7 +124,7 @@ function format_decision_report(input: { total: number; failures: number }): str
 
 // The heading a creation writes its reasoning under. Beside a pattern exactly as `DECISIONS_HEADING`
 // is, and tied to `epic_body`'s own literal by a test that reads a body the builder produced
-// rather than by a string comparison (joshuafolkken/kit#1712).
+// rather than by a string comparison.
 const RATIONALE_HEADING_PATTERN = /^#{1,6}[ \t]+Split rationale\b/u
 
 function read_section(body: string, heading: RegExp): string {
@@ -145,7 +141,7 @@ function read_section(body: string, heading: RegExp): string {
 // Both, not just the first. `josh epic … --ordered` declares a whole chain and records its reasoning
 // under `## Split rationale`, writing no `## Decisions` at all — so a reader that looked only at
 // `## Decisions` would report every correctly-documented ordered epic as unjustified the moment it
-// was created (joshuafolkken/kit#1712). It is this module's because the heading patterns are: a
+// was created. It is this module's because the heading patterns are: a
 // second reader with its own copies is one that comes to disagree with the writers about where a
 // record goes.
 function read_recorded_reasons(body: string | undefined): string {

package/scripts/epic/epic-fetch.ts

@@ -10,7 +10,7 @@ import { epic_relation_recheck } from './epic-relation-recheck'
 //
 // All execution state lives on GitHub and nowhere else — no local state file. A run interrupted
 // halfway is resumed by asking again, which is the whole reason `epic:next` can be the base of an
-// unattended run (joshuafolkken/kit#860).
+// unattended run.
 
 const CHILD_LIMIT = 200
 
@@ -30,17 +30,17 @@ function to_child(parsed: EpicIssue, repo: string): EpicChild {
 // reads it — and a child elsewhere is read through its own repository, exactly as
 // `fetch_external_children` does. Every read of a child's fields goes through this, bodies included:
 // an unqualified read of a cross-repository child returns *this* repository's issue of that number,
-// a different issue entirely (joshuafolkken/kit#1012).
+// a different issue entirely.
 function scope_for(child_repo: string, current_repo: string): string | undefined {
 	return child_repo === current_repo ? undefined : child_repo
 }
 
 // One child's blockers, read from the relations listing rather than from the issue's own summary
-// count (joshuafolkken/kit#1113). Addressed through the same `scope_for` every other read of a child
+// count. Addressed through the same `scope_for` every other read of a child
 // goes through. The recheck only ever reaches children of the epic's own repository, so what the
 // scope varies with is where the *epic* is: `epic:next owner/other#858` run from here reads them
 // through `owner/other`, and reading them unqualified would answer from this repository's issues of
-// those numbers instead (joshuafolkken/kit#1012).
+// those numbers instead.
 async function read_child_blockers(
 	child: EpicChild,
 	current_repo: string,
@@ -60,7 +60,7 @@ interface EpicBody {
 	// failure is invisible downstream**: `parse_task_list_issue_numbers(undefined)` answers `[]`, so a
 	// body nobody could read is indistinguishable from an epic that tracks no children — and that one
 	// is dropped from the views as an ordinary, unpopulated epic. A run whose DNS hiccuped on this one
-	// request therefore reported the backlog empty and ended (joshuafolkken/kit#1690).
+	// request therefore reported the backlog empty and ended.
 	body_failure: IssueReadFailure | undefined
 	child_numbers: ReadonlyArray<number>
 	external: ReadonlyArray<ExternalChild>
@@ -86,7 +86,7 @@ interface RecheckScope {
 	current_repo: string
 }
 
-// joshuafolkken/kit#1113: the second look at the relations, taken here rather than in `epic:next`
+// The second look at the relations, taken here rather than in `epic:next`
 // and `epic:audit` separately — both read their children through this one snapshot, so correcting it
 // once corrects both, and neither command needs to know the check exists.
 // `repo` is the epic's own repository, which is what a bare declared number names — not
@@ -109,7 +109,7 @@ function to_references(issue_numbers: ReadonlyArray<number>, repo: string): Arra
 }
 
 // One child's read: the child when it came back, and whether the failure was one the same request
-// could succeed at a moment later (joshuafolkken/kit#1690). A response that arrived and would not
+// could succeed at a moment later. A response that arrived and would not
 // parse is **not** unreachable — asking again answers the same thing.
 interface ChildRead {
 	child: EpicChild | undefined
@@ -152,20 +152,18 @@ async function fetch_child(
 //
 // Dropping them is not an option in either direction. An epic whose children all failed to read
 // would otherwise look like an epic with no open children — "complete" — and a single unreadable
-// child would vanish from the graph, so whatever it blocks would look unblocked and be run
-// (joshuafolkken/kit#860).
+// child would vanish from the graph, so whatever it blocks would look unblocked and be run.
 //
 // The unread ones carry their repository, not just their number. An epic tracking
-// `- [ ] sveltejs/kit#7` had it refused by the owner restriction and reported as `Could not read #7`,
-// which a reader resolves against the repository they are standing in — a different issue
-// (joshuafolkken/kit#1016).
+// `- [ ] sveltejs/kit#7` refused by the owner restriction and reported as `Could not read #7` would be
+// resolved by a reader against the repository they are standing in — a different issue.
 interface FetchedChildren {
 	children: ReadonlyArray<EpicChild>
 	unreadable: ReadonlyArray<IssueReference>
 	skipped: ReadonlyArray<IssueReference>
 	// How many of the unreadable ones failed on the transport. Carried from the reads themselves
 	// rather than probed afterwards: a connection that dropped for a moment fails a read at t=0 and
-	// answers a probe fired at t=1 that everything is fine (joshuafolkken/kit#1690).
+	// answers a probe fired at t=1 that everything is fine.
 	//
 	// **A count rather than a flag, because the question the caller asks is about _every_ failure.**
 	// One child unreachable beside another permanently refused is not a run worth repeating — the
@@ -211,10 +209,9 @@ async function fetch_children(
 // The children that live in other repositories, read by naming that repository in the read's REST
 // path (`repos/<owner>/<repo>/issues/<n>`). No local checkout is needed: their state is a GitHub
 // fact, and requiring a clone to learn it is what kept the auto-close from ever running on such an
-// epic (joshuafolkken/kit#864).
+// epic.
 //
-// A repository with a different owner is dropped before it is read, inheriting
-// joshuafolkken/kit#869's restriction rather than restating it.
+// A repository with a different owner is dropped before it is read.
 async function fetch_external_children(
 	external: ReadonlyArray<ExternalChild>,
 	current_owner: string,
@@ -244,21 +241,19 @@ async function fetch_external_children(
 interface EpicSnapshot {
 	body: string | undefined
 	// The repository the *epic* lives in — what a bare number in its body and in a declared dependency
-	// names. Distinct from `current_repo` below, which is where the command is running
-	// (joshuafolkken/kit#1126).
+	// names. Distinct from `current_repo` below, which is where the command is running.
 	repo: string
 	// The `owner/repo` the command is running in — the repository against which a reference is written
 	// bare, and every other one written `owner/repo#N`. Deliberately *not* where the epic lives:
 	// `epic:next owner/other#858` reads an epic elsewhere while the person reading the answer is
-	// standing here, so writing an unread child bare would send them to their own issue of that number
-	// (joshuafolkken/kit#1016).
+	// standing here, so writing an unread child bare would send them to their own issue of that number.
 	current_repo: string
 	children: ReadonlyArray<EpicChild>
 	child_numbers: ReadonlyArray<number>
 	unreadable: ReadonlyArray<IssueReference>
 	skipped: ReadonlyArray<IssueReference>
 	has_external_children: boolean
-	// Why the epic's own body produced nothing, when it produced nothing (joshuafolkken/kit#1690).
+	// Why the epic's own body produced nothing, when it produced nothing.
 	body_failure: IssueReadFailure | undefined
 	// Whether **every** read behind this snapshot that failed — the body and each child — failed on
 	// the transport, and at least one did. What a caller does with it is its own: `epic:next` marks
@@ -266,7 +261,7 @@ interface EpicSnapshot {
 	//
 	// It is `every` rather than `any` so the answer terminates: one child refused for good beside one
 	// unreachable would otherwise be retried for ever, and the run would never reach the verdict that
-	// says a person is needed (joshuafolkken/kit#1690).
+	// says a person is needed.
 	is_unreachable: boolean
 }
 
@@ -323,15 +318,14 @@ async function to_snapshot(
 }
 
 // The epic and its children, as one read. `has_external_children` is surfaced rather than silently
-// ignored: a cross-repository child needs joshuafolkken/kit#864, and an epic that holds one is not
-// fully answered by this command yet.
+// ignored: an epic that holds a cross-repository child is not fully answered by this command alone.
 //
 // `repo` is where the *epic* lives and `current_repo` is where the command is running, so the body
 // and its local rows are read through the same `scope_for` every other read goes through. Read
-// unqualified, `epic:next joshuafolkken/app-kit#858` answered from *this* repository's issue 858 and
-// then stamped the children it found there as app-kit's — and since joshuafolkken/kit#1016 makes
-// `repo` decide how an unread child is written, that mislabelling reached the message too. The
-// default keeps a command whose epic is always local reading exactly as before.
+// unqualified, `epic:next joshuafolkken/app-kit#858` would answer from *this* repository's issue 858
+// and stamp the children it found there as app-kit's — and since `repo` decides how an unread child
+// is written, that mislabelling would reach the message too. The default keeps a command whose epic
+// is always local reading its own repository.
 async function fetch_epic(
 	epic_number: number,
 	repo: string,
@@ -339,9 +333,9 @@ async function fetch_epic(
 ): Promise<EpicSnapshot> {
 	const scope = scope_for(repo, current_repo)
 	const epic_body = await fetch_epic_body(epic_number, scope)
-	// joshuafolkken/kit#869's restriction is about who *we* are, so the owner comes from the repository
-	// the command runs in. Derived from the epic's own repository instead, a qualified reference to
-	// somebody else's epic would have made their whole organization readable.
+	// The owner restriction is about who *we* are, so the owner comes from the repository the command
+	// runs in. Derived from the epic's own repository instead, a qualified reference to somebody else's
+	// epic would make their whole organization readable.
 	const owner = epic_cross_repo.owner_of(current_repo)
 	const local = await fetch_children(epic_body.child_numbers, repo, scope)
 	const remote = await fetch_external_children(epic_body.external, owner)