@joshuafolkken/kit 1.1784.0 → 1.2116.0

package/scripts/backlog/backlog-rank.ts

@@ -10,7 +10,8 @@ import { backlog_overlap, type Declared } from './backlog-overlap'
 // What the backlog offers, in the order it is decided: rank, then the
 // `run:solo` gate, then the cap. `backlog:next` and `backlog:plan --waves` both call `select`, so the
 // plan's first wave is what the run starts into an idle repository rather than an order the run never
-// takes.
+// takes. Only the cap's width differs: `backlog:next` prints `DISPLAY_LIMIT` rows, a wave holds the
+// lane limit (`limit`).
 //
 // **The cap comes last.** Applied while the standalone half is classified, before the gate, it would
 // cut a `run:solo` issue ranked sixth or lower before the gate could see it — and offer the issues
@@ -29,37 +30,51 @@ function everything_in(result: EpicNextResult): ReadonlyArray<EpicChild> {
 // The ranking is `epic_rank.rank`, shared with a named epic's lanes.
 const { rank } = epic_rank
 
-// This repository's candidates re-ranked inside the result, so `backlog:plan` prints the order the
-// offer is decided in.
-function rank_result(result: EpicNextResult, repo: string): EpicNextResult {
+// This repository's candidates put in `order` inside the result; another repository's are left as
+// they came.
+function reorder_repo(
+	result: EpicNextResult,
+	repo: string,
+	order: (children: ReadonlyArray<EpicChild>) => ReadonlyArray<EpicChild>,
+): EpicNextResult {
 	if (result.verdict !== 'run') return result
 
-	const pool = everything_in(result)
-
 	return {
 		...result,
 		candidates: result.candidates.map((bundle) =>
-			bundle.repo === repo ? { ...bundle, children: rank(bundle.children, pool) } : bundle,
+			bundle.repo === repo ? { ...bundle, children: order(bundle.children) } : bundle,
 		),
 	}
 }
 
+// The rank `select` starts from; `offer_order` adds the yielded-first step for `backlog:plan`.
+function rank_result(result: EpicNextResult, repo: string): EpicNextResult {
+	const pool = everything_in(result)
+
+	return reorder_repo(result, repo, (children) => rank(children, pool))
+}
+
 // The standalone rows past the cap, in offer order.
 function overflow_of(
 	offered: ReadonlyArray<EpicChild>,
 	standalone: ReadonlySet<string>,
+	limit: number,
 ): ReadonlySet<string> {
 	const keys = offered.map((child) => epic_graph.key_of(child)).filter((key) => standalone.has(key))
 
-	return new Set(keys.slice(git_next_issues.DISPLAY_LIMIT))
+	return new Set(keys.slice(limit))
 }
 
 function is_in(child: EpicChild, keys: ReadonlySet<string>): boolean {
 	return keys.has(epic_graph.key_of(child))
 }
 
-function cap(selection: SoloSelection, standalone: ReadonlySet<string>): SoloSelection {
-	const overflow = overflow_of(selection.offered, standalone)
+function cap(
+	selection: SoloSelection,
+	standalone: ReadonlySet<string>,
+	limit: number,
+): SoloSelection {
+	const overflow = overflow_of(selection.offered, standalone, limit)
 
 	if (overflow.size === 0) return selection
 
@@ -85,12 +100,40 @@ interface OfferInput {
 	declared?: Declared
 	// The issues' lane state records; a clash with a paused holder says so. Absent, none is named.
 	lanes?: LaneRecords
+	// The keys of the issues that gave their lane back (`lane-yield.ts`). Absent, none did.
+	yielded?: ReadonlySet<string>
+	// How many standalone rows the cap keeps. Absent, `DISPLAY_LIMIT` — what `backlog:next` prints.
+	limit?: number
+}
+
+// A yielded issue ahead of the rank: its lane was taken from it, so it takes the first free one
+// once its holder ends rather than queueing behind the pool (joshuafolkken/kit#5107). While the
+// holder runs, its kept plan still withholds it in the separation. It goes ahead of a `run:solo`
+// issue too: the solo gate sees it first.
+function yielded_first(
+	ranked: ReadonlyArray<EpicChild>,
+	yielded: ReadonlySet<string>,
+): Array<EpicChild> {
+	return [
+		...ranked.filter((child) => is_in(child, yielded)),
+		...ranked.filter((child) => !is_in(child, yielded)),
+	]
+}
+
+// A ranked result in the order `select` walks it — a yielded issue ahead of the rank — so
+// `backlog:plan`'s "Ready now" reads in the order each wave is offered in (joshuafolkken/kit#5299).
+function offer_order(
+	result: EpicNextResult,
+	repo: string,
+	yielded: ReadonlySet<string> = new Set(),
+): EpicNextResult {
+	return reorder_repo(result, repo, (children) => yielded_first(children, yielded))
 }
 
 // The overlap separation runs before the cap, for the reason the gate does: the cap only ever
 // removes what would otherwise be offered.
 function select(input: OfferInput): SoloSelection {
-	const ranked = rank(input.candidates, input.pool)
+	const ranked = yielded_first(rank(input.candidates, input.pool), input.yielded ?? new Set())
 	const { read, repo, lanes } = input
 	const gated = epic_solo.select(ranked, read, repo)
 	const separated = backlog_overlap.separate(gated, input.declared ?? new Map(), {
@@ -99,13 +142,17 @@ function select(input: OfferInput): SoloSelection {
 		lanes,
 	})
 
-	return cap(separated, input.standalone)
+	return cap(separated, input.standalone, input.limit ?? git_next_issues.DISPLAY_LIMIT)
 }
 
 interface GateScope {
 	standalone: ReadonlySet<string>
 	declared: Declared
 	lanes?: LaneRecords
+	yielded?: ReadonlySet<string>
+	// How many standalone rows a planned wave holds — the lane limit; `backlog:next`'s offer ignores
+	// it. Absent, a wave is not capped (joshuafolkken/kit#5300).
+	wave_limit?: number | undefined
 }
 
 // `backlog:next`'s gate: `epic_solo.gate` with this selection in place of its bare one.
@@ -117,7 +164,7 @@ function gate(result: EpicNextResult, read: BusyRead, repo: string, scope: GateS
 	)
 }
 
-const backlog_rank = { everything_in, gate, rank_result, select }
+const backlog_rank = { everything_in, gate, offer_order, rank_result, select }
 
 export { backlog_rank }
 export type { GateScope, OfferInput }

package/scripts/backlog/backlog-stalled-detect.ts

@@ -1,4 +1,5 @@
 import { lane_ledger, type LedgerEntry } from '#scripts/lane/lane-ledger'
+import { lane_ledger_write } from '#scripts/lane/lane-ledger-write'
 import { run_event_stream, type RunEvent } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { backlog_ready, type ReadyPorts } from './backlog-ready'
@@ -78,7 +79,7 @@ async function read_real_ledger(): Promise<ReadonlyArray<LedgerEntry>> {
 }
 
 async function real_mark_offerable(is_offerable: boolean): Promise<void> {
-	await lane_ledger.record_offerable(is_offerable)
+	await lane_ledger_write.record_offerable(is_offerable)
 }
 
 function ports_over(ready: ReadyPorts): DetectPorts {

package/scripts/backlog/backlog-waves.ts

@@ -24,7 +24,7 @@ import { backlog_rank, type GateScope } from './backlog-rank'
 // **No rule is written twice.** The first wave is `backlog_rank.select` — rank, `run:solo` gate,
 // overlap 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. Each later wave marks the earlier waves closed and re-classifies the same pool
+// `backlog:next` prints when nothing is running, cut at the lane limit rather than the printed count. 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
 // time — `epic_cross_repo.resolve_cross_repo`, so a blocker in another repository still waits for its
 // release rather than counting as done on close — then puts the runnable set through
@@ -33,9 +33,13 @@ import { backlog_rank, type GateScope } from './backlog-rank'
 const IDLE: BusyRead = { kind: 'idle' }
 const CLOSED = 'CLOSED'
 const EMPTY_SCOPE: GateScope = { standalone: new Set(), declared: new Map() }
+// A wave is as wide as the lanes that run it, not `backlog:next`'s `DISPLAY_LIMIT` — that printed
+// count pushed an issue whose blocker closed in wave k past wave k+1 (joshuafolkken/kit#5300).
+const UNCAPPED = Infinity
 
 const HEADING_ASSUMPTION =
 	'Assumes every issue in a wave merges before the next wave starts. Issues a run already has are left out and count as merged first, and only issues of this repository are planned.'
+const UNCAPPED_WIDTH = 'A wave is not capped: the lane limit could not be read.'
 const UNREACHED_HEADING = 'Not reached — each names what it is waiting on:'
 const PARALLEL_NOTE = '(parallel)'
 const NEEDS_DECISION_NOTE = `waiting on a person (\`${NEEDS_DECISION_LABEL}\`)`
@@ -84,8 +88,10 @@ function offer(
 	pool: WavePool,
 ): ReadonlyArray<EpicChild> {
 	const { repo, scope } = pool
+	const limit = scope.wave_limit ?? UNCAPPED
 
-	return backlog_rank.select({ candidates, pool: children, read: IDLE, repo, ...scope }).offered
+	return backlog_rank.select({ candidates, pool: children, read: IDLE, repo, ...scope, limit })
+		.offered
 }
 
 // Ranked against the whole result, exactly as `backlog:next` ranks it, so the two agree.
@@ -175,6 +181,12 @@ function unreached_lines(plan: WavePlan, context: PlanContext): Array<string> {
 	)
 }
 
+function width_line(wave_limit: number | undefined): string {
+	if (wave_limit === undefined) return UNCAPPED_WIDTH
+
+	return `A wave holds at most ${String(wave_limit)} standalone issues, the lane limit; an epic's children are not counted.`
+}
+
 function format_waves(
 	result: EpicNextResult,
 	context: PlanContext,
@@ -188,6 +200,7 @@ function format_waves(
 	return [
 		`Backlog waves — ${context.repo}`,
 		HEADING_ASSUMPTION,
+		width_line(scope.wave_limit),
 		'',
 		...(waves.length === 0 ? [backlog_plan.NOTHING] : waves),
 		'',
@@ -200,9 +213,11 @@ const backlog_waves = {
 	NEEDS_DECISION_NOTE,
 	PARALLEL_NOTE,
 	run_stalled_note,
+	UNCAPPED_WIDTH,
 	UNREACHED_HEADING,
 	build,
 	format_waves,
+	width_line,
 }
 
 export { backlog_waves }

package/scripts/backlog/backlogrun-launch.ts

@@ -6,6 +6,7 @@ import {
 	type AgentProvider,
 } from '#scripts/agent/agent-role-profile'
 import { agent_session_environment } from '#scripts/josh/agent-session-environment'
+import { durable_state } from '#scripts/josh/durable-state'
 import { process_identity } from '#scripts/josh/process-identity'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { json_value } from '#scripts/lib/json-value'
@@ -27,8 +28,8 @@ import { z } from 'zod'
 // session can still start a Codex parent. The same choice is handed to the parent as
 // `JOSH_AGENT_PROVIDER`, the key a detached child with no session of its own resolves from.
 
-const LAUNCH_PREFIX = 'josh-backlogrun-launch-'
-const LOG_PREFIX = 'josh-backlogrun-log-'
+const LAUNCH_PREFIX = durable_state.PREFIX.BACKLOGRUN_LAUNCH
+const LOG_PREFIX = durable_state.PREFIX.BACKLOGRUN_LOG
 const LOG_SUFFIX = '.log'
 
 const launch_schema = z.object({
@@ -64,11 +65,11 @@ interface Launched {
 type StartResult = { kind: 'launched'; launched: Launched } | { kind: 'failed'; note: string }
 
 function launch_path(git_directory: string): string {
-	return stamp_file.stamp_path(LAUNCH_PREFIX, git_directory)
+	return durable_state.path(LAUNCH_PREFIX, git_directory)
 }
 
 function log_path(git_directory: string): string {
-	return stamp_file.stamp_path(LOG_PREFIX, git_directory, LOG_SUFFIX)
+	return durable_state.path(LOG_PREFIX, git_directory, LOG_SUFFIX)
 }
 
 function read_launch(target: string): LaunchRecord | undefined {
@@ -248,6 +249,8 @@ const backlogrun_launch = {
 	argv_of,
 	chosen_environment,
 	is_running,
+	launch_path,
+	log_path,
 	pending_launch,
 	running_parent,
 	start,

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

@@ -19,55 +19,57 @@ import { cost_pricing } from './cost-pricing'
 const POST_CUT_CONTEXT = 60_000
 
 // The requests a resumed session is expected to still run — the horizon the break-even is measured
-// against. A cut only pays if enough requests remain to recoup the preamble rewrite; even the shortest
-// resume (into the gate, commit, PR and merge) runs on the order of ten. Ten is the conservative
-// horizon: it keeps the shared threshold near the empirically validated 150_000 (this lands at
-// 135_000, inside the simulated 100k–200k band) while pricing the decision from the cost model. It is the knob a before/after lane measurement tunes.
-const EXPECTED_REMAINING_REQUESTS = 10
+// against. A cut only pays if enough requests remain to recoup the preamble rewrite. Measured, not
+// chosen: the lane children resumed after a cut over the 14 days to 2026-10-28 ran a median of 23
+// requests per resumed session (748 sessions; p25 11, p90 68 — #5341). The median, not the mean, so a
+// few long resumes do not pull every cut earlier.
+const EXPECTED_REMAINING_REQUESTS = 23
 
 // The price of a dropped token relative to a rewritten one, from `cost-pricing.ts`. A cache read bills
-// `DEFAULT_CACHE_READ_MULTIPLIER` of base input and a 5-minute cache write `CACHE_WRITE_5M_MULTIPLIER`,
-// so a preamble rewrite costs this many per-request cache reads. The base input rate is common to both
-// and cancels, which is why only the ratio appears.
-//
-// **The standard cache-read rate, deliberately, not the running model's.** Opus 5.5 reads cache at
-// 0.05x and Fable 5.1 at 0.025x, which would move the threshold from 135,000 to 210,000 and 360,000 —
-// outside the 100k–200k band the cut was validated in. That changes when a cut fires, a decision that
-// needs a lane measurement of its own rather than arriving as a side effect of a corrected price list.
-function write_over_read(): number {
-	return cost_pricing.CACHE_WRITE_5M_MULTIPLIER / cost_pricing.DEFAULT_CACHE_READ_MULTIPLIER
+// the running model's cache-read multiplier of base input and a 5-minute cache write
+// `CACHE_WRITE_5M_MULTIPLIER`, so a preamble rewrite costs this many per-request cache reads. The base
+// input rate is common to both and cancels, which is why only the ratio appears. A model that reads
+// cache cheaper (Opus 5.5 at 0.05x, Fable 5.1 at 0.025x) saves less per dropped token, so its cut
+// breaks even later; an unpriced model reads at the standard rate.
+function write_over_read(model: string | undefined): number {
+	return cost_pricing.CACHE_WRITE_5M_MULTIPLIER / cost_pricing.cache_read_multiplier_of(model)
 }
 
-// The current per-request context at which a cut breaks even over exactly `remaining` requests. The
-// shared cut threshold is this evaluated at `EXPECTED_REMAINING_REQUESTS`; rounded to an integer so the
+// The current per-request context at which a cut breaks even for `model` over exactly `remaining`
+// requests. The cut threshold `pnpm josh cost --cut` applies is this evaluated at
+// `EXPECTED_REMAINING_REQUESTS` for the session's newest request's model; rounded to an integer so the
 // `>` comparison against a per-request billed-input count has no floating-point seam.
-function break_even_context(remaining: number = EXPECTED_REMAINING_REQUESTS): number {
+function break_even_context(
+	model: string | undefined,
+	remaining: number = EXPECTED_REMAINING_REQUESTS,
+): number {
 	if (remaining <= 0) return Infinity
 
-	return Math.round(POST_CUT_CONTEXT * (1 + write_over_read() / remaining))
+	return Math.round(POST_CUT_CONTEXT * (1 + write_over_read(model) / remaining))
 }
 
 // The requests a cut must save over before it recoups its own preamble rewrite, at a given current
 // per-request context. Decreasing in context: the more a request currently pays, the fewer resumed
 // requests are needed to earn the cut back. Exposed as the diagnostic the break-even is read in —
-// `break_even_requests(current) < remaining` is the same decision as `pays_back`.
-function break_even_requests(current_context: number): number {
+// `break_even_requests(current, model) < remaining` is the same decision as `pays_back`.
+function break_even_requests(current_context: number, model: string | undefined): number {
 	const saved_per_request = current_context - POST_CUT_CONTEXT
 
 	if (saved_per_request <= 0) return Infinity
 
-	return (POST_CUT_CONTEXT * write_over_read()) / saved_per_request
+	return (POST_CUT_CONTEXT * write_over_read(model)) / saved_per_request
 }
 
 // Whether cutting now pays back: the current per-request context has grown past the break-even point
 // for the expected remaining requests. Compared against the rounded `break_even_context` with `>`, so
-// it agrees to the token with `cost_verdict.classify` reading the derived `CONTEXT_CUT_THRESHOLD` — the
-// same one decision, whether a caller holds the threshold or asks this function.
+// it agrees to the token with `cost_verdict.classify` reading the same threshold — the same one
+// decision, whether a caller holds the threshold or asks this function.
 function pays_back(
 	current_context: number,
+	model: string | undefined,
 	remaining: number = EXPECTED_REMAINING_REQUESTS,
 ): boolean {
-	return current_context > break_even_context(remaining)
+	return current_context > break_even_context(model, remaining)
 }
 
 const context_cut_payback = {

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

@@ -1,7 +1,7 @@
 import { agent_role_profile, type AgentProvider } from '#scripts/agent/agent-role-profile'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { codex_usage } from './codex-usage'
-import { CONTEXT_CUT_THRESHOLD } from './context-cut-threshold'
+import { context_cut_payback } from './context-cut-payback'
 import { cost_corpus } from './cost-corpus'
 import { cost_transcript, type SessionUsage } from './cost-transcript'
 import { cost_usage } from './cost-usage'
@@ -16,7 +16,7 @@ import { transcript_cwd } from './transcript-cwd'
 // (`--session` / `--issue` / `--all` / `--run` / `--json`) and the `--cap` counterfactual were
 // retired because no rule or decision read them — leaving only the entry judgment `fullrun` /
 // `backlogrun` / `halfrun` / `pre-gate-cut` ask, and the `josh time` run-timing report keeps the
-// hand-off aggregates used to compare the shared context-cut threshold.
+// hand-off aggregates used to compare the `--cut` break-even.
 
 const FAILURE_EXIT_CODE = 1
 const USAGE = 'Usage: josh cost (--cut | --over <tokens-per-request>) [--path <dir>]'
@@ -32,8 +32,14 @@ interface SessionFigures {
 	threshold: number
 }
 
+// `--cut` is not a number at parse time: its threshold is the break-even of the model the session's
+// newest request ran on, known only once the transcript is read.
+const CUT_LIMIT = 'cut'
+
+type Limit = number | typeof CUT_LIMIT
+
 interface Options {
-	over?: number
+	over?: Limit
 	// The target project whose transcripts to read, or absent for this process's own working
 	// directory. From the kit checkout, `--path <dir>` reads another
 	// project's cost.
@@ -49,7 +55,7 @@ interface RawValues {
 type Environment = Readonly<Record<string, string | undefined>>
 
 interface RunContext {
-	over: number
+	over: Limit
 	path: string | undefined
 	provider: AgentProvider
 }
@@ -72,10 +78,14 @@ function is_unparsed(raw: string | undefined, parsed: number | undefined): boole
 	return parsed === undefined && raw !== undefined
 }
 
-function selected_threshold(values: RawValues): number | undefined {
-	if (values.cut === true) return CONTEXT_CUT_THRESHOLD
+// The cut threshold of a measured session: the break-even for its newest request's model. With no
+// measurement it is the standard-rate break-even, the figure a report quotes beside no cost.
+function cut_threshold(measurement: OverMeasurement | undefined): number {
+	return context_cut_payback.break_even_context(measurement?.model)
+}
 
-	return to_threshold(values.over)
+function limit_of(limit: Limit, measurement: OverMeasurement): number {
+	return limit === CUT_LIMIT ? cut_threshold(measurement) : limit
 }
 
 function threshold_option(over: number | undefined): Pick<Options, 'over'> {
@@ -86,12 +96,17 @@ function path_option(path: string | undefined): Pick<Options, 'path'> {
 	return path === undefined ? {} : { path }
 }
 
+// `--cut` and `--over` name the same limit, so giving both is a refusal.
+function cut_options(values: RawValues): Options | undefined {
+	return values.over === undefined ? { over: CUT_LIMIT, ...path_option(values.path) } : undefined
+}
+
 // `exactOptionalPropertyTypes` rejects `{ over: undefined }`, so an absent flag contributes no key
 // at all rather than an undefined one.
 function to_options(values: RawValues): Options | undefined {
-	if (values.cut === true && values.over !== undefined) return undefined
+	if (values.cut === true) return cut_options(values)
 
-	const over = selected_threshold(values)
+	const over = to_threshold(values.over)
 
 	if (is_unparsed(values.over, over)) return undefined
 
@@ -147,6 +162,7 @@ function measurement_of(session: SessionUsage): OverMeasurement {
 		billed_input_per_request: session.records.map((record) =>
 			cost_usage.billed_input(record.totals),
 		),
+		model: session.records.at(-1)?.model,
 	}
 }
 
@@ -206,15 +222,20 @@ function measure(
 // missing message; `empty` → the whole-corpus missing message. A measured session that billed
 // nothing falls to `report_over`'s "no requests", which keeps a 0-request transcript distinct from a
 // transcript that is not there at all.
-function run_over_anthropic(own: OwnMeasurement, target: string, limit: number): number {
-	if (own.kind === 'measured') return cost_verdict.report_over(own.measurement, limit)
+function run_over_anthropic(own: OwnMeasurement, target: string, limit: Limit): number {
+	if (own.kind === 'measured') {
+		return cost_verdict.report_over(own.measurement, limit_of(limit, own.measurement))
+	}
 
 	return report_empty(target, own.kind === 'absent' ? own.session_id : undefined)
 }
 
-function run_over_codex(target: string, limit: number, environment: Environment): number {
+function run_over_codex(target: string, limit: Limit, environment: Environment): number {
 	const measurement = measure(target, 'openai', environment)
-	if (measurement !== undefined) return cost_verdict.report_over(measurement, limit)
+
+	if (measurement !== undefined) {
+		return cost_verdict.report_over(measurement, limit_of(limit, measurement))
+	}
 
 	console.error(`No Codex usage found for the current OpenAI thread under ${target}.`)
 
@@ -225,7 +246,7 @@ function run_over_codex(target: string, limit: number, environment: Environment)
 // alone — identified by id, not by mtime.
 function run_over(
 	target: string,
-	limit: number,
+	limit: Limit,
 	provider: AgentProvider,
 	environment: Environment,
 ): number {
@@ -243,7 +264,7 @@ function verdict_of(measurement: OverMeasurement | undefined): CostVerdict {
 		return UNMEASURABLE_VERDICT
 	}
 
-	return cost_verdict.classify(measurement, CONTEXT_CUT_THRESHOLD)
+	return cost_verdict.classify(measurement, cut_threshold(measurement))
 }
 
 // The verdict with the figures it was decided on — the newest request's billed input and the shared
@@ -254,7 +275,7 @@ function figures_of(measurement: OverMeasurement | undefined): SessionFigures {
 	const is_priced = measurement !== undefined && verdict !== UNMEASURABLE_VERDICT
 	const cost = is_priced ? cost_verdict.per_request_cost(measurement) : undefined
 
-	return { verdict, cost, threshold: CONTEXT_CUT_THRESHOLD }
+	return { verdict, cost, threshold: cut_threshold(measurement) }
 }
 
 // The `--cut` verdict and its figures as a value, printing nothing. `run:report --handoff` quotes the

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

@@ -111,6 +111,14 @@ function cache_read_multiplier(price: ModelPrice): number {
 	return price.cache_read_multiplier ?? DEFAULT_CACHE_READ_MULTIPLIER
 }
 
+// The cache-read multiplier a model bills, by id. A model with no price row — an unpriced id, or no
+// model at all — reads at the standard rate.
+function cache_read_multiplier_of(model: string | undefined): number {
+	const price = model === undefined ? undefined : resolve_price(model)
+
+	return price === undefined ? DEFAULT_CACHE_READ_MULTIPLIER : cache_read_multiplier(price)
+}
+
 function estimate_cost(totals: UsageTotals, price: ModelPrice): number {
 	const weighted_input =
 		totals.input_tokens +
@@ -225,6 +233,7 @@ const cost_pricing = {
 	DEFAULT_CACHE_READ_MULTIPLIER,
 	LONG_PROMPT_THRESHOLD,
 	resolve_price,
+	cache_read_multiplier_of,
 	estimate_cost,
 	estimate_composition,
 	cost_by_model,

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

@@ -9,9 +9,12 @@ const UNDER_VERDICT = 'under'
 
 // 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
-// — a sum could not answer what the session's current context costs.
+// — a sum could not answer what the session's current context costs. `model` is the newest request's
+// model, which prices the cut threshold (`context-cut-payback.ts`); a provider that records none
+// leaves it absent and is read at the standard cache rate.
 interface OverMeasurement {
 	billed_input_per_request: ReadonlyArray<number>
+	model?: string | undefined
 }
 
 // What a turn costs is decided by the accumulated preamble, not by what the turn does, so the

package/scripts/delegation/delegation-policy.ts

@@ -46,7 +46,7 @@ const INVESTIGATOR_AGENT = 'investigator'
 // them, so a run told the step up front is told the same step the refusal would name.
 const INVESTIGATION_LIMIT = `${String(INVESTIGATION_FILE_THRESHOLD)} files read and not edited, or ${String(INVESTIGATION_SEARCH_TURN_THRESHOLD)} search turns, since the last delegated unit`
 // Only the dispatch resets the count, so the step names no `josh delegate` call before it (#4345).
-const INVESTIGATION_STEP = `Dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer); it returns \`file:line\` citations, never the file text.`
+const INVESTIGATION_STEP = `Dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer) with \`run_in_background: false\`; it returns \`file:line\` citations, never the file text.`
 
 // The enumeration. Short on purpose: every entry had to name a verifier, and most candidates could
 // not (below).
@@ -75,7 +75,7 @@ const DELEGATABLE_STEPS: ReadonlyArray<DelegatableStep> = [
 		// chain at a small context, and the review round cap already composed the finding text, so what
 		// the unit is handed is mechanical: run the commands and act on their deterministic answers. This
 		// is not the batching guard's business — delegation only moves the chain to a cheaper context.
-		does: 'run the late-run follow-up filing chain in an isolated unit — issue:file (scout, lint, labels, epic:bundle), then epic --add — given the finding text the parent already composed, and return the new Issue number and the epic:bundle answer',
+		does: 'run the late-run follow-up filing chain in an isolated unit — issue:file (lint, labels, scout, epic:bundle), then epic --add — given the finding text the parent already composed, and return the new Issue number and the epic:bundle answer',
 		verifier:
 			"the parent reads the filed Issue from GitHub with `pnpm josh issue:state <new>`, not the unit's summary; a follow-up reported filed but not created is still absent, the way `epic-child`'s reported-done-but-not-merged child is still open. The finding text came from the parent and `issue:file`'s steps are deterministic, so the unit's work is the mechanical execution `issue:state` confirms",
 	},

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

@@ -210,6 +210,7 @@ const notice_refusal_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREF
 const { deny_envelope, DISABLED_VALUES } = hook_decision
 
 const duplicate_reads = {
+	is_successful_read,
 	REASON,
 	NOTICE,
 }

package/scripts/delegation/investigation-guard.ts

@@ -24,8 +24,9 @@ const STAMP_PREFIX = 'josh-investigation-guard-'
 // **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
+// `investigation_reads.should_block` here rather than inside it so the counting rule stays free of the
+// session's switch state and its own suite keeps testing it directly — its only process read is the
+// branch diff it asks before a refusal. 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(
@@ -56,6 +57,16 @@ const investigation_refusal = GUARD.refusal
 const investigation_outcome = GUARD.outcome
 const { is_enabled, refusal_path } = GUARD
 const { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision
+const STAMP = hook_decision.create_refusal_stamp(STAMP_PREFIX)
+
+// Whether this guard refuses the call in hand, asked with its real record — so the batching guard's
+// lane-child search refusal can stand aside for it: only one reason surfaces per call, and delegating
+// the reading supersedes batching it.
+function will_refuse(tail: string, call: GuardedCall, run: GuardRun): boolean {
+	if (!is_enabled() || !investigation_reads.is_refusable_call(call)) return false
+
+	return should_block(tail, call, STAMP.last_ms(STAMP.path(run.transcript)), run)
+}
 
 export {
 	deny_envelope,
@@ -64,6 +75,7 @@ export {
 	is_enabled,
 	load_environment_file,
 	refusal_path,
+	will_refuse,
 	DISABLED_VALUES,
 	SWITCH_ENV_KEY,
 }