@joshuafolkken/kit 1.3000.0 → 1.3044.0

package/scripts/lane/lane-dispatch-prepare.ts

@@ -0,0 +1,83 @@
+import { agent_argv, type AgentArgv, type AgentArgvResult } from '#scripts/agent/agent-argv'
+import {
+	agent_role_profile,
+	type AgentProfile,
+	type ProfileResult,
+} from '#scripts/agent/agent-role-profile'
+import { agent_worker_profile } from '#scripts/agent/agent-worker-profile'
+import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
+import { run_ending } from '#scripts/run/run-ending'
+import { lane_dispatch_log } from './lane-dispatch-log'
+import type { LaneInfo } from './lane-registry'
+import { lane_resume, type ResumePlan } from './lane-resume'
+
+type Prepared =
+	| {
+			kind: 'prepared'
+			invocation: string
+			argv: AgentArgv
+			profile: AgentProfile
+			resumed_from: string | undefined
+	  }
+	| { kind: 'rejected'; note: string }
+
+// Build the argv the plan calls for: a resume carries the stored session id, a fresh start does not.
+// Both run the same profile diagnostics under the already-resolved profile, so a resume is refused for
+// exactly the reasons a fresh dispatch is.
+function built_for(plan: ResumePlan, profile: AgentProfile, lane: LaneInfo): AgentArgvResult {
+	if (plan.kind === 'resume') {
+		return agent_argv.with_resume_in(plan.invocation, profile, plan.session_id, lane.directory)
+	}
+
+	return agent_argv.with_profile_in(plan.invocation, profile, lane.directory)
+}
+
+// **The worker profile the lane's Issue selects, where the repository opts into `josh.worker`**.
+// The Issue's `worker:<name>` label (else the configured default) wins over `JOSH_WORKER_MODEL` /
+// `JOSH_WORKER_EFFORT`; a repository without the setting resolves the worker from the environment as
+// before and never reads the labels. `record_output` keeps the chosen profile in the lane's `.env`,
+// which a cut relaunch resumes on.
+async function worker_profile(lane: LaneInfo): Promise<ProfileResult> {
+	const worker = await agent_worker_profile.resolve(
+		lane.directory,
+		async () => await git_gh_issue_write.read_label_names(lane.issue),
+	)
+
+	if (worker.kind === 'unset') return agent_role_profile.resolve(agent_role_profile.WORKER)
+
+	return worker.kind === 'rejected' ? worker : { kind: 'profile', profile: worker.worker.agent }
+}
+
+// **The re-dispatch decides resume-or-fresh from the lane's own exit record**.
+// The record is read from the log the previous dispatch of this lane wrote — a first dispatch finds
+// none and starts fresh, an `outage` ending with a session id resumes it. The provider is resolved
+// first because the resume mechanism is Claude Code's, and an OpenAI lane falls back to fresh. **A
+// fresh dispatch never reads the record**: a person restarting a child (`lane:restart`) wants a new
+// session that reads the Issue from the start, whatever the previous one ended on.
+async function prepared(lane: LaneInfo, is_fresh: boolean): Promise<Prepared> {
+	const resolved = await worker_profile(lane)
+
+	if (resolved.kind === 'rejected') return resolved
+
+	const record = is_fresh
+		? undefined
+		: run_ending.read_exit(lane_dispatch_log.default_log_path(lane))
+	const plan = lane_resume.plan(lane.issue, record, resolved.profile.provider)
+	const built = built_for(plan, resolved.profile, lane)
+
+	if (built.kind === 'rejected') return built
+	const resumed_from = plan.kind === 'resume' ? plan.session_id : undefined
+
+	return {
+		kind: 'prepared',
+		invocation: plan.invocation,
+		argv: built.argv,
+		profile: built.profile,
+		resumed_from,
+	}
+}
+
+const lane_dispatch_prepare = { prepared }
+
+export type { Prepared }
+export { lane_dispatch_prepare }

package/scripts/lane/lane-dispatch.ts

