@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/scripts/hooks/stop-guard.ts

@@ -5,6 +5,7 @@ import { agent_headless } from '#scripts/agent/agent-headless'
 import { backlog_ready } from '#scripts/backlog/backlog-ready'
 import { backlog_stalled_detect } from '#scripts/backlog/backlog-stalled-detect'
 import { repo_party } from '#scripts/discovery/repo-party'
+import { stop_actions } from '#scripts/hooks/stop-actions'
 import { hook_decision } from '#scripts/josh/hook-decision'
 import { session_language } from '#scripts/josh/session-language'
 import { lane_child_marker } from '#scripts/lane/lane-child-marker'
@@ -13,37 +14,64 @@ import { filing_cap } from '#scripts/rules/filing-cap'
 import { lane_background } from '#scripts/rules/lane-background'
 import { lane_park } from '#scripts/rules/lane-park'
 import { last_prompt } from '#scripts/rules/last-prompt'
+import { pre_gate_cut } from '#scripts/rules/pre-gate-cut'
+import { stop_decision } from '#scripts/rules/stop-decision'
 import { stop_rules, type StopContext, type StopOutcome } from '#scripts/rules/stop-rules'
+import { tail_commands } from '#scripts/rules/tail-commands'
 import { run_carry } from '#scripts/run/carry/run-carry'
 import { run_cut } from '#scripts/run/cut/run-cut'
-import { run_hold } from '#scripts/run/hold/run-hold'
+import { run_cut_report } from '#scripts/run/cut/run-cut-report'
+import { run_hold, type RunHold } from '#scripts/run/hold/run-hold'
+import { run_hold_session } from '#scripts/run/hold/run-hold-session'
 import { run_halfrun_resume } from '#scripts/run/run-halfrun-resume'
 import { run_headless } from '#scripts/run/run-headless'
 import { run_stranded_detect } from '#scripts/run/run-stranded-detect'
 import { time_density_hook } from '#scripts/time-runtime/time-density-hook'
 import { time_hook_transcript } from '#scripts/time-runtime/time-hook-transcript'
 
-// The `Stop` hook entry: one process that delivers the three stop-time rules.
+// The `Stop` hook entry: one process that delivers the stop-time rules, running the fixed ones itself
+// (`stop-actions.ts`).
 // It is the stop-time counterpart of `pretool-guard.ts` — a second entry on the same `hook_decision`
 // foundation, not a second copy of it.
 //
 // **Every failure allows the stop.** A missing transcript, an unreadable hold record, a git status
 // that will not read — each ends as "no block", for the same reason the PreToolUse guard fails open:
-// a hook that failed closed would wedge a run over its own plumbing. The block rules are self-
-// resolving (send the notify, release the hold) and `stop_hook_active` is the backstop, so failing
+// a hook that failed closed would wedge a run over its own plumbing. The hook runs the fixed
+// operations itself (send the notify, release the hold) and `stop_hook_active` is the backstop, so failing
 // open here costs at most a missed nudge, never a stuck run.
 
