@joshuafolkken/kit 1.1136.0 → 1.1178.0

package/scripts/backlog/backlog-restructure.ts

@@ -0,0 +1,152 @@
+import type { BusyRead } from '#scripts/epic/epic-busy'
+import type { EpicChild } from '#scripts/epic/epic-graph'
+import type { SoloSelection } from '#scripts/epic/epic-solo'
+
+// Which candidates may not run side by side because both restructure the same file
+// (joshuafolkken/kit#3221). The condition is deliberately narrow: plain overlap is not serialized,
+// because every resume record of the 2026-10-05 backlog run was resolved mechanically by merging
+// main. What git cannot resolve on its own is a rename or modify/delete conflict — two lanes that
+// each move, split, rename or delete the same file — so only a path both bodies name on a line with
+// such a verb holds the second one back. `remove` is left out: issue bodies use it for lines and
+// options far more often than for files.
+const RESTRUCTURE_WORDS: ReadonlySet<string> = new Set([
+	'move',
+	'moved',
+	'moves',
+	'moving',
+	'rename',
+	'renamed',
+	'renames',
+	'renaming',
+	'split',
+	'splits',
+	'splitting',
+	'delete',
+	'deleted',
+	'deletes',
+	'deleting',
+])
+const RESTRUCTURE_PHRASES: ReadonlyArray<string> = ['移動', '分割', '削除', 'リネーム', '改名']
+const WORD = /[a-z]+/giu
+const CODE_SPAN = /`([^`\s]+)`/gu
+const LINE_SUFFIX = /:\d+(?::\d+)?$/u
+const FILE_EXTENSION = /\.[a-z]\w*$/iu
+
+// The restructured paths each issue declares, by issue number.
+type Declared = ReadonlyMap<number, ReadonlySet<string>>
+
+interface DeclaringIssue {
+	number: number
+	body?: string | undefined
+}
+
+function is_path(token: string): boolean {
+	return token.includes('/') || FILE_EXTENSION.test(token)
+}
+
+function paths_on(line: string): Array<string> {
+	return [...line.matchAll(CODE_SPAN)]
+		.map((match) => (match[1] ?? '').replace(LINE_SUFFIX, ''))
+		.filter((token) => is_path(token))
+}
+
+function is_restructuring(line: string): boolean {
+	const words = line.match(WORD) ?? []
+
+	if (words.some((word) => RESTRUCTURE_WORDS.has(word.toLowerCase()))) return true
+
+	return RESTRUCTURE_PHRASES.some((phrase) => line.includes(phrase))
+}
+
+// The backticked paths on the lines of `body` that carry a restructuring verb.
+function restructured_paths(body: string): ReadonlySet<string> {
+	const lines = body.split('\n').filter((line) => is_restructuring(line))
+
+	return new Set(lines.flatMap((line) => paths_on(line)))
+}
+
+function declared_of(issues: ReadonlyArray<DeclaringIssue>): Declared {
+	return new Map(issues.map((issue) => [issue.number, restructured_paths(issue.body ?? '')]))
+}
+
+interface SeparateContext {
+	read: BusyRead
+	repo: string
+}
+
+// The path each running lane restructures, mapped to the issue that holds it.
+function running_claims(declared: Declared, read: BusyRead): Map<string, number> {
+	const holders = read.kind === 'busy' ? read.issues.map((issue) => issue.number) : []
+	const pairs = holders.flatMap((number) =>
+		[...(declared.get(number) ?? [])].map((path): [string, number] => [path, number]),
+	)
+
+	return new Map(pairs)
+}
+
+function paths_of(child: EpicChild, declared: Declared, repo: string): ReadonlySet<string> {
+	if (child.repo !== repo) return new Set()
+
+	return declared.get(child.number) ?? new Set()
+}
+
+function clash_note(child: EpicChild, path: string, holder: number): string {
+	return `#${String(child.number)} waits: it and #${String(holder)} both restructure \`${path}\`.`
+}
+
+interface Walk {
+	claims: Map<string, number>
+	offered: Array<EpicChild>
+	withheld: Array<EpicChild>
+	notes: Array<string>
+}
+
+function visit(walk: Walk, child: EpicChild, paths: ReadonlySet<string>): void {
+	const clash = [...paths].find((path) => walk.claims.has(path))
+
+	if (clash === undefined) {
+		walk.offered.push(child)
+		for (const path of paths) walk.claims.set(path, child.number)
+
+		return
+	}
+
+	walk.withheld.push(child)
+	walk.notes.push(clash_note(child, clash, walk.claims.get(clash) ?? child.number))
+}
+
+function merged_notice(
+	notice: string | undefined,
+	notes: ReadonlyArray<string>,
+): string | undefined {
+	const parts = notice === undefined ? notes : [notice, ...notes]
+
+	return parts.length === 0 ? undefined : parts.join('\n')
+}
+
+// `selection` with every offered candidate that restructures a path a running lane or an earlier
+// candidate already restructures moved to `withheld`, in offer order.
+function separate(
+	selection: SoloSelection,
+	declared: Declared,
+	context: SeparateContext,
+): SoloSelection {
+	const walk: Walk = {
+		claims: running_claims(declared, context.read),
+		offered: [],
+		withheld: [],
+		notes: [],
+	}
+
+	for (const child of selection.offered) visit(walk, child, paths_of(child, declared, context.repo))
+
+	const notice = merged_notice(selection.notice, walk.notes)
+	const withheld = [...walk.withheld, ...selection.withheld]
+
+	return { offered: walk.offered, withheld, ...(notice !== undefined && { notice }) }
+}
+
+const backlog_restructure = { declared_of, restructured_paths, separate }
+
+export { backlog_restructure }
+export type { Declared }