@@ -1,4 +1,4 @@
-import { agent_argv, type AgentArgv, type AgentArgvResult } from '#scripts/agent/agent-argv'
+import type { AgentArgv } from '#scripts/agent/agent-argv'
 import { agent_role_profile, type AgentProfile } from '#scripts/agent/agent-role-profile'
 import type { LabelWrite } from '#scripts/gh/git-gh-issue-write'
 import { issue_cite } from '#scripts/issue/issue-cite'
@@ -10,15 +10,14 @@ import { detached_launch, type LaunchArgv } from '#scripts/run/detached-launch'
 import { run_event_stream } from '#scripts/run/event/run-event-stream'
 import { run_event_stream_emit } from '#scripts/run/event/run-event-stream-emit'
 import { run_park } from '#scripts/run/park/run-park'
-import { run_ending } from '#scripts/run/run-ending'
 import { run_label } from '#scripts/run/run-label'
 import { lane_child_invocation } from './lane-child-invocation'
 import { lane_child_marker } from './lane-child-marker'
 import { lane_dispatch_log } from './lane-dispatch-log'
+import { lane_dispatch_prepare } from './lane-dispatch-prepare'
 import { lane_ledger_write } from './lane-ledger-write'
 import { lane_output } from './lane-output'
 import { lane_registry, type LaneInfo } from './lane-registry'
-import { lane_resume, type ResumePlan } from './lane-resume'
 import { lane_seat_start } from './lane-seat-start'
 import { lane_state } from './lane-state'
 import { openai_lane_supervisor } from './openai-lane-supervisor'
@@ -51,7 +50,6 @@ const WARNING_RECOVERY =
 // once rather than inlined at each use.
 const LABEL_UNSET_KIND = 'label-unset'
 const RESTART_START = 'restart'