-// The hold record for this working tree is still in place, and whether it is a `prrun` stop's.
-// `unreadable` reads as absent: the safe direction for a stop guard is not to
-// block, and an unreadable record is not proof a run is holding.
-async function hold_facts(): Promise<Pick<StopContext, 'hold_present' | 'prrun_stopped'>> {
+// The hold record for this working tree. `unreadable` reads as absent: the safe direction for a stop
+// guard is not to act, and an unreadable record is not proof a run is holding.
+async function held_record(): Promise<RunHold | undefined> {
 	const directory = await run_hold.worktree_directory()
-	const hold =
-		directory === undefined
-			? undefined
-			: run_halfrun_resume.hold_of(run_hold.read_hold(run_hold.hold_path(directory)))
+	if (directory === undefined) return undefined
 
-	return { hold_present: hold !== undefined, prrun_stopped: hold?.prrun_stop_head !== undefined }
+	return run_halfrun_resume.hold_of(run_hold.read_hold(run_hold.hold_path(directory)))
+}
+
+// The pause was announced: by a `josh notify` on the tail, or by this hook's own send, recorded on the
+// hold since the pause began (joshuafolkken/kit#3961).
+function was_notified(hold: RunHold | undefined, tail: string): boolean {
+	if (lane_park.mentions_confirmation_notify(tail)) return true
+
+	return (
+		hold !== undefined && run_hold_session.is_notified_since(hold, last_prompt.pause_start(tail))
+	)
+}
+
+// The Issue the hold names, whether it is a `prrun` stop's and this session's own, and whether its
+// pause was already announced.
+async function hold_facts(
+	tail: string,
+): Promise<Pick<StopContext, 'hold_issue' | 'hold_owned' | 'notified' | 'prrun_stopped'>> {
+	const hold = await held_record()
+
+	return {
+		hold_issue: hold?.issue,
+		hold_owned: hold === undefined || run_hold_session.is_session_hold(hold),
+		notified: was_notified(hold, tail),
+		prrun_stopped: hold?.prrun_stop_head !== undefined,
+	}
 }
 
 // A `confirmation` notify sits on this run's transcript tail. The tail is derived exactly as the
@@ -60,6 +88,19 @@ function was_filed(tail: string): boolean {
 	return filing_cap.turn_filing_count(tail) > 0
 }
 
+// This turn ended at a cut — a record still `carried`, or this turn's `run:cut` relaunching a successor.
+// The second covers the successor's resume clearing the record before this stop (joshuafolkken/kit#3936);
+// the held cut outside a lane prints no marker, so its person is still notified.
+function is_cut_stop(tail: string): boolean {
+	if (run_cut.carried_cut_sync() !== undefined) return true
+
+	return tail_commands.answered(
+		filing_cap.current_turn(tail),
+		pre_gate_cut.takes_the_cut,
+		run_cut_report.RELAUNCHED_CUT_MARKER,
+	)
+}
+
 // The session language the refusal is written for — `write_stop_decision` has already loaded the `.env`.
 function session_lang(): string {
 	return session_language.resolve_session_lang().lang
@@ -85,13 +126,13 @@ async function build_context(
 	const tail = transcript_tail(transcript_path)
 
 	return {
-		...(await hold_facts()),
+		...(await hold_facts(tail)),
 		tree_clean: !(await run_hold.is_tree_dirty()),
-		notified: lane_park.mentions_confirmation_notify(tail),
 		message: payload_tail.message,
 		prompt: last_prompt.prompt_text(tail),
+		answers_question: stop_decision.is_question(last_prompt.turn_prompt(tail)),
 		stop_hook_active: payload_tail.stop_hook_active,
-		cut_pending: run_cut.carried_cut_sync() !== undefined,
+		cut_pending: is_cut_stop(tail),
 		filed: was_filed(tail),
 		session_owner: repo_party.current_owner(),
 		...(await session_role_facts()),
@@ -167,17 +208,17 @@ async function run_report_checks(): Promise<void> {
 	await run_stranded_detect.run_stranded_check()
 }
 
-// Nothing reaches stdout on an ordinary stop, so what the harness parses stays empty unless the stop
-// is being held — all three rules block, so a bare `#N` is reported the same way.
+// Nothing reaches stdout on an ordinary stop, so what the harness parses stays empty unless the stop is
+// held or the hook acted on it (`stop-actions.ts`).
 async function write_stop_decision(raw_payload: string): Promise<void> {
 	hook_decision.load_environment_file()
 	await run_report_checks()
 
-	const { reason } = await outcome_of(raw_payload)
+	const envelope = await stop_actions.envelope_of(await outcome_of(raw_payload), session_lang())
 
-	if (reason === undefined) return
+	if (envelope === undefined) return
 
-	process.stdout.write(`${stop_rules.block_envelope(reason, session_lang())}\n`)
+	process.stdout.write(`${envelope}\n`)
 }
 
 const stop_guard = { outcome_of, stop_outcome_for_payload }

package/scripts/init/hook-command-rewrite.ts

@@ -65,8 +65,12 @@ function rewrite_command_value(value: string): string {
 		.split(PNPM_JOSH_PREFIX)
 		.join(BUNDLE_INVOCATION)
 
-	if (!rewritten.includes(claude_plugin_config.MARKETPLACE_PATH)) return rewritten
-	if (rewritten.includes(MISSING_INSTALL_GUARD)) return rewritten
+	if (
+		!rewritten.includes(claude_plugin_config.MARKETPLACE_PATH) ||
+		rewritten.includes(MISSING_INSTALL_GUARD)
+	) {
+		return rewritten
+	}
 
 	return `${MISSING_INSTALL_GUARD}${rewritten}`
 }

package/scripts/init/hook-launch.ts

@@ -9,18 +9,23 @@ import { GIT_LOCATION_VARIABLES } from '#scripts/git/git-location-environment'
 // Every path after the prefix is relative, so a hook fired from a
 // subdirectory would otherwise miss its script. The root is git's, resolved with the location
 // variables a git hook exports cleared first, and resolved with them only when that fails — git
-// metadata outside the work tree. The consumer rewrite (`hook-command-rewrite.ts`) keeps this prefix,
-// so both sides stay one mechanism for Claude Code and Codex alike.
+// metadata outside the work tree. When the cleared lookup succeeds the variables are cleared for the
+// hook too, so its own git calls act on the checkout it stands in. The consumer rewrite
+// (`hook-command-rewrite.ts`) keeps this prefix, so both sides stay one mechanism for Claude Code and
+// Codex alike.
 //
-// **Everything after the root is one script** (`scripts/hooks/run-hook.sh`):
-// clearing the location variables for the hook itself, the bundle-ready gate and the live-source
-// fallback live there once, so each hook command names only its hook.
+// **A hook runs on every tool call, so its launch spawns as little as it can** (joshuafolkken/kit#3946):
+// the shell's own `unset` clears the variables rather than an `env` process, and that one lookup
+// both finds the root and decides whether the variables stay — `git` starts once.
+//
+// **Everything after the root is one script** (`scripts/hooks/run-hook.sh`): the bundle-ready gate and
+// the live-source fallback live there once, so each hook command names only its hook.
 
 const HOOK_DIST_DIR = 'dist/hooks'
 const RUN_HOOK_SCRIPT = 'scripts/hooks/run-hook.sh'
-const UNSET_OPTIONS = GIT_LOCATION_VARIABLES.map((name) => `-u ${name}`).join(' ')
+const LOCATION_VARIABLES = GIT_LOCATION_VARIABLES.join(' ')
 const ROOT_LOOKUP = 'git rev-parse --show-toplevel'
-const PROJECT_ROOT_PREFIX = `project_root="$(env ${UNSET_OPTIONS} ${ROOT_LOOKUP} 2>/dev/null || ${ROOT_LOOKUP})" && cd "$project_root" && `
+const PROJECT_ROOT_PREFIX = `if project_root="$(unset ${LOCATION_VARIABLES}; ${ROOT_LOOKUP} 2>/dev/null)"; then unset ${LOCATION_VARIABLES}; else project_root="$(${ROOT_LOOKUP})"; fi && cd "$project_root" && `
 
 // `name` is the hook's bundle under `dist/hooks` without `.js` (e.g. `pretool-guard`), followed by any
 // arguments it takes (e.g. `codex-hook-adapter pretool`).

package/scripts/init/init-logic-deploy-vps.ts

@@ -30,8 +30,10 @@ function patch_deploy_vps_pnpm(content: string): string {
 	const with_pnpm12 = content.replaceAll(PNPM_INSTALL_PATTERN, (command) =>
 		replace_outdated_install(command),
 	)
-	if (with_pnpm12.includes(VERSION_CHECK_MARKER)) return with_pnpm12
-	if (!OLD_PNPM_CHECK_PATTERN.test(with_pnpm12)) return with_pnpm12
+
+	if (with_pnpm12.includes(VERSION_CHECK_MARKER) || !OLD_PNPM_CHECK_PATTERN.test(with_pnpm12)) {
+		return with_pnpm12
+	}
 
 	return with_pnpm12
 		.replace(OLD_MAJOR_LINE_PATTERN, '')

package/scripts/issue/behavior-change-lint.ts

@@ -76,9 +76,12 @@ function firing_point_problem(body: string): string | undefined {
 }
 
 function baseline_problem(body: string): string | undefined {
-	if (!markdown_section.has_line(body, BASELINE_HEADING)) return undefined
-
-	if (baseline_measure.has_command_value(body)) return undefined
+	if (
+		!markdown_section.has_line(body, BASELINE_HEADING) ||
+		baseline_measure.has_command_value(body)
+	) {
+		return undefined
+	}
 
 	return 'baseline must be written as `command → value`, not prose (it has to be re-runnable)'
 }
@@ -86,9 +89,12 @@ function baseline_problem(body: string): string | undefined {
 // The reproduction section is checked for format only where the heading is present — a missing heading
 // is already reported by `heading_problems`, so reporting it here too would double the message.
 function reproduction_problem(body: string): string | undefined {
-	if (!markdown_section.has_line(body, REPRODUCTION_HEADING)) return undefined
-
-	if (reproduction_measure.has_command_output(body)) return undefined
+	if (
+		!markdown_section.has_line(body, REPRODUCTION_HEADING) ||
+		reproduction_measure.has_command_output(body)
+	) {
+		return undefined
+	}
 
 	return 'reproduction must be a command and its actual output (a fenced block), not prose ("確認した" is not re-runnable)'
 }

package/scripts/issue/expected-effect-lint.ts

@@ -0,0 +1,59 @@
+import { markdown_section } from './markdown-section'
+
+// joshuafolkken/kit#3909: a run-time-shortening proposal was filed and implemented on a criterion that
+// never weighed how often the speed-up applies against what it costs when it does not. An Issue that
+// declares that aim must therefore state its expected effect — the hit rate, the gain per hit, the loss
+// per miss and where each number came from — before `issue:lint` and `issue:file` accept it. The
+// declaration, the heading and the item labels are the template's, pinned by the document test.
+
+const DECLARATION_LINE = '- 目的: 時間短縮'
+const BACKGROUND_HEADING = '## 背景'
+const HEADING = '## 期待効果'
+const ITEM_LABELS: ReadonlyArray<string> = ['効く率', '1 回あたりの得', '外れたときの損', '出典']
+// A template placeholder value — the `<...>` guidance a filed Issue replaces. It is not an estimate, but a
+// value that only opens with `<` (an upper bound such as `<1 min`) is one, so the placeholder must close with `>` too.
+const PLACEHOLDER = /^<.*>$/u
+
+// Whether the body declares a run-time-shortening aim under its background heading.
+function is_target(body: string): boolean {
+	const background = markdown_section.section_lines(body, BACKGROUND_HEADING).join('\n')
+
+	return markdown_section.has_unfenced_line(background, DECLARATION_LINE)
+}
+
+function item_value(line: string, label: string): string | undefined {
+	const prefix = `- ${label}:`
+
+	if (!line.startsWith(prefix)) return undefined
+
+	return line.slice(prefix.length).trim()
+}
+
+function has_item(lines: ReadonlyArray<string>, label: string): boolean {
+	return lines.some((line) => {
+		const value = item_value(line.trim(), label)
+
+		return value !== undefined && value.length > 0 && !PLACEHOLDER.test(value)
+	})
+}
+
+// Every expected-effect problem a body has, or an empty array. A body without the declaration has none.
+function problems(body: string): ReadonlyArray<string> {
+	if (!is_target(body)) return []
+	if (!markdown_section.has_line(body, HEADING)) return [`missing heading: ${HEADING}`]
+	const section = markdown_section.section_lines(body, HEADING).join('\n')
+	const lines = markdown_section.unfenced_lines(section)
+
+	return ITEM_LABELS.filter((label) => !has_item(lines, label)).map(
+		(label) => `missing expected-effect item: - ${label}: <value>`,
+	)
+}
+
+const expected_effect_lint = {
+	DECLARATION_LINE,
+	HEADING,
+	ITEM_LABELS,
+	problems,
+}
+
+export { expected_effect_lint }

package/scripts/issue/issue-cite-cli.ts

@@ -101,16 +101,26 @@ async function local_slug_for(targets: ReadonlyArray<CiteTarget>): Promise<strin
 	return has_bare_target ? await git_gh_command.repo_get_name_with_owner() : undefined
 }
 
+// The citation lines and the failure lines of one invocation, apart.
+interface CiteReport {
+	lines: ReadonlyArray<string>
+	failures: ReadonlyArray<string>
+}
+
+function split_results(results: ReadonlyArray<LineResult>): CiteReport {
+	return {
+		lines: results.filter((result) => result.kind === 'ok').map((result) => result.line),
+		failures: results.filter((result) => result.kind === 'fail').map((result) => result.line),
+	}
+}
+
 // Citations to stdout so the block stays paste-ready; failures to stderr so each unanswered number is
 // named without landing in what gets pasted. A failure sets a non-zero exit.
-function report(results: ReadonlyArray<LineResult>): number {
-	const lines = results.filter((result) => result.kind === 'ok').map((result) => result.line)
-	const failures = results.filter((result) => result.kind === 'fail').map((result) => result.line)
-
-	if (lines.length > 0) console.info(lines.join(LINE_SEPARATOR))
-	for (const failure of failures) console.error(failure)
+function report(cited: CiteReport): number {
+	if (cited.lines.length > 0) console.info(cited.lines.join(LINE_SEPARATOR))
+	for (const failure of cited.failures) console.error(failure)
 
-	return failures.length === 0 ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
+	return cited.failures.length === 0 ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE
 }
 
 // The targets the command line names, or `undefined` for a line nobody can read — an unknown flag and
@@ -122,14 +132,11 @@ function read_targets(args: ReadonlyArray<string>): ReadonlyArray<CiteTarget> |
 	return parse_targets(parsed.positionals, parsed.values.repo)
 }
 
-async function run(args: ReadonlyArray<string>): Promise<number> {
+// The lines `issue:cite` prints for `args`, without printing them — the `Stop` hook shows them itself
+// (`stop-actions.ts`). `undefined` for a line nobody can read.
+async function cite(args: ReadonlyArray<string>): Promise<CiteReport | undefined> {
 	const targets = read_targets(args)
-
-	if (targets === undefined) {
-		console.error(USAGE)
-
-		return FAILURE_EXIT_CODE
-	}
+	if (targets === undefined) return undefined
 
 	const local_slug = await local_slug_for(targets)
 	const results = await bounded_pool.bounded_map(
@@ -138,7 +145,19 @@ async function run(args: ReadonlyArray<string>): Promise<number> {
 		async (target) => await cite_target(target, local_slug),
 	)
 
-	return report(results)
+	return split_results(results)
+}
+
+async function run(args: ReadonlyArray<string>): Promise<number> {
+	const cited = await cite(args)
+
+	if (cited === undefined) {
+		console.error(USAGE)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	return report(cited)
 }
 
 async function main(args: ReadonlyArray<string>): Promise<void> {
@@ -147,6 +166,7 @@ async function main(args: ReadonlyArray<string>): Promise<void> {
 
 const issue_cite_cli = {
 	USAGE,
+	cite,
 	parse_targets,
 	run,
 }

package/scripts/issue/issue-classification.ts

@@ -2,7 +2,7 @@ import { issue_bug_label } from './issue-bug-label'
 import { BREAKING_CHANGE_LABEL, BUG_LABEL, ENHANCEMENT_LABEL, has_label_name } from './issue-labels'
 import { markdown_section } from './markdown-section'
 
-const FEATURE_DECLARATIONS = ['- 目的: 機能追加', '- 目的: 機能改善']
+const FEATURE_DECLARATIONS = ['- 目的: 機能追加', '- 目的: 機能改善', '- 目的: 時間短縮']
 const BREAKING_DECLARATION = '- 互換性: 破壊的変更'
 const NON_BUG_DECLARATION = '- 種別: 非不具合'
 const CLASSIFICATION_LABELS = [BUG_LABEL, ENHANCEMENT_LABEL, BREAKING_CHANGE_LABEL]

package/scripts/issue/issue-lint-cli.ts

@@ -2,6 +2,7 @@
 import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
 import { behavior_change_lint } from './behavior-change-lint'
+import { expected_effect_lint } from './expected-effect-lint'
 import { issue_classification } from './issue-classification'
 import { issue_lint } from './issue-lint'
 
@@ -9,7 +10,7 @@ import { issue_lint } from './issue-lint'
 // one per line, exiting non-zero. It reads a path rather than stdin so it can
 // lint a body written to a file before the `gh api … issues` call that files it. A body that declares
 // itself a behavior-change Issue is additionally held to the firing-point, baseline and reproduction
-// rules.
+// rules, and one that declares a run-time-shortening aim to the expected-effect estimate.
 
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
@@ -17,14 +18,15 @@ const OK_MESSAGE = 'ok'
 const NO_LABELS = 'none'
 const USAGE = 'Usage: josh issue:lint <path-to-issue-body>'
 
-// Every problem a body has: the four base template headings it lacks, then the behavior-change
-// problems (empty for an Issue that does not declare itself one).
+// Every problem a body has: the four base template headings it lacks, then the behavior-change and
+// expected-effect problems (each empty for an Issue that does not declare itself one).
 function problems(body: string): ReadonlyArray<string> {
 	const missing = issue_lint.missing_headings(body).map((heading) => `missing heading: ${heading}`)
 
 	return [
 		...missing,
 		...behavior_change_lint.problems(body),
+		...expected_effect_lint.problems(body),
 		...issue_classification.problems(body),
 	]
 }

package/scripts/issue/issue-scout-cli.ts

@@ -73,8 +73,9 @@ function read_arguments(argv: ReadonlyArray<string>): ScoutArguments | undefined
 	const { values, positionals } = parsed
 	const [title] = positionals
 
-	if (has_invalid_arguments(title, values.body, values['body-file'])) return undefined
-	if (title === undefined) return undefined
+	if (title === undefined || has_invalid_arguments(title, values.body, values['body-file'])) {
+		return undefined
+	}
 
 	return { title, body: values.body ?? '', body_file: values['body-file'] }
 }
@@ -102,7 +103,7 @@ function draft_of(args: ScoutArguments, repo: string): BacklogIssue {
 }
 
 // The epic beside a candidate is the placement answer for a draft that cites nothing: the epic half
-// below decides from prose references, and a title-only draft has none to give it.
+// below decides from signal references, and a title-only draft has none to give it.
 function format_duplicate(candidate: DuplicateCandidate): string {
 	const score = candidate.is_referenced === true ? 'ref' : candidate.score.toFixed(SCORE_DIGITS)
 	const epic = candidate.epic === undefined ? '' : ` (epic ${session_cite.issue(candidate.epic)})`
@@ -161,12 +162,13 @@ function format_epic(decision: BundleDecision): Array<string> {
 	return lines
 }
 
-// A draft cites nothing, so the epic half has nothing to decide from: its two signals are prose
-// references and recorded dependencies, and a title carries neither. Saying "file it standalone" there
-// reports a scan that found nothing when none was possible — the confident wrong answer the gap
+// A draft cites nothing where a citation counts, so the epic half has nothing to decide from: its two
+// signals are references in the acceptance criteria or the `parent: #N` line and recorded
+// dependencies, and a title or a background mention carries neither. Saying "file it standalone"
+// there reports a scan that found nothing when none was possible — the confident wrong answer the gap
 // warnings exist to prevent everywhere else in this command.
 const NO_REFERENCE_LINE =
-	'Epic: not asked — no issue number in the summary. Pass --body "…#<N>…", or take the epic printed beside a duplicate above.'
+	'Epic: not asked — no issue number in the summary\'s acceptance criteria or parent line. Pass --body "parent: #<N>", or take the epic printed beside a duplicate above.'
 
 // Every placing verdict above asserts that no epic already tracks the draft's relatives, and a cut
 // epic listing cannot support that: `epic:bundle` withholds them for it,
@@ -194,18 +196,22 @@ function format_epic_decision(
 	return format_epic(decision).join('\n')
 }
 
-// Whether the summary names an issue at all, read through the same parser the decision itself uses —
-// a second reading of "does this body cite anything" could disagree with the one that matters.
-function has_reference(draft: BacklogIssue): boolean {
-	return epic_audit_logic.parse_references(draft.body, draft.repo).length > 0
+// The issue numbers the summary names where `decide_bundle` counts a reference — its acceptance
+// criteria and its `parent: #N` line — read through the same parser the decision itself uses: a
+// second reading of "does this body cite anything" could disagree with the one that matters, and an
+// issue cited only as the background of the filing is not one the draft belongs with.
+function signal_numbers(draft: BacklogIssue): Array<number> {
+	return epic_audit_logic
+		.signal_references(draft.body, draft.repo)
+		.map((reference) => reference.number)
 }
 
 // The open epics the summary names outright. `decide_bundle` excludes an epic from the candidate pool
-// — a container is not a sibling — so a draft saying "part of epic #1153", which is the phrasing the
-// workflow documents themselves suggest, otherwise reaches `none` and is told to file standalone with
-// the epic it named never mentioned.
+// — a container is not a sibling — so a draft whose `parent: #1153` line names the epic, which is the
+// phrasing the workflow documents themselves suggest, otherwise reaches `none` and is told to file
+// standalone with the epic it named never mentioned.
 function named_epics(draft: BacklogIssue, issues: ReadonlyArray<BacklogIssue>): Array<number> {
-	const named = new Set(epic_audit_logic.parse_references(draft.body, draft.repo))
+	const named = new Set(signal_numbers(draft))
 
 	return issues
 		.filter((issue) => issue.is_epic === true && named.has(issue.number))
@@ -240,7 +246,7 @@ function format_epic_answer(
 
 	if (named.length > 0) return format_named_epics(named, decision).join('\n')
 
-	return format_epic_decision(decision, has_reference(draft), is_membership_established)
+	return format_epic_decision(decision, signal_numbers(draft).length > 0, is_membership_established)
 }
 
 // The closed rows reach the duplicate half only. `decide_bundle` places a draft among issues that

package/scripts/issue/markdown-section.ts

@@ -3,6 +3,9 @@
 // way, so the slicing lives in one place rather than being written twice.
 
 const HEADING_PREFIX = '## '
+// A body saved from GitHub's web editor ends its lines with CRLF; a kept `\r` would end every line's
+// text with it and defeat each `$`-anchored match downstream.
+const LINE_BREAK_PATTERN = /\r?\n/u
 
 function is_heading(line: string): boolean {
 	return line.trimStart().startsWith(HEADING_PREFIX)
@@ -29,21 +32,31 @@ function next_fence(line: string, fence: string): string | undefined {
 	return undefined
 }
 
-function unfenced_lines(body: string): ReadonlyArray<string> {
+function lines_of(body: string): ReadonlyArray<string> {
+	return body.split(LINE_BREAK_PATTERN)
+}
+
+// The body's lines with every fenced line, fences included, blanked. Indentation is kept, so a list
+// item's indented continuation survives.
+function fence_free_lines(body: string): ReadonlyArray<string> {
 	let fence = ''
 	const visible: Array<string> = []
 
-	for (const line of body.split('\n')) {
+	for (const line of lines_of(body)) {
 		const next = next_fence(line, fence)
-		const visible_line = line.replace(/^(?: {4}|\t).*/u, '')
 
-		visible.push(next === undefined && fence === '' ? visible_line : '')
+		visible.push(next === undefined && fence === '' ? line : '')
 		fence = next ?? fence
 	}
 
 	return visible
 }
 
+// As `fence_free_lines`, with an indented code line (4 spaces or a tab) blanked too.
+function unfenced_lines(body: string): ReadonlyArray<string> {
+	return fence_free_lines(body).map((line) => line.replace(/^(?: {4}|\t).*/u, ''))
+}
+
 function has_unfenced_line(body: string, text: string): boolean {
 	return unfenced_lines(body).some((line) => line.trim() === text)
 }
@@ -59,7 +72,7 @@ function section_lines_matching(
 	body: string,
 	is_target: (line: string) => boolean,
 ): ReadonlyArray<string> {
-	const lines = body.split('\n')
+	const lines = lines_of(body)
 	const visible = unfenced_lines(body)
 	const start = visible.findIndex((line) => is_target(line))
 
@@ -80,6 +93,7 @@ function section_lines(body: string, heading: string): ReadonlyArray<string> {
 const markdown_section = {
 	section_lines,
 	section_lines_matching,
+	fence_free_lines,
 	unfenced_lines,
 	has_line,
 	has_unfenced_line,