package/scripts/backlog/backlog-waves.ts

@@ -10,7 +10,7 @@ import {
 	NEEDS_DECISION_LABEL,
 } from '#scripts/issue/issue-labels'
 import { backlog_plan, type PlanContext } from './backlog-plan'
-import { backlog_rank } from './backlog-rank'
+import { backlog_rank, type GateScope } from './backlog-rank'
 
 // The order a `backlogrun` takes, wave by wave, before it starts (joshuafolkken/kit#2778).
 //
@@ -18,7 +18,8 @@ import { backlog_rank } from './backlog-rank'
 // made from, so the order past the first answer was left for a person to work out by hand. This plays
 // the asks forward under one assumption: **every issue of a wave merges before the next wave starts**.
 //
-// **No rule is written twice.** The first wave is `backlog_rank.select` — rank, `run:solo` gate, cap —
+// **No rule is written twice.** The first wave is `backlog_rank.select` — rank, `run:solo` gate,
+// restructure separation, cap —
 // over the very candidates `backlog:next` resolves, asked of an idle repository — so it is what
 // `backlog:next` prints when nothing is running (joshuafolkken/kit#2928). Each later wave marks the earlier waves closed and re-classifies the same pool
 // through `epic_classify.classify_children` with the resolver `epic:next` sorted it with the first
@@ -28,6 +29,7 @@ import { backlog_rank } from './backlog-rank'
 
 const IDLE: BusyRead = { kind: 'idle' }
 const CLOSED = 'CLOSED'
+const EMPTY_SCOPE: GateScope = { standalone: new Set(), declared: new Map() }
 
 const HEADING_ASSUMPTION =
 	'Assumes every issue in a wave merges before the next wave starts. Issues a run already has are left out, and only issues of this repository are planned.'
@@ -59,17 +61,17 @@ interface WavePool {
 	children: ReadonlyArray<EpicChild>
 	running: ReadonlySet<string>
 	repo: string
-	standalone: ReadonlySet<string>
+	scope: GateScope
 }
 