-// The role a lane child runs under, resolved once so the fresh and resume builders read the same one.
 
 interface Dispatched {
 	kind: 'dispatched'
@@ -93,16 +91,6 @@ interface StartRequest {
 	resumed_from: string | undefined
 }
 
-type Prepared =
-	| {
-			kind: 'prepared'
-			invocation: string
-			argv: AgentArgv
-			profile: AgentProfile
-			resumed_from: string | undefined
-	  }
-	| { kind: 'rejected'; note: string }
-
 /** The prompt the headless child is given: `fullrun #<N>`, and nothing a caller supplied verbatim. */
 function child_invocation(issue: string): string {
 	return lane_child_invocation.child_invocation(issue)
@@ -276,44 +264,6 @@ async function started(request: StartRequest): Promise<DispatchOutcome> {
 	return await dispatched_start(request, result.pid, notes, nonce)
 }
 
-// Build the argv the plan calls for: a resume carries the stored session id, a fresh start does not.
-// Both run the same profile diagnostics under the already-resolved profile, so a resume is refused for
-// exactly the reasons a fresh dispatch is.
-function built_for(plan: ResumePlan, profile: AgentProfile, lane: LaneInfo): AgentArgvResult {
-	if (plan.kind === 'resume') {
-		return agent_argv.with_resume_in(plan.invocation, profile, plan.session_id, lane.directory)
-	}
-
-	return agent_argv.with_profile_in(plan.invocation, profile, lane.directory)
-}
-
-// **The re-dispatch decides resume-or-fresh from the lane's own exit record**.
-// The record is read from the log the previous dispatch of this lane wrote — a first dispatch finds
-// none and starts fresh, an `outage` ending with a session id resumes it. The provider is resolved
-// first because the resume mechanism is Claude Code's, and an OpenAI lane falls back to fresh. **A
-// fresh dispatch never reads the record**: a person restarting a child (`lane:restart`) wants a new
-// session that reads the Issue from the start, whatever the previous one ended on.
-function prepared(lane: LaneInfo, is_fresh: boolean): Prepared {
-	const resolved = agent_role_profile.resolve(agent_role_profile.WORKER)
-
-	if (resolved.kind === 'rejected') return resolved
-
-	const record = is_fresh ? undefined : run_ending.read_exit(default_log_path(lane))
-	const plan = lane_resume.plan(lane.issue, record, resolved.profile.provider)
-	const built = built_for(plan, resolved.profile, lane)
-
-	if (built.kind === 'rejected') return built
-	const resumed_from = plan.kind === 'resume' ? plan.session_id : undefined
-
-	return {
-		kind: 'prepared',
-		invocation: plan.invocation,
-		argv: built.argv,
-		profile: built.profile,
-		resumed_from,
-	}
-}
-
 // **The parent claims the marker before it starts the child**, so the window in which a running child
 // is uncounted closes at dispatch rather than tens of minutes later once the child's own `fullrun` gets
 // to its (idempotent) apply. `issue_add_label` creates the label if the repository lacks it — a
@@ -400,7 +350,7 @@ async function dispatch_child(
 	const lane = await lane_registry.find_open_lane(issue)
 
 	if (lane === undefined) return { kind: 'no-lane' }
-	const built = prepared(lane, start === RESTART_START)
+	const built = await lane_dispatch_prepare.prepared(lane, start === RESTART_START)
 	const log_path = default_log_path(lane)
 
 	if (built.kind === 'rejected') return { kind: 'failed', lane, log_path, note: built.note }

package/scripts/lane/lane-elapsed-time.ts

@@ -0,0 +1,118 @@
+import { MS_PER_MINUTE } from '#scripts/lib/timeouts'
+import type { RunEvent } from '#scripts/run/event/run-event-stream'
+import { lane_breakdown } from './lane-breakdown'
+import { lane_ledger, type LedgerEntry } from './lane-ledger'
+import { lane_net_time, type LaneSpan } from './lane-net-time'
+import { lane_stage_budget } from './lane-stage-budget'
+import type { ToolCall } from './lane-transcript-calls'
+
+// Wall-clock accounting, separate from legacy lane net. Human wait wins over automatic wait;
+// automatic wait wins over off-tool work. Parallel tool durations remain a separate cumulative value.
+interface ElapsedTime {
+	total_ms: number
+	human_ms: number
+	automatic_ms: number
+	work_ms: number
+	unclassified_ms: number
+	tool_ms: number
+	within_target: boolean
+}
+
+const EDIT_TOOLS: ReadonlySet<string> = new Set(['Edit', 'Write'])
+const AUTOMATIC_STAGES: ReadonlySet<string> = new Set([
+	'gate',
+	'pre-detach',
+	'followup',
+	lane_ledger.CI_WAIT_STAGE,
+])
+
+function tool_spans(calls: ReadonlyArray<ToolCall>): Array<LaneSpan> {
+	return calls.flatMap((call) =>
+		call.duration_ms === undefined || EDIT_TOOLS.has(call.tool ?? '')
+			? []
+			: { from_ms: call.started_ms, to_ms: call.started_ms + call.duration_ms },
+	)
+}
+
+function stage_spans(entries: ReadonlyArray<LedgerEntry>, issue: number): Array<LaneSpan> {
+	return entries.flatMap((entry) =>
+		entry.kind === lane_ledger.KIND.STAGE &&
+		entry.issue === issue &&
+		AUTOMATIC_STAGES.has(entry.stage)
+			? { from_ms: Date.parse(entry.at) - entry.elapsed_ms, to_ms: Date.parse(entry.at) }
+			: [],
+	)
+}
+
+function human_spans(
+	entries: ReadonlyArray<LedgerEntry>,
+	events: ReadonlyArray<RunEvent>,
+	issue: number,
+	span: LaneSpan,
+): ReadonlyArray<LaneSpan> {
+	return lane_net_time.hold_waits(
+		entries,
+		events.filter((event) => event.kind === 'park'),
+		issue,
+		span,
+	)
+}
+
+function tool_ms(span: LaneSpan, calls: ReadonlyArray<ToolCall>): number {
+	return tool_spans(calls).reduce((sum, call) => sum + lane_breakdown.covered_ms(span, [call]), 0)
+}
+
+function partition(
+	span: LaneSpan,
+	human: ReadonlyArray<LaneSpan>,
+	automatic: ReadonlyArray<LaneSpan>,
+	calls: ReadonlyArray<ToolCall>,
+): ElapsedTime {
+	const total_ms = span.to_ms - span.from_ms
+	const human_ms = lane_breakdown.covered_ms(span, human)
+	const occupied_ms = lane_breakdown.covered_ms(span, [...human, ...automatic])
+	const remainder_ms = total_ms - occupied_ms
+
+	return {
+		total_ms,
+		human_ms,
+		automatic_ms: occupied_ms - human_ms,
+		work_ms: calls.length > 0 ? remainder_ms : 0,
+		unclassified_ms: calls.length > 0 ? 0 : remainder_ms,
+		tool_ms: tool_ms(span, calls),
+		within_target: total_ms <= lane_stage_budget.TARGET_MINUTES * MS_PER_MINUTE,
+	}
+}
+
+function of(
+	entries: ReadonlyArray<LedgerEntry>,
+	events: ReadonlyArray<RunEvent>,
+	issue: number,
+	calls: ReadonlyArray<ToolCall>,
+): ElapsedTime | undefined {
+	const span = lane_net_time.span_of(entries, issue)
+	if (span === undefined) return undefined
+	const human = human_spans(entries, events, issue, span)
+	const automatic = [
+		...lane_net_time.automatic_waits(entries, events, issue, span),
+		...stage_spans(entries, issue),
+		...tool_spans(calls),
+	]
+
+	return partition(span, human, automatic, calls)
+}
+
+function text(timing: ElapsedTime): string {
+	const minutes = lane_breakdown.minutes_text
+	const status = timing.within_target ? 'within target' : 'over target'
+
+	return [
+		`End-to-end ${minutes(timing.total_ms)} (${status}); ${lane_stage_budget.DESCRIPTION}`,
+		`Exclusive wall clock: off-tool work ${minutes(timing.work_ms)}; automatic wait ${minutes(timing.automatic_ms)}; human wait ${minutes(timing.human_ms)}; unclassified (missing transcripts) ${minutes(timing.unclassified_ms)}`,
+		`Tool cumulative ${minutes(timing.tool_ms)} (parallel calls overlap; not additive to wall clock). Off-tool work includes unrecorded activity; automatic wait includes tool responses, gate, CI, yield, outage and sleep. Legacy net excludes more than human wait.`,
+	].join('\n')
+}
+
+const lane_elapsed_time = { of, text }
+
+export { lane_elapsed_time }

package/scripts/lane/lane-ledger-schema-ship.ts

@@ -24,7 +24,9 @@ const early_push_schema = z.object({
 // finding that decided a review or round-2 stop — the blocking ones, else the fixed ones
 // (joshuafolkken/kit#4426), absent where none decided the stop. `base` is the change base a review
 // failure or a followup `check` stopped on, so its re-ship can tell a fix-only tree from a moved base
-// (joshuafolkken/kit#6141, joshuafolkken/kit#6675), absent on every other stop. How long it stayed stopped is derived
+// (joshuafolkken/kit#6141, joshuafolkken/kit#6675), absent on every other stop. `checks` names the CI
+// checks a followup `check` stop's wait reported failed (joshuafolkken/kit#7333), absent on every other
+// stop and on one recorded before it had them. How long it stayed stopped is derived
 // from the next ship stage, not recorded, so a resumed ship never has to know the stop it ends.
 const stop_schema = z.object({
 	kind: z.literal(KIND.STOP),
@@ -35,6 +37,7 @@ const stop_schema = z.object({
 	preconditions: z.array(z.string()).optional(),
 	findings: z.array(z.string()).optional(),
 	base: z.string().optional(),
+	checks: z.array(z.string()).optional(),
 })
 // One `josh run:chain` on `issue`, done or stopped: `at` is its end and `elapsed_ms` its length, so the
 // next run's start ends the wait after a stop. `stage` names where it stopped and `reason` why — the

package/scripts/lane/lane-net-time.ts

@@ -4,6 +4,7 @@ import { run_ship_stage } from '#scripts/run/ship/run-ship-stage'
 import type { LedgerEntry } from './lane-ledger'
 import { lane_sleep } from './lane-sleep'
 import { lane_spans, type IssueAt, type Span } from './lane-spans'
+import { lane_stage_events } from './lane-stage-events'
 import { lane_stage_stats } from './lane-stage-stats'
 import { lane_stop_stats } from './lane-stop-stats'
 import { lane_yield } from './lane-yield'
@@ -35,7 +36,9 @@ function entries_of(entries: ReadonlyArray<LedgerEntry>, issue: number): Array<L
 // The first dispatch of `issue` to its merge, or `undefined` while either is missing or the merge comes
 // first.
 function span_of(entries: ReadonlyArray<LedgerEntry>, issue: number): LaneSpan | undefined {
-	const of_issue = entries_of(entries, issue)
+	const of_issue = entries_of(entries, issue).toSorted(
+		(left, right) => Date.parse(left.at) - Date.parse(right.at),
+	)
 	const from = of_issue.find((entry) => lane_stage_stats.is_dispatch(entry))
 	const to = of_issue.findLast((entry) => lane_stage_stats.is_merge(entry))
 
@@ -191,10 +194,7 @@ function split_waits(
 	return cut_inside(split_spans(entries, events_of_issue(events, issue)), span)
 }
 
-// The waits `net_ms` takes out of `span` — each hold from itself to its end, cut at the merge, each
-// yield and split run until its redispatch, and each sleep of the host — the intervals `josh
-// lane:breakdown` counts as excluded (`lane-breakdown.ts`).
-function waits(
+function waiting(
 	entries: ReadonlyArray<LedgerEntry>,
 	events: ReadonlyArray<RunEvent>,
 	issue: number,
@@ -203,11 +203,23 @@ function waits(
 	return joined([
 		...hold_waits(entries, events, issue, span),
 		...yielded(entries, events, issue, span),
-		...split_waits(entries, events, issue, span),
 		...slept(events, span),
 	])
 }
 
+// Legacy net also leaves out the complete run that split its issue.
+function waits(
+	entries: ReadonlyArray<LedgerEntry>,
+	events: ReadonlyArray<RunEvent>,
+	issue: number,
+	span: LaneSpan,
+): Array<LaneSpan> {
+	return joined([
+		...waiting(entries, events, issue, span),
+		...split_waits(entries, events, issue, span),
+	])
+}
+
 function is_followup_start(event: RunEvent): boolean {
 	const { stage, phase } = run_ship_stage.words_of(event.text)
 
@@ -230,6 +242,17 @@ function followed(events: ReadonlyArray<RunEvent>, issue: number, span: LaneSpan
 		.map(({ line, to_ms }) => ({ from_ms: line.at_ms, to_ms }))
 }
 
+function automatic_waits(
+	entries: ReadonlyArray<LedgerEntry>,
+	events: ReadonlyArray<RunEvent>,
+	issue: number,
+	span: LaneSpan,
+): Array<LaneSpan> {
+	const stages = lane_stage_events.of(entries, events, issue)
+
+	return joined([...waiting(entries, events, issue, span), ...followed(stages, issue, span)])
+}
+
 // Every interval `net_ms` leaves out of `span`: the waits and the driver's followups, joined.
 function outside(
 	entries: ReadonlyArray<LedgerEntry>,
@@ -237,7 +260,10 @@ function outside(
 	issue: number,
 	span: LaneSpan,
 ): Array<LaneSpan> {
-	return joined([...waits(entries, events, issue, span), ...followed(events, issue, span)])
+	return joined([
+		...automatic_waits(entries, events, issue, span),
+		...split_waits(entries, events, issue, span),
+	])
 }
 
 /**
@@ -282,6 +308,8 @@ function missing_reason(entries: ReadonlyArray<LedgerEntry>, issue: number): str
 }
 
 const lane_net_time = {
+	automatic_waits,
+	hold_waits,
 	missing_reason,
 	net_minutes,
 	net_ms,

package/scripts/lane/lane-overrun.ts

@@ -215,7 +215,7 @@ type OverranNet = Extract<LaneNet, { kind: 'minutes' }>
 async function overran_text(issue: number, net: OverranNet): Promise<string> {
 	const breakdown =
 		lane_breakdown_implement.breakdown_of(net.entries, net.events, issue) ?? net.breakdown
-	const report = lane_breakdown_text.report_of(issue, breakdown, net.entries)
+	const report = lane_breakdown_text.report_of(issue, breakdown, net.entries, net.events)
 	const comment = lane_breakdown_text.comment(issue, net.minutes, report)
 
 	if (!net.is_commented) await git_gh_issue_write.issue_try_comment(String(issue), comment)

package/scripts/lane/lane-plan-cli.ts

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'node:url'
 import type { LanePlan } from './lane-plan'
 import { lane_plan_approval } from './lane-plan-approval'
 import { lane_plan_check } from './lane-plan-check'
+import { lane_plan_estimate } from './lane-plan-estimate'
 import { lane_plan_imports } from './lane-plan-imports'
 
 // `josh lane:plan <issue> <path>... [--probe] [--imports <path>...]` — the command line over
@@ -16,7 +17,7 @@ const PROBE_FLAG = '--probe'
 const SINGLE_FLAG = '--single'
 const FLAGS = new Set([PROBE_FLAG, SINGLE_FLAG])
 const USAGE =
-	'Usage: josh lane:plan <issue-number> <path> [<path> ...] [--probe] [--single] [--size-approval <json-file>] [--imports <path> ...]'
+	'Usage: josh lane:plan <issue-number> <path> [<path> ...] [--probe] [--single] [--estimate <json-file>] [--size-approval <json-file>] [--imports <path> ...]'
 const { YIELD_EXIT_CODE } = lane_plan_check
 
 async function planned(
@@ -24,12 +25,15 @@ async function planned(
 	directory: string,
 	is_single: boolean,
 ): Promise<LanePlan | undefined> {
-	const input = lane_plan_approval.split(tokens)
+	const estimate = lane_plan_estimate.split(tokens)
+	const input = lane_plan_approval.split(estimate.tokens)
 	const plan = lane_plan_check.plan_of(input.tokens, new Date())
 	if (plan === undefined) return undefined
 	const declared = is_single ? { ...plan, single: true } : plan
 
-	return await lane_plan_approval.attach(lane_plan_check.placed(declared, directory), input.file)
+	const scoped = await lane_plan_estimate.attach(declared, estimate.file)
+
+	return await lane_plan_approval.attach(lane_plan_check.placed(scoped, directory), input.file)
 }
 
 async function run(

package/scripts/lane/lane-plan-estimate.ts

@@ -0,0 +1,57 @@
+import { readFile } from 'node:fs/promises'
+import { split_assess } from '#scripts/split/split-assess'
+import { z } from 'zod'
+import type { LanePlan } from './lane-plan'
+
+// Selected consumers, distributed docs and verification fixtures share the actual-size calculator.
+// A reference alone implies neither an edit nor an independently mergeable split boundary.
+const FLAG = '--estimate'
+const FLAG_WIDTH = 2
+const change_schema = z.object({
+	path: z.string().trim().min(1),
+	changed_lines: z.number().int().nonnegative(),
+})
+const schema = z.object({
+	changes: z.array(change_schema),
+	added: z.array(z.string()).default([]),
+})
+
+function split(tokens: ReadonlyArray<string>): { tokens: Array<string>; file?: string } {
+	const at = tokens.indexOf(FLAG)
+	if (at === -1) return { tokens: [...tokens] }
+	if (tokens.lastIndexOf(FLAG) !== at) throw new Error('duplicate --estimate')
+	const file = tokens[at + 1]
+	if (file === undefined || file.startsWith('--')) throw new Error('--estimate needs a JSON file')
+
+	return { tokens: [...tokens.slice(0, at), ...tokens.slice(at + FLAG_WIDTH)], file }
+}
+
+async function read(file: string): Promise<z.infer<typeof schema>> {
+	const scope = schema.parse(JSON.parse(await readFile(file, 'utf8')))
+	const paths = scope.changes.map((change) => change.path)
+	if (new Set(paths).size !== paths.length) throw new Error('duplicate estimate path')
+
+	if (scope.added.some((path) => !paths.includes(path))) {
+		throw new Error('added path needs an estimate')
+	}
+
+	return scope
+}
+
+async function attach(plan: LanePlan, file: string | undefined): Promise<LanePlan> {
+	if (file === undefined) return plan
+	const scope = await read(file)
+	const paths = scope.changes.map((change) => change.path)
+
+	if (plan.paths.some((path) => !paths.includes(path))) {
+		throw new Error('planned path needs an estimate')
+	}
+
+	const size = split_assess.measure(scope.changes, undefined, new Set(scope.added))
+
+	return { ...plan, paths, estimated_size: { files: size.files, lines: size.lines } }
+}
+
+const lane_plan_estimate = { attach, read, split }
+
+export { lane_plan_estimate }

package/scripts/lane/lane-plan-size.ts

@@ -1,4 +1,3 @@
-import { codex_hooks } from '#scripts/agent/codex-hooks'
 import type { OpenIssueData } from '#scripts/git/git-schemas'
 import { issue_body_keys } from '#scripts/issue/issue-body-keys'
 import { session_cite } from '#scripts/issue/session-cite'
@@ -163,20 +162,10 @@ function files_approved(
 	)
 }
 
-// An artifact a build regenerates from one of `sources` (joshuafolkken/kit#6666): its edit is its source's,
-// so it is not counted and stays or splits off with its source — apart, the parity test fails.
-function is_generated_from(file: string, sources: ReadonlyArray<string>): boolean {
-	const source = codex_hooks.GENERATED_SOURCES.get(file)
-
-	return source !== undefined && sources.includes(source)
-}
-
-function is_counted(file: string, paths: ReadonlyArray<string>): boolean {
-	return !test_declared_logic.is_test_file(file) && !is_generated_from(file, paths)
-}
-
-function with_artifacts(files: ReadonlyArray<string>, paths: ReadonlyArray<string>): Array<string> {
-	return [...files, ...paths.filter((file) => is_generated_from(file, files))]
+// Estimate paths and the actual diff exclude the same tests and run records. Generated pairs are
+// grouped by `split_assess.units_of`, so no caller can split an artifact from its source.
+function is_counted(file: string): boolean {
+	return split_assess.is_deliverable({ path: file, changed_lines: 0 })
 }
 
 function files_over(
@@ -186,7 +175,7 @@ function files_over(
 	signals: PlanSignals,
 ): FilesOver | undefined {
 	const limit = declared * declared_growth.factor(ratios_of(signals), 'files')
-	const counted = plan.paths.filter((file) => is_counted(file, plan.paths))
+	const counted = plan.paths.filter((file) => is_counted(file))
 	const units = units_of(ordered(counted, recorded?.paths ?? []), signals)
 
 	if (units.length <= limit || files_approved(plan, declared, recorded, units.length)) {
@@ -194,8 +183,8 @@ function files_over(
 	}
 
 	const tests = plan.paths.filter((file) => test_declared_logic.is_test_file(file))
-	const kept = with_artifacts(units.slice(0, limit).flat(), plan.paths)
-	const split_off = with_artifacts(units.slice(limit).flat(), plan.paths)
+	const kept = counted.filter((file) => units.slice(0, limit).flat().includes(file))
+	const split_off = counted.filter((file) => units.slice(limit).flat().includes(file))
 
 	return { reason: 'files', declared, limit, kept, split_off, tests }
 }
@@ -286,9 +275,11 @@ function measure_over(
 ): MeasureOver | undefined {
 	if (signals.split_filed) return undefined
 
+	const estimated = Math.max(declared.lines, plan.estimated_size?.lines ?? 0)
+
 	return (
 		hunks_over(declared.files, unplanned_hunks(signals, plan, recorded), signals) ??
-		planned_lines(declared.lines, signals, plan, recorded)
+		planned_lines(estimated, signals, plan, recorded)
 	)
 }
 
@@ -343,7 +334,7 @@ const SIZE_PREFIX = issue_body_keys.prefix('size')
 
 function files_text(issue: number, over: FilesOver): string {
 	const planned = [...over.kept, ...over.split_off]
-	const counted = planned.filter((file) => is_counted(file, planned)).length
+	const counted = split_assess.units_of(planned, new Set()).length
 	const bar = `${String(counted)} files (tests and generated artifacts excluded), over ${String(over.limit)} — ${String(over.limit / over.declared)} times the ${String(over.declared)} its \`${SIZE_PREFIX}\` declares`
 	const replan = ['pnpm josh lane:plan', String(issue), ...over.kept, ...over.tests].join(' ')
 

package/scripts/lane/lane-plan.ts

@@ -24,6 +24,7 @@ const lane_plan_schema = z.object({
 	issue: z.number(),
 	paths: z.array(z.string()),
 	planned_at: z.string(),
+	estimated_size: z.object({ files: z.number(), lines: z.number() }).optional(),
 	size_approval: lane_plan_approval.approval_schema.optional(),
 	// `--single`: the plan is one deliverable with no separately-mergeable part, so a files-axis overrun
 	// is noted for the pre-gate `run:cut` to verify rather than refused (joshuafolkken/kit#6647).

package/scripts/lane/lane-relaunch.ts

@@ -1,4 +1,5 @@
 import { agent_argv } from '#scripts/agent/agent-argv'
+import { git_gh_issue_write } from '#scripts/gh/git-gh-issue-write'
 import { error_text } from '#scripts/lib/error-message'
 import { detached_launch, type LaunchResult } from '#scripts/run/detached-launch'
 import { run_ship_detach } from '#scripts/run/ship/run-ship-detach'
@@ -22,7 +23,7 @@ const { SUPERVISED_KEY } = run_ship_detach
 const OPENAI_PROVIDER = 'openai'
 
 type RelaunchResult = LaunchResult | { kind: 'rejected'; note: string }
-type Prepared = Exclude<ReturnType<typeof agent_argv.resume_argv>, { kind: 'rejected' }>
+type Prepared = Exclude<Awaited<ReturnType<typeof agent_argv.resume_argv>>, { kind: 'rejected' }>
 
 function launch(lane: LaneInfo, built: Prepared, on_note: (note: string) => void): RelaunchResult {
 	return detached_launch.launch(
@@ -53,10 +54,14 @@ async function relaunch(
 	phase: string,
 	on_note: (note: string) => void,
 ): Promise<RelaunchResult> {
-	const built = agent_argv.resume_argv(invocation, lane.profile, phase, lane.directory)
-	if (built.kind === 'rejected') return built
-
 	try {
+		// The labels are read only when `josh.worker` caps the phase's model; a failed read refuses.
+		const built = await agent_argv.resume_argv(invocation, lane.profile, phase, {
+			cwd: lane.directory,
+			labels: async () => await git_gh_issue_write.read_label_names(lane.issue),
+		})
+		if (built.kind === 'rejected') return built
+
 		return await lane_seat_start.start(lane, async (seated) => launch(seated, built, on_note))
 	} catch (error) {
 		return { kind: 'failed', note: error_text.message_of(error) }

package/scripts/lane/lane-stage-budget.ts

@@ -12,6 +12,11 @@ const BUDGET_MINUTES = {
 	followup: 5,
 } as const
 
+// An end-to-end target, independent of the internal stage budgets and legacy lane net exclusions.
+const TARGET_MINUTES = 30
+const INTERNAL_MINUTES = Object.values(BUDGET_MINUTES).reduce((sum, minutes) => sum + minutes, 0)
+const DESCRIPTION = `target ${String(TARGET_MINUTES)} min dispatch to merge (human wait reported separately, included); internal stage budgets ${String(INTERNAL_MINUTES)} min (plan 3 + implement 9 + ship 8 + followup 5)`
+
 type BudgetStage = keyof typeof BUDGET_MINUTES
 
 // The whole minutes `elapsed_ms` runs past `stage`'s budget, `undefined` within it.
@@ -21,7 +26,7 @@ function over_minutes(stage: BudgetStage, elapsed_ms: number): number | undefine
 	return over_ms > 0 ? Math.ceil(over_ms / MS_PER_MINUTE) : undefined
 }
 
-const lane_stage_budget = { BUDGET_MINUTES, over_minutes }
+const lane_stage_budget = { BUDGET_MINUTES, DESCRIPTION, TARGET_MINUTES, over_minutes }
 
 export { lane_stage_budget }
 export type { BudgetStage }