@joshuafolkken/kit 1.872.0

package/scripts/rules/issue-citation.ts

@@ -0,0 +1,242 @@
+// The bare-`#N` predicate behind the `issue-citation` row of the stop guard (joshuafolkken/kit#2121),
+// and the printing-side formatter that keeps a bare `#N` out of session-facing output in the first
+// place (joshuafolkken/kit#2329).
+//
+// **Session-facing output cites an Issue as a number-link, never a bare `#N`.** `CLAUDE.md` and
+// `prompts/collaboration-workflow/issue-citation.md` require `[#<N>](https://github.com/<owner>/<repo>/issues/<N>) — <short summary>`
+// in what the person reads: a bare `#123` is not clickable and does not say which repository's Issue
+// it is. The stop guard reads `last_assistant_message` — the turn's session-facing text — and this
+// predicate answers whether a bare number slipped into it.
+//
+// **It blocks the stop, so a false positive costs a wasted turn** (joshuafolkken/kit#2247). The nudge
+// now reaches the model rather than the person, so the detection is tightened to what is genuinely a
+// bare citation: a `#N` inside a fenced code block, inside an inline-code span, on a quote line, or
+// right after `PR` / `pull request` is not a citation slip and is skipped. The scan is line-based so
+// each exclusion is decided from the one line the mention sits on.
+//
+// **`linkify` runs that same scan the other way** (joshuafolkken/kit#2329): a command whose stdout a
+// run copies into its reply passes the text through it, and every bare `#N` the predicate would flag
+// is rewritten to `[#N](url)` — which the predicate then reads as linked, so the material that fed the
+// duplicate reply is fixed where it is printed rather than scolded after it reaches the screen. The
+// same exclusions hold, so a `#N` in a fenced example or an already-linked reference is left untouched.
+
+import { issue_cite } from '#scripts/issue/issue-cite'
+
+// An Issue number: `#` and its digits. One quantifier, no backtracking — the `#N` alone locates the
+// mention, and any `owner/repo` prefix is read off the surrounding text (`repo_prefix`) rather than
+// folded into the pattern, so the scan never carries two variable-length segments (sonar super-linear).
+const ISSUE_NUMBER = /#\d+/gu
+// The characters that bound an `owner/repo` prefix: whitespace, another `#`, and the brackets a
+// citation or prose wraps a reference in. Tested one character at a time by the prefix scan, so that
+// scan stays linear.
+const REFERENCE_BOUNDARY = /[\s#()[\]<>|]/u
+// A well-formed `owner/repo`: exactly one slash between two non-empty segments — the same shape
+// `issue:cite`'s parser accepts. A path-like run (`src/lib`, `a/b/c`) is not one, so it is not emitted
+// as a prefix that would make the suggested `issue:cite` call refuse the very reference it names.
+const OWNER_REPO = /^[^\s/#]+\/[^\s/#]+$/u
+// A markdown link, with its text captured as group 1: `[text](target)`. Each class excludes *both*
+// of its delimiters — no `[`/`]` in the text, no `(`/`)` in the target — so neither star is ambiguous
+// against a nested bracket and there is nothing to backtrack.
+const MARKDOWN_LINK = /\[([^[\]]*)\]\([^()]*\)/gu
+// A fenced-code delimiter line: three or more backticks or tildes after optional indentation — both
+// delimiters CommonMark allows. Toggling on each one brackets the fenced block, so a `closes #N` shown
+// in a `gh api` example never reads as a slip whichever fence the reply drew it with.
+const FENCE_MARKER = /^\s*(?:`{3,}|~{3,})/u
+// A quote line: a `>` after optional indentation. An Issue body quoted back carries its own `#N`, and
+// a quote is not the run's own citation.
+const QUOTE_LINE = /^\s*>/u
+// A `#N` written as a PR reference: `PR` or `pull request` (word-bounded) right before it. `#N` alone
+// cannot tell an Issue from a PR, but the preceding word can, and reading it needs no network round
+// trip inside the hook.
+const PR_PREFIX = /\b(?:pr|pull request)\s*$/iu
+// Two backticks bracket one inline-code span, so an odd count of them before an index means the index
+// sits inside a span.
+const BACKTICK_PAIR = 2
+
+// Whether a markdown link's *text* span — between the `[` and the `]`, never its `(target)` — covers
+// `index`. A `#N` inside the text is the approved `[#N](url)` citation; one in the target is not
+// reachable, since an issues URL carries no `#N`.
+function text_span_covers(link: RegExpMatchArray, index: number): boolean {
+	const start = (link.index ?? 0) + 1
+	const end = start + (link[1] ?? '').length
+
+	return index >= start && index < end
+}
+
+// The line is searched for a link whose text span covers this index, so `see [#12](url) and #34`
+// reads the first as linked and the second as bare. The scan is line-based (`is_bare_at` passes one
+// line), so a link and the `#N` it wraps must sit on the same line — which they always do.
+function is_linked_at(line: string, index: number): boolean {
+	for (const link of line.matchAll(MARKDOWN_LINK)) {
+		if (text_span_covers(link, index)) return true
+	}
+
+	return false
+}
+
+// **The message text alone, never a GitHub-bound artifact.** An Issue body or comment is passed to
+// `gh` as a `Bash` argument, not spoken in `last_assistant_message`, so those never reach here — which
+// is exactly the "silent on GitHub-bound artifacts" behavior the issue asks for, obtained by what the
+// stop guard reads rather than by a second exclusion here.
+//
+// The `owner/repo` written immediately before a `#N`, or '' when the mention is bare — the run of
+// non-boundary characters ending at the `#`, kept only when it holds a `/`. Read backwards a
+// character at a time so a repository name of any length costs its own length and no more.
+function repo_prefix(message: string, hash_index: number): string {
+	let start = hash_index
+	while (start > 0 && !REFERENCE_BOUNDARY.test(message.charAt(start - 1))) start -= 1
+
+	const token = message.slice(start, hash_index)
+
+	return OWNER_REPO.test(token) ? token : ''
+}
+
+// Whether the index sits inside an inline-code span: an odd number of backticks precede it on the line.
+function is_inline_code_at(line: string, index: number): boolean {
+	const backticks = line.slice(0, index).split('`').length - 1
+
+	return backticks % BACKTICK_PAIR === 1
+}
+
+// Whether the `#N` at this index on the line is a real bare citation rather than an excluded mention —
+// a linked reference, an inline-code span, or a PR reference read off the word before it.
+function is_bare_at(line: string, index: number): boolean {
+	if (is_linked_at(line, index) || is_inline_code_at(line, index)) return false
+
+	return !PR_PREFIX.test(line.slice(0, index))
+}
+
+// One bare reference and where it sits on its line: the `#N` text, the index its `#` starts at, and
+// the `owner/repo` prefix that precedes it (or ''). Shared so the collector and `linkify` read the
+// line the same way and cannot drift about what counts as bare.
+interface LineReference {
+	index: number
+	prefix: string
+	text: string
+}
+
+// The bare references on one line, in order — the excluded mentions (linked, inline-code, PR) already
+// dropped by `is_bare_at`, so a caller acts on citations alone.
+function line_references(line: string): ReadonlyArray<LineReference> {
+	const references: Array<LineReference> = []
+
+	for (const match of line.matchAll(ISSUE_NUMBER)) {
+		const { index } = match
+
+		if (is_bare_at(line, index)) {
+			references.push({ index, prefix: repo_prefix(line, index), text: match[0] })
+		}
+	}
+
+	return references
+}
+
+// The bare references on one non-excluded line are appended in order, each carrying its `owner/repo`
+// prefix when it had one.
+function collect_line_references(line: string, found: Array<string>): void {
+	for (const reference of line_references(line)) found.push(`${reference.prefix}${reference.text}`)
+}
+
+// The message lines that sit outside every fenced-code block, with the fence delimiter lines
+// themselves dropped: toggling on each delimiter brackets the block, so a `#N` shown in an example is
+// never scanned.
+function lines_outside_fences(message: string): ReadonlyArray<string> {
+	const lines: Array<string> = []
+	let is_in_fence = false
+
+	for (const line of message.split('\n')) {
+		if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence
+		else if (!is_in_fence) lines.push(line)
+	}
+
+	return lines
+}
+
+// The run's own prose: the lines outside every fenced-code block and off every quote line. Shared with
+// the filing-offer row of the stop guard (joshuafolkken/kit#2422), which asks the same "is this the
+// run speaking, not an example or a quote" question of the same reply.
+function prose_lines(message: string): ReadonlyArray<string> {
+	return lines_outside_fences(message).filter((line) => !QUOTE_LINE.test(line))
+}
+
+// The bare references in the message, in the order they appear and de-duplicated: the block reason
+// names them and turns them into `issue:cite` arguments, so a reference cited twice is not nudged
+// about twice. Fenced-code blocks and quote lines are skipped, so a `#N` shown in an example or quoted
+// from an Issue body is not read as the run's own citation.
+function bare_references(message: string): ReadonlyArray<string> {
+	const found: Array<string> = []
+
+	for (const line of prose_lines(message)) collect_line_references(line, found)
+
+	return [...new Set(found)]
+}
+
+function has_bare_reference(message: string): boolean {
+	return bare_references(message).length > 0
+}
+
+// The token `issue:cite` takes for one reference: a qualified `owner/repo#N` is passed as-is, a bare
+// `#N` loses its `#` so the command reads `issue:cite 123` rather than `issue:cite #123`.
+function cite_argument(reference: string): string {
+	return reference.startsWith('#') ? reference.slice(1) : reference
+}
+
+function cite_arguments(references: ReadonlyArray<string>): ReadonlyArray<string> {
+	return references.map((reference) => cite_argument(reference))
+}
+
+// One bare reference rewritten as a number-link: `[#N](url)` for a same-repo mention, or
+// `[owner/repo#N](url)` for a qualified one — the label is the reference exactly as it was written, so
+// the reader sees the number they would have, now clickable. The URL is `issue-cite`'s own assembly,
+// reused rather than restated so the two agree on the shape of a link.
+function reference_link(reference: LineReference, default_slug: string): string {
+	const slug = reference.prefix === '' ? default_slug : reference.prefix
+	const number = reference.text.slice(1)
+
+	return `[${reference.prefix}${reference.text}](${issue_cite.issue_url(slug, number)})`
+}
+
+// One eligible line with every bare reference rewritten, left to right: a reference spans its
+// `owner/repo` prefix through its `#N`, so the slice before it ends where the prefix begins and the
+// cursor resumes after the `#N`.
+function linkify_line(line: string, slug: string): string {
+	let result = ''
+	let cursor = 0
+
+	for (const reference of line_references(line)) {
+		const start = reference.index - reference.prefix.length
+
+		result += line.slice(cursor, start) + reference_link(reference, slug)
+		cursor = reference.index + reference.text.length
+	}
+
+	return result + line.slice(cursor)
+}
+
+// A line is rewritten only outside a fenced block and off a quote line, and never the fence delimiter
+// itself — the same three exclusions `bare_references` reads, so what `linkify` leaves bare is exactly
+// what the predicate would not have flagged.
+function rewrite_line(line: string, slug: string, is_in_fence: boolean): string {
+	if (is_in_fence || FENCE_MARKER.test(line) || QUOTE_LINE.test(line)) return line
+
+	return linkify_line(line, slug)
+}
+
+// Session-facing text with every bare `#N` rewritten to a number-link against `slug` (`owner/repo`),
+// so a command's stdout a run copies into its reply carries links rather than the bare references that
+// fed the duplicate reply. Fence state is carried across lines, since a fenced block spans them.
+function linkify(message: string, slug: string): string {
+	const out: Array<string> = []
+	let is_in_fence = false
+
+	for (const line of message.split('\n')) {
+		if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence
+		out.push(rewrite_line(line, slug, is_in_fence))
+	}
+
+	return out.join('\n')
+}
+
+const issue_citation = { bare_references, cite_arguments, has_bare_reference, linkify, prose_lines }
+
+export { issue_citation }

package/scripts/rules/issue-fold.ts

@@ -0,0 +1,73 @@
+import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
+import { bash_triggers } from './bash-triggers'
+import { filing_cap } from './filing-cap'
+import { shell_segments } from './shell-segments'
+import { tail_commands } from './tail-commands'
+
+// The trigger and the delivered text behind the `issue-fold` row of `delivered-rules.ts`
+// (joshuafolkken/kit#2213).
+//
+// **A second filing in one run with no `pnpm josh issue:fold` in front of it, refused at that second
+// filing.** A run that files several findings from one session should first ask whether they fold
+// into one Issue — the filing-time counterpart to the split assessment. The **first** filing asks
+// nothing: there is nothing yet to fold it with, which is why the rule stands down when no earlier
+// filing is on the tail. From the second on the run holds two or more findings and the fold question
+// binds. The input is mechanical — has the run filed before, did it fold — so it is a delivered rule
+// rather than resident prose.
+//
+// **It is `issue-scout`'s shape, not `filing-cap`'s.** Once per run with an `already_satisfied`
+// stand-down read off the tail: a filing with no prior filing is stood down (nothing to fold), and so
+// is one the run has already folded. The refusal hands over the command rather than asking the run to
+// "fold first". **No new predicate**: the filing trigger is `bash_triggers.is_issue_filing`, and the
+// prior-filing count is `filing_cap.prior_filing_count`, both reused verbatim.
+
+// `pnpm josh issue:fold`, the one act the rule asks for. The alias `isf` is expanded where the command
+// is read, so the canonical name matches both spellings.
+const FOLD_NAMES: ReadonlySet<string> = new Set(['issue:fold'])
+
+// Keeping the rule: a call that runs the fold. Segment-wise, so a spelling quoted inside a filing's
+// own body is not read as the fold that filing skipped.
+function runs_the_fold(command: string): boolean {
+	return shell_segments
+		.segments_of(command)
+		.some((segment) => shell_segments.is_josh_command(segment, FOLD_NAMES))
+}
+
+// The `already_satisfied` stand-down. Two runs ask nothing new: one with no earlier filing — the first
+// filing has nothing to fold with — and one that has already folded. Only the second-or-later filing
+// of an unfolded run is left for the delivery. `prior_filing_count` counts real filings, excluding a
+// guard-refused one, exactly as `filing-cap` reads it (no clones).
+function already_folded(tail: string, _call: GuardedCall): boolean {
+	if (filing_cap.prior_filing_count(tail) === 0) return true
+
+	return tail_commands.prior_bash_commands(tail).some((command) => runs_the_fold(command))
+}
+
+// The instruction in the shape a refusal can carry: what the call skipped, the criterion it reuses,
+// and the command that fixes it. The default is named because it is the half that makes the rule
+// believable — fold is what a session's several findings do unless the size clearly forbids it.
+const ISSUE_FOLD_REASON =
+	'⛔ issue fold: this run has filed an Issue before and is filing another with no `pnpm josh ' +
+	'issue:fold` between them. Several findings from one session fold into one Issue by default — the ' +
+	'filing-time counterpart to the split assessment, whose two questions it reuses: are the findings ' +
+	'separable, and does the whole clearly exceed one verification gate (the size half is ' +
+	'`split:assess`, called not recomputed). Reissue after folding: `pnpm josh issue:fold "<title>" ' +
+	'"<title>" …` — `fold` means file one Issue covering them, `separate` means file them apart ' +
+	'(separable findings whose combined size clears the split guide), and the default is `fold`. Add ' +
+	'`--not-separable` when they are really one deliverable. The procedure is ' +
+	'`.claude/skills/workflow-commands/split-assessment.md` → "The question". It fires once per run ' +
+	'and cannot repeat on the call in hand.'
+
+// The enumeration row itself, so `delivered-rules.ts` spreads one entry rather than restating the
+// trigger and reason it already single-sources here. Once per run with the stand-down above.
+const ROW = {
+	id: 'issue-fold',
+	is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
+	reason: ISSUE_FOLD_REASON,
+	already_satisfied: already_folded,
+	keeps: bash_triggers.on_bash_command(runs_the_fold),
+}
+
+const issue_fold = { ISSUE_FOLD_REASON, ROW, already_folded, runs_the_fold }
+
+export { issue_fold }

package/scripts/rules/issue-scout.ts

@@ -0,0 +1,64 @@
+import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
+import { bash_triggers } from './bash-triggers'
+import { shell_segments } from './shell-segments'
+import { tail_commands } from './tail-commands'
+
+// The trigger and the delivered text behind the `issue-scout` row of `delivered-rules.ts`
+// (joshuafolkken/kit#2119).
+//
+// **A filing without `pnpm josh issue:scout` in front of it, refused at the filing itself.** §2e
+// requires the scout before every `gh api … issues` call, and a duplicate is likeliest for the work
+// that just finished — the one case self-restraint is least able to catch. The input is mechanical —
+// did the run already run the scout — so it is a delivered rule rather than resident prose.
+//
+// **It is `issue-comments`'s shape, not the WIP cap's.** Like that row it is once per run with an
+// `already_satisfied` stand-down read off the tail, and the refusal hands over the command rather than
+// asking the run to "scout first" — a body-only read is refused so the reissue makes the comments
+// present, and here a scout-less filing is refused so the reissue makes the scout present. **No new
+// delivery path**: the trigger is `bash_triggers.is_issue_filing`, reused verbatim.
+
+// `pnpm josh issue:scout`, the one act the rule asks for. The alias `isc` is expanded where the
+// command is read, so the canonical name matches both spellings (joshuafolkken/kit#1789).
+const SCOUT_NAMES: ReadonlySet<string> = new Set(['issue:scout'])
+
+// Keeping the rule: a call that runs the scout. Segment-wise, so a spelling quoted inside a filing's
+// own body is not read as the scout that filing skipped.
+function runs_the_scout(command: string): boolean {
+	return shell_segments
+		.segments_of(command)
+		.some((segment) => shell_segments.is_josh_command(segment, SCOUT_NAMES))
+}
+
+// The `already_satisfied` stand-down: the run has already scouted, so this filing asks for nothing new.
+// The tool-name gate the row's trigger applies has already passed, so `call` only marks the shape; the
+// answer is entirely in the tail.
+function already_scouted(tail: string, _call: GuardedCall): boolean {
+	return tail_commands.prior_bash_commands(tail).some((command) => runs_the_scout(command))
+}
+
+// The instruction in the shape a refusal can carry: what the call skipped, why it matters most here,
+// and the command that fixes it. The duplicate risk is named because it is the half that makes the
+// rule believable — the filing most likely to duplicate is the one about work that just finished.
+const ISSUE_SCOUT_REASON =
+	'⛔ issue scout: this files an Issue with no `pnpm josh issue:scout` earlier in the run. A ' +
+	'duplicate is likeliest for the work that just finished, which is exactly where self-restraint is ' +
+	'weakest. Reissue after scouting: `pnpm josh issue:scout "<title>"` (add `--body "<one-line ' +
+	'summary, citing #N where the work follows one>"` so the epic half can answer), then read its ' +
+	'`Duplicates:` — an **open** candidate covering the same work stops the run rather than filing a ' +
+	'second Issue, and a `(closed)` one means the work is already done — before reissuing this filing. ' +
+	'The procedure is `.claude/skills/workflow-commands/SKILL.md` → §2e. It fires once per run and ' +
+	'cannot repeat on the call in hand.'
+
+// The enumeration row itself, so `delivered-rules.ts` spreads one entry rather than restating the
+// trigger and reason it already single-sources here. Once per run with the stand-down above.
+const ROW = {
+	id: 'issue-scout',
+	is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
+	reason: ISSUE_SCOUT_REASON,
+	already_satisfied: already_scouted,
+	keeps: bash_triggers.on_bash_command(runs_the_scout),
+}
+
+const issue_scout = { ISSUE_SCOUT_REASON, ROW, already_scouted, runs_the_scout }
+
+export { issue_scout }

package/scripts/rules/josh-git-bare.ts

@@ -0,0 +1,80 @@
+import { time_shell } from '#scripts/time-runtime/time-shell'
+import { bash_triggers } from './bash-triggers'
+import { shell_segments } from './shell-segments'
+
+// The trigger and the delivered text behind the `josh-git-bare` row of `delivered-rules.ts`
+// (joshuafolkken/kit#2297): a `pnpm josh git` issued without `-y` / `--yes`.
+//
+// **A bare `pnpm josh git` cannot succeed from an agent, and it wastes the time it takes to fail.** The
+// command prompts to confirm the staging, and with no TTY the prompt falls to its cancel branch —
+// `Checking unstaged files... Found` → `Operation cancelled.` — so the run throws the time away and then
+// reissues with `-y` (about 31 seconds in one measured lane). The confirmation flag is what makes it the
+// run's own unattended commit-push-PR step rather than a person's interactive invocation.
+//
+// **It is not `run-tail`.** That row governs a `pnpm josh git -y` push already carrying the flag, issued
+// in the *foreground* rather than backgrounded; this one governs a push that carries *no* flag at all.
+// The two triggers are disjoint by the flag — `run-tail` requires it, this refuses its absence — so no
+// two rows claim one command, which `delivered-rules-bash.test.ts` pins.
+//
+// **The stop is one shell call, so the rule is delivered rather than resident**
+// (`prompts/collaboration-workflow/rule-delivery.md`). It fires on every occurrence: a bare invocation
+// wastes the same time every time it is issued, so refused-once-and-free-after would put the next one
+// back on the run's self-restraint — the disposition `git-force.ts` takes for the same reason.
+
+// The `josh git` subcommand, in canonical form. `shell_segments.is_josh_command` canonicalizes an alias
+// (`g`) before the match, so `pnpm josh g` arrives as `git`.
+const GIT_COMMAND: ReadonlySet<string> = new Set(['git'])
+
+// The confirmation flags that make the invocation unattended. Either spelling is enough; the recovery
+// form `pnpm josh git -y --skip-commit --skip-push` carries `-y` and so is not bare.
+const CONFIRM_FLAGS: ReadonlySet<string> = new Set(['-y', '--yes'])
+
+function has_confirm_flag(args: ReadonlyArray<string>): boolean {
+	return args.some((argument) => CONFIRM_FLAGS.has(argument))
+}
+
+// A segment that invokes `pnpm josh git` with no confirmation flag. The command test comes first, so the
+// argument read runs only on a `josh git` segment. Segment-wise and alias-expanded for the reason every
+// command predicate in this directory is: one shell line carries several commands, and a name quoted
+// inside a body is not the command being invoked.
+function is_bare_segment(segment: string): boolean {
+	if (!shell_segments.is_josh_command(segment, GIT_COMMAND)) return false
+
+	return !has_confirm_flag(time_shell.josh_arguments(segment))
+}
+
+function is_bare_josh_git(command: string): boolean {
+	return shell_segments.segments_of(command).some((segment) => is_bare_segment(segment))
+}
+
+// The instruction in the shape a refusal can carry: what the bare call does, why it fails, and the one
+// form that works. Apostrophes are avoided so the single-quoted literal needs no escaping, as the
+// sibling reasons do.
+const JOSH_GIT_BARE_REASON =
+	'⛔ bare `pnpm josh git`: this prompts to confirm the staging, and with no TTY the prompt falls to ' +
+	'its cancel branch — `Checking unstaged files... Found` then `Operation cancelled.` — so the call ' +
+	'throws away the time it takes to fail (about 31 seconds in one measured lane) and you reissue it ' +
+	'with `-y` anyway (joshuafolkken/kit#2297). Run it unattended from the start: ' +
+	'`pnpm josh git -y "<title> #<N>"`. The recovery form that opens the PR for a push that already ' +
+	'landed is `pnpm josh git -y --skip-commit --skip-push`. This rule fires on every occurrence, not ' +
+	'once per run.'
+
+// The row itself, so `delivered-rules.ts` spreads one entry. `is_trigger` reads the input through
+// `on_bash_command` — the `Bash` tool-name gate every command row shares — and `decide` returns true so
+// it refuses every occurrence. It declares no `keeps`: the corrected call is `pnpm josh git -y`, which is
+// `run-tail`'s push step and scored there, so this row is reported unmeasured rather than double-counting
+// it (`git-force.ts`).
+const ROW = {
+	id: 'josh-git-bare',
+	is_trigger: bash_triggers.on_bash_command(is_bare_josh_git),
+	reason: JOSH_GIT_BARE_REASON,
+	decide: (): boolean => true,
+}
+
+const josh_git_bare = {
+	JOSH_GIT_BARE_REASON,
+	ROW,
+	is_bare_josh_git,
+}
+
+export { josh_git_bare }

package/scripts/rules/lane-carry-conflict.ts

@@ -0,0 +1,96 @@
+import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import { bash_triggers } from './bash-triggers'
+import { shell_segments } from './shell-segments'
+
+// A dispatched lane child is stopped from running its parent's budget commands, and told the live
+// carry record is its parent's rather than a competing run (joshuafolkken/kit#2267).
+//
+// **A child read its own parent as a competitor and refused to implement.** On 2026-09-21, inside
+// `backlogrun #2252`, a lane launched for #2258 stopped before touching a line: the child ran
+// `pnpm josh run:merge`, was answered `busy`, and read that as another session holding the run budget
+// over the same Issue. It parked #2258 with `needs-decision` and exited. **The "other session" was the
+// parent that launched it** — the parent holds the repository's one carry budget, and every lane
+// shares the common git directory that budget is keyed on, so the live owner a lane child reads is
+// always its parent. `run:merge` and `run:carry` are the parent's own budget/ownership commands; a
+// child has no business running either, and the `busy` it gets back is never a competitor.
+//
+// **The judgement material already exists.** `JOSH_LANE_CHILD` (`lane-child-marker.ts`) is the same
+// mechanical human-or-child fact the pre-gate cut and the interactive-ask refusal already read: a
+// person working in a lane carries no mark and sees no refusal, and a mark naming a *different* issue
+// leaked in from a parent session and is read as absent. The budget/ownership path reads it here so
+// the parent's record is resolved as the child's own parent, not a conflict.
+//
+// **The stop is one shell call, so the rule is delivered rather than resident** — a lane child is
+// always a `claude -p` process, so this leaves residency entirely
+// (`prompts/collaboration-workflow/rule-delivery.md`). It fires on every occurrence, not once per run:
+// a child must never run these commands, so the route is always "continue implementing", never a
+// reissue — the disposition `git-force.ts` and `lane-interactive-ask.ts` take for the same
+// "must never happen" reason.
+
+// The parent backlogrun budget/ownership commands. A child never runs either: `run:carry` begins and
+// advances the run budget the parent owns, and `run:merge` counts a returned child into it. Named in
+// canonical form only — `shell_segments.is_josh_command` canonicalizes an alias (`rc`, `rmg`) before
+// the match, so `pnpm josh rmg` arrives as `run:merge`.
+const RUN_BUDGET_COMMANDS: ReadonlySet<string> = new Set(['run:merge', 'run:carry'])
+
+// A segment that invokes one of the parent's budget commands. Segment-wise and alias-expanded for the
+// reason every command predicate in this directory is: one shell line carries several commands, and a
+// name quoted inside a body is not the command being invoked.
+function invokes_budget_command(command: string): boolean {
+	return shell_segments
+		.segments_of(command)
+		.some((segment) => shell_segments.is_josh_command(segment, RUN_BUDGET_COMMANDS))
+}
+
+// **The command test comes first and the world is consulted second**, so the `is_child_of` read — the
+// dispatch mark against this checkout's own issue — runs only on the handful of calls that invoke a
+// budget command, not on every `Bash` call in the run. A person working in a lane carries no mark and
+// sees no refusal, exactly as `lane-park.ts` and `lane-interactive-ask.ts` gate their own reads.
+function is_carry_conflict(
+	command: string,
+	is_lane_child: boolean = lane_child_marker.is_child_of(process.cwd()),
+): boolean {
+	if (!invokes_budget_command(command)) return false
+
+	return is_lane_child
+}
+
+// The instruction in the shape a refusal can carry: what the child cannot do, why the record is not a
+// conflict, and the mechanical branch to take instead — continue, never park or ask. **The procedure
+// is named, not restated** — its single sources are `pre-gate-cut.md` and `backlogrun-progress.md` →
+// "The hand-off", and a second copy here would be the clone `CLAUDE.md` prohibits. Apostrophes are
+// avoided so the single-quoted literal needs no escaping, as the sibling reasons do.
+const LANE_CARRY_CONFLICT_REASON =
+	'⛔ lane child carry conflict: this session is a dispatched lane child, and ' +
+	'`pnpm josh run:merge` / `pnpm josh run:carry` are the parent backlogrun budget commands — a child ' +
+	'must never run them. The live carry record here belongs to the parent that launched this child, ' +
+	'not to a competing run: the parent holds the one run budget for the repository, and every lane ' +
+	'shares the common git directory it is keyed on, so a live owner a lane child reads is always its ' +
+	'parent (joshuafolkken/kit#2267, measured 2026-09-21 in backlogrun #2252 — a child read run:merge ' +
+	'`busy` as a competitor and parked #2258 unimplemented). Do not run this command, and do not treat ' +
+	'it as a conflict: no `needs-decision`, no `confirmation` Telegram, no question to a person — a ' +
+	'dispatched child cannot ask, and there is nothing to decide. Continue implementing this Issue; the ' +
+	'parent owns the budget and counts the outcome at the return. The procedure is ' +
+	'`.claude/skills/workflow-commands/pre-gate-cut.md` and `backlogrun-progress.md` → "The hand-off". ' +
+	'This rule fires on every occurrence, not once per run.'
+
+// The row itself, so `delivered-rules.ts` spreads one entry. `is_trigger` reads the input through
+// `on_bash_command` — the `Bash` tool-name gate every command row shares — and `decide` returns true
+// so it refuses every occurrence. It declares no `keeps`: continuing is the absence of a call, not a
+// call, so the row is reported unmeasured rather than scored on an act that does not exist
+// (`git-force.ts`).
+const ROW = {
+	id: 'lane-carry-conflict',
+	is_trigger: bash_triggers.on_bash_command(is_carry_conflict),
+	reason: LANE_CARRY_CONFLICT_REASON,
+	decide: (): boolean => true,
+}
+
+const lane_carry_conflict = {
+	LANE_CARRY_CONFLICT_REASON,
+	ROW,
+	invokes_budget_command,
+	is_carry_conflict,
+}
+
+export { lane_carry_conflict }

package/scripts/rules/lane-interactive-ask.ts

@@ -0,0 +1,71 @@
+import { interactive_ask } from '#scripts/agent/interactive-ask'
+import { lane_child_marker } from '#scripts/lane/lane-child-marker'
+import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
+
+// A dispatched lane child's interactive ask is refused and routed to the park procedure, delivered at
+// the call it binds on (joshuafolkken/kit#2201).
+//
+// **This is joshuafolkken/kit#2034's rule, moved one tool-call earlier.** #2034 gave a lane child that
+// stops for a decision the right instruction — park the question on the Issue before it notifies — but
+// wired it to the `confirmation` notify. A child that reaches for `AskUserQuestion` never gets that
+// far: the ask is refused by the harness, the turn ends there, and #2034's guard never fires. Measured
+// on 2026-09-20 inside `backlogrun #2163 --only`: #2178's child hit a Tier B branch, called
+// `AskUserQuestion`, was refused, and died with the question stranded in its exit record's
+// `permission_denials`. So the trigger is the ask itself, not the stop that a routed child would have
+// reached afterward.
+//
+// **A hook denial is guidance, where the harness's own denial is death.** The harness refuses an
+// interactive ask in a headless session by ending the turn; this rule refuses the same call with a
+// `PreToolUse` deny, which returns to the model with the park procedure — so the refusal becomes an
+// instruction the child can act on rather than the end of its run. That is the same shape
+// `prompts/collaboration-workflow/rule-delivery.md` names: a rule whose trigger is one tool call is
+// delivered by a hook that refuses it and states the rule.
+//
+// **It fires on every occurrence, not once per run.** An interactive ask must never succeed in a lane
+// child, so refused-once-and-free-after would put the second ask back on the harness's fatal denial —
+// the disposition `git-force.ts` takes for the same "must never happen" reason. The child's route is
+// always the park, never a reissue of the ask.
+//
+// **The world is consulted after the tool name, never on every call.** `is_child_of` reads the
+// dispatch mark against this checkout's own issue; the tool-name test runs first, so a run that never
+// asks pays nothing for it, and a person working in a lane carries no mark and sees no refusal.
+
+function is_interactive_ask(
+	call: GuardedCall,
+	is_lane_child: boolean = lane_child_marker.is_child_of(process.cwd()),
+): boolean {
+	if (!interactive_ask.is_interactive_tool(call.name)) return false
+
+	return is_lane_child
+}
+
+// The instruction in the shape a refusal can carry: what the child cannot do, what to do instead, and
+// the pointer to the procedure. **The park is named, not restated** — its single source is
+// `backlogrun-park.md` → "park and continue", and a second copy here would be the clone `CLAUDE.md`
+// prohibits. The one command is spelled so the child is not left to reconstruct it from a doc read.
+const LANE_INTERACTIVE_ASK_REASON =
+	'⛔ lane child interactive ask: this session is a dispatched lane child and cannot ask a person, so ' +
+	'this call is refused. Left to run it would end the turn with nothing on the Issue — the parent then ' +
+	'finds an OPEN Issue with `in-progress` and no question (joshuafolkken/kit#2201; joshuafolkken/kit#2034 ' +
+	'placed the same rule one tool-call too late). Do not ask: park the decision instead. Apply ' +
+	'`needs-decision` and post a comment carrying the question, the options and whether work was stashed — ' +
+	"`gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'` then " +
+	'`pnpm josh issue:comment <N> --body-file <path>` — then send the ' +
+	'`confirmation` Telegram and stop. The procedure is ' +
+	'`.claude/skills/workflow-commands/pre-gate-cut.md` → "A lane child records its park before it stops", ' +
+	'and the park itself is `backlogrun-park.md` → "park and continue". This rule fires on every ' +
+	'occurrence, not once per run.'
+
+// The row itself, so `delivered-rules.ts` spreads one entry. `decide` returns true so it refuses every
+// occurrence; it declares no `keeps` — not asking is the absence of a call, not a call, so the row is
+// reported unmeasured rather than scored on an act that does not exist (`git-force.ts`).
+const ROW = {
+	id: 'lane-interactive-ask',
+	is_trigger: is_interactive_ask,
+	reason: LANE_INTERACTIVE_ASK_REASON,
+	decide: (): boolean => true,
+}
+
+const lane_interactive_ask = { LANE_INTERACTIVE_ASK_REASON, ROW, is_interactive_ask }
+
+export { lane_interactive_ask }