@joshuafolkken/kit 1.1128.0 → 1.1166.0

package/scripts/run/run-ship-review.ts

@@ -23,6 +23,12 @@ const LINE_SEPARATOR = /\r?\n/u
 const HIGH = 'high'
 const MEDIUM = 'medium'
 const FIXED_PREFIX = 'fixed '
+// What a finding line carries after its spec: one sentence saying what is wrong, so a stopped ship's
+// log tells the resumed lane child the defect rather than only its location (joshuafolkken/kit#3159).
+const DESCRIPTION_SEPARATOR = ' — '
+// Where the spec ends on read: a reviewer that types the dash as `-`, `--` or `–` still ends it there,
+// so its sentence never lands in the ledger's file field.
+const DESCRIPTION_BOUNDARY = / [—–-]{1,2} /u
 
 const VERDICT = {
 	CLEAN: 'clean',
@@ -35,6 +41,7 @@ type ReviewVerdict =
 	| {
 			kind: typeof VERDICT.CLEAN | typeof VERDICT.FIXED | typeof VERDICT.BLOCKING
 			specs: ReadonlyArray<string>
+			report: ReadonlyArray<string>
 	  }
 	| { kind: typeof VERDICT.INVALID; note: string }
 
@@ -49,6 +56,7 @@ interface RoundOutcome {
 interface Finding {
 	spec: string
 	is_fixed: boolean
+	line: string
 }
 
 const MISSING_NOTE = 'the reviewer wrote no findings file — the review did not complete'
@@ -69,7 +77,8 @@ function findings_instruction(findings_path: string, fixed_clause: string): stri
 	const categories = review_finding_ledger.CATEGORIES.join(', ')
 
 	return [
-		`Then write every finding to ${findings_path}, one per line as <category>:<severity>:<file>[:<line>]`,
+		`Then write every finding to ${findings_path}, one per line as`,
+		`<category>:<severity>:<file>[:<line>]${DESCRIPTION_SEPARATOR}<one sentence: what is wrong and why>`,
 		`(category one of ${categories}; severity high, medium or low)${fixed_clause},`,
 		'and an empty file when there is none.',
 	].join(' ')
@@ -99,10 +108,17 @@ function verification_prompt(brief_path: string, findings_path: string): string
 	].join(' ')
 }
 
