@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/scripts/backlog/backlog-ready.ts

@@ -2,10 +2,13 @@ import { git_gh_command } from '#scripts/gh/git-gh-command'
 import { issue_cite } from '#scripts/issue/issue-cite'
 import { josh_command, type JoshResult } from '#scripts/josh/josh-run'
 import { lane_capacity } from '#scripts/lane/lane-capacity'
-import { lane_registry } from '#scripts/lane/lane-registry'
+import { lane_registry, type LaneInfo } from '#scripts/lane/lane-registry'
+import { lane_spent } from '#scripts/lane/lane-spent'
 import type { RunCarry } from '#scripts/run/carry/run-carry'
+import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_headless } from '#scripts/run/run-headless'
 import { run_invocation } from '#scripts/run/run-invocation'
+import { backlog_occupied, type OccupiedRead } from './backlog-occupied'
 import { backlog_stalled } from './backlog-stalled'
 
 // The ready line reports runnable work to the driving backlogrun parent on a watcher wake.
@@ -18,18 +21,60 @@ interface ReadyReading {
 	free_lanes: number
 }
 
+// How many open lanes hold a place under the limit, and how many hold a port seat.
+interface LaneUse {
+	occupied: number
+	seated: number
+}
+
 interface ReadyPorts {
 	free_lane_count: () => Promise<number>
 	ready_issues: () => Promise<ReadonlyArray<string>>
 }
 