-function pool_of(result: EpicNextResult, repo: string, standalone: ReadonlySet<string>): WavePool {
+function pool_of(result: EpicNextResult, repo: string, scope: GateScope): WavePool {
 	const all = backlog_rank.everything_in(result)
 
 	return {
 		children: all.filter((child) => !is_running(child)),
 		running: epic_outside_blocker.running_keys(all),
 		repo,
-		standalone,
+		scope,
 	}
 }
 
@@ -78,9 +80,9 @@ function offer(
 	children: ReadonlyArray<EpicChild>,
 	pool: WavePool,
 ): ReadonlyArray<EpicChild> {
-	const { repo, standalone } = pool
+	const { repo, scope } = pool
 
-	return backlog_rank.select({ candidates, pool: children, read: IDLE, repo, standalone }).offered
+	return backlog_rank.select({ candidates, pool: children, read: IDLE, repo, ...scope }).offered
 }
 
 // Ranked against the whole result, exactly as `backlog:next` ranks it, so the two agree.
@@ -106,14 +108,10 @@ function next_wave(pool: WavePool, done: ReadonlySet<string>): ReadonlyArray<Epi
 }
 
 // Each wave is closed before the next is asked for; a wave that offers nothing ends the plan, which
-// the pool's size bounds because every wave closes at least one child. `standalone` names the rows the
-// offer's cap bounds; left empty, no wave is capped.
-function build(
-	result: EpicNextResult,
-	repo: string,
-	standalone: ReadonlySet<string> = new Set(),
-): WavePlan {
-	const pool = pool_of(result, repo, standalone)
+// the pool's size bounds because every wave closes at least one child. `scope` names the rows the
+// offer's cap bounds and the paths each issue restructures; left empty, no wave is capped or separated.
+function build(result: EpicNextResult, repo: string, scope: GateScope = EMPTY_SCOPE): WavePlan {
+	const pool = pool_of(result, repo, scope)
 	const done = new Set<string>()
 	const waves: Array<ReadonlyArray<EpicChild>> = []
 
@@ -155,11 +153,11 @@ function unreached_lines(plan: WavePlan, context: PlanContext): Array<string> {
 function format_waves(
 	result: EpicNextResult,
 	context: PlanContext,
-	standalone: ReadonlySet<string> = new Set(),
+	scope: GateScope = EMPTY_SCOPE,
 ): string {
 	if (result.verdict === 'error') return backlog_plan.format_unusable(result)
 
-	const plan = build(result, context.repo, standalone)
+	const plan = build(result, context.repo, scope)
 	const waves = plan.waves.map((wave, index) => wave_line(wave, index, context.repo))
 
 	return [

package/scripts/behavior/behavior-rules.ts

@@ -13,7 +13,13 @@ const TOOL_USE = 'tool_use'
 const COMMAND_KEY = 'command'
 const FIRST_POSITION_OFFSET = 1
 const TOOL_RESULT = 'tool_result'
-const DENIED_BASH_PREFIX = 'Permission to use Bash with command '
+// The openings of the two results that mean a Bash call never ran: the permission layer's refusal,
+// and a PreToolUse hook's block (joshuafolkken/kit#3197). A PostToolUse hook error is deliberately
+// absent — that hook fires after the command has already run.
+const DENIED_BASH_PREFIXES = [
+	'Permission to use Bash with command ',
+	'PreToolUse:Bash hook error: ',
+]
 
 // The git subcommands that stage or rewrite the index — the ones `CLAUDE.md` reserves for `pnpm josh
 // git` under "Never stage or mutate the git index on your own". An agent that runs one directly has
@@ -71,14 +77,15 @@ function is_index_mutation(command: string): boolean {
 		.some((segment) => INDEX_MUTATION_HEAD.test(segment) && !is_dry_run(segment))
 }
 
-// An errored result alone may mean a command ran and failed. Only the permission layer's refusal
-// identifies a Bash call that never ran; the parser keeps the opening of that result's text.
+// An errored result alone may mean a command ran and failed. Only a refusal before execution — the
+// permission layer's or a PreToolUse hook's — identifies a Bash call that never ran; the parser keeps
+// the opening of that result's text.
 function is_denied_result(block: Block): boolean {
 	return (
 		block.type === TOOL_RESULT &&
 		block.result_id !== '' &&
 		block.is_error === true &&
-		block.error_text.startsWith(DENIED_BASH_PREFIX)
+		DENIED_BASH_PREFIXES.some((prefix) => block.error_text.startsWith(prefix))
 	)
 }
 

package/scripts/cost-runtime/context-cut-threshold.ts

@@ -10,12 +10,4 @@ import { context_cut_payback } from './context-cut-payback'
 // from the cache-price multipliers and the horizon rather than restated, so it moves with the model.
 const CONTEXT_CUT_THRESHOLD = context_cut_payback.break_even_context()
 
-// The hand-off prices the average billed input of the most recent requests, not the whole session
-// (joshuafolkken/kit#2295). A long parent session's whole-session average lags its current context by
-// dozens of requests — measured at 85 requests (~4 hours) behind on the 2026-09-21 parent — so it
-// keeps supervising an already-oversized context long after a cut was due. Ten requests is enough to
-// smooth a single outlier without reaching back into the cheap early context; it sits beside the
-// threshold so the window and the limit are read from one place and cannot drift.
-const RECENT_REQUEST_WINDOW = 10
-
-export { CONTEXT_CUT_THRESHOLD, RECENT_REQUEST_WINDOW }
+export { CONTEXT_CUT_THRESHOLD }

package/scripts/cost-runtime/cost-verdict.ts

@@ -3,42 +3,31 @@
 // of a session will cost, and takes only the figures its verdict needs — an over measurement — never
 // a whole report. The `--cap` counterfactual it once sat beside was retired in #2016 as readerless.
 
-import { RECENT_REQUEST_WINDOW } from './context-cut-threshold'
-
 const FAILURE_EXIT_CODE = 1
 const OVER_VERDICT = 'over'
 const UNDER_VERDICT = 'under'
 
-// What `--over` reads of a session: the billed input each request paid, oldest first. The whole
-// per-request sequence is carried rather than a single sum because the hand-off prices the recent
-// tail alone (joshuafolkken/kit#2295) — a long session's whole-session average lags its current
-// context by dozens of requests, so a sum could not answer what the recent window actually cost.
+// What `--over` reads of a session: the billed input each request paid, oldest first. The sequence
+// is carried rather than a single sum because the hand-off prices the newest request alone
+// (joshuafolkken/kit#3224) — a sum could not answer what the session's current context costs.
 interface OverMeasurement {
 	billed_input_per_request: ReadonlyArray<number>
 }
 
-// The most recent requests the hand-off prices, oldest first — the whole sequence when it is shorter
-// than the window, so a session with fewer than `RECENT_REQUEST_WINDOW` requests is priced on what it
-// has rather than padded.
-function recent_requests(measurement: OverMeasurement): ReadonlyArray<number> {
-	return measurement.billed_input_per_request.slice(-RECENT_REQUEST_WINDOW)
-}
-
 // What a turn costs is decided by the accumulated preamble, not by what the turn does, so the
-// marginal cost of a session is the billed input its recent requests paid. Measured across one
+// marginal cost of a session is the billed input its newest request paid. Measured across one
 // `epicrun` that ran six children in one context: 222k per request during the first child, 645k
 // during the sixth — the same work at 2.9x the price (joshuafolkken/kit#968).
 //
-// The recent window rather than the whole session, because a long parent's whole-session average
-// lags its current context by dozens of requests (joshuafolkken/kit#2295); the recent average says
-// what the *next* turn will cost, which is the thing a hand-off decision turns on.
+// **The newest request, not an average.** joshuafolkken/kit#2295 replaced the whole-session average,
+// which lagged a long parent by dozens of requests, with the average of the last ten; that still
+// lagged. A session's billed input only grows between compactions (a unit writes its own transcript),
+// so an average smooths no outlier — it only trails the context it averages. On 2026-10-05 wake
+// session 03367124 crossed the threshold at request 65 and its ten-request average at request 70
+// (joshuafolkken/kit#3224). The threshold is a break-even on the *current* context
+// (`context-cut-payback.ts`), so the current context is what it is compared against.
 function per_request_cost(measurement: OverMeasurement): number {
-	const window = recent_requests(measurement)
-	if (window.length === 0) return 0
-
-	const total = window.reduce((sum, billed) => sum + billed, 0)
-
-	return Math.round(total / window.length)
+	return measurement.billed_input_per_request.at(-1) ?? 0
 }
 
 // The bare over/under decision, without a report: `run:status` reads this same verdict read-only
@@ -51,14 +40,12 @@ function classify(
 	return per_request_cost(measurement) > limit ? OVER_VERDICT : UNDER_VERDICT
 }
 
-// The stderr line names the window the average covers, so the reader can tell a recent-tail average
-// from a whole-session one (joshuafolkken/kit#2295): "the last W of T request(s)" reads W when the
-// session is longer than the window and the whole count when it is shorter.
+// The stderr line names which request was priced, so the reader can tell the newest request's cost
+// from an average over the session (joshuafolkken/kit#3224).
 function over_summary(measurement: OverMeasurement, limit: number): string {
 	const total = measurement.billed_input_per_request.length
-	const window = recent_requests(measurement).length
 
-	return `${String(per_request_cost(measurement))} billed input tokens per request over the last ${String(window)} of ${String(total)} request(s); limit ${String(limit)}`
+	return `${String(per_request_cost(measurement))} billed input tokens per request, on the newest of ${String(total)} request(s); limit ${String(limit)}`
 }
 
 // A verdict, not a table: the point of the flag is that the hand-off is decided by a number rather

package/scripts/delegation/investigation-reads.ts

@@ -71,7 +71,7 @@ const INVESTIGATOR_AGENT = 'investigator'
 // What the refusal tells the model. It has to name the count, the command and the return shape,
 // because the deny reason is the only text that reaches the model — a run that is refused and told
 // nothing reads it as a broken tool.
-const REASON = `⛔ investigation: ${String(delegation_policy.INVESTIGATION_FILE_THRESHOLD)} files read and not edited, or ${String(delegation_policy.INVESTIGATION_SEARCH_TURN_THRESHOLD)} search turns, since the last delegated unit, so the reading from here goes to a unit of its own (a successful write also starts the search count over). Ask \`pnpm josh delegate investigation\`, then dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer) with a brief of what the main line has already concluded and what is left to find out; it returns the conclusion plus its \`file:line\` citations, never the file text. Keep a read in the main line only where this run will edit that file — an \`Edit\` cannot be issued against text you do not hold. This run's own instructions and the harness's own session files — a backgrounded call's output, a persisted tool result, this session's scratchpad — never count toward the files, so they are not what took the file count here; every read-only search turn counts, whatever it names. The rule is \`.claude/skills/workflow-commands/SKILL.md\` → §2b, "The pre-implementation reading".`
+const REASON = `⛔ investigation: ${String(delegation_policy.INVESTIGATION_FILE_THRESHOLD)} files read and not edited, or ${String(delegation_policy.INVESTIGATION_SEARCH_TURN_THRESHOLD)} search turns, since the last delegated unit, so the reading from here goes to a unit of its own (a successful write also starts the search count over). Ask \`pnpm josh delegate investigation\`, then dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer) with a brief of what the main line has already concluded and what is left to find out; it returns the conclusion plus its \`file:line\` citations, never the file text. Keep a read in the main line only where this run will edit that file — an \`Edit\` cannot be issued against text you do not hold. This run's own instructions and the harness's own session files — a backgrounded call's output, a persisted tool result, this session's scratchpad — never count toward the files, so they are not what took the file count here; every read-only search turn counts, whatever it names. The rule is \`.claude/skills/workflow-commands/delegation.md\` → "The pre-implementation reading".`
 
 interface ReadTally {
 	// The files read and not since edited, resolved so the two ways a target reaches here compare.
@@ -92,13 +92,13 @@ interface ReadTally {
 	searches: number
 	searches_since: number
 	// The files this run has successfully edited within the window, resolved (joshuafolkken/kit#1840).
-	// A re-read of one of them is a read of a file the run edited, which §2b keeps in the main line — so
+	// A re-read of one of them is a read of a file the run edited, which `delegation.md` keeps in the main line — so
 	// it is excluded from the count and from a call's projected growth rather than counted as fresh
 	// investigation.
 	edited: ReadonlySet<string>
 }
 
-// **The run's own instructions are not the Issue's subject, so reading them is not what §2b delegates.**
+// **The run's own instructions are not the Issue's subject, so reading them is not what `delegation.md` delegates.**
 // #1426's rule is about reading to find out how the subject works; `CLAUDE.md`, a `prompts/` topic and
 // a skill file are read to find out what to *do*, they are read by nearly every run, and a unit cannot
 // be sent to read them on the main line's behalf. #1441's own measurement excluded 5 of them by hand
@@ -264,7 +264,7 @@ function is_failed_outcome(span: Span): boolean {
 
 // **Every file the run successfully wrote within the window, resolved** (joshuafolkken/kit#1840). It
 // is the one source of "this run edited that file", shared by the live tally and the replay: a read of
-// a file the run edits is reading §2b keeps in the main line, so it is never counted — whether the read
+// a file the run edits is reading `delegation.md` keeps in the main line, so it is never counted — whether the read
 // came before the edit or after it. A failed edit wrote nothing and so exempts nothing, and a file
 // edited outside the window is unknown rather than assumed: the set is only ever as wide as the tail
 // the hook read, which is the bound joshuafolkken/kit#1764 already holds the accumulation to.
@@ -444,7 +444,7 @@ function is_at_search_threshold(search_count: number): boolean {
 //
 // **A delegated unit is not re-armed here because it is not refused at all** (joshuafolkken/kit#1840).
 // The hook counts a unit's reading against the unit (joshuafolkken/kit#1424), and the refusal asks for
-// a dispatch — but a unit is already where §2b sends the reading, and a read-only one (`Explore`,
+// a dispatch — but a unit is already where `delegation.md` sends the reading, and a read-only one (`Explore`,
 // `Plan`) has no `Agent` tool to dispatch with. It was formerly degraded to a single first refusal,
 // which still asked for an action the unit could not take; now the unit short circuit in `should_block`
 // turns it off entirely, so this function is the parent's alone and needs no delegation condition.

package/scripts/discovery/repo-discovery.ts

@@ -59,22 +59,35 @@ function resolve_git_directory(repository_path: string): string | undefined {
 	}
 }
 
-// The `origin` URL a work tree declares, or nothing when it has no `origin`, no readable config, or
-// is not a work tree at all. Every failure reads as "no remote" so one unreadable sibling cannot
-// fail a command whose contract is to report what it could find.
-function read_origin_url(repository_path: string): string | undefined {
+// The work tree's git config text, or nothing when it is unreadable or not a work tree.
+function read_config(repository_path: string): string | undefined {
 	const git_directory = resolve_git_directory(repository_path)
 	if (git_directory === undefined) return undefined
 
 	try {
-		return repo_origin.parse_origin_from_config(
-			readFileSync(path.join(git_directory, GIT_CONFIG), 'utf8'),
-		)
+		return readFileSync(path.join(git_directory, GIT_CONFIG), 'utf8')
 	} catch {
 		return undefined
 	}
 }
 
+// The `origin` URL a work tree declares, or nothing when it has no `origin`, no readable config, or
+// is not a work tree at all. Every failure reads as "no remote" so one unreadable sibling cannot
+// fail a command whose contract is to report what it could find.
+function read_origin_url(repository_path: string): string | undefined {
+	const config = read_config(repository_path)
+
+	return config === undefined ? undefined : repo_origin.parse_origin_from_config(config)
+}
+
+// The `url` of every remote the work tree declares, with the same "unreadable reads as none" contract
+// as `read_origin_url`.
+function read_remote_urls(repository_path: string): Array<string> {
+	const config = read_config(repository_path)
+
+	return config === undefined ? [] : repo_origin.parse_remote_urls_from_config(config)
+}
+
 // Every immediate child directory of `parent`, in name order. An unreadable parent yields nothing
 // rather than throwing: `josh doctor` reports what it could find, and a permission error on the
 // parent is not a broken install.
@@ -158,6 +171,7 @@ const repo_discovery = {
 	OVERRIDE_ENV_KEY,
 	main_worktree,
 	read_origin_url,
+	read_remote_urls,
 	resolve_current_owner,
 	scan_siblings,
 	discover_repositories,

package/scripts/discovery/repo-origin.ts

@@ -26,6 +26,7 @@ const REPO_PATH_SEGMENTS = 2
 const NOT_FOUND = -1
 const SECTION_PREFIX = '['
 const ORIGIN_SECTION = /^\[remote\s+"origin"\]$/u
+const REMOTE_SECTION = /^\[remote\s+"[^"]+"\]$/u
 const URL_KEY = 'url'
 
 // Whether a URL's hostname is GitHub. Exact, with no alias spelling accepted: an alias is a name
@@ -132,6 +133,30 @@ function parse_origin_from_config(content: string): string | undefined {
 		.find((url) => url !== undefined)
 }
 
+// The config's lines grouped by section, each group led by its header. Lines before the first header
+// belong to no section and are dropped.
+function section_groups(lines: ReadonlyArray<string>): Array<Array<string>> {
+	const groups: Array<Array<string>> = []
+
+	for (const line of lines) {
+		if (is_section_header(line)) groups.push([line])
+		else groups.at(-1)?.push(line)
+	}
+
+	return groups
+}
+
+// The `url` of every `[remote "…"]` section, in config order — the candidates `gh` picks its base
+// repository from when it expands the `{owner}` placeholder (joshuafolkken/kit#3188).
+function parse_remote_urls_from_config(content: string): Array<string> {
+	const lines = content.split('\n').map((line) => line.trim())
+
+	return section_groups(lines)
+		.filter((group) => REMOTE_SECTION.test(group[0] ?? ''))
+		.flatMap((group) => group.map((line) => entry_value(line, URL_KEY)))
+		.filter((url) => url !== undefined)
+}
+
 // The `owner/repo` key a discovery map is keyed by. Lowercased, because GitHub resolves owner and
 // repository names case-insensitively: two remotes spelling the same repository differently are the
 // same repository, and keying by the spelling would put both in the map — where an override, which
@@ -146,6 +171,7 @@ const repo_origin = {
 	is_github_ssh_host,
 	parse_origin_from_config,
 	parse_origin_url,
+	parse_remote_urls_from_config,
 	format_identity,
 }
 

package/scripts/discovery/repo-party.ts

@@ -16,6 +16,8 @@ type Party = 'first-party' | 'third-party' | 'unknown'
 const FIRST_PARTY: Party = 'first-party'
 const THIRD_PARTY: Party = 'third-party'
 const UNKNOWN: Party = 'unknown'
+const GH_REPO_ENV_KEY = 'GH_REPO'
+const GH_REPO_PATH_SEGMENTS = 2
 
 // `unknown` is not `third-party`. An owner that cannot be read — no `origin`, an unreadable config —
 // is a "cannot decide", and reading it as third-party would refuse first-party writes whenever the
@@ -40,7 +42,46 @@ function current_owner(repository_path: string = process.cwd()): string | undefi
 	return repo_discovery.resolve_current_owner(repository_path)
 }
 
-const repo_party = { FIRST_PARTY, THIRD_PARTY, UNKNOWN, classify, current_owner, target_owner }
+// The owner `GH_REPO` names, read from its last two segments so an optional host prefix is skipped.
+function gh_repo_owners(gh_repo: string): Array<string | undefined> {
+	return [target_owner(gh_repo.split('/').slice(-GH_REPO_PATH_SEGMENTS).join('/'))]
+}
+
+// The owner of every remote the work tree declares. A remote whose owner cannot be read stays in the
+// set as `undefined` rather than being dropped: an SSH host alias (`git@github-work:o/r.git`) is one
+// `gh` translates to github.com and may pick, so dropping it would hide the owner `gh` writes to.
+function remote_owners(repository_path: string): Array<string | undefined> {
+	return repo_discovery
+		.read_remote_urls(repository_path)
+		.map((url) => repo_origin.parse_origin_url(url)?.owner)
+}
+
+// Every owner `gh` could expand the `{owner}` placeholder to (joshuafolkken/kit#3188). `GH_REPO`
+// (`[HOST/]OWNER/REPO`) overrides the remotes outright; otherwise `gh` picks its base repository among
+// the GitHub remotes — `upstream` ahead of `origin`, or a `gh repo set-default` choice — so in a fork
+// checkout it can expand to the upstream owner. Answering the whole candidate set rather than
+// re-implementing that pick keeps the caller safe whichever remote `gh` chooses. An `undefined` entry
+// is a candidate whose owner could not be read, which the caller must not assume is first-party.
+function placeholder_owners(
+	repository_path: string = process.cwd(),
+	environment: NodeJS.ProcessEnv = process.env,
+): Array<string | undefined> {
+	const gh_repo = environment[GH_REPO_ENV_KEY]
+
+	return gh_repo === undefined || gh_repo === ''
+		? remote_owners(repository_path)
+		: gh_repo_owners(gh_repo)
+}
+
+const repo_party = {
+	FIRST_PARTY,
+	THIRD_PARTY,
+	UNKNOWN,
+	classify,
+	current_owner,
+	placeholder_owners,
+	target_owner,
+}
 
 export type { Party }
 export { repo_party }

package/scripts/document/backlogrun-parent-read-set.ts

@@ -8,25 +8,19 @@
 // (`lane-child-read-set.ts`) — through the shared `read-set-trim`.
 //
 // **This is a different set from the worker's.** The parent keeps §0 (its session-cut / resume
-// paragraph is the parent's own), §2b (the parent's whole job is the epic-child delegation §2b
-// defines), §2c (the parent is the entry that receives an `owner/repo#` prefix), §2e and §2i (the
-// parent files prerequisites and observations for the batch) — all of which the worker drops. What the
-// parent drops is the implementer-only set below. **The parent owns every point-of-use document**, so
-// unlike the worker it drops none of them: the trim is the `SKILL.md` sections alone.
+// paragraph is the parent's own), which the worker drops. **The parent owns every point-of-use
+// document**, so unlike the worker it drops none of them: the trim is the `SKILL.md` sections alone.
 
 import type { ReadSetCost } from './entry-read-set'
 import { read_set_trim } from './read-set-trim'
 
 const BACKLOGRUN = 'backlogrun'
 
-// **The `SKILL.md` sections the `backlogrun` parent never uses.** The parent has no `new` entry, so it
-// names no `into` target (§2a); it claims no working tree, a dispatched child does that in its own
-// unit (§2f, `backlogrun.md:47-49`); it implements nothing, so it reads no Issue's comments before
-// implementing (§2g); and it edits no rule mid-run (§3, read only on an editing turn).
+// **The `SKILL.md` sections the `backlogrun` parent never uses.** It edits no rule mid-run (§3, read
+// only on an editing turn). The implementer-only rules it used to skip — the `into` target, the
+// working-tree hold, the Issue's comments — are single rows of §2's table since joshuafolkken/kit#3174,
+// so there is no section of them left to trim.
 const UNUSED_SKILL_SECTIONS: ReadonlyArray<string> = [
-	'2a. The `into <target>` suffix — where the new Issue lands',
-	'2f. The working-tree hold — one run per tree',
-	"2g. An Issue's comments are part of the Issue",
 	'3. What stays resident, and what is read from here',
 ]
 
@@ -34,10 +28,15 @@ const UNUSED_SKILL_SECTIONS: ReadonlyArray<string> = [
 // the park — so it drops none. Named empty so the shared trim reads the same shape as the worker's.
 const SKIPPED_POINT_OF_USE: ReadonlySet<string> = new Set<string>()
 
-// **The parent runs the end-of-run retrospective** (`SKILL.md` §2j) when `run:step` prints it, but its
+// **The parent runs the end-of-run retrospective** (`retrospective.md`) when `run:step` prints it, but its
 // manifest names `retrospective.md` only through `backlogrun-steps.md` — one hop further than the
-// derivation follows — so the parent's reach names it (joshuafolkken/kit#3078).
-const REACHED_POINT_OF_USE: ReadonlySet<string> = new Set(['retrospective.md'])
+// derivation follows — so the parent's reach names it (joshuafolkken/kit#3078). **It polls a
+// delegated unit that went silent** through `backlogrun-recovery.md`, named only from
+// `backlogrun-child.md`, so the reach names that too (joshuafolkken/kit#3175).
+const REACHED_POINT_OF_USE: ReadonlySet<string> = new Set([
+	'retrospective.md',
+	'backlogrun-recovery.md',
+])
 
 function costed(root: string): ReadSetCost {
 	return read_set_trim.costed(root, {