+// The spec is what `review:record` reads; the description after it travels only in the stage output.
+function spec_of(unmarked: string): string {
+	const end = unmarked.search(DESCRIPTION_BOUNDARY)
+
+	return (end === -1 ? unmarked : unmarked.slice(0, end)).trim()
+}
+
 function finding_of(line: string): Finding {
-	if (!line.startsWith(FIXED_PREFIX)) return { spec: line, is_fixed: false }
+	const is_fixed = line.startsWith(FIXED_PREFIX)
 
-	return { spec: line.slice(FIXED_PREFIX.length).trim(), is_fixed: true }
+	return { spec: spec_of(is_fixed ? line.slice(FIXED_PREFIX.length) : line), is_fixed, line }
 }
 
 function spec_findings(text: string): ReadonlyArray<Finding> {
@@ -133,7 +149,8 @@ function scored_kind(findings: ReadonlyArray<Finding>): ScoredVerdict['kind'] {
 
 // Absent means the reviewer never finished; a line outside the grammar means its verdict cannot be
 // recorded — both stop the ship rather than read as clean. The specs are recorded without the `fixed`
-// mark: a fixed finding was still a finding of that round.
+// mark: a fixed finding was still a finding of that round. The report keeps each line whole — mark and
+// description — for the stage output a resumed lane child reads.
 function read_verdict(text: string | undefined): ReviewVerdict {
 	if (text === undefined) return { kind: VERDICT.INVALID, note: MISSING_NOTE }
 
@@ -144,7 +161,11 @@ function read_verdict(text: string | undefined): ReviewVerdict {
 		return { kind: VERDICT.INVALID, note: `unreadable finding: ${invalid.spec}` }
 	}
 
-	return { kind: scored_kind(findings), specs: findings.map((finding) => finding.spec) }
+	return {
+		kind: scored_kind(findings),
+		specs: findings.map((finding) => finding.spec),
+		report: findings.map((finding) => finding.line),
+	}
 }
 
 // Round 1 passes clean or with every blocking finding fixed in place; round 2 follows the commit.

package/scripts/run/run-step-cli.ts

@@ -10,6 +10,7 @@ import { run_carry, type CarryRead } from './run-carry'
 import { run_event_scope } from './run-event-scope'
 import { run_event_stream } from './run-event-stream'
 import { run_headless } from './run-headless'
+import { run_prep, type PrepParts } from './run-prep'
 import { run_prep_cli } from './run-prep-cli'
 import { run_retrospective } from './run-retrospective'
 import { run_step, type StepInput } from './run-step'
@@ -85,14 +86,14 @@ function read_run(
 	}
 }
 
-async function gather(issue_number: string): Promise<StepInput> {
-	const reads = await run_prep_cli.gather(issue_number)
-	const parts = run_prep_cli.to_parts(issue_number, reads)
-	const is_lane_child = lane_child_marker.is_child_of(process.cwd())
-	const run_reads = read_run(await run_carry.repository_directory(), issue_number, is_lane_child)
+interface Gathered {
+	input: StepInput
+	ship_problems: ReadonlyArray<string>
+}
 
+function step_input(parts: PrepParts, run_reads: RunReads, is_lane_child: boolean): StepInput {
 	return {
-		issue_number,
+		issue_number: parts.issue_number,
 		state: parts.state?.state,
 		is_human_review: parts.state?.is_human_review ?? false,
 		latest_scope: parts.latest_scope,
@@ -110,6 +111,15 @@ async function gather(issue_number: string): Promise<StepInput> {
 	}
 }
 
+async function gather(issue_number: string): Promise<Gathered> {
+	const reads = await run_prep_cli.gather(issue_number)
+	const parts = run_prep_cli.to_parts(issue_number, reads)
+	const is_lane_child = lane_child_marker.is_child_of(process.cwd())
+	const run_reads = read_run(await run_carry.repository_directory(), issue_number, is_lane_child)
+
+	return { input: step_input(parts, run_reads, is_lane_child), ship_problems: parts.ship_problems }
+}
+
 async function run(argv: ReadonlyArray<string>): Promise<number> {
 	const issue_number = run_prep_cli.parse_number(argv)
 
@@ -119,9 +129,12 @@ async function run(argv: ReadonlyArray<string>): Promise<number> {
 		return FAILURE_EXIT_CODE
 	}
 
-	const input = await gather(issue_number)
+	const { input, ship_problems } = await gather(issue_number)
 
 	console.info(run_step.next_action(input).line)
+	// On stderr, so stdout stays the one action line (joshuafolkken/kit#3154): what `josh ship` would
+	// refuse on is said at every step, while it is still cheap to meet.
+	if (ship_problems.length > 0) console.error(run_prep.ship_body(ship_problems))
 
 	// A state that could not be read exits non-zero, exactly as `run:prep` and `run:next` exit on the
 	// same failure, so a position missing its issue state is never read as a confident next step.

package/scripts/run/run-wake-driver.ts

@@ -37,13 +37,36 @@ function details_tail(details: string): string {
 		: details
 }
 
+// **The hand-off names its next move, so the woken session never searches the procedure for it**
+// (joshuafolkken/kit#3156). Whatever the branch, the session acts on it and hands the loop back to the
+// supervisor with a cut; only a person's stop ends the run instead.
+const HAND_BACK = 'then hand the loop back with pnpm josh run:carry --cut --owner "$PPID"'
+const NEXT_BY_VERDICT: ReadonlyArray<readonly [string, string]> = [
+	[
+		'retrospective',
+		`run what pnpm josh run:step prints (retrospective.md), close it with pnpm josh run:carry --retrospective --summary "<result>" --owner "$PPID", ${HAND_BACK}`,
+	],
+	[
+		'merge human-review',
+		'the child stopped before its commit for a person; stop the run (needs-human-review.md)',
+	],
+	['epic #', `follow backlogrun-steps.md → "Named issues run first, in order", ${HAND_BACK}`],
+]
+const NEXT_DEFAULT = `act on the result by backlogrun-steps.md → "The loop", ${HAND_BACK}`
+
+function next_move(verdict: string): string {
+	const found = NEXT_BY_VERDICT.find(([prefix]) => verdict.startsWith(prefix))
+
+	return `\nNext: ${found?.[1] ?? NEXT_DEFAULT}`
+}
+
 function handoff_material(verdict: string, resume: string, details: string): string {
 	const context = details === '' ? '' : `\nDetails: ${details_tail(details)}`
 	const epic = verdict.startsWith('epic #')
 		? '\nThe named item is an epic. Follow backlogrun-steps.md named epic procedure; do not launch the epic root as a fullrun child. After all children merge or park, record the root with pnpm josh run:carry --done <epic-number> --owner "$PPID" before continuing to the next named item.'
 		: ''
 
-	return `Driver result: ${verdict}\n${resume}${epic}${context}`
+	return `Driver result: ${verdict}\n${resume}${epic}${next_move(verdict)}${context}`
 }
 
 function driver_result(out: string, read: CarryRead, details = ''): DriveResult {

package/scripts/run/run-wake-session.ts

@@ -29,7 +29,8 @@ import { run_invocation } from './run-invocation'
 //
 // **The waker adds nothing to what may be run.** The argument vector is the constant command plus an
 // invocation rebuilt to say exactly what the record said, and nothing here writes a label: `auto-ok`
-// stays a person's to apply, so a woken session is offered by exactly the rules the first one was. A
+// arrives only through `issue:file`'s default, so a woken session is offered by exactly the rules the
+// first one was. A
 // pool that grew across the seam is `backlogrun-steps.md` → "What one invocation approves", not the
 // waker's doing (joshuafolkken/kit#1675).
 const WAKE_COMMAND = claude_agent_argv.AGENT_COMMAND

package/scripts/test/test-declared-logic.ts

@@ -12,7 +12,7 @@
 // can catch a defect in it; this set keeps documentation *in* because a test could never have caught a
 // prose defect either way. The two answer different questions, so sharing one list would be wrong, not
 // a clone avoided. Here only paths that are mechanically certain to touch no runtime code are exempt —
-// the non-executable config and cosmetic-asset arms of `CLAUDE.md`'s "Non-runtime updates" exception
+// the non-executable config and cosmetic-asset arms of `prompts/testing-guide.md`'s "Non-runtime updates" exception
 // stay `required`, and a person declares that exception in the Step 0 work summary. Under-exempting
 // costs one declared exception; over-exempting ships an untested runtime change. The one widening is
 // the basic profile's manual check below, for files no runner kit has could test.

package/scripts/test/test-related.ts

@@ -26,12 +26,7 @@ import { test_unit_guard } from './test-unit-guard'
 function conclusive_tree(before: GateTree | undefined): GateTree | undefined {
 	if (before === undefined) return undefined
 
-	const action = test_unit_guard.resolve_guard_action(
-		test_unit_guard.is_vitest_installed(process.cwd()),
-		test_unit_guard.has_unit_tests(process.cwd()),
-	)
-
-	return action === 'run' ? before : undefined
+	return test_unit_guard.guard_action(process.cwd()) === 'run' ? before : undefined
 }
 
 async function run_related_tests(command_arguments: ReadonlyArray<string>): Promise<number> {

package/scripts/test/test-unit-guard.ts

@@ -79,6 +79,24 @@ function has_unit_tests(project_directory: string): boolean {
 	return matches.length > 0
 }
 
+// The guard's decision for one project, asked here once so the run, the scoped record and the gate's
+// precondition can never disagree about whether this project's vitest runs (joshuafolkken/kit#3136).
+function guard_action(project_directory: string): GuardAction {
+	return resolve_guard_action(
+		is_vitest_installed(project_directory),
+		has_unit_tests(project_directory),
+		project_checks.is_basic(project_directory),
+	)
+}
+
+// **A skip is the project having no unit suite, so no unit check can ever vouch for its tree.** The
+// failing branch is not one: it is a broken suite, and it is left to fail where it is reported.
+function is_skipping(project_directory: string): boolean {
+	const action = guard_action(project_directory)
+
+	return action === SKIP_ACTION || action === SKIP_NO_TESTS_ACTION
+}
+
 // A lane's port allocation belongs to its development and preview servers, not to unit fixtures.
 // Passing it into Vitest makes every case that deliberately omits or replaces the seed inherit the
 // checkout's seat instead. Keep the rest of the caller's environment, including CI and PATH guards.
@@ -155,13 +173,7 @@ async function run_guarded_vitest(
 	command_label: string = UNIT_COMMAND_LABEL,
 	announcement?: string,
 ): Promise<number> {
-	const is_installed = is_vitest_installed(project_directory)
-	const has_tests = has_unit_tests(project_directory)
-	const action = resolve_guard_action(
-		is_installed,
-		has_tests,
-		project_checks.is_basic(project_directory),
-	)
+	const action = guard_action(project_directory)
 
 	if (action !== 'run') return report_no_run(action, command_label)
 	if (announcement !== undefined) process.stdout.write(`${announcement}\n`)
@@ -185,6 +197,8 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 
 const test_unit_guard = {
 	SKIP_MARKER,
+	guard_action,
+	is_skipping,
 	resolve_guard_action,
 	is_vitest_installed,
 	has_unit_tests,

package/scripts/time-runtime/time-batch-guard.ts

@@ -114,6 +114,10 @@ interface GuardedCall {
 	input: unknown
 }
 
+// What naming a call reads off it — a closed turn's span or the call in hand alike, so the live density
+// line can name the call that has just run beside the turns behind it (joshuafolkken/kit#3157).
+type NamedCall = Pick<Span, 'is_bundleable' | 'is_writing' | 'label' | 'targets'>
+
 // **A write is refusable, and the exclusion that said otherwise is gone** (joshuafolkken/kit#1762).
 // Read over 19 recorded runs, 261 of 1,737 round trips (15.0%) were recoverable by batching and **184
 // of them (70.5%) were writes** — 158 `Edit` alone. The refusal's own text has always said the rule
@@ -171,7 +175,7 @@ const REASON =
 	`the calls meant to follow it that do not need its result. **The criterion is whether this call's ` +
 	`input needs another call's result, not what kind of call it is** — edits are covered exactly as ` +
 	`reads are, and it never authorizes weakening a verification gate or a review: fewer turns, never ` +
-	`less work. The measured cost and the rejected mechanisms are in ` +
+	`less work. The rule, and where its measured cost and rejected mechanisms are, is in ` +
 	`\`prompts/collaboration-workflow/turn-batching.md\`. If this turn was already batching, or the call ` +
 	`genuinely has nothing to go beside it, reissue it as it was: this fires once per run of ` +
 	`single-call turns and cannot repeat on the call in hand.`
@@ -188,7 +192,7 @@ const NOTICE =
 	`write proceeds. Where the writes meant to follow it do not need its result, issue them in one turn ` +
 	`together. **The criterion is whether a call's input needs another call's result, not what kind of ` +
 	`call it is** — it never authorizes weakening a verification gate or a review: fewer turns, never ` +
-	`less work. The measured cost and the rejected mechanisms are in ` +
+	`less work. The rule, and where its measured cost and rejected mechanisms are, is in ` +
 	`\`prompts/collaboration-workflow/turn-batching.md\`. If this run was already batching, or the write ` +
 	`genuinely has nothing to go beside it, carry on: this recurs every ` +
 	`${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`
@@ -205,8 +209,8 @@ const LANE_NOTICE =
 	`proceeds, because a dispatched lane child ends its turn on a denial. Where the calls meant to follow ` +
 	`it do not need its result, issue them in one turn together. **The criterion is whether a call's ` +
 	`input needs another call's result, not what kind of call it is** — it never authorizes weakening a ` +
-	`verification gate or a review: fewer turns, never less work. The measured cost and the rejected ` +
-	`mechanisms are in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already ` +
+	`verification gate or a review: fewer turns, never less work. The rule, and where its measured cost ` +
+	`and rejected mechanisms are, is in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already ` +
 	`batching, or the call genuinely has nothing to go beside it, carry on: this recurs every ` +
 	`${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`
 
@@ -410,7 +414,7 @@ function should_notify(text: string, call: GuardedCall, notified_at_ms: number):
 // touched where the label does not already carry it (joshuafolkken/kit#2276). `label` is the tool name
 // for a non-shell call and the command for a shell one, so the target is appended only where it adds
 // something the label has not already said.
-function describe_span(span: Span): string {
+function describe_span(span: NamedCall): string {
 	const target = span.targets[0] ?? ''
 	if (target === '' || span.label.includes(target)) return span.label
 
@@ -428,7 +432,7 @@ const FOLD_MINIMUM = 2
 // `read:files` cannot read — it would emit `Cannot read scripts/` and exit 1, so the paste-ready
 // command must never carry it). The directory test is `has_extension` reused from the target scanner,
 // not a second copy. Deduped, so a run that read one file twice folds it once and names it once.
-function read_targets(sequence: ReadonlyArray<Span>): ReadonlyArray<string> {
+function read_targets(sequence: ReadonlyArray<NamedCall>): ReadonlyArray<string> {
 	const paths = sequence
 		.filter((span) => span.is_bundleable && !span.is_writing)
 		.map((span) => span.targets[0] ?? '')
@@ -445,7 +449,7 @@ function read_targets(sequence: ReadonlyArray<Span>): ReadonlyArray<string> {
 // kit#2202); so the guard now offers *that* command, the one the model can emit in a single turn,
 // rather than another way to say "batch". Below two reads there is nothing to fold, so it is empty and
 // the guidance stands alone.
-function read_fold_directive(sequence: ReadonlyArray<Span>): string {
+function read_fold_directive(sequence: ReadonlyArray<NamedCall>): string {
 	const paths = read_targets(sequence)
 	if (paths.length < FOLD_MINIMUM) return ''
 
@@ -459,7 +463,7 @@ function read_fold_directive(sequence: ReadonlyArray<Span>): string {
 // can emit in a single turn where reissuing the edits as parallel `tool_use` blocks is the shape it
 // resists. Only `Edit` counts: a whole-file `Write` creates content this command cannot content-address,
 // and it earns its own notice already. Below two edits there is nothing to fold.
-function write_targets(sequence: ReadonlyArray<Span>): ReadonlyArray<string> {
+function write_targets(sequence: ReadonlyArray<NamedCall>): ReadonlyArray<string> {
 	const paths = sequence
 		.filter((span) => span.label === EDIT_TOOL)
 		.map((span) => span.targets[0] ?? '')
@@ -468,13 +472,24 @@ function write_targets(sequence: ReadonlyArray<Span>): ReadonlyArray<string> {
 	return [...new Set(paths)]
 }
 
-function write_fold_directive(sequence: ReadonlyArray<Span>): string {
+function write_fold_directive(sequence: ReadonlyArray<NamedCall>): string {
 	const paths = write_targets(sequence)
 	if (paths.length < FOLD_MINIMUM) return ''
 
 	return ` Fold them into one \`pnpm josh edit:files\` call with a plan over: ${paths.join(' ')}.`
 }
 
+// The calls named, and their folds offered — the text both the refusable-call notice and the live
+// density line carry, written once so the two cannot word the same calls differently.
+function name_candidates(calls: ReadonlyArray<NamedCall>): string {
+	if (calls.length === NONE) return ''
+
+	const named = calls.map((call) => describe_span(call)).join(', ')
+	const folds = `${read_fold_directive(calls)}${write_fold_directive(calls)}`
+
+	return ` Just issued one per turn, so at least these could have shared a turn: ${named}.${folds}`
+}
+
 // **The concrete half of the notice** (joshuafolkken/kit#2276): the most recent single-call turns,
 // named, so the model is shown the calls it should have batched rather than only told to batch — and,
 // since kit#2311, the one `read:files` call that folds them where they were reads. Parsed from the tail
@@ -482,16 +497,36 @@ function write_fold_directive(sequence: ReadonlyArray<Span>): string {
 // which is rare enough that the second parse costs less than carrying the spans through the hook's
 // notice contract. An empty sequence names nothing and the notice falls back to its guidance alone.
 function recent_candidates(tail: string): string {
-	const recent = time_bundles
-		.open_sequence(time_spans.parse_timeline(tail).spans)
-		.slice(-NAMED_CANDIDATE_COUNT)
+	return name_candidates(
+		time_bundles.open_sequence(time_spans.parse_timeline(tail).spans).slice(-NAMED_CANDIDATE_COUNT),
+	)
+}
+
+// **The candidates for a call that has already run** (joshuafolkken/kit#3157): what the `PostToolUse`
+// density line names. A lane child never sees the notice above — kit#2405 turned it `off` there — so
+// the density line is the one batching signal a lane receives, and until this it named nothing. The
+// call in hand is not in the open sequence (its turn has not closed), so it is named after the turns
+// behind it — and it is checked against them with the same shared-target test the refusal uses, so a
+// call that read what the turn before it wrote is never offered as one that could have gone beside
+// it. A call that is not bundleable names no targets, so the shared-target test cannot see what it
+// needs — `pnpm josh gate` after a run of edits reads every one of them — and it is never offered
+// either, exactly as `is_guarded_call` never refuses one. An empty answer means there is no concrete
+// pair to name, and the caller says nothing at all. A call the payload does not name is judged on the
+// closed turns alone.
+function pairing_candidates(tail: string, call: GuardedCall | undefined): string {
+	const sequence = time_bundles.open_sequence(time_spans.parse_timeline(tail).spans)
+
+	if (call === undefined || sequence.length === NONE) {
+		return name_candidates(sequence.slice(-NAMED_CANDIDATE_COUNT))
+	}
 
-	if (recent.length === NONE) return ''
+	const facts = time_bundle_call.call_facts(call.name, call.input)
 
-	const named = recent.map((span) => describe_span(span)).join(', ')
-	const folds = `${read_fold_directive(recent)}${write_fold_directive(recent)}`
+	if (!facts.is_bundleable || depends_on_sequence(sequence, facts)) return ''
 
-	return ` Just issued one per turn, so at least these could have shared a turn: ${named}.${folds}`
+	const current = time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
+
+	return name_candidates([...sequence.slice(ONE_TURN - NAMED_CANDIDATE_COUNT), current])
 }
 
 // **This guard's own name for its once-per-run record.** It lives beside the rule rather than in
@@ -519,6 +554,7 @@ const time_batch_guard = {
 	is_guarded_call,
 	is_notice_call,
 	is_read_only_call,
+	pairing_candidates,
 	recent_candidates,
 	should_block,
 	should_notify,

package/scripts/time-runtime/time-density-hook.ts

@@ -1,6 +1,7 @@
 import { closeSync, fstatSync, openSync, readSync } from 'node:fs'
 import { stamp_file } from '#scripts/josh/stamp-file'
 import { z } from 'zod'
+import { time_batch_guard, type GuardedCall } from './time-batch-guard'
 import { time_density } from './time-density'
 import { time_hook_transcript } from './time-hook-transcript'
 
@@ -61,6 +62,7 @@ const payload_schema = z.object({
 	agent_id: z.string().nullish(),
 })
 const notice_schema = z.object({ notified_at_ms: z.number() })
+const call_schema = z.object({ tool_name: z.string().min(1), tool_input: z.unknown() })
 
 function parse_transcript_path(raw_payload: string): string | undefined {
 	const parsed = payload_schema.safeParse(JSON.parse(raw_payload))
@@ -70,6 +72,17 @@ function parse_transcript_path(raw_payload: string): string | undefined {
 	return time_hook_transcript.transcript_of(parsed.data.transcript_path, parsed.data.agent_id)
 }
 
+// The call that has just run, as the payload names it (joshuafolkken/kit#3157) — what the line checks
+// against the turns behind it, so a call that needed their result is never offered as one that could
+// have shared their turn. A payload without a tool name answers `undefined`, judged on those turns alone.
+function parse_call(raw_payload: string): GuardedCall | undefined {
+	const parsed = call_schema.safeParse(JSON.parse(raw_payload))
+
+	if (!parsed.success) return undefined
+
+	return { name: parsed.data.tool_name, input: parsed.data.tool_input }
+}
+
 // The last `max_bytes` of a file, as text. The leading line is usually cut mid-way, which every
 // reader below already handles: an unparseable line is dropped rather than dated.
 //
@@ -135,14 +148,19 @@ function notice_for(raw_payload: string, now_ms: number): string | undefined {
 
 	if (transcript_path === undefined) return undefined
 
-	const reading = time_density.read_window(read_tail(transcript_path))
+	const tail = read_tail(transcript_path)
+	const reading = time_density.read_window(tail)
 	const target = notice_path(transcript_path)
 
 	if (!time_density.is_due(reading, now_ms - last_notice_ms(target))) return undefined
 
+	const candidates = time_batch_guard.pairing_candidates(tail, parse_call(raw_payload))
+
+	if (candidates === '') return undefined
+
 	arm_throttle(target, now_ms)
 
-	return time_density.format_notice(reading)
+	return time_density.format_notice(reading, candidates)
 }
 
 // The whole call in one guard: every path above may throw on a file that moved or a payload that is

package/scripts/time-runtime/time-density.ts

@@ -120,8 +120,9 @@ function is_due(reading: DensityReading, since_last_ms: number): boolean {
 // One line, and it says three things: what the density is, what it is being measured against, and
 // what to do differently. The instruction is last because it is the only part worth acting on, and it
 // names the resident rule rather than restating it — the rule is already in the run's context, and a
-// second wording of it would be a clone that can drift.
-function format_notice(reading: DensityReading): string {
+// second wording of it would be a clone that can drift. `candidates` is the concrete calls that could
+// have shared a turn (joshuafolkken/kit#3157), appended last so the line ends on what to do next.
+function format_notice(reading: DensityReading, candidates = ''): string {
 	const density = time_round_trips.format_density(reading.density)
 	const floor = time_round_trips.format_density(time_round_trips.CALLS_PER_ROUND_TRIP_FLOOR)
 
@@ -130,7 +131,7 @@ function format_notice(reading: DensityReading): string {
 		`under the ${floor} floor, and this turn issued one call. ` +
 		`Independent reads, greps, gh queries and edits go out together; the criterion is whether this ` +
 		`call's input needs another call's result, not what kind of call it is — ` +
-		`prompts/collaboration-workflow/turn-batching.md.`
+		`prompts/collaboration-workflow/turn-batching.md.${candidates}`
 	)
 }
 

package/scripts/time-runtime/time-markers.ts

@@ -111,6 +111,12 @@ const BODY_FLAG_PATTERN = /--body(?:-file)?\b/u
 const ISSUE_LABELS_PATTERN = /repos\/\S+\/issues\/(\d+)\/labels\b(?!\/)/u
 const IN_PROGRESS_FIELD = 'labels[]=in-progress'
 
+// **`run:entry` applies the label itself now** (joshuafolkken/kit#3182), so a run opened through it
+// leaves no `gh api` add form in its transcript — the call that opens the run and names its issue is
+// `pnpm josh run:entry <N>`, and it is read as the same declaration. `run:release` is not: like the
+// removal form above, it ends a hold rather than opening one.
+const RUN_ENTRY_PATTERN = /\bjosh\s+run:entry\s+(\d+)\b/u
+
 // "This call declares no issue", which is the attribution's own sentinel rather than a second one:
 // what `bash_issue` returns is read by `cost_attribute` and by nothing else, so two spellings of "no
 // issue" could only drift apart.
@@ -161,6 +167,10 @@ function is_in_progress_label(command: string): boolean {
 	return ISSUE_LABELS_PATTERN.test(command) && command.includes(IN_PROGRESS_FIELD)
 }
 
+function is_run_start(command: string): boolean {
+	return is_in_progress_label(command) || RUN_ENTRY_PATTERN.test(command)
+}
+
 // Which issue a Bash call declares its run to be running, or `undefined` where it declares nothing.
 //
 // **Attribution's other evidence is the branch, and a lane run has none to give**
@@ -185,15 +195,16 @@ function is_in_progress_label(command: string): boolean {
 // shape `sonarjs/super-linear-regex` refuses.
 const COMMAND_SEPARATOR = /&&|\|\||;/u
 
-function label_issue(part: string): number {
-	const matched = ISSUE_LABELS_PATTERN.exec(part)
+function declared_issue(part: string): number {
+	const pattern = is_in_progress_label(part) ? ISSUE_LABELS_PATTERN : RUN_ENTRY_PATTERN
+	const matched = pattern.exec(part)
 
 	return matched?.[1] === undefined ? NO_ISSUE : Number(matched[1])
 }
 
 function bash_issue(command: string): number {
 	for (const part of command.split(COMMAND_SEPARATOR)) {
-		if (is_in_progress_label(part)) return label_issue(part)
+		if (is_run_start(part)) return declared_issue(part)
 	}
 
 	return NO_ISSUE
@@ -207,7 +218,7 @@ function bash_issue(command: string): number {
 // auto-decision log take the same shape, so `time-phases.ts` accepts only a marker that closes
 // before the first edit. The label carries no body, so the two tests cannot both match one command.
 function bash_marker(command: string): PhaseMarker {
-	if (is_in_progress_label(command)) return WORKFLOW_MARKER
+	if (is_run_start(command)) return WORKFLOW_MARKER
 
 	return is_api_body_write(command) || is_issue_comment(command) ? PLAN_MARKER : NO_MARKER
 }

package/scripts/time-runtime/time-spans.ts

@@ -138,6 +138,9 @@ interface ToolCall {
 	// second write to one file is independent work, a read of a file just written is not
 	// (joshuafolkken/kit#1509).
 	is_writing: boolean
+	// The conservative write answer `is_read_only_call` asks of a live call, carried so a reader of the
+	// transcript asks the same read-only question as the guard (joshuafolkken/kit#3139).
+	may_write: boolean
 	// Whether this is a subagent launch whose prompt builds on an earlier launch's finding
 	// (joshuafolkken/kit#1854). Carried for the reason every field here is — the prompt it is read from
 	// is the input, and a span keeps none. `time-agent-bundles.ts` reads it.
@@ -474,6 +477,7 @@ function to_spans(events: ReadonlyArray<TimelineEvent>, finished: FinishedAt): A
 		is_bundleable: event.is_bundleable,
 		targets: event.targets,
 		is_writing: event.is_writing,
+		may_write: event.may_write,
 		has_prior_reference: event.has_prior_reference,
 		writes: event.writes,
 		message_id: event.message_id,

package/scripts/version/npm-registry.ts

@@ -92,6 +92,16 @@ function read_release_times(package_name: string): Record<string, string> | unde
 	return parsed.success ? parsed.data.time : undefined
 }
 
-const npm_registry = { packument_url, read_latest, read_release_times }
+// Whether public npm already carries `<name>@<version>`. **Asked of public npm regardless of how this
+// checkout routes the scope**, unlike the two readers above: `josh release` waits for `publish.yml`'s
+// `publish-npm` job and links the npmjs.com page, so GitHub Packages answering would not be the
+// question it asks (joshuafolkken/kit#3193).
+function has_public_version(package_name: string, version: string): boolean {
+	const parsed = times_schema.safeParse(read_packument(package_name, FULL_ACCEPT))
+
+	return parsed.success && parsed.data.time[version] !== undefined
+}
+
+const npm_registry = { has_public_version, packument_url, read_latest, read_release_times }
 
 export { npm_registry }

package/templates/workflows/ci.yml

@@ -227,9 +227,17 @@ jobs:
         if: steps.profile.outputs.is_basic == 'true'
         run: pnpm josh gate --verbose
 
+      # size-limit is an opt-in bundle budget kit does not install, so a full project that never
+      # added it skips the check instead of failing on a missing command (joshuafolkken/kit#3217).
       - name: Check bundle size
+        id: bundle-size
         if: steps.profile.outputs.is_basic != 'true'
-        run: pnpm size-limit
+        run: |
+          if [ -x node_modules/.bin/size-limit ]; then
+            pnpm size-limit
+          else
+            echo 'size-limit is not installed — skipping the bundle-size check.'
+          fi
 
   security:
     name: Security Audit