-// The lanes in use: the open worktrees an interruption has not stranded. `josh lane:limit` prints it.
-async function live_lane_count(): Promise<number> {
-	return lane_registry.live_count(await lane_registry.list_lanes())
+// What decides which open lanes hold a place, read from this checkout's live run.
+async function occupied_read(): Promise<OccupiedRead> {
+	const carry = await run_headless.current_carry()
+
+	return {
+		invocation: carry?.invocation,
+		events: carry === undefined ? [] : await run_event_stream_emit.scoped_current_events(),
+		idle: lane_spent.idle_lanes,
+	}
+}
+
+// The lanes that hold a place under the limit (`backlog-occupied.ts`).
+async function occupied_lanes(lanes?: ReadonlyArray<LaneInfo>): Promise<Array<LaneInfo>> {
+	const open = lanes ?? (await lane_registry.list_lanes())
+
+	return backlog_occupied.occupied_lanes(open, await occupied_read())
+}
+
+// The open lanes as the free count reads them: those that hold a place under the limit, and every
+// open one, since an uncounted lane still holds its port seat.
+async function lane_use(lanes?: ReadonlyArray<LaneInfo>): Promise<LaneUse> {
+	const open = lanes ?? (await lane_registry.list_lanes())
+	const occupied = await occupied_lanes(open)
+
+	return { occupied: occupied.length, seated: open.filter((lane) => !lane.is_stranded).length }
+}
+
+function free_of(limit: number, use: LaneUse): number {
+	return lane_capacity.free_lanes(limit, use.occupied, use.seated)
+}
+
+// Free lanes beside `lanes`, `undefined` where the limit could not be read: the count `lane:limit`
+// prints, and the one `run:board` draws, so the two never answer apart.
+async function free_lanes_beside(lanes: ReadonlyArray<LaneInfo>): Promise<number | undefined> {
+	const limit = await lane_capacity.lane_limit()
+
+	if (limit.kind !== 'limit') return undefined
+
+	return free_of(limit.limit, await lane_use(lanes))
 }
 
 async function free_under(limit: number): Promise<number> {
-	return lane_capacity.free_lanes(limit, await live_lane_count())
+	return free_of(limit, await lane_use())
 }
 
 // Free lanes right now: the limit less the live lanes. An unreadable limit reads as no free lane — the
@@ -38,15 +83,12 @@ async function free_under(limit: number): Promise<number> {
 //
 // **Occupancy is the local worktree count, not the dispatch budget's busy read.** `epic-lane-offer`
 // measures occupancy with `epic_busy.occupied_lanes`, a network read of in-progress issue labels; this
-// counts live worktrees instead, deliberately — it runs on the cheap-first path where the costly read
-// (`backlog:next`) is gated behind a free lane, so a network read here would defeat that design. The
-// two can diverge, but only toward over-counting live lanes → fewer free lanes, the safe direction.
+// counts the worktrees that hold a place instead (`backlog-occupied.ts`), deliberately — it runs on the
+// cheap-first path where the costly read (`backlog:next`) is gated behind a free lane, so a network
+// read here would defeat that design. The two can diverge, but only toward over-counting live lanes →
+// fewer free lanes, the safe direction.
 async function free_lane_count(): Promise<number> {
-	const limit = await lane_capacity.lane_limit()
-
-	if (limit.kind !== 'limit') return NO_FREE
-
-	return await free_under(limit.limit)
+	return (await free_lanes_beside(await lane_registry.list_lanes())) ?? NO_FREE
 }
 
 // **The drive's count throws on an unreadable limit**. The drive launches no
@@ -165,7 +207,9 @@ const backlog_ready = {
 	read_backlog_next,
 	print_offer_hint,
 	free_lane_count,
-	live_lane_count,
+	free_lanes_beside,
+	lane_use,
+	occupied_lanes,
 	drive_free_lane_count,
 	drains_pool,
 	print_ready_line,
@@ -175,4 +219,4 @@ const backlog_ready = {
 }
 
 export { backlog_ready }
-export type { ReadyPorts, ReadyReading }
+export type { LaneUse, ReadyPorts, ReadyReading }

package/scripts/behavior/behavior-rules.ts

@@ -53,8 +53,9 @@ const INDEX_ASSERTION_NAME = 'no-direct-git-index-mutation'
 // a tool result, or a call to any tool but `Bash`. Read through `json_value.is_record` so a malformed
 // input is treated as absent rather than throwing mid-scan.
 function command_of(block: Block): string | undefined {
-	if (block.type !== TOOL_USE || block.name !== BASH_TOOL) return undefined
-	if (!json_value.is_record(block.input)) return undefined
+	if (block.type !== TOOL_USE || block.name !== BASH_TOOL || !json_value.is_record(block.input)) {
+		return undefined
+	}
 
 	const command = block.input[COMMAND_KEY]
 

package/scripts/cost-runtime/codex-usage.ts

@@ -56,8 +56,10 @@ function measurement_from(
 		return parsed.success ? [parsed.data.payload.info] : []
 	})
 	const session = metadata.find((entry) => entry.payload.id === thread_id)
-	if (session === undefined || usages.length === 0) return undefined
-	if (!same_project(session.payload.cwd, target)) return undefined
+
+	if (session === undefined || usages.length === 0 || !same_project(session.payload.cwd, target)) {
+		return undefined
+	}
 
 	return { billed_input_per_request: billed_per_request(usages) }
 }

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

@@ -56,8 +56,7 @@ interface RunContext {
 // `--over=` does not arrive as "hand off after any request" and stop an unattended run after its
 // first child.
 function to_threshold(raw: string | undefined): number | undefined {
-	if (raw === undefined) return undefined
-	if (raw.trim() === '') return undefined
+	if (raw === undefined || raw.trim() === '') return undefined
 
 	const parsed = Number(raw)
 

package/scripts/delegation/duplicate-read-guard.ts

@@ -176,8 +176,8 @@ function is_candidate(call: GuardedCall): boolean {
 }
 
 // A refusable call is refused only where the mode is `refuse`. A lane child is `notice`, so it reaches
-// here and is withheld the refusal — the notice branch carries the guidance instead, because a refusal
-// ends a headless child's turn.
+// here and is withheld the refusal — the notice branch carries the guidance instead, for the reason its
+// `because` in `lane-guard-policy.ts` records.
 function should_block_here(tail: string, call: GuardedCall, refused_at_ms: number): boolean {
 	if (duplicate_mode() !== 'refuse') return false
 

package/scripts/delegation/investigation-guard.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env tsx
 import { text } from 'node:stream/consumers'
 import { fileURLToPath } from 'node:url'
+import { agent_session_role } from '#scripts/agent/agent-session-role'
 import { hook_decision, type GuardRun } from '#scripts/josh/hook-decision'
-import { lane_guard_policy, type LaneGuardMode } from '#scripts/lane/lane-guard-policy'
+import { lane_guard_policy } from '#scripts/lane/lane-guard-policy'
 import type { GuardedCall } from '#scripts/time-runtime/time-batch-guard'
 import { investigation_reads } from './investigation-reads'
 
@@ -21,91 +22,42 @@ import { investigation_reads } from './investigation-reads'
 // file — debugging the guard itself, or a session whose reading really is all edit targets.
 const SWITCH_ENV_KEY = 'JOSH_INVESTIGATION_GUARD'
 
-// This guard's refusal record, and the notice's own record — distinct so a lane-child notice never
-// spends the refusal's stamp, the same split the batching guard keeps.
 const STAMP_PREFIX = 'josh-investigation-guard-'
-const NOTICE_STAMP_PREFIX = 'josh-investigation-guard-notice-'
 
-// **How the guard behaves for the session in hand, decided from the one-place enumeration**.
-// Outside a lane child the mode is `refuse` and the
-// guard refuses; in a dispatched lane child it is `notice`, because a lane child does read unedited
-// files and can dispatch sub-agents, so the reading is there to send out. The enumeration reads `JOSH_LANE_CHILD` against this checkout's own
-// issue only for a guard whose mode it would change, so a person working in a lane sees the guard
-// unchanged. It wraps `investigation_reads.should_block` here rather than inside it so the pure counting
-// rule stays free of process state and its own suite keeps testing it directly.
-function investigation_mode(): LaneGuardMode {
-	return lane_guard_policy.mode_here('investigation')
-}
-
-// A refusable call is refused only where the mode is `refuse` — the main line. A lane child is
-// `notice`, so it reaches the notice branch and is withheld the refusal that would end its headless
-// turn; an `off` some future enumeration sets stays silent here too.
+// **How the guard behaves for the session in hand, decided from the one-place enumeration**. It is
+// `refuse` in a dispatched lane child too (joshuafolkken/kit#3927): a hook denial returns to the model
+// as guidance, and the notice it replaced was measured not to move the reading. It wraps
+// `investigation_reads.should_block` here rather than inside it so the pure counting rule stays free of
+// process state and its own suite keeps testing it directly. A reviewer session stands down: reading
+// the diff's files is its whole task, and it carries the lane's marker, so it would otherwise be refused
+// like the child it reviews — the stand-down `implementation-cut.ts` takes for the same session.
 function should_block(
 	tail: string,
 	call: GuardedCall,
 	refused_at_ms: number,
 	run?: GuardRun,
 ): boolean {
-	if (investigation_mode() !== 'refuse') return false
+	if (
+		agent_session_role.is_reviewer() ||
+		lane_guard_policy.mode_here('investigation') !== 'refuse'
+	) {
+		return false
+	}
 
 	return investigation_reads.should_block(tail, call, refused_at_ms, run)
 }
 
-// The lane-child notice: the same threshold, delivered without a `permissionDecision`. It
-// reads the notify stamp's own record, so a notice never spends the refusal's stamp and re-arms on the
-// next accumulation exactly as the refusal does.
-function should_notify(
-	tail: string,
-	call: GuardedCall,
-	notified_at_ms: number,
-	run?: GuardRun,
-): boolean {
-	if (investigation_mode() !== 'notice') return false
-
-	return investigation_reads.should_block(tail, call, notified_at_ms, run)
-}
-
-// **The lane-child counterpart of REASON, delivered as a notice rather than a refusal**.
-// A dispatched lane child ends its turn on a denial, so
-// the same guidance is carried without a `permissionDecision`: the read proceeds and the child is nudged
-// to delegate rather than killed. It carries no ⛔, so a person watching reads it as advice.
-const NOTICE = `💡 investigation: files read and not edited, or search turns, since the last delegated unit reached the threshold, so the reading from here should go to a unit of its own. This is a notice, not a refusal — the read proceeds, because a dispatched lane child ends its turn on a denial. Ask \`pnpm josh delegate investigation\`, then dispatch the \`${investigation_reads.INVESTIGATOR_AGENT}\` agent (\`kit:${investigation_reads.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. This recurs on the next accumulation.`
-
-// The notice as it reaches the model: the base guidance with the concrete unedited reads named, so a
-// lane child is shown *which* reads to send to a unit rather than only told to delegate. An empty
-// set names nothing and the notice falls back to its guidance alone. The call is part of the notify
-// contract but this guard's wording depends on the tail alone.
-function notice_text(_call: GuardedCall, tail: string): string {
-	const pending = investigation_reads
-		.tally_of(tail)
-		.pending.map((absolute) => investigation_reads.repository_relative(absolute))
-
-	return pending.length === 0
-		? NOTICE
-		: `${NOTICE} Read and not edited so far: ${pending.join(' ')}.`
-}
-
 const GUARD = hook_decision.create_transcript_guard({
 	prefix: STAMP_PREFIX,
 	switch_key: SWITCH_ENV_KEY,
 	is_candidate: investigation_reads.is_refusable_call,
 	should_block,
 	reason: investigation_reads.REASON,
-	// The lane-child notice fires where the refusal is withheld, on a record of its own so it
-	// never spends the refusal's stamp.
-	notify: {
-		prefix: NOTICE_STAMP_PREFIX,
-		should_notify,
-		text: notice_text,
-	},
 })
 
 const investigation_refusal = GUARD.refusal
 const investigation_outcome = GUARD.outcome
 const { is_enabled, refusal_path } = GUARD
-// The notice's stamp path, exposed the way `refusal_path` is so a test can clean it apart from the
-// refusal's record.
-const investigation_notice_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREFIX).path
 const { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
@@ -115,13 +67,11 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 
 export {
 	deny_envelope,
-	investigation_notice_path,
 	investigation_outcome,
 	investigation_refusal,
 	is_enabled,
 	load_environment_file,
 	refusal_path,
 	DISABLED_VALUES,
-	NOTICE,
 	SWITCH_ENV_KEY,
 }

package/scripts/delegation/investigation-reads.ts

@@ -42,7 +42,7 @@ const SEARCH_LABELS: ReadonlySet<string> = new Set(
 const INVESTIGATOR_AGENT = 'investigator'
 
 // The deny reason is the only text that reaches the model, so it names the count, command and return shape.
-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".`
+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. Run \`pnpm josh delegate investigation\`, then dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer); it returns \`file:line\` citations, never the file text. Keep main-line reads to files you will edit; every read-only search turn counts. \`.claude/skills/workflow-commands/delegation.md\``
 
 interface ReadTally {
 	// The files read and not since edited, resolved.
@@ -362,7 +362,6 @@ const investigation_reads = {
 	is_session_artifact,
 	is_subject_file,
 	projected_count,
-	repository_relative,
 	resolved,
 	should_block,
 	tally_of,

package/scripts/discovery/repo-discovery.ts

@@ -138,8 +138,10 @@ function resolve_current_owner(repository_path: string): string | undefined {
 // all — the very failure this function exists to close, moved somewhere else.
 function main_worktree(repository_path: string): string {
 	const git_directory = resolve_git_directory(repository_path)
-	if (git_directory === undefined) return repository_path
-	if (path.basename(git_directory) !== GIT_DIRECTORY) return repository_path
+
+	if (git_directory === undefined || path.basename(git_directory) !== GIT_DIRECTORY) {
+		return repository_path
+	}
 
 	return path.dirname(git_directory)
 }

package/scripts/discovery/repo-origin.ts

@@ -68,8 +68,7 @@ function parse_scp_like(url: string): RepoIdentity | undefined {
 	const user_end = url.indexOf(USER_SEPARATOR)
 	const authority = user_end === NOT_FOUND ? url : url.slice(user_end + 1)
 	const host_end = authority.indexOf(HOST_SEPARATOR)
-	if (host_end === NOT_FOUND) return undefined
-	if (!is_github_ssh_host(authority.slice(0, host_end))) return undefined
+	if (host_end === NOT_FOUND || !is_github_ssh_host(authority.slice(0, host_end))) return undefined
 
 	return to_identity(authority.slice(host_end + 1))
 }
@@ -115,8 +114,7 @@ function origin_section_lines(lines: ReadonlyArray<string>): Array<string> {
 // the first separator rather than matched, for the reason `parse_scp_like` is split by hand.
 function url_value(line: string): string | undefined {
 	const separator = line.indexOf('=')
-	if (separator === NOT_FOUND) return undefined
-	if (line.slice(0, separator).trim() !== URL_KEY) return undefined
+	if (separator === NOT_FOUND || line.slice(0, separator).trim() !== URL_KEY) return undefined
 
 	return line.slice(separator + 1).trim()
 }

package/scripts/doctor/doctor-logic.ts

@@ -69,9 +69,12 @@ function decide_reclaim(
 	global_josh: string | undefined,
 	shim_content: string,
 ): ReclaimDecision {
-	if (!is_shadowed(path_josh, global_josh)) return { action: 'none', reason: NO_SHADOW_REASON }
-	// is_shadowed already guarantees path_josh is defined; this narrows the type for the return.
-	if (path_josh === undefined) return { action: 'none', reason: NO_SHADOW_REASON }
+	// is_shadowed already implies path_josh is defined; the undefined check narrows the type for the
+	// return.
+	if (path_josh === undefined || !is_shadowed(path_josh, global_josh)) {
+		return { action: 'none', reason: NO_SHADOW_REASON }
+	}
+
 	if (!is_kit_shim(shim_content)) return { action: 'none', reason: NOT_KIT_SHIM_REASON }
 
 	return { action: 'remove', target: path_josh, reason: RECLAIM_REASON }

package/scripts/document/document-byte-budget.ts

@@ -57,52 +57,53 @@ function block_ceiling(size: number): number {
 // a stale entry (a file that no longer exists or that an entry now reads) and on an un-budgeted
 // unreached file, so the definition cannot rot as documents move on or off the execution path.
 const DOCUMENT_BYTE_BUDGET: ReadonlyArray<DocumentBudget> = [
-	{ path: '.claude/skills/dependency-update/SKILL.md', bytes: 8192 },
-	{ path: '.claude/skills/epic-commands/SKILL.md', bytes: 16_384 },
-	{ path: '.claude/skills/epic-commands/epic-bundle.md', bytes: 8192 },
-	{ path: '.claude/skills/epic-commands/execution-waves.md', bytes: 8192 },
-	{ path: '.claude/skills/verify-ui/SKILL.md', bytes: 8192 },
+	{ path: '.claude/skills/dependency-update/SKILL.md', bytes: 4096 },
+	{ path: '.claude/skills/epic-commands/SKILL.md', bytes: 12_288 },
+	{ path: '.claude/skills/epic-commands/epic-bundle.md', bytes: 4096 },
+	{ path: '.claude/skills/epic-commands/execution-waves.md', bytes: 4096 },
+	{ path: '.claude/skills/verify-ui/SKILL.md', bytes: 4096 },
 	{ path: '.claude/skills/workflow-commands/backlogrun-handoff-report.md', bytes: 4096 },
 	{ path: '.claude/skills/workflow-commands/fullrun-steps.md', bytes: 8192 },
 	{ path: '.claude/skills/workflow-commands/into-target.md', bytes: 4096 },
 	{ path: '.claude/skills/workflow-commands/issue-comments.md', bytes: 8192 },
 	{ path: '.claude/skills/workflow-commands/issue-fold-existing.md', bytes: 4096 },
 	{ path: '.claude/skills/workflow-commands/needs-human-review.md', bytes: 4096 },
-	{ path: '.claude/skills/workflow-commands/observation-filing.md', bytes: 12_288 },
-	{ path: '.claude/skills/workflow-commands/observation-ledger.md', bytes: 12_288 },
+	{ path: '.claude/skills/workflow-commands/observation-filing.md', bytes: 8192 },
+	{ path: '.claude/skills/workflow-commands/observation-ledger.md', bytes: 8192 },
 	{ path: '.claude/skills/workflow-commands/prerequisite.md', bytes: 8192 },
 	{ path: '.claude/skills/workflow-commands/target-repository.md', bytes: 4096 },
 	{ path: '.claude/skills/workflow-commands/working-tree-hold.md', bytes: 8192 },
-	{ path: 'docs/josh-commands-automation.md', bytes: 53_248 },
-	{ path: 'docs/josh-commands-run.md', bytes: 77_824 },
-	{ path: 'docs/josh-commands-backlog.md', bytes: 61_440 },
-	{ path: 'docs/josh-commands.md', bytes: 57_344 },
+	{ path: 'docs/josh-commands-automation.md', bytes: 49_152 },
+	{ path: 'docs/josh-commands-run.md', bytes: 65_536 },
+	{ path: 'docs/josh-commands-backlog.md', bytes: 53_248 },
+	{ path: 'docs/josh-commands.md', bytes: 49_152 },
 	{ path: 'docs/labels-and-run-states.md', bytes: 8192 },
-	{ path: 'prompts/coding-standards.md', bytes: 8192 },
-	{ path: 'prompts/collaboration-workflow.md', bytes: 8192 },
-	{ path: 'prompts/collaboration-workflow/file-edits.md', bytes: 12_288 },
-	{ path: 'prompts/collaboration-workflow/gh-rest.md', bytes: 8192 },
+	{ path: 'prompts/coding-standards.md', bytes: 4096 },
+	{ path: 'prompts/collaboration-workflow.md', bytes: 4096 },
+	{ path: 'prompts/collaboration-workflow/file-edits.md', bytes: 4096 },
+	{ path: 'prompts/collaboration-workflow/gh-rest.md', bytes: 4096 },
 	{ path: 'prompts/collaboration-workflow/glossary.md', bytes: 4096 },
 	{ path: 'prompts/collaboration-workflow/issue-citation.md', bytes: 4096 },
-	{ path: 'prompts/collaboration-workflow/issue-template.md', bytes: 12_288 },
-	{ path: 'prompts/collaboration-workflow/operating-rules.md', bytes: 12_288 },
+	{ path: 'prompts/collaboration-workflow/issue-template.md', bytes: 8192 },
+	{ path: 'prompts/collaboration-workflow/lane-instructions.md', bytes: 4096 },
+	{ path: 'prompts/collaboration-workflow/operating-rules.md', bytes: 8192 },
 	{ path: 'prompts/collaboration-workflow/output-bounds.md', bytes: 4096 },
 	{ path: 'prompts/collaboration-workflow/overview.md', bytes: 4096 },
-	{ path: 'prompts/collaboration-workflow/plan-comment.md', bytes: 8192 },
-	{ path: 'prompts/collaboration-workflow/principles.md', bytes: 16_384 },
+	{ path: 'prompts/collaboration-workflow/plan-comment.md', bytes: 4096 },
+	{ path: 'prompts/collaboration-workflow/principles.md', bytes: 12_288 },
 	{ path: 'prompts/collaboration-workflow/proposal-request.md', bytes: 4096 },
-	{ path: 'prompts/collaboration-workflow/report-format.md', bytes: 16_384 },
+	{ path: 'prompts/collaboration-workflow/report-format.md', bytes: 12_288 },
 	{ path: 'prompts/collaboration-workflow/residency.md', bytes: 8192 },
 	{ path: 'prompts/collaboration-workflow/rule-delivery.md', bytes: 4096 },
-	{ path: 'prompts/collaboration-workflow/shell-body.md', bytes: 8192 },
-	{ path: 'prompts/collaboration-workflow/turn-batching.md', bytes: 8192 },
-	{ path: 'prompts/collaboration-workflow/upstream-interrupt.md', bytes: 12_288 },
-	{ path: 'prompts/collaboration-workflow/wip-cap.md', bytes: 12_288 },
+	{ path: 'prompts/collaboration-workflow/shell-body.md', bytes: 4096 },
+	{ path: 'prompts/collaboration-workflow/turn-batching.md', bytes: 4096 },
+	{ path: 'prompts/collaboration-workflow/upstream-interrupt.md', bytes: 8192 },
+	{ path: 'prompts/collaboration-workflow/wip-cap.md', bytes: 8192 },
 	{ path: 'prompts/refactoring.md', bytes: 8192 },
-	{ path: 'prompts/review-rubric.md', bytes: 16_384 },
-	{ path: 'prompts/review.md', bytes: 16_384 },
+	{ path: 'prompts/review-rubric.md', bytes: 12_288 },
+	{ path: 'prompts/review.md', bytes: 12_288 },
 	{ path: 'prompts/sonar-hotspot-handling.md', bytes: 8192 },
-	{ path: 'prompts/testing-guide.md', bytes: 16_384 },
+	{ path: 'prompts/testing-guide.md', bytes: 12_288 },
 ]
 
 // The recorded ceiling for one path, or undefined when it carries no budget entry.

package/scripts/document/document-byte-check.ts

@@ -26,8 +26,7 @@ function ceiling_message(
 	current_bytes: number,
 	recorded_bytes: number | undefined,
 ): string | undefined {
-	if (recorded_bytes === undefined) return undefined
-	if (current_bytes <= recorded_bytes) return undefined
+	if (recorded_bytes === undefined || current_bytes <= recorded_bytes) return undefined
 
 	return document_byte_budget.over_budget_message(relative_path, current_bytes, recorded_bytes)
 }

package/scripts/document/document-section-cli.ts

@@ -2,6 +2,7 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { find_package_directory } from '#scripts/josh/package-directory'
 import { capped_output } from './capped-print'
 import { document_section } from './document-section'
 import { entry_read_set } from './entry-read-set'
@@ -35,14 +36,25 @@ const USAGE = 'Usage: josh doc:section <file.md> "<heading>"'
 // directory, a bare name that happened to exist beside the caller would beat the document under
 // `root` and print a section of the wrong file — silently, which is the failure this command exists
 // to refuse.
-function resolve_document(name: string, root: string = process.cwd()): string {
-	const named = path.resolve(root, name)
+//
+// **The kit package is the fallback.** A consumer keeps no `prompts/` of its own — the package ships
+// it under `node_modules/@joshuafolkken/kit/` — so `prompts/review.md` resolves there when `root` has
+// no copy, exactly as `review:brief` resolves the rubric.
+const PACKAGE_DIRECTORY = find_package_directory(path.dirname(fileURLToPath(import.meta.url)))
 
-	if (existsSync(named)) return named
+function candidates_under(directory: string, name: string): Array<string> {
+	return [path.resolve(directory, name), entry_read_set.document_path(directory, name)]
+}
 
-	const in_skill = entry_read_set.document_path(root, name)
+function resolve_document(
+	name: string,
+	root: string = process.cwd(),
+	package_directory: string = PACKAGE_DIRECTORY,
+): string {
+	const named = path.resolve(root, name)
+	const candidates = [...candidates_under(root, name), ...candidates_under(package_directory, name)]
 
-	return existsSync(in_skill) ? in_skill : named
+	return candidates.find((candidate) => existsSync(candidate)) ?? named
 }
 
 function report_missing(markdown: string, heading: string): number {

package/scripts/document/entry-read-budget.ts

@@ -47,9 +47,9 @@ const ENTRY_READ_BUDGET: ReadonlyArray<EntryBudget> = [
 	{ entry: 'kickoff', bytes: 36_864 },
 	{ entry: 'fullrun', bytes: 53_248 },
 	{ entry: 'halfrun', bytes: 49_152 },
-	{ entry: 'prrun', bytes: 57_344 },
-	{ entry: 'backlogrun', bytes: 90_112 },
-	{ entry: LANE_CHILD, bytes: 49_152 },
+	{ entry: 'prrun', bytes: 53_248 },
+	{ entry: 'backlogrun', bytes: 81_920 },
+	{ entry: LANE_CHILD, bytes: 45_056 },
 ]
 
 function byte_size(root: string, relative_path: string): number {

package/scripts/document/read-set-cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { lane_instructions } from '#scripts/agent/lane-instructions'
 import { backlogrun_parent_read_set } from './backlogrun-parent-read-set'
 import { entry_read_set, type ReadSetCost, type SectionCost } from './entry-read-set'
 import { lane_child_read_set } from './lane-child-read-set'
@@ -192,7 +193,9 @@ function total_lines(report: ReadSetCost, width: number): Array<string> {
 }
 
 function note_lines(report: ReadSetCost): Array<string> {
-	if (report.entry === lane_child_read_set.LANE_CHILD) return [...LANE_CHILD_NOTE, '']
+	if (report.entry === lane_child_read_set.LANE_CHILD) {
+		return [...LANE_CHILD_NOTE, lane_instructions.resident_line(), '']
+	}
 
 	if (report.entry === BACKLOGRUN) return [...BACKLOGRUN_PARENT_NOTE, '']
 

package/scripts/epic/epic-audit-orphans.ts

@@ -14,7 +14,6 @@ import { epic_parse } from './epic-parse'
 // the children the epic already names, while this one searches for issues the epic does *not* name.
 
 const SEARCH_LIMIT = 50
-const PARENT_MARKERS: ReadonlyArray<string> = ['親:', 'Parent:', '親：']
 // Named apart from `epic_audit_checks.ORPHAN_CHILD`: that check reports an orphan it found, this one
 // reports that the search for orphans was incomplete, and a reader has to be able to tell them apart.
 const ORPHAN_SEARCH = 'orphan search'
@@ -25,18 +24,15 @@ const CAPPED_BY_MATCHES = `The open-issue scan filled its ${String(SEARCH_LIMIT)
 
 const searched_issue_schema = z.object({ number: z.number(), body: z.string().nullable() })
 
-function has_parent_marker(line: string): boolean {
-	return PARENT_MARKERS.some((marker) => line.includes(marker))
-}
-
 // Whether an issue's body names this epic as its parent, in the shape the issue template uses.
 //
 // Both halves must be on the *same line*. An issue parented to a different epic routinely backlinks
 // this one elsewhere in its body, and matching the marker and the number independently reported
 // every such issue as an orphan.
 //
-// The number is read through the same reference parse the checks use, so a parent line (a PARENT_MARKERS
-// prefix) such as `owner/other#858` names that repository's epic and not this one's.
+// The number is read through the same reference parse the checks use, so a parent line (one
+// `epic_audit_logic.has_parent_marker` accepts) such as `owner/other#858` names that repository's
+// epic and not this one's.
 // The known set is this repository alone — a parent line names this epic or it names nothing here —
 // and it is passed rather than omitted so a repository whose own name contains a dot still recognizes
 // `joshuafolkken/site.com#858`.
@@ -49,7 +45,8 @@ function names_this_epic(line: string, epic_number: number, repo: string): boole
 function claims_parent(body: string | null, epic_number: number, repo: string): boolean {
 	return (body ?? '')
 		.split('\n')
-		.some((line) => has_parent_marker(line) && names_this_epic(line, epic_number, repo))
+		.filter((line) => epic_audit_logic.has_parent_marker(line))
+		.some((line) => names_this_epic(line, epic_number, repo))
 }
 
 // Why the scan stopped before the end of the open backlog, or that it did not. Both cutoffs hide the

package/scripts/epic/epic-audit-rationale.ts

@@ -68,9 +68,15 @@ function order_pairs(
 	return links.flatMap((link) => {
 		const blocker = find_child(children, { repo: epic_repo, number: link.blocker })
 		const blocked = find_child(children, { repo: epic_repo, number: link.blocked })
-		if (blocker === undefined || blocked === undefined) return []
 
-		if (!is_open_local(blocker, current_repo) || !is_open_local(blocked, current_repo)) return []
+		if (
+			blocker === undefined ||
+			blocked === undefined ||
+			!is_open_local(blocker, current_repo) ||
+			!is_open_local(blocked, current_repo)
+		) {
+			return []
+		}
 
 		// eslint-disable-next-line unicorn/no-unnecessary-array-flat-map -- one return type (sonarjs/function-return-type)
 		return [{ blocker, blocked }]